<file_sep>﻿using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
using System.Runtime.Serialization.Formatters.Binary;
using System;
using System.IO;

public class game_handler : MonoBehaviour {

    public List<GameObject> indice_objetos;
    public List<GameObject> spawns;
    public List<int> vidas_j;
    public List<int> puntos_j;
    public float offset_x_lifes;



    // Use this for initialization
    void Start() {
        load_data();
        

    }

    void spawn_j1()
    {
        for (int i = 0; i < vidas_j[0]; i++) //Recorro las vidas del Jugador
        {
            GameObject newVida = Instantiate(indice_objetos[4], GameObject.Find("corchete1").transform); //Instanciar una nueva vida y agregar como hijo al corchete correspondiente
            newVida.GetComponent<RectTransform>().position += new Vector3((i) * offset_x_lifes, 0, 0); //Posiciono vida segun el offset (elemento i)
            newVida.name = "Vida" + i;
        }
        GameObject newBilly = Instantiate(indice_objetos[0], spawns[0].transform.position, Quaternion.identity);
        newBilly.name = "Billy";
        newBilly.GetComponent<player_handler>().player_n = 1;
    }

    void spawn_j2()
    {
        for (int i = 0; i < vidas_j[0]; i++) //Recorro las vidas del Jugador
        {
            GameObject newVida = Instantiate(indice_objetos[4], GameObject.Find("corchete2").transform); //Instanciar una nueva vida y agregar como hijo al corchete correspondiente
            newVida.GetComponent<RectTransform>().position += new Vector3((i) * offset_x_lifes, 0, 0); //Posiciono vida segun el offset (elemento i)
            newVida.name = "Vida" + i;
        }
        GameObject newCormano = Instantiate(indice_objetos[1], spawns[1].transform.position, Quaternion.identity);
        newCormano.name = "Cormano";
        newCormano.GetComponent<player_handler>().player_n = 2;
    }

    void actualizar_puntos(int n_jugador)
    {
        string numero_corchete_jugador = "corchete" + n_jugador.ToString();
        GameObject.Find(numero_corchete_jugador).transform.Find("txt_puntos").GetComponent<Text>().text = "$" + puntos_j[n_jugador - 1].ToString();
    }

    public void set_vidas(int valor, int jugador_n)
    {
        Debug.Log(jugador_n);
        vidas_j[jugador_n] += valor; //Le incrementa x vidas al jugador_n
        if (valor < 0)
        {
            check_vidas(jugador_n); //Chequeamos si le quedan vidas para respawnear
            if(vidas_j[jugador_n] >= 0)
                eliminar_vida(jugador_n); //Actualizo GUI
        }
            

    }

    void check_vidas(int jugador_n)
    {
        if (vidas_j[jugador_n] >= 0) //Compruebo si el jugador tiene mas de 0 vidas
        {
                string nombre_jugador = "respawn_j" + (jugador_n+1);
                Invoke(nombre_jugador, 2.0f); //Respawneo al jugador dentro de 2 segundos
        }
        else //Se murio y no tiene mas vidas
        {
            for(int i = 0; i < vidas_j.Count; i++) //Recorro cuantos jugadores existan para ver si alguno tiene vidas, sino termino el juego
            {
                if(vidas_j[i] > 0) //Si algun jugador todavia tiene vidas o esta vivo con su ultima
                {
                    return; //No termino el juego, finalizo la funcion
                }
            }

            Invoke("back_menu", 3.0f); //Espero 3 segundos para volver al menu
        }
    }

    void back_menu()
    {
        SceneManager.LoadScene(0); //Carga el menu principal
    }

    void respawn_j1()
    {
        GameObject newBilly = Instantiate(indice_objetos[0], spawns[0].transform.position, Quaternion.identity);
        newBilly.name = "Billy";
        newBilly.GetComponent<player_handler>().player_n = 1;
    }

    void respawn_j2()
    {
        GameObject newCormano = Instantiate(indice_objetos[1], spawns[1].transform.position, Quaternion.identity);
        newCormano.name = "Cormano";
        newCormano.GetComponent<player_handler>().player_n = 2;
    }

    void eliminar_vida(int jugador_n) //Actualiza las vidas en la interfaz (GUI/HUD)
    {
            string nombre_corchete = "corchete" + (jugador_n+1);
            if(GameObject.Find(nombre_corchete).transform.Find("Vida" + vidas_j[jugador_n]))
            {
                Destroy(GameObject.Find(nombre_corchete).transform.Find("Vida" + vidas_j[jugador_n]).gameObject);
            }
    }

    public void asignar_puntos(int n_jugador, int puntos_n)
    {
        puntos_j[n_jugador] += puntos_n; //Le agrego puntos_n al jugador_n
        actualizar_puntos(n_jugador+1);
    }

	// Update is called once per frame
	void Update () {
		
	}

