Пример #1
0
    private void seleccionarUnidad()
    {
        if (Input.GetMouseButtonDown(0))
        {
            foreach (Unidad u in unidades)
            {
                u.setSeleccionada(false);
            }
            selected.GetComponent <MeshRenderer>().enabled = false;
            bool        unidadEncontrada = false;
            int         i               = 0;
            int         size            = unidades.Count;
            CasillaGrid casillaObjetivo = getCasillaRaton();

            if (casillaObjetivo == null)
            {
                return;
            }

            while (i < size && !unidadEncontrada)
            {
                if (unidades[i].getCoordenadas() == casillaObjetivo.getPosicionGrid())
                {
                    unidadEncontrada = true;
                    unidades[i].setSeleccionada(true);
                    unidadSeleccionada = unidades[i];
                    return;
                }
                i++;
            }
        }
    }
Пример #2
0
    // Start is called before the first frame update
    void Awake()
    {
        //tilemap = GameObject.FindGameObjectWithTag("TileGrid").GetComponent<Tilemap>();
        Vector3 posicionGlobal = Vector3.zero;

        casillas       = new CasillaGrid[dim, dim];
        mapaInfluencia = new float[dim, dim];

        for (int i = 0; i < dim; i++)
        {
            for (int j = 0; j < dim; j++)
            {
                posicionGlobal = new Vector3((float)0.5 * j + (float)0.5 * i, (float)-0.25 * j + (float)0.25 * i, 0);
                casillas[i, j] = new CasillaGrid(posicionGlobal, new Vector2(i, j));
            }
        }
        getName();
        inicializarAdyacentes();

        baseA = getCasillaAt(6, 2);
        baseB = getCasillaAt(37, 36);

        tiempoBaseA = 0;
        tiempoBaseB = 0;
    }
Пример #3
0
 public CasillaGrid(CasillaGrid casilla)
 {
     posicion    = casilla.getPosicion();
     coordenadas = casilla.getPosicionGrid();
     adyacentes  = casilla.getAdyacentes();
     tipo        = casilla.getTipoCasilla();
 }
Пример #4
0
    /**
     * A* y métodos asociados
     * */


    protected List <NodoA> AStar(CasillaGrid actual, CasillaGrid goal, Dictionary <TipoCasilla, float> moveIndex)
    {
        //List<NodoA> cerrados = new List<NodoA>();
        //List<NodoA> abiertos = new List<NodoA>();
        Dictionary <Vector2, NodoA> cerrados = new Dictionary <Vector2, NodoA>();
        Dictionary <Vector2, NodoA> abiertos = new Dictionary <Vector2, NodoA>();
        CasillaGrid target  = goal;
        NodoA       starter = new NodoA(actual, null, 0);

        abiertos.Add(starter.getCasilla().getPosicionGrid(), starter);

        while (abiertos.Count != 0)
        {
            NodoA bestNode = GetLowestCostNode(abiertos);

            abiertos.Remove(bestNode.getCasilla().getPosicionGrid());
            cerrados.Add(bestNode.getCasilla().getPosicionGrid(), bestNode);


            if (bestNode.getCasilla().getPosicionGrid() == goal.getPosicionGrid())
            {
                ICollection <NodoA> camino = cerrados.Values;
                return(ReconstructPath(camino));
            }



            List <NodoA> vecinos = Neighbours(bestNode.getCasilla(), moveIndex);
            foreach (NodoA n in vecinos)
            {
                if (cerrados.ContainsKey(n.getCasilla().getPosicionGrid()))
                {
                    continue;
                }

                float costeNodo = bestNode.g + EuclideanDistance(bestNode.getCasilla().getPosicionGrid(), n.getCasilla().getPosicionGrid()) + moveIndex[n.getCasilla().getTipoCasilla()];
                n.g = +costeNodo;
                n.h = EuclideanDistance(n.getCasilla().getPosicionGrid(), goal.getPosicionGrid());
                n.setPadre(bestNode.getCasilla());


                if (abiertos.ContainsKey(n.getCasilla().getPosicionGrid()))
                {
                    continue;
                }

                abiertos.Add(n.getCasilla().getPosicionGrid(), n);
            }
        }
        return(null);
    }
