コード例 #1
0
ファイル: AStar.cs プロジェクト: Pokoi/SGDJamII
    private void Algorithm(int destX, int destZ, int origX, int origZ, box[,] table)
    {
        Node minimo = null;

        //timeTaken = Time.time;

        DateTime d = DateTime.Now;

        timeTaken = d.Millisecond;

        // bucle principal a partir del cual se ejecutara la logica del algoritmo
        while (abiertos.Count > 0 && !FOUND)
        {
            // sacamos el nodo minimo de la cola
            minimo = abiertos.Top(); abiertos.Pop();

            // lo guardamos en la cola de cerrados, ya esta comprobado
            cerrados.Add(minimo);

            // este metodo devuelve las coordenadas de las casillas adyacentes a
            // la que estamos comprobando (cada nodo tiene la informacion de en
            // que posicion esta su casilla)
            List <coords> adyacentes = calcAdyacentes(minimo.i_, minimo.j_, table);

            foreach (coords c in adyacentes)
            {
                // si el nodo a comprobar esta en cerrados no hacemos nada
                if (cerrados.Contains(nodeMatrix[c.x_, c.z_]))
                {
                    continue;
                }

                // si en esa posicion no hay un nodo asociado lo creamos,
                // le ponemos los valores en funcion de su coste y la heuristica
                // a utilizar y le asignamos el padre
                if (nodeMatrix[c.x_, c.z_] == null)
                {
                    Node ady = new Node();
                    ady.setPosition(c.x_, c.z_);
                    ady.Parent_ = minimo;
                    ady.h_      = calculateH(HEURISTIC, ady.i_, ady.j_, origX, origZ);
                    ady.g_      = calculateG(ady, table);
                    ady.f_      = ady.h_ + ady.g_;

                    // si la casilla a la que se le asocia dicho nodo no es una habitación
                    // lo metemos en abiertos
                    if (table[ady.i_, ady.j_].cell != Cells.Room)
                    {
                        abiertos.Insert(ady.i_ + table.GetLength(0) * ady.j_, ady);
                    }
                    //// en caso contrario lo metemos en cerrados
                    //else
                    //{
                    //    cerrados.Add(ady);
                    //}

                    // actualizamos matriz de nodos
                    nodeMatrix[ady.i_, ady.j_] = ady;
                }

                // si el nodo ya esta creado lo que haremos sera
                // ver si el nuevo camino que va a el es mejor
                else
                {
                    Node ady = nodeMatrix[c.x_, c.z_];

                    int weight = 0;

                    if (table[ady.i_, ady.j_].cell == Cells.Empty)
                    {
                        weight = 1;
                    }
                    else if (table[ady.i_, ady.j_].cell == Cells.Door)
                    {
                        weight = 4;
                    }
                    else if (table[ady.i_, ady.j_].cell == Cells.Corridor)
                    {
                        weight = 4;
                    }
                    else if (table[ady.i_, ady.j_].cell == Cells.Room)
                    {
                        weight = int.MaxValue;
                    }
                    int g = minimo.g_ + weight;

                    // si el nuevo camino es mejor, actualizamos el nodo
                    if (g + ady.h_ < ady.f_)
                    {
                        ady.Parent_ = minimo;
                        ady.g_      = g;
                        ady.f_      = ady.g_ + ady.h_;
                    }
                }
            }

            // si las coordenadas asociadas al nodo coinciden con el destino,
            // hemos llegado, salimos del bucle
            if (minimo.i_ == destX && minimo.j_ == destZ)
            {
                FOUND = true;
            }
        }

        if (FOUND)
        {
            // para saber el tiempo que ha tardado en finalizar el algoritmo
            //DateTime da = DateTime.Now;
            //float auxTime = da.Millisecond - timeTaken;

            // ahora calculamos el camino a seguir recorriendo los nodos que nos han llevado a la solucion
            calculatePath(minimo, origX, origZ);

            // feedback visual
            //GameObject.FindGameObjectWithTag("Destiny").GetComponent<Renderer>().material.color = Color.green;
            //FindObjectOfType<HUDControllScript>().setTime(auxTime);
        }
        else
        {
            // feedbakc visual
            // si entramos aqui es que no hay solucion
            //GameObject.FindGameObjectWithTag("Destiny").GetComponent<Renderer>().material.color = Color.red;
        }
    }
コード例 #2
0
    private void Algorithm(int destX, int destZ, int origX, int origZ)
    {
        Node minimo = null;

        //timeTaken = Time.time;

        DateTime d = DateTime.Now;

        timeTaken = d.Millisecond;

        // bucle principal a partir del cual se ejecutara la logica del algoritmo
        while (abiertos.Count > 0 && !FOUND)
        {
            // sacamos el nodo minimo de la cola
            minimo = abiertos.Top(); abiertos.Pop();

            // lo guardamos en la cola de cerrados, ya esta comprobado
            cerrados.Add(minimo);

            // este metodo devuelve las coordenadas de las casillas adyacentes a
            // la que estamos comprobando (cada nodo tiene la informacion de en
            // que posicion esta su casilla)
            List <coords> adyacentes = calcAdyacentes(minimo.i_, minimo.j_);

            foreach (coords c in adyacentes)
            {
                // si el nodo a comprobar esta en cerrados no hacemos nada
                if (cerrados.Contains(nodeMatrix[c.x_, c.z_]))
                {
                    continue;
                }

                // si en esa posicion no hay un nodo asociado lo creamos,
                // le ponemos los valores en funcion de su coste y la heuristica
                // a utilizar y le asignamos el padre
                if (nodeMatrix[c.x_, c.z_] == null)
                {
                    Node ady = new Node();
                    ady.setPosition(c.x_, c.z_);
                    ady.Parent_ = minimo;
                    ady.h_      = calculateH(HEURISTIC, ady.i_, ady.j_, origX, origZ);
                    ady.g_      = calculateG(ady);
                    ady.f_      = ady.h_ + ady.g_;

                    abiertos.Insert(ady.i_ + 7 * ady.j_, ady);

                    // actualizamos matriz de nodos
                    nodeMatrix[ady.i_, ady.j_] = ady;
                }

                // si el nodo ya esta creado lo que haremos sera
                // ver si el nuevo camino que va a el es mejor
                else
                {
                    Node ady = nodeMatrix[c.x_, c.z_];

                    int weight = 0;

                    int g = minimo.g_ + weight;

                    // si el nuevo camino es mejor, actualizamos el nodo
                    if (g + ady.h_ < ady.f_)
                    {
                        ady.Parent_ = minimo;
                        ady.g_      = g;
                        ady.f_      = ady.g_ + ady.h_;
                    }
                }
            }

            // si las coordenadas asociadas al nodo coinciden con el destino,
            // hemos llegado, salimos del bucle
            if (minimo.i_ == destX && minimo.j_ == destZ)
            {
                FOUND = true;
            }
        }

        if (FOUND)
        {
            // para saber el tiempo que ha tardado en finalizar el algoritmo
            DateTime da      = DateTime.Now;
            float    auxTime = da.Millisecond - timeTaken;

            // ahora calculamos el camino a seguir recorriendo los nodos que nos han llevado a la solucion
            calculatePath(minimo, origX, origZ);
        }
        else
        {
            Debug.Log("No hay solución");
        }
    }