    void load_data()
    {
        int cant_players = 1;
        if (File.Exists(Application.persistentDataPath + "/gamedata.dat"))
        {
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            FileStream file = File.Open(Application.persistentDataPath + "/gamedata.dat", FileMode.Open); //Generamos lectura del archivo
            cant_players = (int)bf.Deserialize(file);
            //Todas las lineas de lectura (importante orden)
            file.Close();

            for(int i = 0; i < cant_players; i++)
            {
                vidas_j[i] = 0; //Le asigno 2 vidas a la cantidad de players que se haya seleccionado
            }
        }

        spawn_j1(); //Siempre spawnea al menos al jugador 1

        if(cant_players > 1)
        {
            spawn_j2();
        }

        for(int i = 0; i < cant_players; i++)
        {
            actualizar_puntos(i+1);
        }

    }
}
<file_sep>﻿using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI; //Libreria de UI y Funciones de Interfaz
using UnityEngine.SceneManagement; //Libreria para administrar escenas
using System.Runtime.Serialization.Formatters.Binary;
using System;
using System.IO;

public class menu_handler : MonoBehaviour {

    bool opc_act = true; //True es 1 player, false es 2 player
    public GameObject pistola1;
    public GameObject pistola2;
    public datos data_g = new datos(); //Creamos un objeto del tipo datos (serializable)

	// Use this for initialization
	void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {

        if (Input.GetKeyDown(KeyCode.Z)) //Tecla select
        {
            opc_act = !opc_act; //Siempre va a la opcion contraria (el opuesto)
            if(opc_act) //Si es player 1 (cambiar grafico pistola a player 1)
            {
                data_g.players = 1;
                pistola1.GetComponent<Image>().enabled = true;
                pistola2.GetComponent<Image>().enabled = false;
            }
            else //Si es player 2 (cambiar grafico pistola a player 2)
            {
                data_g.players = 2;
                pistola2.GetComponent<Image>().enabled = true;
                pistola1.GetComponent<Image>().enabled = false;
            }
        }

        if(Input.GetKeyDown(KeyCode.X)) //Start
        {
            save_data();
            SceneManager.LoadScene(1); //Cambio a la escena 1 (escena del juego)
        }
            
    }


    void save_data()
    {
        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
        FileStream file = File.Open(Application.persistentDataPath + "/gamedata.dat", FileMode.Create);
        bf.Serialize(file, data_g.players); //Guardo este dato
        //Si tuviera mas datos los guardo aca, importante el orden porque se leeran en mismo orden
        file.Close();

    }