Пример #5
0
    public List <NodoA> Neighbours(CasillaGrid casilla, Dictionary <TipoCasilla, float> moveIndex)
    {
        NodoA              aux        = null;
        List <NodoA>       listNodes  = new List <NodoA>();
        List <CasillaGrid> adyacentes = casilla.getAdyacentes();

        foreach (CasillaGrid c in adyacentes)
        {
            if (moveIndex[c.getTipoCasilla()] == Mathf.Infinity)
            {
                continue;
            }
            aux = new NodoA(c, casilla, moveIndex[c.getTipoCasilla()]);
            listNodes.Add(aux);
        }

        return(listNodes);
    }
Пример #6
0
    private CasillaGrid getCasillaObjetivo(Vector2 posicionImpacto)
    {
        float       distanciaMinima = Mathf.Infinity;
        float       distancia;
        Vector3     posicionImpactoMundo = new Vector3(posicionImpacto.x, posicionImpacto.y, 0);
        CasillaGrid objetivo             = null;

        foreach (CasillaGrid c in casillas)
        {
            distancia = (c.getPosicion() - posicionImpactoMundo).magnitude;
            if (distancia < distanciaMinima)
            {
                distanciaMinima = distancia;
                objetivo        = c;
            }
        }
        return(objetivo);
    }
Пример #7
0
    public CasillaGrid getClosest(CasillaGrid current, CasillaGrid goal)
    {
        float              bestDist   = Mathf.Infinity;
        float              bestCost   = Mathf.Infinity;
        CasillaGrid        best       = null;
        List <CasillaGrid> adyacentes = goal.getAdyacentes();

        foreach (CasillaGrid c in adyacentes)
        {
            /*
             * TODO
             * Antes de comprobar el adyacente más cercano al actual, comprobar el adyacente de menor coste.
             * Si todos tienen el mismo coste, comprobar distancias.
             *
             * */

            if (moveIndex[c.getTipoCasilla()] < bestCost)
            {
                bestDist = calcDist(current, c);
                best     = c;
                bestCost = moveIndex[c.getTipoCasilla()];
            }
        }

        if (bestCost == Mathf.Infinity)
        {
            foreach (CasillaGrid c in adyacentes)
            {
                if (calcDist(current, c) <= bestDist)
                {
                    bestDist = calcDist(current, c);
                    best     = c;
                    bestCost = moveIndex[c.getTipoCasilla()];
                }
            }
        }

        if (bestCost == Mathf.Infinity)
        {
            best = getClosest(current, best);
        }

        return(best);
    }
Пример #8
0
    public List <NodoA> ReconstructPath(ICollection <NodoA> lista)
    {
        List <NodoA> path = new List <NodoA>();
        List <NodoA> aux  = new List <NodoA>(lista);

        aux.Reverse();
        CasillaGrid padre = null;

        if (lista == null || lista.Count == 0)
        {
            return(null);
        }


        foreach (NodoA current in aux)
        {
            if (current.getPadre() != null)
            {
                if (path.Count == 0)
                {
                    path.Add(current);
                    padre = current.getPadre();
                }
                else if (current.getCasilla() == padre)
                {
                    path.Add(current);
                    padre = current.getPadre();
                }
            }
            else
            {
                path.Add(current);
            }
        }
        path.Reverse();
        return(path);
    }
Пример #9
0
 public float getInfluenciaAt(CasillaGrid cg)
 {
     return(getInfluenciaAt(cg.getPosicionGrid()));
 }
Пример #10
0
 public void setTarget(CasillaGrid objetivo)
 {
     this.target = objetivo;
 }
