Neugier Battles - Wintergarnele Studios

Programación Orientada a Objetos (Tower defense - kingdom rush)

Moderator: julianmartinez16

User avatar
wintuh
Posts: 32
Joined: Tue Jan 22, 2019 12:13 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by wintuh » Fri Feb 22, 2019 3:38 am

21/02/2019

Image Animación: Ciclo de correr constructor

Image Animación: Idle de constructor
Image Animación: Cuadros implementados

Image Diseño: Base del mapa
Programación y diseño orientado a objetos (pdoo1)

Martín Jaramillo Nicholls

User avatar
wintuh
Posts: 32
Joined: Tue Jan 22, 2019 12:13 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by wintuh » Fri Feb 22, 2019 3:45 am

Más evidencia del Sprint #3

Programación y diseño orientado a objetos (pdoo1)

Martín Jaramillo Nicholls

User avatar
Gamba04
Posts: 23
Joined: Tue Jan 22, 2019 12:14 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by Gamba04 » Fri Feb 22, 2019 3:46 am

Seguimiento

¿Qué hemos hecho?
  • Programación: Se integró el personaje "constructor", un tipo de tropa diferente a las demás encargado de contruir las torretas. Esta tropa se instancia de la misma manera que las otras tropas pero solo pueden haber máximo 3 de estas a la vez. EL constructor va hacia una torreta si se solicita que se construya, mientras que hay un constructor llendo hacia una torreta o esta ya se construyo, ningun constructor podrá ir a esa torreta, y tampoco podrá ir el constructor en camino a otra torreta hasta que no termine su trabajo inicial. Cuando terminan su trabajo estos se devuelven a una zona segura establecida, separandose los unos de los otros en esta zona segura. El jugador puede seleccionar que constructor controlar y alternar entre ellos, con un indicador del constructor seleccionado.
    Se adaptó el segundo jugador, fucnionando con teclas diferentes, controlando todo desde el otro lado del mapa, teniendo un recorrido inverso del camino del mapa, se separaron todos los tags y tipos de tropas y torretas para cada jugador para que funcionen como dos sistemas independientes al tiempo. Junto con esto se programó la interacción de las tropas enemigas, de tal manera que se detengan cuando se detecta el enemigo cercano y comienzen a atacarse. Se agregaron indicadores de batalla como un signo de exclamación que indica que se detectó el enemigo, y animaciones básicas de recepción de daño. Las tropas tienen asignados valores de vida, ataque y rango que se podrán modificar para cada tipo de tropa futuramente. Al morir las tropas se destruyen y se desasignan de los grupos que las controlaban para que estos puedan reasignar tropas en ellos.
    Se programaron animaciones de Idle y movimiento al constructor.
    Se corrigieron errores variados.

    Animacion y diseño: Se hizo las respectivas animaciones del constructor. Se hizo la base del mapa. Se hizo un diseño básico del HUD con información básica de los controles para cada jugador, donde se muestra que tropa o torreta se tiene seleccionada. Se reemplazaron los sprites de seleccion de torretas, ubicación de las tropas y selección del constructor.
¿Qué se va a hacer?
  • Próximamente vamos a implementar una tropa distinta que servirá de primera línea de defensa para el juego, el tanque. Pasará por un proceso de diseño al cuál luego se programará y animará para ponerlo en el juego con su parte en el HUD. Al igual que una tropa de mayor rango, el arquero, quien podrá disparar flechas para atacar al enemigo a distancia y hacerle daño a las torretas enemigas cuando no hay enemigos cerca. Se programará el espacio para la torreta del centro, de tal manera que sólo un jugador pueda tener una torreta ahí al tiempo, y después de cierto tiempo inicial. Se añadirán y sofisticarán las animaciones para mayor fluidez y se revisará que el juego para 2 jugadores sea claro y eficiente, adaptando sistemas de información que estarán ubicados en las barras de información.
Dificultades
  • Se complicó más de la cuenta la adaptación a dos jugadores, ya que se descuadraron muchas funcionalidades del sistema de controlamiento de las tropas y el control por grupos. Se tuvieron que corregir muchos errores y hubo que reestructurar tanto los códigos como los objetos en el proyecto de Unity. Hubo un poco de complicaciones manejando bien el espacio para la futura información detallada de opciones y detalles de las tropas o torretas, congruente con la decoración del mapa.
Juan Camilo Quintero

POO1

User avatar
Gamba04
Posts: 23
Joined: Tue Jan 22, 2019 12:14 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by Gamba04 » Fri Feb 22, 2019 3:59 am

ControlGeneral.cs

Code: Select all

public class ControlGeneral : MonoBehaviour {

    public KeyCode kIzquierda;
    public KeyCode kDerecha;
    public KeyCode kArriba;
    public KeyCode kAbajo;
    public KeyCode kAlternarD;
    public KeyCode kAlternarI;
    public KeyCode kColocar_Enviar;
    public KeyCode kEliminar;
    public KeyCode kSpawn_Reparar;
    public KeyCode kAlternarConstructor;
    public KeyCode kModo;
    public GameObject grupo;
    public GameObject tropa;
    public bool modotropas;
    public int seleccionnodo;
    public int nodoactivo;
    public GameObject[] espaciostorretas;
    public int seleccionespacio;
    public int espacioarriba;
    public int espacioabajo;
    public int espacioderecha;
    public int espacioizquierda;
    public GameObject[] nodos;
    public int tipotropa;
    public GameObject tropa1;
    public GameObject tropa2;
    public GameObject tropa3;
    public GameObject imagentropa0;
    public GameObject imagentropa1;
    public GameObject imagentropa2;
    public GameObject imagentropa3;
    public int tipotorreta;
    public GameObject imagentorreta1;
    public GameObject imagentorreta2;
    public GameObject imagentorreta3;
    public GameObject constructoractivo;
    public int seleccionconstructor;
    public GameObject constructor;
    public GameObject parentTropas;

    string tag_tropas;
    string tag_constructor;
    string tag_turretslot;
    string tag_Path;
    string tag_grupo;


    void Start () {
        GameObject[] nodosorigen;
        nodosorigen = GameObject.FindGameObjectsWithTag("Path");
        nodos = new GameObject[nodosorigen.Length];
        if (gameObject.name == "Control General A")
        {
            tag_tropas = "TropasA";
            tag_constructor = "ConstructorA";
            tag_turretslot = "Turret SlotA";
            tag_Path = "PathA";
            tag_grupo = "GrupoA";
            //organizacion del array de nodos
            for (int i = 0; i < nodosorigen.Length; i++)
            {
                nodos[int.Parse(nodosorigen[i].name)] = nodosorigen[i];
            }
        }
        if (gameObject.name == "Control General B")
        {
            tag_tropas = "TropasB";
            tag_constructor = "ConstructorB";
            tag_turretslot = "Turret SlotB";
            tag_Path = "PathB";
            tag_grupo = "GrupoB";
            //organizacion del array de nodos
            for (int i = 0; i < nodosorigen.Length; i++)
            {
                nodos[nodosorigen.Length - int.Parse(nodosorigen[i].name) - 1] = nodosorigen[i];
            }
        }

        modotropas = true;
        espaciostorretas = GameObject.FindGameObjectsWithTag(tag_turretslot);

       

        
        tipotropa = 0;
        seleccionconstructor = 1;
    }//Organizar Al revez los nodos del equipo contrario
	
