Un poco perdido en A*

[Vicente]

Jejeje, no me di cuenta que ya lo habias puesto tu blau en tu codigo

[BitEver]

Bueno, he conseguido un pasito más, ahora ya llego al final de camino, pero ahora el problema lo tengo al volver hacia atrás, pasando de hijo a padre.

El problema que tenía lo solucione como decíais, me buscaba la F más baja, pero a veces esa F ya estaba en la lista cerrada, con lo que al comprobar vecinos, siempre daba los mismos, y se quedaba en bucle. Lo que he hecho, ha sido una vez cogido el valor F más bajo, comprobar que no esta en la listaCerrada, y si es así coger el segundo valor más bajo F, el tercero, etc...

No creo que sea la mejor solución, pero de esta forma llego al final del camino, comprobando todos los posibles caminos.

Ahora tengo el problema, como decía en volver hacia atrás, voy pasando de hijo a padre, pero llega un momento, que se queda en bucle en dos cuadros, pasando entre ellos de hijo a padre. Esto es supongo, por que a la hora de crear el camino, tengo que tener al conflicto a la hora de asignar o cambiar el padre de cada nodo vecino.

Este es el código para ir hacia atrás, que creo que esta bien:

Código: [Seleccionar]

if(!listaPadres.Contains(nodo[inicioX,inicioY]))
{
int aux;
int auy;
aux = inicioX;
auy = inicioY;
listaPadres.Add(nodo[aux,auy]);
inicioX = nodo[aux,auy].padre.x;
inicioY = nodo[aux,auy].padre.y;

}

Aunque el fallo, pienso que tiene que estar como digo, a la hora de asignar o comprobar el padre (si tiene un valor G más bajo):

Código: [Seleccionar]

         if(listaAbierta.Contains(nodo[ix, iy]))
         {           
            if(nodo[ix,iy].valorG <= nodoRecorrido.valorG)
            {
               nodo[ix,iy].padre = nodoRecorrido;
               nodo[ix,iy].CalcularG();
               nodo[ix,iy].CalcularF();
            }
         }
         else {
               nodo[ix, iy].padre = nodoRecorrido;
               nodo[ix, iy].valorH = 10*(Mathf.Abs(ix  - fx) + Mathf.Abs(iy - fy));
               nodo[ix, iy].CalcularG();
               nodo[ix, iy].CalcularF();
               listaAbierta.Add(nodo[ix, iy]);               
         }

También es posible que siga calculando mal la G?? y cuando compruebo si un nodo que ya esta en la lista abierta tiene un valor G más bajo, y le cambio el padre por el nodo comprobado, y que de esta manera tambien me falle al asignar el padre, no??

Bueno, gracias a vosotros, poquito a poquito parece que lo voy consiguiendo, también es verdad que cada vez me canso más, llevo ya varios días dedicandole muchas horas a este código, y frusta no conseguir algo, y aunque no suelo rendirme, esta casi a punto de superarme, jeje.

Saludos.

[blau]

Código: [Seleccionar]

        if(listaAbierta.Contains(nodo[ix, iy]))
         {            
            if(nodo[ix,iy].valorG <= nodoRecorrido.valorG)
            {    


Vamos a ver, sin verme el algoritmo y por lo que yo entiendo que debe hacer:

Si el nodo (V) que esta en la lista abierta, previamente calculado  e introducido en ella, tiene un coste real (Gv) mayor que el coste de llegar al nodo que estamos evaluando como padre (N) + el coste de llegar de N a V, significa que a traves de N se llega con menor coste, o sea que se llega con menor coste que a traves del nodo Padre (Pv) de V que introdujo a V en la lista abierta. Luego hay que actualizar el coste de V y su padre,Pv, para que pasen a traves de N.

Quedaria algo asi:

          if(nodo[ix,iy].G > nodoRecorrido.G + 10) {
            nodo[[ix,iy].G = nodoRecorrido.G+10;
            nodo[ix,iy].H = manahtan; // Esto no cambi, no es necesario
            nodo[ix,iy].F = G + H;   // Hay que reordenar la lista
            nodo[ix,iy].Padre = nodoRecorrido;
          }  

Por otra, parte yo no llamaría a funciones tipo calcularG o calcularF desde el bucle principal, creo que para unos cálculos tan simples merece la pena ir viéndolos sobre el algoritmo y evita que te pierdas con lo que se esta haciendo en cada momento.

Por otro lado deberías poner mas enfoque en entender el algoritmo antes de liarte a programar.

[BitEver]

Conseguido!!!   

Era eso que calculaba mal la G. Bueno, mi máximo agradecimiento, es todo un logro para mi, haber conseguido y entendido realizar esto, con toda vuestra ayuda, que no ha sido poca. Aunque lo importante es que ahora lo entiendo, a parte de saber hacerlo, y el subidon que te pega cuando realizas algo en lo que llevas tanto esforzandote, estoy muy contento en este momento.

Se que para muchos es fácil, pero para mi es todo un logro, lograr aplicar algo así cuando nunca antes he programado.

Lo dicho que muchas gracias por vuestra ayuda, seguro que sin ella no habría podido lograrlo, o entenderlo, y que siento haber sido tan pesado.

Saludos.