Exemplo n.º 1
0
    public void TakeSnapshot(Grilla <Nodo> grid, Nodo current, List <Nodo> openList, List <Nodo> closedList)
    {
        GridSnapshotAction gridSnapshotAction = new GridSnapshotAction();

        gridSnapshotAction.AddAction(HideNodeVisuals);

        for (int x = 0; x < grid.GetWidth(); x++)
        {
            for (int y = 0; y < grid.GetHeight(); y++)
            {
                Nodo Nodo = grid.GetGridObject(x, y);

                int     CostoG         = Nodo.CostoG;
                int     CostoH         = Nodo.CostoH;
                int     CostoF         = Nodo.CostoF;
                Vector3 gridPosition   = new Vector3(Nodo.x, Nodo.y) * grid.GetCellSize() + Vector3.one * grid.GetCellSize() * .5f;
                bool    isCurrent      = Nodo == current;
                bool    isInOpenList   = openList.Contains(Nodo);
                bool    isInClosedList = closedList.Contains(Nodo);
                int     tmpX           = x;
                int     tmpY           = y;

                gridSnapshotAction.AddAction(() => {
                    Transform visualNode = visualNodeArray[tmpX, tmpY];
                    SetupVisualNode(visualNode, CostoG, CostoH, CostoF);

                    Color backgroundColor = UtilsClass.GetColorFromString("636363");

                    if (isInClosedList)
                    {
                        backgroundColor = new Color(1, 0, 0);
                    }
                    if (isInOpenList)
                    {
                        backgroundColor = UtilsClass.GetColorFromString("009AFF");
                    }
                    if (isCurrent)
                    {
                        backgroundColor = new Color(0, 1, 0);
                    }

                    visualNode.Find("sprite").GetComponent <SpriteRenderer>().color = backgroundColor;
                });
            }
        }

        gridSnapshotActionList.Add(gridSnapshotAction);
    }
Exemplo n.º 2
0
    public void TakeSnapshotFinalPath(Grilla <CasillaNodo> grid, List <CasillaNodo> path)
    {
        GridSnapshotAction gridSnapshotAction = new GridSnapshotAction();

        gridSnapshotAction.AddAction(HideNodeVisuals);

        for (int x = 0; x < grid.GetWidth(); x++)
        {
            for (int y = 0; y < grid.GetHeight(); y++)
            {
                CasillaNodo CasillaNodo = grid.GetGridObject(x, y);


                Vector3 gridPosition = new Vector3(CasillaNodo.x, CasillaNodo.y) * grid.GetCellSize() + Vector3.one * grid.GetCellSize() * .5f;
                bool    isInPath     = path.Contains(CasillaNodo);
                int     tmpX         = x;
                int     tmpY         = y;

                gridSnapshotAction.AddAction(() => {
                    Transform visualNode = visualNodeArray[tmpX, tmpY];


                    Color backgroundColor;

                    if (isInPath)
                    {
                        backgroundColor = new Color(0, 1, 0);
                    }
                    else
                    {
                        backgroundColor = UtilsClass.GetColorFromString("636363");
                    }

                    visualNode.Find("sprite").GetComponent <SpriteRenderer>().color = backgroundColor;
                });
            }
        }

        gridSnapshotActionList.Add(gridSnapshotAction);
    }
Exemplo n.º 3
0
    public List <Nodo> EncontrarCamino(int startX, int startY, int endX, int endY, int type)
    {
        Nodo StartNode = grilla.GetGridObject(startX, startY);
        Nodo endNode   = grilla.GetGridObject(endX, endY);

        CaminosPosibles = new List <Nodo> {
            StartNode
        };
        CaminosVisitados = new List <Nodo>();
        for (int x = 0; x < grilla.GetWidth(); x++)
        {
            for (int y = 0; y < grilla.GetHeight(); y++)
            {
                Nodo nodo = grilla.GetGridObject(x, y);
                nodo.CostoG = int.MaxValue;
                nodo.CalcularCostoF();
                nodo.Padre = null;
            }
        }
        StartNode.CostoG = 0;
        StartNode.CostoH = CalcularDistanciaEntre(StartNode, endNode);
        StartNode.CalcularCostoF();

        PathfindingDebugStepVisual.Instance.ClearSnapshots();
        PathfindingDebugStepVisual.Instance.TakeSnapshot(grilla, StartNode, CaminosPosibles, CaminosVisitados);

        while (CaminosPosibles.Count > 0)
        {
            Nodo NodoActual = EncontrarValorMenor(CaminosPosibles, type);
            if (NodoActual == endNode)
            {
                PathfindingDebugStepVisual.Instance.TakeSnapshot(grilla, StartNode, CaminosPosibles, CaminosVisitados);
                PathfindingDebugStepVisual.Instance.TakeSnapshotFinalPath(grilla, CaminoCalculado(endNode));
                return(CaminoCalculado(endNode));
            }
            CaminosPosibles.Remove(NodoActual);
            CaminosVisitados.Add(NodoActual);

            foreach (Nodo nodoVecino in ValorarVecindad(NodoActual))
            {
                if (CaminosVisitados.Contains(nodoVecino))
                {
                    continue;
                }
                if (!nodoVecino.casillaValida)
                {
                    CaminosVisitados.Add(nodoVecino);
                    continue;
                }
                int CostoGIdeal = NodoActual.CostoG + CalcularDistanciaEntre(NodoActual, nodoVecino);
                if (CostoGIdeal < nodoVecino.CostoG)
                {
                    nodoVecino.Padre  = NodoActual;
                    nodoVecino.CostoG = CostoGIdeal;
                    nodoVecino.CostoH = CalcularDistanciaEntre(nodoVecino, endNode);
                    nodoVecino.CalcularCostoF();
                    if (!CaminosPosibles.Contains(nodoVecino))
                    {
                        CaminosPosibles.Add(nodoVecino);
                    }
                }
                PathfindingDebugStepVisual.Instance.TakeSnapshot(grilla, StartNode, CaminosPosibles, CaminosVisitados);
            }
        }

        //una vez se acaben los caminos posibles y no hay solucion
        return(null);
    }