	void Update () {

        grupo = GameObject.FindGameObjectsWithTag(tag_grupo)[GameObject.FindGameObjectsWithTag(tag_grupo).Length - 1];

        if (GameObject.FindGameObjectsWithTag(tag_constructor).Length == 0)
        {
            constructoractivo = null;
            seleccionconstructor = 0;
        }
        else
        {
            if (Input.GetKeyDown(kAlternarConstructor)) seleccionconstructor++;

            if (seleccionconstructor > GameObject.FindGameObjectsWithTag(tag_constructor).Length) seleccionconstructor = 1;

            if (seleccionconstructor == 1) constructoractivo = GameObject.FindGameObjectsWithTag(tag_constructor)[0];
            if (seleccionconstructor == 2) constructoractivo = GameObject.FindGameObjectsWithTag(tag_constructor)[1];
            if (seleccionconstructor == 3) constructoractivo = GameObject.FindGameObjectsWithTag(tag_constructor)[2];

            foreach (GameObject c in GameObject.FindGameObjectsWithTag(tag_constructor)) if (c == constructoractivo) c.GetComponent<Constructor>().resplandor.SetActive(true);
                else c.GetComponent<Constructor>().resplandor.SetActive(false);
        }

        if (modotropas)
        {
            imagentorreta1.SetActive(false);
            imagentorreta2.SetActive(false);
            imagentorreta3.SetActive(false);


            if (Input.GetKeyDown(kAlternarD)) tipotropa++;
            if (Input.GetKeyDown(kAlternarI)) tipotropa--;
            if (tipotropa < 0) tipotropa = 0;
            if (tipotropa > 3) tipotropa = 3;

            if (tipotropa == 0)
            {
                imagentropa0.SetActive(true);
                imagentropa1.SetActive(false);
                imagentropa2.SetActive(false);
                imagentropa3.SetActive(false);
            }
            if (tipotropa == 1)
            {
                tropa = tropa1;
                imagentropa0.SetActive(false);
                imagentropa1.SetActive(true);
                imagentropa2.SetActive(false);
                imagentropa3.SetActive(false);
            }
            if (tipotropa == 2)
            {
                tropa = tropa2;
                imagentropa0.SetActive(false);
                imagentropa1.SetActive(false);
                imagentropa2.SetActive(true);
                imagentropa3.SetActive(false);
            }
            if (tipotropa == 3)
            {
                tropa = tropa3;
                imagentropa0.SetActive(false);
                imagentropa1.SetActive(false);
                imagentropa2.SetActive(false);
                imagentropa3.SetActive(true);
            }
        }
        else
        {
            imagentropa0.SetActive(false);
            imagentropa1.SetActive(false);
            imagentropa2.SetActive(false);
            imagentropa3.SetActive(false);

            if (Input.GetKeyDown(kAlternarD)) tipotorreta++;
            if (Input.GetKeyDown(kAlternarI)) tipotorreta--;
            if (tipotorreta < 1) tipotorreta = 1;
            if (tipotorreta > 3) tipotorreta = 3;

            if (tipotorreta == 1)
            {
                imagentorreta1.SetActive(true);
                imagentorreta2.SetActive(false);
                imagentorreta3.SetActive(false);
            }
            if (tipotorreta == 2)
            {
                imagentorreta1.SetActive(false);
                imagentorreta2.SetActive(true);
                imagentorreta3.SetActive(false);
            }
            if (tipotorreta == 3)
            {
                imagentorreta1.SetActive(false);
                imagentorreta2.SetActive(false);
                imagentorreta3.SetActive(true);
            }

        }
        //spawn tropas
        if (Input.GetKeyDown(kSpawn_Reparar) && modotropas)
        {
            if (tipotropa != 0)
            {
                Instantiate(grupo, transform.position, transform.rotation);
                Instantiate(tropa, transform.position, transform.rotation, parentTropas.transform);
            }
            else
            {
                if (GameObject.FindGameObjectsWithTag(tag_constructor).Length < 3)
                {
                    Instantiate(constructor, constructor.transform.position, constructor.transform.rotation);
                    seleccionconstructor = 1;
                }
            }

        }

        //viesualización del nodo seleccionado
        for (int i = 0; i < nodos.Length; i++)
        {

            if (i == seleccionnodo && modotropas) foreach (Transform t in nodos[i].transform) { if (t.CompareTag(tag_Path)) t.GetComponent<SpriteRenderer>().enabled = true; }
            else
            {
                foreach (Transform t in nodos[i].transform) if (t.CompareTag(tag_Path)) t.GetComponent<SpriteRenderer>().enabled = false;
            }
        }
        //alternar modo
        if (Input.GetKeyDown(kModo)) modotropas = !modotropas;

        //navegación nodo
        if (modotropas)
        {
            if (Input.GetKeyDown(kDerecha)) seleccionnodo++;
            if (Input.GetKeyDown(kIzquierda)) seleccionnodo--;

            if (Input.GetKeyDown(kColocar_Enviar)) nodoactivo = seleccionnodo;
        }
        else
        {
            //navegación torretas
            for (int i = 0; i < espaciostorretas.Length; i++)
            {
                if (espaciostorretas[i].transform.position.y > espaciostorretas[seleccionespacio].transform.position.y + 1 && ((espaciostorretas[i].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude < (espaciostorretas[espacioarriba].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude || espaciostorretas[espacioarriba].transform.position.y <= espaciostorretas[seleccionespacio].transform.position.y + 1))
                {
                    espacioarriba = i;
                }
                if (espaciostorretas[i].transform.position.y < espaciostorretas[seleccionespacio].transform.position.y - 1 && ((espaciostorretas[i].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude < (espaciostorretas[espacioabajo].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude || espaciostorretas[espacioabajo].transform.position.y >= espaciostorretas[seleccionespacio].transform.position.y - 1))
                {
                    espacioabajo = i;
                }
                if (espaciostorretas[i].transform.position.x > espaciostorretas[seleccionespacio].transform.position.x + 1 && ((espaciostorretas[i].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude < (espaciostorretas[espacioderecha].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude || espaciostorretas[espacioderecha].transform.position.x <= espaciostorretas[seleccionespacio].transform.position.x + 1))
                {
                    espacioderecha = i;
                }
                if (espaciostorretas[i].transform.position.x < espaciostorretas[seleccionespacio].transform.position.x - 1 && ((espaciostorretas[i].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude < (espaciostorretas[espacioizquierda].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude || espaciostorretas[espacioizquierda].transform.position.x >= espaciostorretas[seleccionespacio].transform.position.x - 1))
                {
                    espacioizquierda = i;
                }

            }
            if (espaciostorretas[espacioarriba].transform.position.y <= espaciostorretas[seleccionespacio].transform.position.y + 1) espacioarriba = seleccionespacio;
            if (espaciostorretas[espacioabajo].transform.position.y >= espaciostorretas[seleccionespacio].transform.position.y - 1) espacioabajo = seleccionespacio;
            if (espaciostorretas[espacioderecha].transform.position.x <= espaciostorretas[seleccionespacio].transform.position.x + 1) espacioderecha = seleccionespacio;
            if (espaciostorretas[espacioizquierda].transform.position.x >= espaciostorretas[seleccionespacio].transform.position.x - 1) espacioizquierda = seleccionespacio;

            if (Input.GetKeyDown(kArriba)) seleccionespacio = espacioarriba;
            if (Input.GetKeyDown(kIzquierda)) seleccionespacio = espacioizquierda;
            if (Input.GetKeyDown(kAbajo)) seleccionespacio = espacioabajo;
            if (Input.GetKeyDown(kDerecha)) seleccionespacio = espacioderecha;

            if (Input.GetKeyDown(kColocar_Enviar) && GameObject.FindGameObjectsWithTag(tag_constructor).Length != 0)
            {
                if (!constructoractivo.GetComponent<Constructor>().ocupado && espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().disponible && !espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().ocupada)
                {
                    constructoractivo.GetComponent<Constructor>().torreta = espaciostorretas[seleccionespacio].GetComponent<TurretSlot>();
                    espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().tipotorreta = tipotorreta;
                    espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().ocupada = true;
                    constructoractivo.GetComponent<Constructor>().destino = espaciostorretas[seleccionespacio].transform.position;
                    constructoractivo.GetComponent<Constructor>().ocupado = true;
                }
            }
            if (Input.GetKeyDown(kEliminar) && !espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().disponible)
            {
                espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().disponible = true;
            }
        }
        //visualizacion de slot seleccionado
        for (int i = 0; i < espaciostorretas.Length; i++)
        {
            if (i == seleccionespacio && !modotropas) espaciostorretas[i].GetComponent<SpriteRenderer>().enabled = true;
            else espaciostorretas[i].GetComponent<SpriteRenderer>().enabled = false;
        }
        //limites seleccion nodos
        if (seleccionnodo < 0) seleccionnodo = 0;
        if (seleccionnodo > nodos.Length - 1) seleccionnodo = nodos.Length - 1;

       
    }

}

Tropa.cs

Code: Select all

public class Tropa : MonoBehaviour {

    public float dist;
    public int mascercano;
    public GameObject grupo;
    public bool entro;
    public int dir;
    public Vector3 posicionanterior;
    public int vida;
    public Tropa enemigo;

    string tag_Grupo;
    string tag_TropaEnemiga;

    public bool atacando;
    public float rango;

    public GameObject signoexclamacion;
    bool exclamacion;
    int frente;


    void Start () {
        if (gameObject.CompareTag("TropasA"))
        {
            tag_Grupo = "GrupoA";
            tag_TropaEnemiga = "TropasB";
            frente = 1;
        }
        if (gameObject.CompareTag("TropasB"))
        {
            tag_Grupo = "GrupoB";
            tag_TropaEnemiga = "TropasA";
            frente = -1;
        }
        dir = 1;
        //adoptamiento de grupo
        dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[0].transform.position).magnitude);
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_Grupo).Length; i++)
        {
            if (Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[i].transform.position).magnitude) < dist)
            {
                dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[i].transform.position).magnitude);
                mascercano = i;
            }
        }
        grupo = GameObject.FindGameObjectsWithTag(tag_Grupo)[mascercano];

            //Anotarse a la fila
        if (!grupo.GetComponent<Translacion>().lleno)
        {
            for (int i = 0; i < grupo.GetComponent<Translacion>().arraytropas.Length; i++)
            {
                if (!grupo.GetComponent<Translacion>().arraytropas[i])
                {
                    grupo.GetComponent<Translacion>().arraytropas[i] = true;
                    entro = true;
                    break;
                }

            }

        }
        posicionanterior = transform.position;
        StartCoroutine(UpdatePosition());
        StartCoroutine(Ataque());
    }
	