    [Serializable]
    public class datos
    {
        public int players = 1;
    }

}
<file_sep>﻿using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class camara_handler : MonoBehaviour {

    public GameObject min;
    public GameObject max;
    public bool min_act = false;
    public bool max_act = false;

	// Use this for initialization
	void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {

        
        if (max_act && !min_act)
        {
            if (max.transform.position.x < GameObject.FindGameObjectWithTag("Nivel").GetComponent<level_handler>().max.transform.position.x)
            {
                transform.position += new Vector3(0.02f, 0, 0); //Aumenta posicion de camara en 5X
            }
        }
	}

}
<file_sep>﻿using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class spawn_e1 : MonoBehaviour {

    public int num_enemigo;

	// Use this for initialization
	void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {
		
	}

    private void OnBecameVisible()
    {
        GameObject newEnemy = Instantiate(GameObject.Find("GameHandler").GetComponent<game_handler>().indice_objetos[num_enemigo], transform.position, Quaternion.identity); //Instanciamos nuevo enemigo
        Destroy(gameObject);
    }
}
<file_sep>﻿using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class bala : MonoBehaviour {

    Vector2 velocidad;
    public float vel_desp;
    public int n_jugador; //Numero de jugador propietario de este proyectil


    // Use this for initialization
    void Start () {
        
	}
	
	// Update is called once per frame
	void Update () {

	}

    private void FixedUpdate()
    {
        GetComponent<Rigidbody2D>().position += velocidad * Time.deltaTime;
    }

    
    private void OnBecameInvisible()
    {
        Destroy(gameObject);
    }

    private void OnCollisionEnter2D(Collision2D collision)
    {
        if(transform.tag == "Bala_E" && collision.gameObject.tag == "Player")
        {
            collision.gameObject.GetComponent<player_handler>().muerte();
        }
        else if(transform.tag == "Bala_J" && collision.gameObject.tag == "Enemigo")
        {
            collision.gameObject.GetComponent<enemy1_handler>().muerte();
            GameObject.Find("GameHandler").GetComponent<game_handler>().asignar_puntos(n_jugador, collision.gameObject.GetComponent<enemy1_handler>().puntos); //Asignamos puntos al jugador que lo mato
        }
    }

    public void asignar_velocidad(float angulo)
    {
        velocidad.x = vel_desp * Mathf.Cos(deg2rad(angulo)); //ADYACENTE = HIPOTENUSA * COS ANGULO
        velocidad.y = vel_desp * Mathf.Sin(deg2rad(angulo)); //OPUESTO = HIPOTENUSA * SIN ANGULO
    }

    public float deg2rad(float angulo)
    {
        return angulo * 3.14f / 180.0f;
    }

   
    
}
<file_sep>﻿using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class enemy1_handler : MonoBehaviour {

    Vector2 velocidad;
    bool is_grounded = false;
    bool plataforma = false;
    bool cooldown = true;
    public float vel_desp;
    public float vel_salto;
    public GameObject bala;
    public GameObject spawns;
    public GameObject laser_spawn;
    public int puntos; //Puntos que otorgara el enemigo al morir
    private Vector2 pos_min;
    private Vector2 pos_max;
    public enum estados { idle, walking, jump, shooting, dead }
    public estados estado_actual = estados.walking;
    enum direcciones { derecha, izquierda, arriba, abajo, derarr, derab, izqarr, izqab }
    direcciones direccion = direcciones.izquierda;

    // Use this for initialization
    void Start () {
        pos_min = GameObject.Find("min").transform.position;
        pos_max = GameObject.Find("max").transform.position;
        GetComponent<Animator>().SetInteger("estado", 7);
        Invoke("disparar", 1.5f);
    }

    // Update is called once per frame
    void Update()
    {
        if (estado_actual != estados.dead) //Si no esta muerto entonces chequeo teclas, etc
        {
            if(estado_actual == estados.walking && is_grounded)
            {
                if(!GetComponent<SpriteRenderer>().flipX)
                {
                    velocidad.x = -vel_desp;
                }
                else
                {
                    velocidad.x = vel_desp;
                }
            }
        }
    }

    public void muerte()
    {
        if (estado_actual != estados.dead) //Si no estaba muerto, muere
        {
            velocidad.x = 0;
            GetComponent<Animator>().SetInteger("estado", 6); //Cambio estado 1 (animacion caminar)
            estado_actual = estados.dead;
            Destroy(gameObject, 1.0f);
        }
    }

    private void FixedUpdate()
    {
        if (!is_grounded)
        {
            velocidad += Physics2D.gravity * Time.deltaTime; //Multiplicamos gravedad * tiempo para obtener velocidad (v = a*t)
        }

        GetComponent<Rigidbody2D>().position += velocidad * Time.deltaTime;
        check_limites();
    }

    void check_limites()
    {
        if (GetComponent<Rigidbody2D>().position.x > pos_max.x)
        {
            GetComponent<Rigidbody2D>().position = new Vector2(pos_max.x, GetComponent<Rigidbody2D>().position.y);
        }
        else if (GetComponent<Rigidbody2D>().position.x < pos_min.x)
        {
            GetComponent<Rigidbody2D>().position = new Vector2(pos_min.x, GetComponent<Rigidbody2D>().position.y);
        }
    }

    private void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.gameObject.tag == "Suelo" || (collision.gameObject.tag == "Plataforma" && velocidad.y < 0))
        {
            if (!is_grounded)
            {
                is_grounded = true;
                velocidad.y = 0;

                GetComponent<Animator>().SetInteger("estado", 0); //Cambio estado 1 (animacion caminar)

                if (collision.gameObject.tag == "Plataforma")
                    plataforma = true;
                else
                    plataforma = false;

                if (estado_actual == estados.dead)
                    velocidad.x = 0;
            }
        }
        else if (collision.gameObject.tag == "Plataforma" && velocidad.y > 0)
        {
            GetComponent<Animator>().SetInteger("estado", 5); //Cambio estado trepar
            velocidad.y += vel_salto * 1.0f;
        }

        if (collision.gameObject.tag == "Obstaculo") //Si colisiona un obstaculo
        {
            velocidad.x = 0; //Velocidad en X es 0 (no avanza)
            RaycastHit2D col = Physics2D.Raycast(new Vector2(laser_spawn.transform.position.x, laser_spawn.transform.position.y), new Vector2(0, 1)); //Creamos Raycast (suerte de laser) para detectar plataforma sup
            
            if (col != null && col.collider != null) //Si colisiono con algo y no estoy tratando de detectar la nada misma
            {
                if (col.collider.gameObject.tag == "Plataforma")
                {
                    if(is_grounded)
                        saltar();
                }
            }

            GetComponent<SpriteRenderer>().flipX = !GetComponent<SpriteRenderer>().flipX; //Hago el volteado contrario (opuesto)
        }

        if(estado_actual != estados.dead && collision.gameObject.tag == "Bala_J") //Si colisiono con bala de jugador
        {
            GameObject.Find("GameHandler").GetComponent<game_handler>().asignar_puntos(collision.gameObject.GetComponent<bala>().n_jugador, puntos); //Asignamos puntos al jugador que lo mato
            muerte();
        }
    }

    private void OnCollisionExit2D(Collision2D collision) //Al salir de colision
    {
        if ((collision.gameObject.tag == "Plataforma" || collision.gameObject.tag == "Obstaculo") && velocidad.y <= 0) //Chequeo si el objeto del cual sali es una plataforma u obstaculo
        {
            if (collision.transform.position.y < transform.position.y)
            {
                is_grounded = false; //Habilito la caida
                GetComponent<Animator>().SetInteger("estado", 7); //Estado cayendo (animacion)
            }
        }
    }

    void saltar()
    {
        velocidad.x = 0;
        GetComponent<Animator>().SetInteger("estado", 7); //Cambio estado 2 (animacion jump)
        velocidad.y += vel_salto;
        is_grounded = false;
    }


    void disparar()
    {
        if(is_grounded && estado_actual != estados.dead)
        {
            int resultado = Random.Range(0, 11); //Recordar que al ser int el maximo no sera inclusivo (en este caso es de 0 a 10)
            if(resultado > 5)
            {
                estado_actual = estados.shooting;
                velocidad.x = 0;
                GameObject jugador = GameObject.FindGameObjectWithTag("Player").transform.Find("Corazon").gameObject;
                Vector2 distancia = new Vector2(jugador.transform.position.x - Mathf.Abs(transform.position.x), (jugador.transform.position.y - transform.position.y)); //Distancia entre enemigo y jugador (Vector)
                if(distancia.x > 0)
                {
                    GetComponent<SpriteRenderer>().flipX = true;
                }
                else
                {
                    GetComponent<SpriteRenderer>().flipX = false;
                }
                float angulo = Mathf.Atan2(distancia.y, distancia.x); //Utilizo Pitagoras (Tang Ang = Op / Ady) para obtener el angulo al que tendria que apuntar
                angulo *= Mathf.Rad2Deg;
                if(angulo < 0f)
                    angulo += 360;

                angulo = Mathf.Round(angulo / 45); //Esto es para que solo pueda rotar cada 45°
                angulo *= 45;

                Vector3 spawn_bala = determinar_posicion(angulo); //Determinare el punto de spawn de la bala

                GameObject newBala = Instantiate(bala, spawn_bala, Quaternion.identity);
                newBala.GetComponent<bala>().asignar_velocidad(angulo);
                newBala.tag = "Bala_E"; //Le pongo etiqueta de Bala_E (bala enemigo)
                Invoke("cooldown_reincorporarse", 1.0f); //Reincorporo para correr
            }
        }

        Invoke("disparar", 1.5f);
    }

    void cooldown_reincorporarse()
    {
        estado_actual = estados.walking;
        GetComponent<Animator>().SetInteger("estado", 0);
    }

    Vector3 determinar_posicion(float angulo)
    {
        if(angulo == 0)
        {
            GetComponent<Animator>().SetInteger("estado", 3);
            return spawns.transform.Find("Spawn_D").transform.position;
        }
        else if(angulo == 90)
        {
            GetComponent<Animator>().SetInteger("estado", 1);
            return spawns.transform.Find("Spawn_AR").transform.position;
        }
        else if(angulo == 180)
        {
            GetComponent<Animator>().SetInteger("estado", 3);
            return spawns.transform.Find("Spawn_I").transform.position;
        }
        else if(angulo == 270)
        {
            GetComponent<Animator>().SetInteger("estado", 4);
            return spawns.transform.Find("Spawn_AB").transform.position;
        }
        else if(angulo == 45)
        {
            GetComponent<Animator>().SetInteger("estado", 2);
            return spawns.transform.Find("Spawn_DARR").transform.position;
        }
        else if(angulo == 135)
        {
            GetComponent<Animator>().SetInteger("estado", 2);
            return spawns.transform.Find("Spawn_IARR").transform.position;
        }     
        else if(angulo == 225)
        {
            GetComponent<Animator>().SetInteger("estado", 4);
            return spawns.transform.Find("Spawn_IAB").transform.position;
        }
        else if(angulo == 315)
        {
            GetComponent<Animator>().SetInteger("estado", 4);
            return spawns.transform.Find("Spawn_DAB").transform.position;
        }
            

        return new Vector3(0,0,0);
    }


    void habilitar_cooldown()
    {
        cooldown = true;
       GetComponent<Animator>().SetInteger("estado", 0);
    }


    public void check_direccion(Vector3 posicion)
    {
        GameObject newBala = Instantiate(bala, posicion, Quaternion.identity);

        switch (direccion)
        {
            case direcciones.derecha:
                newBala.GetComponent<bala>().asignar_velocidad(0);
                break;

            case direcciones.izquierda:
                newBala.GetComponent<bala>().asignar_velocidad(180);
                break;

            case direcciones.arriba:
                newBala.GetComponent<bala>().asignar_velocidad(90);
                break;

            case direcciones.abajo:
                newBala.GetComponent<bala>().asignar_velocidad(270);
                break;

            case direcciones.derab:
                newBala.GetComponent<bala>().asignar_velocidad(315);
                break;

            case direcciones.derarr:
                newBala.GetComponent<bala>().asignar_velocidad(45);
                break;

            case direcciones.izqab:
                newBala.GetComponent<bala>().asignar_velocidad(225);
                break;

            case direcciones.izqarr:
                newBala.GetComponent<bala>().asignar_velocidad(135);
                break;
        }
    }

    private void OnBecameInvisible() //Al salir de la camara
    {
        Destroy(gameObject); //Destruye el objeto
    }
}
<file_sep>﻿using System.Collections;
using System.Collections.Generic;
using UnityEngine;