Пример #11
0
 public NodoA(CasillaGrid casilla, CasillaGrid pred, float coste)
 {
     c     = casilla;
     padre = pred;
     g     = coste;
 }
Пример #12
0
    // Start is called before the first frame update
    protected void Start()
    {
        coordenadas      = Vector2.zero;
        ataqueDisponible = true;
        unidadViva       = true;
        canMove          = true;
        batallaTotal     = false;

        enemigos = new List <Unidad>();
        Unidad[] unidades = GameObject.FindObjectsOfType <Unidad>();
        foreach (Unidad u in unidades)
        {
            if (bando != u.getBando())
            {
                enemigos.Add(u);
            }
        }


        // Definimos los rallypoints
        rallypoints = new List <RallyPoint>();

        rallypoints.Add(new RallyPoint(new Vector2(6, 2), TipoRallyPoint.baseA));
        rallypoints.Add(new RallyPoint(new Vector2(37, 36), TipoRallyPoint.baseB));

        rallypoints.Add(new RallyPoint(new Vector2(9, 16), TipoRallyPoint.paso));
        rallypoints.Add(new RallyPoint(new Vector2(9, 20), TipoRallyPoint.paso));
        rallypoints.Add(new RallyPoint(new Vector2(32, 11), TipoRallyPoint.paso));
        rallypoints.Add(new RallyPoint(new Vector2(32, 15), TipoRallyPoint.paso));

        rallypoints.Add(new RallyPoint(new Vector2(13, 4), TipoRallyPoint.paso));
        rallypoints.Add(new RallyPoint(new Vector2(35, 6), TipoRallyPoint.paso));
        rallypoints.Add(new RallyPoint(new Vector2(4, 23), TipoRallyPoint.paso));
        rallypoints.Add(new RallyPoint(new Vector2(30, 18), TipoRallyPoint.paso));

        if (bando)
        {
            baseUnidad = controlador.getCasillaAt(6, 2);
        }
        else
        {
            baseUnidad = controlador.getCasillaAt(37, 36);
        }


        // Inicializamos las casillas de las patrullas
        patrullas = new List <CasillaGrid> [6];

        CasillaGrid pasoA1    = controlador.getCasillaAt(9, 16);
        CasillaGrid pasoA2    = controlador.getCasillaAt(32, 11);
        CasillaGrid pasoA3    = controlador.getCasillaAt(13, 4);
        CasillaGrid pasoA4    = controlador.getCasillaAt(35, 6);
        CasillaGrid curacionA = controlador.getCasillaAt(13, 4);

        CasillaGrid pasoB1 = controlador.getCasillaAt(9, 20);
        CasillaGrid pasoB2 = controlador.getCasillaAt(6, 35);
        CasillaGrid pasoB3 = controlador.getCasillaAt(30, 18);
        CasillaGrid baseB  = controlador.getCasillaAt(37, 36);

        List <CasillaGrid> patrullaRioNorte = new List <CasillaGrid>();

        patrullaRioNorte.Add(pasoA1);
        patrullaRioNorte.Add(pasoA2);

        List <CasillaGrid> patrullaNorte = new List <CasillaGrid>();

        patrullaNorte.Add(pasoA3);
        patrullaNorte.Add(pasoA4);

        List <CasillaGrid> patrullaBosque = new List <CasillaGrid>();

        patrullaBosque.Add(pasoA3);
        patrullaBosque.Add(pasoA1);
        patrullaBosque.Add(pasoA2);

        List <CasillaGrid> patrullaRioSur = new List <CasillaGrid>();

        patrullaRioSur.Add(pasoB1);
        patrullaRioSur.Add(pasoB3);


        List <CasillaGrid> patrullaSur = new List <CasillaGrid>();

        patrullaSur.Add(pasoB2);
        patrullaSur.Add(baseB);

        List <CasillaGrid> patrullaCuadrado = new List <CasillaGrid>();

        patrullaCuadrado.Add(pasoB1);
        patrullaCuadrado.Add(pasoB2);
        patrullaCuadrado.Add(baseB);
        patrullaCuadrado.Add(pasoB3);


        // Asignamos todas las patrullas a la estructura de datos patrullas.
        // Cada unidad tendrá asignada una patrulla por medio de un parámetro
        patrullas[0] = patrullaRioNorte;
        patrullas[1] = patrullaNorte;
        patrullas[2] = patrullaBosque;
        patrullas[3] = patrullaRioSur;
        patrullas[4] = patrullaSur;
        patrullas[5] = patrullaCuadrado;

        spriteBuscaEnemigo     = Resources.Load <Sprite>("buscaEnemigo");
        spritePatrulla         = Resources.Load <Sprite>("patrulla");
        spriteAtacaBaseEnemiga = Resources.Load <Sprite>("atacaBaseEnemiga");
        spriteDefiendeBase     = Resources.Load <Sprite>("defiendeBase");
        spriteCuracion         = Resources.Load <Sprite>("curacion");
    }