	void Update () {
        //readopatmiento de grupo
        if (grupo == null || (grupo.GetComponent<Translacion>().lleno && !entro))
        {
            entro = false;
            mascercano = 0;
            //dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[0].transform.position).magnitude);
            dist = Mathf.Infinity;
            for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_Grupo).Length; i++)
            {
                if (Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[i].transform.position).magnitude) < dist && !GameObject.FindGameObjectsWithTag(tag_Grupo)[i].GetComponent<Translacion>().lleno)
                {
                    dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[i].transform.position).magnitude);
                    mascercano = i;
                }
            }
            grupo = GameObject.FindGameObjectsWithTag(tag_Grupo)[mascercano].gameObject;
            //Anotarse a la fila
            if (!grupo.GetComponent<Translacion>().lleno)
            {
                for (int i = 0; i < grupo.GetComponent<Translacion>().arraytropas.Length; i++)
                {
                    if (!grupo.GetComponent<Translacion>().arraytropas[i])
                    {
                        grupo.GetComponent<Translacion>().arraytropas[i] = true;
                        entro = true;
                        break;
                    }

                }

            }
        }
        //atracción al grupo
        GetComponent<Rigidbody2D>().AddForce((grupo.transform.position - transform.position) * 20 * Random.Range(0, 20));

        if ((grupo.transform.position - transform.position).magnitude > 2) transform.position = grupo.transform.position;

        if (grupo.GetComponent<Translacion>().frente.x > grupo.GetComponent<Translacion>().atras.x) dir = 1 * grupo.GetComponent<Translacion>().dir;
        if (grupo.GetComponent<Translacion>().frente.x < grupo.GetComponent<Translacion>().atras.x) dir = -1 * grupo.GetComponent<Translacion>().dir;

        transform.localScale = new Vector3(-dir, 1, 1) * 0.4f;

        //enemigo mas cercano
        if (GameObject.FindGameObjectsWithTag(tag_TropaEnemiga).Length > 0)
        {
            mascercano = 0;
            dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_TropaEnemiga)[0].transform.position).magnitude);
            for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_TropaEnemiga).Length; i++)
            {
                if (Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_TropaEnemiga)[i].transform.position).magnitude) < dist)
                {
                    dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_TropaEnemiga)[i].transform.position).magnitude);
                    mascercano = i;
                }
            }
            enemigo = GameObject.FindGameObjectsWithTag(tag_TropaEnemiga)[mascercano].GetComponent<Tropa>();
        }

        //muerte
        if (vida <= 0)
        {
            //Desanotarse de la fila
            for (int i = grupo.GetComponent<Translacion>().arraytropas.Length - 1; i >= 0; i--)
            {
                if (grupo.GetComponent<Translacion>().arraytropas[i])
                {
                    grupo.GetComponent<Translacion>().arraytropas[i] = false;
                    break;
                }

            }
            Destroy(gameObject);
        }
        //atacando
        if ((transform.position - enemigo.transform.position).magnitude <= rango)
        {
            atacando = true;
            grupo.GetComponent<Translacion>().enfrentamiento = true;
            if (!exclamacion)
            {
                exclamacion = true;
                Instantiate(signoexclamacion, transform.position + new Vector3(0.5f * frente, 0.5f, 0), transform.rotation);
            }
        }
        else
        {
            atacando = false;
            exclamacion = false;
        }
    }
    IEnumerator UpdatePosition()
    {
        if (Mathf.Abs((transform.position - posicionanterior).magnitude) > 0.1f)
        {
            GetComponent<Animator>().SetBool("Corriendo", true);
        }
        else
        {
            GetComponent<Animator>().SetBool("Corriendo", false);
        }
        posicionanterior = transform.position;
        yield return new WaitForSeconds(0.5f);
        StartCoroutine(UpdatePosition());
    }

    IEnumerator Ataque()
    {
        if (atacando)
        {
            enemigo.vida--;
            GetComponent<Animator>().SetTrigger("Ataque");
            enemigo.GetComponent<Animator>().SetTrigger("Daño");
        }
        yield return new WaitForSeconds(0.5f);
        grupo.GetComponent<Translacion>().enfrentamiento = false;
        StartCoroutine(Ataque());
    }

}

Translacion.cs

Code: Select all

public class Translacion : MonoBehaviour {


    public GameObject[] nodos;
    public float ubicacionfrontal;
    public float ubicaciontrasera;
    public float separacion;
    public Vector3 frente;
    public Vector3 atras;

    public int nodoactivo;
    public float magnitudactual;
    public float diferenciaubicaciones;

    public bool[] arraytropas;
    public bool lleno;
    public int cantidadtropas;

    public int numerofila;
    public int dir;
    public ControlGeneral cg;
    public bool debugnumerofila;

    float offsettiempo;
    public bool enfrentamiento;

    void Start () {
        offsettiempo = Time.time;
        diferenciaubicaciones = 5;
        ubicacionfrontal = 0;
        arraytropas = new bool[10];
        numerofila = 0;

    }//Reemplazar ControlGeneral y array de Translacion

    void Update() {
        //información de ControlGeneral
        nodos = cg.nodos;
        nodoactivo = cg.nodoactivo;
        
        //float ubicación --> posición real
        for (int i = 0; i < nodos.Length - 1; i++)
        {

            if (ubicacionfrontal >= i * 100f / (nodos.Length - 1) && ubicacionfrontal <= (i + 1) * 100f / (nodos.Length - 1))
            {
                frente = nodos[i].transform.position + (nodos[i + 1].transform.position - nodos[i].transform.position) * ((ubicacionfrontal - i * 100f / (nodos.Length - 1)) / (100f / (nodos.Length - 1)));
                magnitudactual = (nodos[i + 1].transform.position - nodos[i].transform.position).magnitude;
            }

            if (ubicaciontrasera >= i * 100f / (nodos.Length - 1) && ubicaciontrasera <= (i + 1) * 100f / (nodos.Length - 1))
            {
                atras = nodos[i].transform.position + (nodos[i + 1].transform.position - nodos[i].transform.position) * ((ubicaciontrasera - i * 100f / (nodos.Length - 1)) / (100f / (nodos.Length - 1)));

            }

        }

        //voy a hacerme las pastas, anda viendo el codigo <<<<<

        //movimiento hacia nodoactivo
        if (ubicacionfrontal + numerofila * 1.5f < nodoactivo * 100 / (nodos.Length - 1) + 2.5f && !enfrentamiento)
        {
            ubicacionfrontal += 0.05f * separacion / magnitudactual;
            dir = 1;
        }
        if (ubicacionfrontal + numerofila * 1.5f > nodoactivo * 100 / (nodos.Length - 1) + 2.5f)
        {
            ubicacionfrontal -= 0.05f * separacion / magnitudactual;
            dir = -1;
        }

        //limites de ubicacion frontal
        if (ubicacionfrontal < 0) ubicacionfrontal = 0;
        if (ubicacionfrontal > 100) ubicacionfrontal = 100;

        //separacion ubicaciones
        diferenciaubicaciones += (5 / magnitudactual - diferenciaubicaciones) * 0.01f;
        ubicaciontrasera = ubicacionfrontal - diferenciaubicaciones;

        //limite ubicacion trasera
        if (ubicaciontrasera < 0) ubicaciontrasera = 0;

        //posicion grupo
        transform.position = atras + (frente - atras) * 0.5f;


        Debug.DrawRay(atras, frente - atras, Color.white);

        //bool lleno
        lleno = true;
        cantidadtropas = 0;
        foreach (bool b in arraytropas) if (!b) lleno = false; else cantidadtropas++;

        //fusion grupos
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(gameObject.tag).Length; i++)
        {
            if (this == GameObject.FindGameObjectsWithTag(gameObject.tag)[i].GetComponent<Translacion>())
            {
                for (int o = 0; o < GameObject.FindGameObjectsWithTag(gameObject.tag).Length; o++)
                {
                    if (Mathf.Abs(this.ubicacionfrontal - GameObject.FindGameObjectsWithTag(gameObject.tag)[o].GetComponent<Translacion>().ubicacionfrontal) < 1 && i > o && Time.time - offsettiempo > 1)
                    {
                        if (cantidadtropas + GameObject.FindGameObjectsWithTag(gameObject.tag)[o].GetComponent<Translacion>().cantidadtropas <= 10)
                        {
                            Destroy(GameObject.FindGameObjectsWithTag(gameObject.tag)[i].gameObject);
                        }
                        else
                        {
                            numerofila = GameObject.FindGameObjectsWithTag(gameObject.tag)[o].GetComponent<Translacion>().numerofila + 1;
                        }
                    }

                }
            }
            

        }
        //Debug numero fila
        debugnumerofila = false;
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(gameObject.tag).Length; i++)
        {
            if (GameObject.FindGameObjectsWithTag(gameObject.tag)[i].GetComponent<Translacion>().numerofila == numerofila - 1) debugnumerofila = true;
        }
            if (!debugnumerofila && numerofila < 0) numerofila--;
    
    }

    
}