public class player_handler : MonoBehaviour {

    Vector2 velocidad;
    bool is_grounded = false;
    bool plataforma = false;
    bool cooldown = true;
    public int player_n;
    public float vel_desp;
    public float vel_salto;
    public GameObject spr1;
    public GameObject bala;
    public GameObject spr2;
    public GameObject spawns;
    public GameObject spr_sup;
    public GameObject spr_inf;
    public GameObject ref_colA;
    public GameObject ref_colI;
    public GameObject ref_posA;
    public GameObject ref_posI;
    public GameObject ref_flipV;
    public GameObject ref_flipF;
    Vector2 last_collider;
    public List<KeyCode> tecla;
    private Vector2 pos_min;
    private Vector2 pos_max;
    enum estados { idle, walking, jump, dead }
    estados estado_actual = estados.idle;
    bool[] teclas = { false, false, false, false }; //0 Arriba, 1 Abajo,2 Izquierda, 3 Derecha
    enum direcciones {derecha,izquierda,arriba,abajo,derarr,derab,izqarr,izqab }
    direcciones direccion = direcciones.derecha;

    void Start() { //Bloque
        pos_min = GameObject.Find("min").transform.position;
        pos_max = GameObject.Find("max").transform.position;
        GetComponent<Animator>().SetInteger("estado", 2);
        spr2.transform.position += new Vector3(-0.09f, 0, 0);
    }
	