Exemplo n.º 4
0
 private void Start()
 {
     iniciargrilla(20, 10);
     //pathfindingDebugStepVisual.Setup(grilla);
     pathfindingVisual.SetGrid(grilla);
     pathfindingVisual1.SetGrid(grilla);
     pathfindingVisual2.SetGrid(grilla);
     pathfindingVisual3.SetGrid(grilla);
     pathfindingVisual4.SetGrid(grilla);
     pathfindingVisual5.SetGrid(grilla);
     pathfindingVisualP.SetGrid(grilla);
     pathfindingVisualP1.SetGrid(grilla);
     pathfindingVisualP2.SetGrid(grilla);
     pathfindingVisualP3.SetGrid(grilla);
     StartNode         = grilla.GetGridObject(0, 0);
     VecindadValida    = new List <CasillaNodo>(); // casillas de la vecindad que puede visitar
     SegurosSinVisitar = new List <CasillaNodo> {
         StartNode
     };                                                       // casillas seguras posibles sin visitar
     CaminosVisitados = new List <CasillaNodo>();
     NodoActual       = grilla.GetGridObject(0, 0);
     NodoActual.CrearPosible(-1);
 }
Exemplo n.º 5
0
    //public CasillaNodo ResolverPasoCaminito(int startX, int startY)
    //{
    //    CasillaNodo StartNode = grilla.GetGridObject(startX, startY);
    //    CasillaNodo NodoActual; // es la pocicion del agente
    //    VecindadValida = new List<CasillaNodo> { StartNode }; // casillas de la vecindad que puede visitar
    //    SegurosSinVisitar = new List<CasillaNodo> { StartNode }; // casillas seguras posibles sin visitar
    //    CaminosVisitados = new List<CasillaNodo> { StartNode };


    //   // PathfindingDebugStepVisual.Instance.ClearSnapshots();
    //    //PathfindingDebugStepVisual.Instance.TakeSnapshot(grilla, StartNode, SegurosSinVisitar, CaminosVisitados);

    //    NodoActual = StartNode;

    //    while (SegurosSinVisitar.Count > 0) // mientras que haya casillas seguras sin visitar
    //    {

    //       SegurosSinVisitar.Remove(NodoActual);
    //        CaminosVisitados.Add(NodoActual);
    //        NodoActual.CrearReal(-1);

    //        EvaluarVecindadEfectos(NodoActual);
    //        //VecindadValida = ValorarVecindad(NodoActual);

    //        foreach (CasillaNodo NodoValido in EncontrarVecindad(NodoActual)) // para cada vecino valido ....
    //        {

    //            if (CaminosVisitados.Contains(NodoValido)) continue;  //si el vecino ya fue visitado, ignorelo


    //            if (NodoValido.Grilla_Agente == 0 )
    //            {
    //                VecindadValida.Add(NodoValido);

    //                if (!SegurosSinVisitar.Contains(NodoValido))
    //                {
    //                   SegurosSinVisitar.Add(NodoValido);
    //                }

    //                continue;
    //            }
    //        }


    //        if (EvaluarVecindadMov(VecindadValida) != null) // si la vecindad tiene un nodo seguro no visitado ....
    //        {
    //             NodoActual = EvaluarVecindadMov(VecindadValida); // el nodo al que se mueve es el mejor que determina evaluarvecindad ... osea el primero que encuentra seguro en orden horario

    //        }else
    //        {
    //            NodoActual = NodoActual.Padre;


    //        }


    //           // PathfindingDebugStepVisual.Instance.TakeSnapshot(grilla, StartNode,SegurosSinVisitar, CaminosVisitados);
    //    }
    //}



    public CasillaNodo GetNodo(int x, int y)
    {
        return(grilla.GetGridObject(x, y));
    }