TurretSlot.cs

Code: Select all

public class TurretSlot : MonoBehaviour {

    public bool disponible;
    public bool ocupada;
    public int tipotorreta;
    public GameObject torreta1;
    public GameObject torreta2;
    public GameObject torreta3;

    void Start () {
        disponible = true;
        tipotorreta = 1;
	}
	
	void Update () {
        if (!disponible)
        {
            if (tipotorreta == 1)
            {
                torreta1.SetActive(true);
                torreta2.SetActive(false);
                torreta3.SetActive(false);
            }
            if (tipotorreta == 2)
            {
                torreta1.SetActive(false);
                torreta2.SetActive(true);
                torreta3.SetActive(false);
            }
            if (tipotorreta == 3)
            {
                torreta1.SetActive(false);
                torreta2.SetActive(false);
                torreta3.SetActive(true);
            }
        }
        else
        {
            torreta1.SetActive(false);
            torreta2.SetActive(false);
            torreta3.SetActive(false);
        }
	}
}

SignoExclamacion.cs

Code: Select all

public class SignoExclamacion : MonoBehaviour {

    float a = 1;

	void Start () {
        StartCoroutine(Fade());
	}
	
    IEnumerator Fade()
    {
        yield return new WaitForSeconds(0.7f);
        for (int i = 0; i < 10; i++)
        {
            a -= 0.1f;
            GetComponent<SpriteRenderer>().color = new Color(1, 1, 1, a);
            yield return new WaitForSeconds(0.03f);
        }
        Destroy(gameObject);
    }
}

Constructor.cs

Code: Select all

public class Constructor : MonoBehaviour {

    public ControlGeneral cg;
    public bool ocupado;
    public Vector3 prehome;
    public Vector3 home;
    public Vector3 destino;
    public int dir;
    public int velocidad;
    public TurretSlot torreta;
    public GameObject resplandor;
    public int numero = 0;
    Vector3 posicionanterior;
    string tag_constructor;

    void Start () {
        if (gameObject.CompareTag("ConstructorA"))
        {
            tag_constructor = "ConstructorA";
        }
        if (gameObject.CompareTag("ConstructorB"))
        {
            tag_constructor = "ConstructorB";
        }
        //StartCoroutine(UpdatePosition());
        prehome = transform.position;
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_constructor).Length; i++)
        {
            if (GameObject.FindGameObjectsWithTag(tag_constructor)[i] == gameObject) numero = i;
        }
        home = prehome + Vector3.down * numero * 0.5f;
        destino = home;
        dir = 1;
        velocidad = 1;
	}
	
	void Update () {
        GetComponent<SpriteRenderer>().sortingOrder = numero + 2;
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_constructor).Length; i++)
        {
            if (GameObject.FindGameObjectsWithTag(tag_constructor)[i] == gameObject) numero = i;
        }
        home = prehome + Vector3.down * numero * 0.5f;


        transform.position += (destino - transform.position).normalized * 0.01f * velocidad;

        //instante en el que llega a la torreta
        if ((transform.position - destino).magnitude < 0.1f)
        {
            if (ocupado)
            {
                ocupado = false;
                destino = home;
                torreta.disponible = false;
                torreta.ocupada = false;
                StartCoroutine(DelayConstruir());
            }
            else if ((transform.position - destino).magnitude < 0.02f)
            {
                transform.position = destino;
                GetComponent<Animator>().SetBool("Corriendo", false);
            }
        }
        else
        {
            GetComponent<Animator>().SetBool("Corriendo", true);
        }
        //cambio de direccion
        if (destino.x >= transform.position.x) dir = 1;
        else dir = -1;

        transform.localScale = new Vector3(-dir, 1, 1);
	}
    IEnumerator DelayConstruir()
    {
        velocidad = 0;
        yield return new WaitForSeconds(0.5f);
        velocidad = 1;
    }

    IEnumerator UpdatePosition()
    {
        if (Mathf.Abs((transform.position - posicionanterior).magnitude) > 0.1f)
        {
            GetComponent<Animator>().SetBool("Corriendo", true);
        }
        else
        {
            GetComponent<Animator>().SetBool("Corriendo", false);
        }
        posicionanterior = transform.position;
        yield return new WaitForSeconds(0.5f);
        StartCoroutine(UpdatePosition());
    }
}
Juan Camilo Quintero

POO1

User avatar
wintuh
Posts: 32
Joined: Tue Jan 22, 2019 12:13 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by wintuh » Tue Feb 26, 2019 12:17 am

Sprint #4

Fecha inicio: 21/03/2019
Fecha de finalización: 28/03/2019

Actividad #1
Programación de tropas nuevas y hud
  • Características base tanque y arquero (Juan Camilo) :: 1
  • Ataque a distancia hacia las tropas del arquero (Juan Camilo) :: 3
  • Ataque a distancia hacia torretas (Juan Camilo) :: 4
  • Muerte Constructor (Juan Camilo) :: 4
  • Detallar información en el hud (Martín) :: 2
Actividad #2
Animación y diseño de las tropas nuevas
  • Constructor: Creación torreta (Martín) :: 3
  • Tierra: Puñitos (Martín) :: 2
  • Tank: Caminata y manotazo (Martín) :: 3
  • Concept y sprite: base del archer (Martín) :: 2
  • Sprite flechita (Juan Camilo) :: 2
  • Instructor diseño
Programación y diseño orientado a objetos (pdoo1)

Martín Jaramillo Nicholls

User avatar
wintuh
Posts: 32
Joined: Tue Jan 22, 2019 12:13 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by wintuh » Tue Feb 26, 2019 11:57 pm

Avance de animación

Image

Image Image Image Image
Programación y diseño orientado a objetos (pdoo1)

Martín Jaramillo Nicholls

User avatar
wintuh
Posts: 32
Joined: Tue Jan 22, 2019 12:13 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by wintuh » Thu Feb 28, 2019 11:54 pm

Seguimiento

¿Qué hemos hecho?
  • Programación: Se programó el comportamiento del tanque y del arquero. Respectivamente, el primero es más resistente pero a su vez, hace menos daño, el segundo, hace más daño porque tiene un ritmo de ataque más elevado, puede atacar a distancia pero es muy vulnerable ya que muere de un golpe. El ataque a distancia permite que las tropas puedan atacar desde una distancia segura, y también atacar las torretas. Se implementó un sistema de salud de constructor y torretas, haciendo que estas puedan ser derrotados/derribadas apropiadamente. A su vez, se detalló que información sobre que irá en el hud, y se programó para que se muestre respectivo a las opciones posibles en cada situación. Se implementó un sistema para que el hud del juego se escale con respecto a cada pantalla existente en el planeta (Siempre y cuando conserve proporción).
  • Animación: Se animaron ciclos de construcción para el constructor y refinaron las sombras de estos. La tropa tierra ya puede golpear con un ciclo de 4 frames. El tanque tiene ciclo de caminar y de idle.
¿Qué vamos a hacer?
  • Vamos a hacer ataques de torretas de diferentes tipos de torretas, organizar lo que concierna la torreta de la mitad del mapa, separar capas del mapa para crear varios sprites que se sobrepongan sobre otros. Se añadirán las animaciones básicas del arquero. Se mostrarán diferentes etapas de las torretas correspondiente al daño que le hayan hecho. Animación de construcción refinada.
Dificultades:
Fue difícil ajustar las tropas para atacar a las torretas correctamente y a los constructores, además de dificultades en la reorganización de los constructores después de morir.


Image
Animación Idle del constructor

Image
Animación walk cycle
Programación y diseño orientado a objetos (pdoo1)

Martín Jaramillo Nicholls

User avatar
wintuh
Posts: 32
Joined: Tue Jan 22, 2019 12:13 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by wintuh » Fri Mar 01, 2019 2:26 am

Gameplay de elementos hasta ahora:

Programación y diseño orientado a objetos (pdoo1)

Martín Jaramillo Nicholls

User avatar
Gamba04
Posts: 23
Joined: Tue Jan 22, 2019 12:14 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by Gamba04 » Fri Mar 01, 2019 2:27 am

ConstrolGeneral.cs

Code: Select all

public class ControlGeneral : MonoBehaviour {