	void Update () { //Actualizar

        if (estado_actual != estados.dead) //Si no esta muerto entonces chequeo teclas, etc
        {
            Vector3 posicion = transform.position; //Creamos una variable para copiar la posicion del transform provisoriamente
                                                   //SI presiono tal tecla hace tal cosa
            if (Input.GetKeyDown(tecla[1]) && GetComponent<Animator>().GetInteger("estado") != 3)
            {
                teclas[2] = true;
                velocidad.x = -vel_desp;
                if (!spr1.GetComponent<SpriteRenderer>().flipX)
                {
                    spr1.GetComponent<SpriteRenderer>().flipX = true;
                    spr2.GetComponent<SpriteRenderer>().flipX = true;
                    if (is_grounded)
                        spr2.transform.position += new Vector3(-0.07f, 0, 0);
                    else
                        spr2.transform.position += new Vector3(0.09f, 0, 0);
                }
                if (is_grounded)
                {
                    GetComponent<Animator>().SetInteger("estado", 1); //Cambio estado 1 (animacion walk)
                }
            }

            if (Input.GetKeyDown(tecla[3]) && GetComponent<Animator>().GetInteger("estado") != 3)
            {
                teclas[3] = true;
                velocidad.x = vel_desp;
                if (spr1.GetComponent<SpriteRenderer>().flipX)
                {
                    spr1.GetComponent<SpriteRenderer>().flipX = false;
                    spr2.GetComponent<SpriteRenderer>().flipX = false;
                    if (is_grounded)
                        spr2.transform.position += new Vector3(+0.07f, 0, 0);
                    else
                        spr2.transform.position += new Vector3(-0.09f, 0, 0);
                }

                if (is_grounded)
                    GetComponent<Animator>().SetInteger("estado", 1); //Cambio estado 1 (animacion walk)
            }

            if (((Input.GetKeyUp(tecla[1]) && velocidad.x < 0) || (Input.GetKeyUp(tecla[3]) && velocidad.x > 0)))
            {
                velocidad.x = 0.0f;
                if (is_grounded)
                    GetComponent<Animator>().SetInteger("estado", 0); //Cambio estado 1 (animacion walk)
            }

            if (Input.GetKeyDown(tecla[2]) && is_grounded)
            {
                velocidad.x = 0.0f;
                GetComponent<Animator>().SetInteger("estado", 3); //Agacha
                spr2.transform.position = ref_posA.transform.position;
                transform.position += new Vector3(0, -0.2f, 0);
                GetComponent<BoxCollider2D>().offset = ref_colA.GetComponent<BoxCollider2D>().offset;
                GetComponent<BoxCollider2D>().size = ref_colA.GetComponent<BoxCollider2D>().size;

                if (spr1.GetComponent<SpriteRenderer>().flipX)
                {
                    spr2.transform.position = new Vector2(ref_flipV.transform.position.x, spr2.transform.position.y);
                }
                else
                {
                    spr2.transform.position = new Vector2(ref_flipF.transform.position.x, spr2.transform.position.y);
                }
            }

            if (Input.GetKeyUp(tecla[2]) && (GetComponent<Animator>().GetInteger("estado") == 3 || GetComponent<Animator>().GetInteger("estado") == 0 || GetComponent<Animator>().GetInteger("estado") == 1))
            {
                GetComponent<Animator>().SetInteger("estado", 0); //Idle
                
                transform.position += new Vector3(0, 0.2f, 0);
                if(spr1.GetComponent<SpriteRenderer>().flipX)
                {
                    spr2.transform.position = ref_flipV.transform.position;
                }
                else
                {
                    spr2.transform.position = ref_flipF.transform.position;
                }
                GetComponent<BoxCollider2D>().offset = ref_colI.GetComponent<BoxCollider2D>().offset;
                GetComponent<BoxCollider2D>().size = ref_colI.GetComponent<BoxCollider2D>().size;
            }

            if (Input.GetKeyDown(tecla[0]))
                teclas[0] = true;

            if (Input.GetKeyDown(tecla[2]))
                teclas[1] = true;

            if (Input.GetKeyUp(tecla[1]))
                teclas[2] = false;

            if (Input.GetKeyUp(tecla[3]))
                teclas[3] = false;

            if (Input.GetKeyUp(tecla[0]))
                teclas[0] = false;

            if (Input.GetKeyUp(tecla[2]))
                teclas[1] = false;


            if (Input.GetKeyUp(tecla[5]) && is_grounded) //Salto
            {
                if (GetComponent<Animator>().GetInteger("estado") != 3)
                {
                    GetComponent<Animator>().SetInteger("estado", 2); //Cambio estado 2 (animacion jump)
                    velocidad.y += vel_salto;
                    is_grounded = false;

                    if (!spr1.GetComponent<SpriteRenderer>().flipX)
                    {
                        spr2.transform.position += new Vector3(-0.09f, 0, 0);
                    }
                    else
                    {
                        spr2.transform.position += new Vector3(0.09f, 0, 0);
                    }
                }
                else if (plataforma) //Si esta agachado voy a querer ver si esta en plataforma para bajarlo
                {
                    plataforma = false;
                    GetComponent<Animator>().SetInteger("estado", 2);
                    spr2.transform.position += new Vector3(0, -0.0911f, 0);
                    is_grounded = false;

                    if (!spr1.GetComponent<SpriteRenderer>().flipX)
                    {
                        spr2.transform.position += new Vector3(-0.09f, 0, 0);
                    }
                    else
                    {
                        spr2.transform.position += new Vector3(0.09f, 0, 0);
                    }
                }
            }

            if (Input.GetKeyDown(tecla[4]) && cooldown)
            {

                cooldown = false;
                chequear_teclas();
                Invoke("habilitar_cooldown", 0.5f);
            }
        }
	}