Пример #13
0
 public float calcDist(Vector3 origen, CasillaGrid fin)
 {
     return(Mathf.Sqrt(Mathf.Pow((origen.x - fin.getPosicionGrid().x), 2) + Mathf.Pow((origen.y - fin.getPosicionGrid().y), 2)));
 }
Пример #14
0
    protected void Update()
    {
        actualizaBarraSalud();

        if (seleccionada)
        {
            controlador.selected.GetComponent <MeshRenderer>().enabled = true;
            controlador.selected.transform.position = new Vector3(transform.position.x, transform.position.y, controlador.selected.transform.position.z);
        }

        int    coordenadaGridX = (int)controlador.getCasillaActual(this).getPosicionGrid().x;
        int    coordenadaGridY = (int)controlador.getCasillaActual(this).getPosicionGrid().y;
        Accion a = Accion.buscaEnemigo;

        this.setCoordenadas(coordenadaGridX, coordenadaGridY);

        bool click = Input.GetMouseButtonDown(1);

        if (seleccionada && click || path.Count > 0)
        {
            path.Clear();
            if (click)
            {
                target = controlador.getCasillaRaton();
            }

            if (target != null)
            {
                cg         = controlador.getCasillaActual(this);
                adyacentes = cg.getAdyacentes();

                if (moveIndex[target.getTipoCasilla()] == Mathf.Infinity)
                {
                    target = getClosest(cg, target);
                }

                setPath(AStar(cg, target, moveIndex));
                MovePlayer();
            }
        }


        if (!seleccionada)
        {
            a      = sbr.tomaDecision(this);
            target = new CasillaGrid(parseAction(a));


            if (target != null)
            {
                if (patrullando)
                {
                    List <CasillaGrid> patrullaActual = patrullas[numeroPatrulla];
                    int size = patrullaActual.Count;
                    if (Vector3.Distance(transform.position, target.getPosicion()) < 0.5f)
                    {
                        indicePatrulla = (indicePatrulla + 1) % size;
                        target         = patrullaActual[indicePatrulla];
                    }
                }
                //TODO: hacer que se compruebe constantemente la posición del target, y cuando cambie, volver a lanzar el A*
                //COMPROBAR LA POSICIÓN FINAL DEL TARGET DE CADA UNIDAD

                cg         = controlador.getCasillaActual(this);
                adyacentes = cg.getAdyacentes();


                setPath(AStar(cg, target, moveIndex));
                MovePlayer();
            }
        }
        actualizarIcono(a);
    }
Пример #15
0
 public void setPadre(CasillaGrid pred)
 {
     this.padre = pred;
 }
Пример #16
0
 public void AddAdyacente(CasillaGrid casilla)
 {
     adyacentes.Add(casilla);
 }
Пример #17
0
 public void setCasilla(CasillaGrid casilla)
 {
     this.c = casilla;
 }