    public KeyCode kIzquierda;
    public KeyCode kDerecha;
    public KeyCode kArriba;
    public KeyCode kAbajo;
    public KeyCode kAlternarD;
    public KeyCode kAlternarI;
    public KeyCode kColocar_Enviar;
    public KeyCode kEliminar;
    public KeyCode kSpawn_Reparar;
    public KeyCode kAlternarConstructor;
    public KeyCode kModo;
    public GameObject grupo;
    public GameObject tropa;
    public bool modotropas;
    public int seleccionnodo;
    public int nodoactivo;
    public GameObject[] espaciostorretas;
    public int seleccionespacio;
    public int espacioarriba;
    public int espacioabajo;
    public int espacioderecha;
    public int espacioizquierda;
    public GameObject[] nodos;
    public int tipotropa;
    public GameObject tropa1;
    public GameObject tropa2;
    public GameObject tropa3;
    public GameObject imagentropa0;
    public GameObject imagentropa1;
    public GameObject imagentropa2;
    public GameObject imagentropa3;
    public int tipotorreta;
    public GameObject imagentorreta1;
    public GameObject imagentorreta2;
    public GameObject imagentorreta3;
    public GameObject constructoractivo;
    public int seleccionconstructor;
    public GameObject constructor;
    public GameObject parentTropas;

    string tag_tropas;
    string tag_constructor;
    string tag_turretslot;
    string tag_Path;
    string tag_grupo;

    int lado;
    public GameObject hud1;
    public GameObject hud2;


    void Start () {
        GameObject[] nodosorigen;
        nodosorigen = GameObject.FindGameObjectsWithTag("Path");
        nodos = new GameObject[nodosorigen.Length];
        if (gameObject.name == "Control General A")
        {
            tag_tropas = "TropasA";
            tag_constructor = "ConstructorA";
            tag_turretslot = "Turret SlotA";
            tag_Path = "PathA";
            tag_grupo = "GrupoA";
            lado = 1;
            //organizacion del array de nodos
            for (int i = 0; i < nodosorigen.Length; i++)
            {
                nodos[int.Parse(nodosorigen[i].name)] = nodosorigen[i];
            }
        }
        if (gameObject.name == "Control General B")
        {
            tag_tropas = "TropasB";
            tag_constructor = "ConstructorB";
            tag_turretslot = "Turret SlotB";
            tag_Path = "PathB";
            tag_grupo = "GrupoB";
            lado = -1;
            //organizacion del array de nodos
            for (int i = 0; i < nodosorigen.Length; i++)
            {
                nodos[nodosorigen.Length - int.Parse(nodosorigen[i].name) - 1] = nodosorigen[i];
            }
        }

        modotropas = true;
        espaciostorretas = GameObject.FindGameObjectsWithTag(tag_turretslot);

       

        
        tipotropa = 0;
        seleccionconstructor = 1;
    }//Organizar Al revez los nodos del equipo contrario
	
	void Update () {

        grupo = GameObject.FindGameObjectsWithTag(tag_grupo)[GameObject.FindGameObjectsWithTag(tag_grupo).Length - 1];

        if (GameObject.FindGameObjectsWithTag(tag_constructor).Length == 0)
        {
            constructoractivo = null;
            seleccionconstructor = 0;
        }
        else
        {
            if (Input.GetKeyDown(kAlternarConstructor)) seleccionconstructor++;

            if (seleccionconstructor > GameObject.FindGameObjectsWithTag(tag_constructor).Length) seleccionconstructor = 1;

            if (seleccionconstructor == 1) constructoractivo = GameObject.FindGameObjectsWithTag(tag_constructor)[0];
            if (seleccionconstructor == 2) constructoractivo = GameObject.FindGameObjectsWithTag(tag_constructor)[1];
            if (seleccionconstructor == 3) constructoractivo = GameObject.FindGameObjectsWithTag(tag_constructor)[2];

            foreach (GameObject c in GameObject.FindGameObjectsWithTag(tag_constructor)) if (c == constructoractivo) c.GetComponent<Constructor>().resplandor.SetActive(true);
                else c.GetComponent<Constructor>().resplandor.SetActive(false);
        }

        if (modotropas)
        {
            //hud
            hud1.SetActive(true);
            hud2.SetActive(false);

            imagentorreta1.SetActive(false);
            imagentorreta2.SetActive(false);
            imagentorreta3.SetActive(false);


            if (Input.GetKeyDown(kAlternarD)) tipotropa++;
            if (Input.GetKeyDown(kAlternarI)) tipotropa--;
            if (tipotropa < 0) tipotropa = 0;
            if (tipotropa > 3) tipotropa = 3;

            if (tipotropa == 0)
            {
                imagentropa0.SetActive(true);
                imagentropa1.SetActive(false);
                imagentropa2.SetActive(false);
                imagentropa3.SetActive(false);
            }
            if (tipotropa == 1)
            {
                tropa = tropa1;
                imagentropa0.SetActive(false);
                imagentropa1.SetActive(true);
                imagentropa2.SetActive(false);
                imagentropa3.SetActive(false);
            }
            if (tipotropa == 2)
            {
                tropa = tropa2;
                imagentropa0.SetActive(false);
                imagentropa1.SetActive(false);
                imagentropa2.SetActive(true);
                imagentropa3.SetActive(false);
            }
            if (tipotropa == 3)
            {
                tropa = tropa3;
                imagentropa0.SetActive(false);
                imagentropa1.SetActive(false);
                imagentropa2.SetActive(false);
                imagentropa3.SetActive(true);
            }
        }
        else
        {
            //hud
            hud1.SetActive(false);
            hud2.SetActive(true);

            imagentropa0.SetActive(false);
            imagentropa1.SetActive(false);
            imagentropa2.SetActive(false);
            imagentropa3.SetActive(false);

            if (Input.GetKeyDown(kAlternarD)) tipotorreta++;
            if (Input.GetKeyDown(kAlternarI)) tipotorreta--;
            if (tipotorreta < 1) tipotorreta = 1;
            if (tipotorreta > 3) tipotorreta = 3;

            if (tipotorreta == 1)
            {
                imagentorreta1.SetActive(true);
                imagentorreta2.SetActive(false);
                imagentorreta3.SetActive(false);
            }
            if (tipotorreta == 2)
            {
                imagentorreta1.SetActive(false);
                imagentorreta2.SetActive(true);
                imagentorreta3.SetActive(false);
            }
            if (tipotorreta == 3)
            {
                imagentorreta1.SetActive(false);
                imagentorreta2.SetActive(false);
                imagentorreta3.SetActive(true);
            }

        }
        //spawn tropas
        if (Input.GetKeyDown(kSpawn_Reparar) && modotropas)
        {
            if (tipotropa != 0)
            {
                Instantiate(grupo, transform.position, transform.rotation);
                Instantiate(tropa, transform.position, transform.rotation, parentTropas.transform);
            }
            else
            {
                if (GameObject.FindGameObjectsWithTag(tag_constructor).Length < 3)
                {
                    Instantiate(constructor, constructor.transform.position, constructor.transform.rotation);
                    seleccionconstructor = 1;
                }
            }

        }

        //visualización del nodo seleccionado
        for (int i = 0; i < nodos.Length; i++)
        {

            if (i == seleccionnodo && modotropas) foreach (Transform t in nodos[i].transform) { if (t.CompareTag(tag_Path)) t.GetComponent<SpriteRenderer>().enabled = true; }
            else
            {
                foreach (Transform t in nodos[i].transform) if (t.CompareTag(tag_Path)) t.GetComponent<SpriteRenderer>().enabled = false;
            }
        }
        //alternar modo
        if (Input.GetKeyDown(kModo)) modotropas = !modotropas;

        //navegación nodo
        if (modotropas)
        {
            if (Input.GetKeyDown(kDerecha)) seleccionnodo += lado;
            if (Input.GetKeyDown(kIzquierda)) seleccionnodo -= lado;

            if (Input.GetKeyDown(kColocar_Enviar)) nodoactivo = seleccionnodo;
        }
        else
        {
            //navegación torretas
            for (int i = 0; i < espaciostorretas.Length; i++)
            {
                if (espaciostorretas[i].transform.position.y > espaciostorretas[seleccionespacio].transform.position.y + 1 && ((espaciostorretas[i].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude < (espaciostorretas[espacioarriba].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude || espaciostorretas[espacioarriba].transform.position.y <= espaciostorretas[seleccionespacio].transform.position.y + 1))
                {
                    espacioarriba = i;
                }
                if (espaciostorretas[i].transform.position.y < espaciostorretas[seleccionespacio].transform.position.y - 1 && ((espaciostorretas[i].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude < (espaciostorretas[espacioabajo].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude || espaciostorretas[espacioabajo].transform.position.y >= espaciostorretas[seleccionespacio].transform.position.y - 1))
                {
                    espacioabajo = i;
                }
                if (espaciostorretas[i].transform.position.x > espaciostorretas[seleccionespacio].transform.position.x + 1 && ((espaciostorretas[i].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude < (espaciostorretas[espacioderecha].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude || espaciostorretas[espacioderecha].transform.position.x <= espaciostorretas[seleccionespacio].transform.position.x + 1))
                {
                    espacioderecha = i;
                }
                if (espaciostorretas[i].transform.position.x < espaciostorretas[seleccionespacio].transform.position.x - 1 && ((espaciostorretas[i].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude < (espaciostorretas[espacioizquierda].transform.position - espaciostorretas[seleccionespacio].transform.position).magnitude || espaciostorretas[espacioizquierda].transform.position.x >= espaciostorretas[seleccionespacio].transform.position.x - 1))
                {
                    espacioizquierda = i;
                }

            }
            if (espaciostorretas[espacioarriba].transform.position.y <= espaciostorretas[seleccionespacio].transform.position.y + 1) espacioarriba = seleccionespacio;
            if (espaciostorretas[espacioabajo].transform.position.y >= espaciostorretas[seleccionespacio].transform.position.y - 1) espacioabajo = seleccionespacio;
            if (espaciostorretas[espacioderecha].transform.position.x <= espaciostorretas[seleccionespacio].transform.position.x + 1) espacioderecha = seleccionespacio;
            if (espaciostorretas[espacioizquierda].transform.position.x >= espaciostorretas[seleccionespacio].transform.position.x - 1) espacioizquierda = seleccionespacio;

            if (Input.GetKeyDown(kArriba)) seleccionespacio = espacioarriba;
            if (Input.GetKeyDown(kIzquierda)) seleccionespacio = espacioizquierda;
            if (Input.GetKeyDown(kAbajo)) seleccionespacio = espacioabajo;
            if (Input.GetKeyDown(kDerecha)) seleccionespacio = espacioderecha;
            //colocar torreta
            if (Input.GetKeyDown(kColocar_Enviar) && GameObject.FindGameObjectsWithTag(tag_constructor).Length != 0)
            {
                if (!constructoractivo.GetComponent<Constructor>().ocupado && espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().disponible && !espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().ocupada)
                {
                    constructoractivo.GetComponent<Constructor>().torreta = espaciostorretas[seleccionespacio].GetComponent<TurretSlot>();
                    espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().tipotorreta = tipotorreta;
                    espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().ocupada = true;
                    constructoractivo.GetComponent<Constructor>().ocupado = true;
                    constructoractivo.GetComponent<Constructor>().destino = espaciostorretas[seleccionespacio].transform.position;
                }
            }
            //eliminar torreta
            if (Input.GetKeyDown(kEliminar) && !espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().disponible)
            {
                espaciostorretas[seleccionespacio].GetComponent<TurretSlot>().disponible = true;
            }
        }
        //visualizacion de slot seleccionado
        for (int i = 0; i < espaciostorretas.Length; i++)
        {
            if (i == seleccionespacio && !modotropas) espaciostorretas[i].GetComponent<SpriteRenderer>().enabled = true;
            else espaciostorretas[i].GetComponent<SpriteRenderer>().enabled = false;
        }
        //limites seleccion nodos
        if (seleccionnodo < 0) seleccionnodo = 0;
        if (seleccionnodo > nodos.Length - 1) seleccionnodo = nodos.Length - 1;

       
    }

}
Tropa.cs

Code: Select all

public class Tropa : MonoBehaviour {

    public int vida;
    public float rango;
    public float ritmoataque;
    public int dañoataque;
    public float tamaño;
    public bool ataqueadistancia;

    public GameObject flecha;
    public float dist;
    public int mascercano;
    public GameObject grupo;
    public bool entro;
    public int dir;
    public Vector3 posicionanterior;
    public Tropa enemigotropa;
    public Constructor enemigoconstructor;
    public TurretSlot enemigotorreta;

    string tag_Grupo;
    string tag_TropaEnemiga;
    string tag_ConstructorEnemigo;
    string tag_TorretaEnemiga;

    public bool atacando;
    public GameObject signoexclamacion;
    bool exclamacion;
    int frente;
    GameObject proyectil;
    public string tipoenemigo;
    public bool prioridadtropas;
    public Vector3 areabase;
    public GameObject silueta;
    float r;
    float g;
    float b;

    float rand;

    void Start () {
        r = GetComponent<SpriteRenderer>().color.r;
        g = GetComponent<SpriteRenderer>().color.g;
        b = GetComponent<SpriteRenderer>().color.b;
        if (gameObject.CompareTag("TropasA"))
        {
            tag_Grupo = "GrupoA";
            tag_TropaEnemiga = "TropasB";
            tag_ConstructorEnemigo = "ConstructorB";
            tag_TorretaEnemiga = "Turret SlotB";
            frente = 1;
        }
        if (gameObject.CompareTag("TropasB"))
        {
            tag_Grupo = "GrupoB";
            tag_TropaEnemiga = "TropasA";
            tag_ConstructorEnemigo = "ConstructorA";
            tag_TorretaEnemiga = "Turret SlotA";
            frente = -1;
        }
        dir = 1;
        //adoptamiento de grupo
        dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[0].transform.position).magnitude);
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_Grupo).Length; i++)
        {
            if (Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[i].transform.position).magnitude) < dist)
            {
                dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[i].transform.position).magnitude);
                mascercano = i;
            }
        }
        grupo = GameObject.FindGameObjectsWithTag(tag_Grupo)[mascercano];