    public void muerte()
    {
        if (estado_actual != estados.dead) //Si no estaba muerto, entonces muere
        {
            GetComponent<Animator>().SetInteger("estado", 5); //Cambio estado 1 (animacion caminar)
            spr_sup.GetComponent<Animator>().SetInteger("estado", 7);
            estado_actual = estados.dead;
            GameObject.Find("GameHandler").GetComponent<game_handler>().set_vidas(-1, player_n-1); //Quitamos vida al jugador
            string nombre_spawn = "spawn_j" + player_n;
            GameObject.Find(nombre_spawn).transform.position = Camera.main.transform.position;
            Destroy(gameObject, 2.0f);
        }
    }

    private void FixedUpdate()
    {

        detectar_suelo();
        detectar_obstaculo();

        if (!is_grounded)
        {
            velocidad += Physics2D.gravity * Time.deltaTime; //Multiplicamos gravedad * tiempo para obtener velocidad (v = a*t)
        }
        
        GetComponent<Rigidbody2D>().position += velocidad * Time.deltaTime;
        check_limites();
    }


    void detectar_obstaculo()
    {
        RaycastHit2D col;
        if (!spr1.GetComponent<SpriteRenderer>().flipX)
            col = Physics2D.Raycast(new Vector2(transform.Find("Pies").transform.position.x, transform.Find("Pies").transform.position.y), new Vector2(1, 0));
        else
            col = Physics2D.Raycast(new Vector2(transform.Find("Pies").transform.position.x, transform.Find("Pies").transform.position.y), new Vector2(-1, 0));
        if (col && col.transform.tag == "Obstaculo") //Si colisiona un obstaculo
        {
            if (Mathf.Abs(col.point.x - transform.Find("Pies").transform.position.x) < 0.08f)
            {
                Debug.Log(col.point.x - transform.Find("Corazon").transform.position.x);
                velocidad.x = 0; //Velocidad en X es 0 (no avanza)
                if (GetComponent<Animator>().GetInteger("estado") == 1) //Si estaba caminando
                {
                    GetComponent<Animator>().SetInteger("estado", 0); //Lo pongo en reposo
                }

                if (!spr1.GetComponent<SpriteRenderer>().flipX)
                {
                    transform.position += new Vector3(-0.09f, 0, 0);
                }
                else
                {
                    transform.position += new Vector3(0.09f, 0, 0);
                }
            }
        }
    }

