public void findNodoTest()
    {
        Abiertos abiertos = new Abiertos(9, 3, 3);
        bool     comprobar;
        Nodo     comprobar_nodo;

        Nodo nodo = new Nodo();

        nodo.vector = new Vector3(1.0f, 0.0f, 0.0f);
        nodo.coste  = 1.0f;

        abiertos.add(nodo);

        comprobar = abiertos.find(nodo, out comprobar_nodo);
        Assert.IsTrue(comprobar_nodo.coste == nodo.coste && comprobar_nodo.vector == nodo.vector, "6) No es el mismo nodo que introducimos");
        Assert.IsTrue(comprobar, "7) No se ha encontrado el nodo que introducimos");

        abiertos.delete(nodo);

        comprobar = abiertos.find(nodo, out comprobar_nodo);
        Assert.IsNull(comprobar_nodo, "8) No tenia que haber encontrado el nodo");
        Assert.IsFalse(comprobar, "9) No tenia que haber encontrado el nodo");
    }
    public override bool pasoCalcularRuta(out bool error)
    {
        error = false;

        if (abiertos.count() > 0 && !meta_encontrada)
        {
            nodo_actual = abiertos.getFirst();


            if (esMeta(nodo_actual, vector_meta))
            {
                meta_encontrada = true;
                nodo_final      = nodo_actual;

                v_trayectoria = vectoresCamino(nodo_final);
                n_trayectoria = nodosCamino(nodo_final);
            }
            else
            {
                cerrados.add(nodo_actual);

                if (dibujar_casillas)
                {
                    parrilla.visualizarCasilla(nodo_actual.vector, Constantes._CERRADOS);
                }

                sucesores = CalcularSucesores(nodo_actual, vector_meta, mapa);

                foreach (Nodo sucesor in sucesores)
                {
                    Nodo anterior;

                    if (abiertos.find(sucesor, out anterior))
                    {
                        if (anterior.coste > sucesor.coste)
                        {
                            anterior.padre  = nodo_actual;
                            anterior.coste  = sucesor.coste;
                            anterior.costeG = sucesor.costeG;
                            anterior.costeH = sucesor.costeH;

                            //Para el hybrid
                            anterior.sentido       = sucesor.sentido;
                            anterior.vector_hybrid = sucesor.vector_hybrid;
                            anterior.angulo_hybrid = sucesor.angulo_hybrid;
                            abiertos.updatePrioridad(anterior, anterior.coste);
                        }
                    }
                    else
                    {
                        if (cerrados.find(sucesor, out anterior))
                        {
                            if (anterior.coste > sucesor.coste)
                            {
                                cerrados.delete(anterior);
                                abiertos.add(sucesor);

                                if (dibujar_casillas)
                                {
                                    parrilla.visualizarCasilla(sucesor.vector, Constantes._ABIERTOS);
                                }
                            }
                        }
                        else                             //No esta ni en abiertos ni en cerrados
                        {
                            abiertos.add(sucesor);

                            if (dibujar_casillas)
                            {
                                parrilla.visualizarCasilla(sucesor.vector, Constantes._ABIERTOS);
                            }
                        }
                    }
                }
            }
        }
        else             //abiertos esta vacio
        {
            if (abiertos.count() == 0)
            {
                error = true;
            }
        }

        return(meta_encontrada);
    }