            //Anotarse a la fila
        if (!grupo.GetComponent<Translacion>().lleno)
        {
            for (int i = 0; i < grupo.GetComponent<Translacion>().arraytropas.Length; i++)
            {
                if (!grupo.GetComponent<Translacion>().arraytropas[i])
                {
                    grupo.GetComponent<Translacion>().arraytropas[i] = true;
                    entro = true;
                    break;
                }

            }

        }
        rand = Random.Range(-0.1f, 0.1f);
        posicionanterior = transform.position;
        StartCoroutine(UpdatePosition());
        StartCoroutine(Ataque());
    }
	
	void Update () {
        //silueta base
        if ((areabase - transform.position).magnitude < 2.5f - frente * 0.5f)
        {
            silueta.SetActive(true);
        }
        else
        {
            silueta.SetActive(false);
        }
        //readopatmiento de grupo
        if (grupo == null || (grupo.GetComponent<Translacion>().lleno && !entro))
        {
            entro = false;
            mascercano = 0;
            //dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[0].transform.position).magnitude);
            dist = Mathf.Infinity;
            for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_Grupo).Length; i++)
            {
                if (Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[i].transform.position).magnitude) < dist && !GameObject.FindGameObjectsWithTag(tag_Grupo)[i].GetComponent<Translacion>().lleno)
                {
                    dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_Grupo)[i].transform.position).magnitude);
                    mascercano = i;
                }
            }
            grupo = GameObject.FindGameObjectsWithTag(tag_Grupo)[mascercano].gameObject;
            //Anotarse a la fila
            if (!grupo.GetComponent<Translacion>().lleno)
            {
                for (int i = 0; i < grupo.GetComponent<Translacion>().arraytropas.Length; i++)
                {
                    if (!grupo.GetComponent<Translacion>().arraytropas[i])
                    {
                        grupo.GetComponent<Translacion>().arraytropas[i] = true;
                        entro = true;
                        break;
                    }

                }

            }
        }
        //atracción al grupo
        GetComponent<Rigidbody2D>().AddForce((grupo.transform.position - transform.position) * 20 * Random.Range(0, 20));

        if ((grupo.transform.position - transform.position).magnitude > 2) transform.position = grupo.transform.position;

        if (grupo.GetComponent<Translacion>().frente.x > grupo.GetComponent<Translacion>().atras.x) dir = 1 * grupo.GetComponent<Translacion>().dir;
        if (grupo.GetComponent<Translacion>().frente.x < grupo.GetComponent<Translacion>().atras.x) dir = -1 * grupo.GetComponent<Translacion>().dir;

        transform.localScale = new Vector3(-dir, 1, 1) * tamaño;

        dist = Mathf.Infinity;
        prioridadtropas = false;
        //enemigo mas cercano
        if (GameObject.FindGameObjectsWithTag(tag_TropaEnemiga).Length > 0)
        {
            mascercano = 0;
            for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_TropaEnemiga).Length; i++)
            {
                if (Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_TropaEnemiga)[i].transform.position).magnitude) < dist)
                {
                    dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_TropaEnemiga)[i].transform.position).magnitude);
                    mascercano = i;
                    tipoenemigo = "Tropa";
                }
            }
                enemigotropa = GameObject.FindGameObjectsWithTag(tag_TropaEnemiga)[mascercano].GetComponent<Tropa>();
            if(enemigotropa != null) if ((transform.position - enemigotropa.transform.position).magnitude <= rango) prioridadtropas = true;
        }
            //constructor mas cercano
        if (GameObject.FindGameObjectsWithTag(tag_ConstructorEnemigo).Length > 0 )
        {
            mascercano = 0;
            
            for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_ConstructorEnemigo).Length; i++)
                {
                    if (Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_ConstructorEnemigo)[i].transform.position).magnitude) < dist && !prioridadtropas)
                    {
                        dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_ConstructorEnemigo)[i].transform.position).magnitude);
                        mascercano = i;
                        tipoenemigo = "Constructor";
                    }
                }
            enemigoconstructor = GameObject.FindGameObjectsWithTag(tag_ConstructorEnemigo)[mascercano].GetComponent<Constructor>();
        }
            // torreta mas cercana
        if (GameObject.FindGameObjectsWithTag(tag_TorretaEnemiga).Length > 0)
        {
            mascercano = 0;
            for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_TorretaEnemiga).Length; i++)
                {
                    if (Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_TorretaEnemiga)[i].transform.position).magnitude) < dist && !GameObject.FindGameObjectsWithTag(tag_TorretaEnemiga)[i].GetComponent<TurretSlot>().disponible && !prioridadtropas)
                    {
                        dist = Mathf.Abs((transform.position - GameObject.FindGameObjectsWithTag(tag_TorretaEnemiga)[i].transform.position).magnitude);
                        mascercano = i;
                        tipoenemigo = "Torreta";
                    }
                }
                enemigotorreta = GameObject.FindGameObjectsWithTag(tag_TorretaEnemiga)[mascercano].GetComponent<TurretSlot>();
        }

        //muerte
        if (vida <= 0)
        {
            //Desanotarse de la fila
            for (int i = grupo.GetComponent<Translacion>().arraytropas.Length - 1; i >= 0; i--)
            {
                if (grupo.GetComponent<Translacion>().arraytropas[i])
                {
                    grupo.GetComponent<Translacion>().arraytropas[i] = false;
                    break;
                }

            }
            Destroy(gameObject);
        }
        //atacando
        if (tipoenemigo == "Tropa")
        {
            if (enemigotropa != null)
            {
                if ((transform.position - enemigotropa.transform.position).magnitude <= rango)
                {
                    atacando = true;
                    grupo.GetComponent<Translacion>().enfrentamiento = true;
                    if (!exclamacion)
                    {
                        exclamacion = true;
                        Instantiate(signoexclamacion, transform.position + new Vector3(0.5f * frente, 0.5f, 0), transform.rotation);
                    }

                }
                else
                {
                    atacando = false;
                    exclamacion = false;
                }
            }
            else
            {
                atacando = false;
            }
        }
        if (tipoenemigo == "Constructor")
        {
            if (enemigoconstructor != null)
            {
                if ((transform.position - enemigoconstructor.transform.position).magnitude <= rango && !enemigoconstructor.protegido)
                {
                    atacando = true;
                    grupo.GetComponent<Translacion>().enfrentamiento = true;
                    if (!exclamacion)
                    {
                        exclamacion = true;
                        Instantiate(signoexclamacion, transform.position + new Vector3(0.5f * frente, 0.5f, 0), transform.rotation);
                    }
                }
                else
                {
                    atacando = false;
                    exclamacion = false;
                }
            }
            else
            {
                atacando = false;
            }
        }
        if (tipoenemigo == "Torreta" )
        {
            if (!enemigotorreta.disponible)
            {
                if ((transform.position - enemigotorreta.transform.position).magnitude <= rango)
                {
                    atacando = true;
                    if (!exclamacion)
                    {
                        exclamacion = true;
                        Instantiate(signoexclamacion, transform.position + new Vector3(0.5f * frente, 0.5f, 0), transform.rotation);
                    }
                }
                else
                {
                    atacando = false;
                    exclamacion = false;
                }
            }
            else
            {
                atacando = false;
            }
        }
        transform.position = new Vector3(transform.position.x, transform.position.y, rand);
    }
    IEnumerator UpdatePosition()
    {
        if (Mathf.Abs((transform.position - posicionanterior).magnitude) > 0.1f)
        {
            GetComponent<Animator>().SetBool("Corriendo", true);
        }
        else
        {
            GetComponent<Animator>().SetBool("Corriendo", false);
        }
        posicionanterior = transform.position;
        yield return new WaitForSeconds(0.5f);
        StartCoroutine(UpdatePosition());
    }

    IEnumerator Ataque()
    {
        if (atacando)
        {
            GetComponent<Animator>().SetBool("Ataque", true);
            if (tipoenemigo == "Tropa" && enemigotropa != null)
            {
                enemigotropa.vida -= dañoataque;
                enemigotropa.GetComponent<Animator>().SetTrigger("Daño");
            }
            if (tipoenemigo == "Constructor" && enemigoconstructor != null)
            {
                enemigoconstructor.vida -= dañoataque;
                //enemigo.GetComponent<Animator>().SetTrigger("Daño");
            }
            if (tipoenemigo == "Torreta" && ataqueadistancia && enemigotorreta != null)
            {
                enemigotorreta.vida -= dañoataque;
                //enemigo.GetComponent<Animator>().SetTrigger("Daño");
            }
            if (ataqueadistancia)
            {
                proyectil = Instantiate(flecha, transform.position, transform.rotation);
                if (tipoenemigo == "Tropa" && enemigotropa != null) proyectil.GetComponent<Proyectil>().destino = enemigotropa.transform.position;
                if (tipoenemigo == "Constructor" && enemigoconstructor != null) proyectil.GetComponent<Proyectil>().destino = enemigoconstructor.transform.position;
                if (tipoenemigo == "Torreta" && enemigotorreta != null) proyectil.GetComponent<Proyectil>().destino = enemigotorreta.transform.position;
            }
        }
        else
        {
            GetComponent<Animator>().SetBool("Ataque", false);
        }
        for (int i = 0; i < ritmoataque * 50; i++)
        {
            yield return new WaitForEndOfFrame();
        }
        grupo.GetComponent<Translacion>().enfrentamiento = false;
        StartCoroutine(Ataque());
    }
    IEnumerator Daño()
    {
        float cr = r;
        float cg = g;
        float cb = b;
        for (int i = 0; i < 50; i++)
        {
            cg -= 0.02f * g;
            cb -= 0.02f * b;
            GetComponent<SpriteRenderer>().color = new Color(cr, cg, cb);
            yield return new WaitForSeconds(0.01f);
        }
        for (int i = 0; i < 50; i++)
        {
            cg += 0.02f * g;
            cb += 0.02f * b;
            GetComponent<SpriteRenderer>().color = new Color(cr, cg, cb);
            yield return new WaitForSeconds(0.01f);
        }
    }
}
Constructor.cs