    void detectar_suelo()
    {
        RaycastHit2D col = Physics2D.Raycast(new Vector2(transform.Find("Corazon").transform.position.x, transform.Find("Corazon").transform.position.y), new Vector2(0, -10));
   
        if (col && GetComponent<Animator>().GetInteger("estado") != 3 && (col.collider.tag == "Suelo" || col.collider.tag == "Plataforma" || col.collider.tag == "Obstaculo"))
        {
            last_collider = col.point;
            if (Mathf.Abs(col.point.y - transform.Find("Pies").transform.position.y) > 0.05f && is_grounded) //Si la distancia entre pies y collider (suelo) es mayor a 10
            {
                cayendo();
            }
            else if(Mathf.Abs(col.point.y - transform.Find("Pies").transform.position.y) <= 0.03f)
            {
              
                transform.position = new Vector3(transform.position.x, col.point.y + (transform.position.y - transform.Find("Pies").transform.position.y) + 0.03f, transform.position.z);


                if (col.transform.tag == "Suelo" || (col.transform.tag == "Obstaculo" && velocidad.y < 0) || (col.transform.tag == "Plataforma" && velocidad.y < 0))
                {
                    if (!is_grounded)
                    {
                        is_grounded = true;
                        velocidad.y = 0;

                        if (velocidad.x != 0) //Si la velocidad es diferente a 0, es porque me estoy moviendo hacia algun lado
                            GetComponent<Animator>().SetInteger("estado", 1); //Cambio estado 1 (animacion caminar)
                        else
                            GetComponent<Animator>().SetInteger("estado", 0); //Cambio estado 0 (animacion idle)

                        spr_sup.GetComponent<Animator>().SetInteger("estado", 0); //CAmbio a idle la parte de arriba tambien

                        if (!spr1.GetComponent<SpriteRenderer>().flipX)
                        {
                            spr2.transform.position += new Vector3(0.09f, 0, 0);
                        }
                        else
                        {
                            spr2.transform.position += new Vector3(-0.09f, 0, 0);
                        }

                        if (col.transform.tag == "Plataforma")
                            plataforma = true;
                        else
                            plataforma = false;

                        if (estado_actual == estados.dead)
                            velocidad.x = 0;
                    }
                }
    

            }
        }
        else
        {
            if(GetComponent<Animator>().GetInteger("estado") != 3)
                transform.position = new Vector3(transform.position.x, last_collider.y + (transform.position.y - transform.Find("Pies").transform.position.y) + 0.1f, transform.position.z);
        }
    }

    private void OnCollisionEnter2D(Collision2D collision)
    {
        
        if (collision.gameObject.transform.tag == "Bala_E" || collision.gameObject.transform.tag == "Enemigo") //Si colisiono con bala de enemigo
        {
            if (collision.gameObject.transform.tag == "Enemigo" && collision.gameObject.transform.GetComponent<enemy1_handler>().estado_actual == enemy1_handler.estados.dead)
            {
                return; //Salgo y no ejecuto muerte porque el enemigo ya esta muerto y no quiero que afecte al personaje
            }
            muerte();

            if (is_grounded) //Si esta en el suelo cuando murio
                velocidad.x = 0; //Detener
        }
        else if (collision.gameObject.transform.tag == "Plataforma" && velocidad.y > 0 && teclas[0] == true)
        {
            GetComponent<Animator>().SetInteger("estado", 4); //Cambio estado trepar
            spr_sup.GetComponent<Animator>().SetInteger("estado", 6);
            velocidad.y += vel_salto * 1.2f;
        }
        
    }

    void check_limites()
    {
        if(GetComponent<Rigidbody2D>().position.x > pos_max.x)
        {
            GetComponent<Rigidbody2D>().position = new Vector2(pos_max.x, GetComponent<Rigidbody2D>().position.y);
        }
        else if(GetComponent<Rigidbody2D>().position.x < pos_min.x)
        {
            GetComponent<Rigidbody2D>().position = new Vector2(pos_min.x, GetComponent<Rigidbody2D>().position.y);
        }

        float ancho_camara = Camera.main.aspect * Camera.main.orthographicSize; //Obtengo mitad del ancho de la camara segun su relacion de aspecto en la proyeccion ortografica

        if (GetComponent<Rigidbody2D>().position.x < Camera.main.transform.position.x - ancho_camara) //Si me fui en X al inferior de la camara entonces
        {
            GetComponent<Rigidbody2D>().position = new Vector2(Camera.main.transform.position.x - ancho_camara, GetComponent<Rigidbody2D>().position.y);
        }

        if (GetComponent<Rigidbody2D>().position.x > GameObject.Find("cam_max").transform.position.x) //Si me fui en X al inferior de la camara entonces
        {
            GetComponent<Rigidbody2D>().position = new Vector2(GameObject.Find("cam_max").transform.position.x, GetComponent<Rigidbody2D>().position.y);
        }
    }






    void cayendo()
    {
        is_grounded = false; //Habilito la caida
        GetComponent<Animator>().SetInteger("estado", 2); //Estado cayendo (animacion)

        if (!spr1.GetComponent<SpriteRenderer>().flipX)
        {
            spr2.transform.position += new Vector3(-0.09f, 0, 0);
        }
        else
        {
            spr2.transform.position += new Vector3(0.09f, 0, 0);
        }
    }

    void habilitar_cooldown()
    {
        cooldown = true;
        spr_sup.GetComponent<Animator>().SetInteger("estado", 0);
    }

    void chequear_teclas()
    {
        Vector3 posicion = new Vector3();

        if (teclas[0]) //Arriba
        {
            if (teclas[2])
            {
                direccion = direcciones.izqarr;
                spr_sup.GetComponent<Animator>().SetInteger("estado", 2);
                posicion = spawns.transform.Find("Spawn_IARR").transform.position;
            }
            else if (teclas[3])
            {
                direccion = direcciones.derarr;
                spr_sup.GetComponent<Animator>().SetInteger("estado", 2);
                posicion = spawns.transform.Find("Spawn_DARR").transform.position;
            }
            else
            {
                direccion = direcciones.arriba;
                spr_sup.GetComponent<Animator>().SetInteger("estado", 4);
                posicion = spawns.transform.Find("Spawn_AR").transform.position;
            }

        }
        else if (teclas[1]) //Abajo
        {
            if (teclas[2])
            {
                direccion = direcciones.izqab;
                spr_sup.GetComponent<Animator>().SetInteger("estado", 3);
                posicion = spawns.transform.Find("Spawn_IAB").transform.position;
            }

            else if (teclas[3])
            {
                direccion = direcciones.derab;
                spr_sup.GetComponent<Animator>().SetInteger("estado", 3);
                posicion = spawns.transform.Find("Spawn_DAB").transform.position;
            }
            else
            {
                direccion = direcciones.abajo;
                spr_sup.GetComponent<Animator>().SetInteger("estado", 5);
                posicion = spawns.transform.Find("Spawn_AB").transform.position;
                
            }

        }
        else if (teclas[2]) //Izquierda
        {
            direccion = direcciones.izquierda;
            spr_sup.GetComponent<Animator>().SetInteger("estado", 1);
            posicion = spawns.transform.Find("Spawn_I").transform.position;
            
        }
        else if (teclas[3]) //Derecha
        {
            direccion = direcciones.derecha;
            spr_sup.GetComponent<Animator>().SetInteger("estado", 1);
            posicion = spawns.transform.Find("Spawn_D").transform.position;
        }
        else
        {
            spr_sup.GetComponent<Animator>().SetInteger("estado", 1);
            if(spr1.GetComponent<SpriteRenderer>().flipX)
            {
                posicion = spawns.transform.Find("Spawn_I").transform.position;
                direccion = direcciones.izquierda;
            }
            else
            {
                posicion = spawns.transform.Find("Spawn_D").transform.position;
                direccion = direcciones.derecha;

            }
                
        }

        check_direccion(posicion);


    }

    public void check_direccion(Vector3 posicion)
    {
        GameObject newBala = Instantiate(bala, posicion, Quaternion.identity);
        newBala.GetComponent<bala>().n_jugador = 0; //Le identificamos la bala como del player 0 (player 1)

        switch (direccion)
        {
            case direcciones.derecha:
                newBala.GetComponent<bala>().asignar_velocidad(0);
                break;

            case direcciones.izquierda:
                newBala.GetComponent<bala>().asignar_velocidad(180);
                break;

            case direcciones.arriba:
                newBala.GetComponent<bala>().asignar_velocidad(90);
                break;

            case direcciones.abajo:
                newBala.GetComponent<bala>().asignar_velocidad(270);
                break;

            case direcciones.derab:
                newBala.GetComponent<bala>().asignar_velocidad(315);
                break;

            case direcciones.derarr:
                newBala.GetComponent<bala>().asignar_velocidad(45);
                break;

            case direcciones.izqab:
                newBala.GetComponent<bala>().asignar_velocidad(225);
                break;

            case direcciones.izqarr:
                newBala.GetComponent<bala>().asignar_velocidad(135);
                break;
        }
    }
}
<file_sep>﻿using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class cam_trigger : MonoBehaviour {

    public bool minmax; //Min falso, Max verdadero

	// Use this for initialization
	void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {
		
	}

    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.transform.tag == "Player")
        {
            if(minmax)
            {
                transform.parent.GetComponent<camara_handler>().max_act = true;
            }
            else
            {
                transform.parent.GetComponent<camara_handler>().min_act = true;
            }
        }
    }

    private void OnTriggerExit2D(Collider2D collision)
    {
        if (collision.transform.tag == "Player")
        {
            if(minmax)
            {
                transform.parent.GetComponent<camara_handler>().max_act = false;
            }
            else
            {
                transform.parent.GetComponent<camara_handler>().min_act = false;
            }
        }
    }
}
<file_sep>﻿using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class level_handler : MonoBehaviour {

    public GameObject min;
    public GameObject max;

	// Use this for initialization
	void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {
		
	}
}