Code: Select all

public class Constructor : MonoBehaviour {

    public bool ocupado;
    public Vector3 prehome;
    public Vector3 home;
    public Vector3 destino;
    public int dir;
    public int velocidad;
    public TurretSlot torreta;
    public GameObject resplandor;
    public int numero = 0;
    Vector3 posicionanterior;
    string tag_constructor;

    public bool protegido;

    public int vida;

    void Start () {
        vida = 100;
        if (gameObject.CompareTag("ConstructorA"))
        {
            tag_constructor = "ConstructorA";
        }
        if (gameObject.CompareTag("ConstructorB"))
        {
            tag_constructor = "ConstructorB";
        }
        //StartCoroutine(UpdatePosition());
        prehome = transform.position;
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_constructor).Length; i++)
        {
            if (GameObject.FindGameObjectsWithTag(tag_constructor)[i] == gameObject) numero = i;
        }
        home = prehome + Vector3.down * numero * 0.5f;
        destino = home;
        dir = 1;
        velocidad = 1;
	}
	
	void Update () {
        GetComponent<SpriteRenderer>().sortingOrder = numero + 3;
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(tag_constructor).Length; i++)
        {
            if (GameObject.FindGameObjectsWithTag(tag_constructor)[i] == gameObject) numero = i;
        }
        home = prehome + Vector3.down * numero * 0.5f;


        transform.position += (destino - transform.position).normalized * 0.01f * velocidad;

        //instante en el que llega a la torreta
        if ((transform.position - destino).magnitude < 0.1f)
        {
            if (ocupado)
            {
                ocupado = false;
                destino = home;
                torreta.disponible = false;
                torreta.ocupada = false;
                torreta.vida = 1000;
                StartCoroutine(DelayConstruir());
                GetComponent<Animator>().SetTrigger("Construir");
            }
            else if ((transform.position - destino).magnitude < 0.02f)
            {
                transform.position = destino;
                GetComponent<Animator>().SetBool("Corriendo", false);
            }
        }
        else
        {
            GetComponent<Animator>().SetBool("Corriendo", true);
        }
        //cambio de direccion
        if (destino.x >= transform.position.x) dir = 1;
        else dir = -1;

        transform.localScale = new Vector3(-dir, 1, 1);

        if (vida <= 0)
        {
            if(torreta != null) torreta.ocupada = false;
            Destroy(gameObject);
        }
        //reestablecimiento de base
        if ((destino - home).magnitude <= 1.5f && !ocupado)
        {
            destino = home;
        }
        //zona segura
        if ((transform.position - home).magnitude < 1.5f)
        {
            protegido = true;
        }
        else
        {
            protegido = false;
        }
	}
    IEnumerator DelayConstruir()
    {
        velocidad = 0;
        yield return new WaitForSeconds(0.5f);
        velocidad = 1;
    }

    IEnumerator UpdatePosition()
    {
        if (Mathf.Abs((transform.position - posicionanterior).magnitude) > 0.1f)
        {
            GetComponent<Animator>().SetBool("Corriendo", true);
        }
        else
        {
            GetComponent<Animator>().SetBool("Corriendo", false);
        }
        posicionanterior = transform.position;
        yield return new WaitForSeconds(0.5f);
        StartCoroutine(UpdatePosition());
    }
    
}
Proyectil.cs

Code: Select all

public class Proyectil : MonoBehaviour {

    Vector3 origen;
    public Vector3 destino;

	void Start () {
        origen = transform.position;
	}
	
	void Update () {
        transform.position += (destino - origen) * Time.deltaTime;
        if ((transform.position - destino).magnitude < 0.5f) Destroy(gameObject);
	}
}
SignoExclamacion.cs

Code: Select all

public class SignoExclamacion : MonoBehaviour {

    float a = 1;

	void Start () {
        StartCoroutine(Fade());
	}
	
    IEnumerator Fade()
    {
        yield return new WaitForSeconds(0.7f);
        for (int i = 0; i < 10; i++)
        {
            a -= 0.1f;
            GetComponent<SpriteRenderer>().color = new Color(1, 1, 1, a);
            yield return new WaitForSeconds(0.03f);
        }
        Destroy(gameObject);
    }
}
Translacion.cs

Code: Select all

public class Translacion : MonoBehaviour {


    public GameObject[] nodos;
    public float ubicacionfrontal;
    public float ubicaciontrasera;
    public float separacion;
    public Vector3 frente;
    public Vector3 atras;

    public int nodoactivo;
    public float magnitudactual;
    public float diferenciaubicaciones;

    public bool[] arraytropas;
    public bool lleno;
    public int cantidadtropas;

    public int numerofila;
    public int dir;
    public ControlGeneral cg;
    public bool debugnumerofila;

    float offsettiempo;
    public bool enfrentamiento;

    void Start () {
        offsettiempo = Time.time;
        diferenciaubicaciones = 5;
        ubicacionfrontal = 0;
        arraytropas = new bool[10];
        numerofila = 0;

    }//Reemplazar ControlGeneral y array de Translacion

    void Update() {
        //información de ControlGeneral
        nodos = cg.nodos;
        nodoactivo = cg.nodoactivo;
        
        //float ubicación --> posición real
        for (int i = 0; i < nodos.Length - 1; i++)
        {

            if (ubicacionfrontal >= i * 100f / (nodos.Length - 1) && ubicacionfrontal <= (i + 1) * 100f / (nodos.Length - 1))
            {
                frente = nodos[i].transform.position + (nodos[i + 1].transform.position - nodos[i].transform.position) * ((ubicacionfrontal - i * 100f / (nodos.Length - 1)) / (100f / (nodos.Length - 1)));
                magnitudactual = (nodos[i + 1].transform.position - nodos[i].transform.position).magnitude;
            }

            if (ubicaciontrasera >= i * 100f / (nodos.Length - 1) && ubicaciontrasera <= (i + 1) * 100f / (nodos.Length - 1))
            {
                atras = nodos[i].transform.position + (nodos[i + 1].transform.position - nodos[i].transform.position) * ((ubicaciontrasera - i * 100f / (nodos.Length - 1)) / (100f / (nodos.Length - 1)));

            }

        }

        //voy a hacerme las pastas, anda viendo el codigo <<<<<

        //movimiento hacia nodoactivo
        if (ubicacionfrontal + numerofila * 1.5f < nodoactivo * 100 / (nodos.Length - 1) + 2.5f && !enfrentamiento)
        {
            ubicacionfrontal += 0.05f * separacion / magnitudactual;
            dir = 1;
        }
        if (ubicacionfrontal + numerofila * 1.5f > nodoactivo * 100 / (nodos.Length - 1) + 2.5f)
        {
            ubicacionfrontal -= 0.05f * separacion / magnitudactual;
            dir = -1;
        }

        //limites de ubicacion frontal
        if (ubicacionfrontal < 0) ubicacionfrontal = 0;
        if (ubicacionfrontal > 100) ubicacionfrontal = 100;

        //separacion ubicaciones
        diferenciaubicaciones += (5 / magnitudactual - diferenciaubicaciones) * 0.01f;
        ubicaciontrasera = ubicacionfrontal - diferenciaubicaciones;

        //limite ubicacion trasera
        if (ubicaciontrasera < 0) ubicaciontrasera = 0;

        //posicion grupo
        transform.position = atras + (frente - atras) * 0.5f;


        Debug.DrawRay(atras, frente - atras, Color.white);

        //bool lleno
        lleno = true;
        cantidadtropas = 0;
        foreach (bool b in arraytropas) if (!b) lleno = false; else cantidadtropas++;
        //debug enfrentamiento grupo vacio  
        if (cantidadtropas == 0) enfrentamiento = false;

        //fusion grupos
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(gameObject.tag).Length; i++)
        {
            if (this == GameObject.FindGameObjectsWithTag(gameObject.tag)[i].GetComponent<Translacion>())
            {
                for (int o = 0; o < GameObject.FindGameObjectsWithTag(gameObject.tag).Length; o++)
                {
                    if (Mathf.Abs(this.ubicacionfrontal - GameObject.FindGameObjectsWithTag(gameObject.tag)[o].GetComponent<Translacion>().ubicacionfrontal) < 1 && i > o && Time.time - offsettiempo > 1)
                    {
                        if (cantidadtropas + GameObject.FindGameObjectsWithTag(gameObject.tag)[o].GetComponent<Translacion>().cantidadtropas <= 10)
                        {
                            Destroy(GameObject.FindGameObjectsWithTag(gameObject.tag)[i].gameObject);
                        }
                        else
                        {
                            numerofila = GameObject.FindGameObjectsWithTag(gameObject.tag)[o].GetComponent<Translacion>().numerofila + 1;
                        }
                    }

                }
            }
            

        }
        //Debug numero fila
        debugnumerofila = false;
        for (int i = 0; i < GameObject.FindGameObjectsWithTag(gameObject.tag).Length; i++)
        {
            if (GameObject.FindGameObjectsWithTag(gameObject.tag)[i].GetComponent<Translacion>().numerofila == numerofila - 1) debugnumerofila = true;
        }
            if (!debugnumerofila && numerofila < 0) numerofila--;
    
    }

    
}
TurretSlot.cs

Code: Select all

public class TurretSlot : MonoBehaviour {

    public bool disponible;
    public bool ocupada;
    public int tipotorreta;
    public GameObject torreta1;
    public GameObject torreta2;
    public GameObject torreta3;

    public int vida;

    void Start () {
        disponible = true;
        tipotorreta = 1;
        vida = 1000;
	}
	
	void Update () {
        if (!disponible)
        {
            if (tipotorreta == 1)
            {
                torreta1.SetActive(true);
                torreta2.SetActive(false);
                torreta3.SetActive(false);
            }
            if (tipotorreta == 2)
            {
                torreta1.SetActive(false);
                torreta2.SetActive(true);
                torreta3.SetActive(false);
            }
            if (tipotorreta == 3)
            {
                torreta1.SetActive(false);
                torreta2.SetActive(false);
                torreta3.SetActive(true);
            }
        }
        else
        {
            torreta1.SetActive(false);
            torreta2.SetActive(false);
            torreta3.SetActive(false);
        }
        if (vida <= 0)
        {
            disponible = true;
            vida = 1000;
        }
	}
}
Juan Camilo Quintero

POO1

User avatar
wintuh
Posts: 32
Joined: Tue Jan 22, 2019 12:13 pm
Location: Medellín

Re: Neugier Battles - Wintergarnele Studios

Post by wintuh » Tue Mar 05, 2019 11:46 pm

Sprint #5

Actividad #1
Programación torretas
  • Mecanismos mortero (Juan Camilo) :: 3
  • Mecanismos Lanzallamas (Juan Camilo) :: 2
  • Rotación torreta base (Juan Camilo) :: 3
  • Información UI (Juan Camilo) :: 2
  • Economía base (Juan Camilo) :: 3
Activadad #2
Refinamiento e implementación de animaciones
  • Golpe del tanque (Martín) :: 2
  • Concept torretas nuevas (Martín y Juan Camilo) :: 2
  • Concept nuevo arquero (Martín y Juan Camilo) :: 2
Programación y diseño orientado a objetos (pdoo1)

Martín Jaramillo Nicholls

Post Reply