hola, voy a estar fuera 2 días pero antes de salir quiero darlos mi regalo de navidad, como respuesta al de Splinter... je je je
bueno, hice una cosa que se carga y que te permite usar la función path find ocultando su complejidad.
el código de la función es:
EDITADO: AGREGO UNA NUEVA FUNCIÓN Y ACOMODO ALGUNOS DATOS DE LA FUNCIÓN AVANZA. TRANSFORMO LA FUNCIÓN AVANZA EN LOCAL COMPLETAMENTE.
[code language="bennu"]function avanza(fichero,grafico,x1,y1,efecto,int * arx,int * ary, *dat,velocidad,float escala);
private
dato;
begin
x=father.x; y=father.y;
if (velocidad>dat[1]-1-dat[0]) velocidad=dat[1]-1-dat[0]; end
if (velocidad<0) velocidad=0; end
if (escala<0.25) escala=0.25; end
if (dat[0]<(dat[1]-1) & x1==arx[dat[1]-1] & y1==ary[dat[1]-1] & father.x==arx[dat[0]] & father.y==ary[dat[0]]) //si las coordenadas no han cambiado
dat[0]+=velocidad;
father.x=arx[dat[0]]*escala; father.y=ary[dat[0]]*escala;
else
if (map_get_pixel(fichero,gráfico,x1/escala,y1/escala)==0)
dato=path_find(fichero,grafico,x/escala,y/escala,x1/escala,y1/escala,efecto);
if (dato)
dat[1]=0;
dat[0]=0;
while (path_getxy(&arx[dat[0]], &ary[dat[0]]));
dat[1]++;
dat[0]++;
end
dat[0]=0;
else
return(dato);
end
else
return(0);
end
end
return(1);
end
function g_recta(fichero,grafico,x,y,x1,y1,escala);
private
float ter,x2,y2;
begin
x2=x1-x;
y2=y1-y;
ter=fget_angle(x/escala,y/escala,x1/escala,y1/escala);
x2=x; y2=y;
repeat
angle=ter;
x2=x2+cos(ter);
y2=y2+sin(ter)*-1;
x=x2;
y=y2;
if (map_get_pixel(fichero,gráfico,x/escala,y/escala)<>0)
return(-361000);
end
until (fget_dist(x/escala,y/escala,x1/escala,y1/escala)<2);
return(angle);
end
[/code]
su uso es:
avanza(
| fichero, | //del gráfico con blanco y negro |
| gráfico, | //en blanco y negro |
| xdestino, |
| ydestino, |
| flags, | //lo de no diag y eso |
| array con más de 350 espacios ejemplo: puntosx[400]), | //array para almacenar los puntos x, pasarle el puntero |
| otro array del mismo tamaño, | //para almacenar las y |
| array con dos dimenciones, | ////uso interno |
| velocidad, | //la velocidad a la que irá nuestro proceso |
| escala | //la que usamos en nuestro mapa de búsquedas (ejemplo: 5 (nuestro mapa de búsqueda es 5 veces más pequeño que el real) |
);
incluyo un ejemplo sencillo de un mínimo de líneas.
nos vemos en breve. :)
para el ejemplo usen la tecla u para hacerlo correr key(_u) esto es para que no se trave, pues si movemos como loco el mouse se travará, y este es un seguro.
la tecla _e sirve para verificar si se puede llegar en línea recta a un punto.
en el paquete de abajo está la función para cargarse mediante include y el ejemplo.
espero les sirva a más de alguno.
VALORES DE RETORNO DE LAS FUNCIONES:
FUNCIÓN AVANZA:
| retorno | significado |
| 0 | no se puede avanzar, ya sea que no hay camino o que el destino se encuentra muy lejos |
| 1 | se ha avanzado |
FUNCIÓN G_RECTA:
| retorno | significado |
| -361000 | no se puede ir en línea recta |
| algún ángulo válido | el ángulo con el que se puede ir hacia el punto en línea recta |
Muchas gracias!
Ya que andamos con los regalos ahi va un karma!
Gracias, ya he visto preguntas de pathfinding más de una vez así que seguro que le es útil a mucha gente.
Karma +1 (tu Splinter también lo tuviste por tu regalo ;))
muchísimas gracias por los karmas.
Estoy agregando una función para saber si se puede llegar a un punto en línea recta, por el momento sólo funciona si la línea es de pi/2 rad o múltiplos, sin embargo deceo tenerlo para todos los ángulos para eso de lanzar disparos. espero poderlo hacer. :)
eh corregido el hecho de que puedas mover el proceso que crea el camino y entonces busque el camino no importa que no sean las posiciones adecuadas, y he agragado algunas cositas. voy a comer, pues acabo de llegar de viaje, pero al rato subo una versión con los cambios agregados. :)
agregada nueva función y modificada función avanza para hacerla más útil.
:)
descarga en el primer post
a propósito, hace unas horas no podía entrar al foro. a alguno le pasó lo mismo, o sólo a mí ??? .
Es estupendo, me faltaba un modulo de estos para mi coleccion, muchas gracias.
Solo una cuestion, ¿Todavia no hay forma de incrementar la profundidad de busqueda? Aun a costa de saturar el sistema me refiero...
:)
¿con profundidad de búsqueda te refieres a la distancia?
si es así, la única forma es hacer tus mapas de búsqueda más pequeños que los de visualización, y poner ese valor en la escala. eso es lo único que se me ocurre :)
Si, esa es la solucion facil (Y la que uso por ahora...).
Me referia a si es posible editar el codigo fuente de la funcion path_find(). Supongo que se tratara de un algoritmo de busqueda en un arbol, y no creo que sea muy dificil modificar la profundidad. Quiza cambiando un simple valor numerico ZAS!
Imagino que la funcion formara parte de alguno de los DLL de Bennu, nunca me ha dado por intentar modificar un DLL, soy completamente virgen en ese sentido xD
He estado informándome para desensamblar el DLL de path_find, pero al ser un binario y no conocer el lenguaje original en el que fue programado debe ser cosa difícil...
Investigo tu código minuciosamente, aunque por ahora no he podido adaptar la función avanza() a mis juegos, con cambiar la escala no me ha sido suficiente. Sé que es mucho pedir pero si subes una versión con algún comentario más sería muy muy útil.
Estoy interesadísimo en el path_find y lo más útil que he visto en ese sentido es tu ejemplo, ¿Alguna versión nueva?
Ánimo que el path_find bien utilizado puede dar muchísimo juego, ya tengo en mente usar path_find para hacer un juego de "Tower Defence" llamado Corral de Mocos (Aunque por ahora es sólo un sueño :'()
imagino que te referis a la mod_path... bueno, aca tenes todos los fuentes de bennu...
http://bennugd.svn.sourceforge.net/viewvc/bennugd/
Cielo santo!!!
No sabía que estaba el fuente disponible para path_find...
http://bennugd.svn.sourceforge.net/viewvc/bennugd/modules/mod_path/mod_path.c?revision=6&view=markup
No he revisado muy a fondo el código y de hecho me iré a dormir ya mismo porque estoy medio muerto, pero no veo limitaciones en la profundidad de búsqueda... He hecho pruebas con el típico test de dibujar un laberinto y dejar que lo resuelva y resuelve laberintos de durezas de tamaño considerable (Aprox 100x100 pixels!!!).
Sencillamente estupendo, un trabajo de auténticos ARTESANOS!!!
Muchísimas gracias, veré si puedo hacer algo digno con la librería mod_path y en cuanto lo tenga lo subiré al foro, mil gracias a todos!!!!
Me parece que en la función de PathFind de DIV2, esa profundidad era mayor. Yo trabajaba con mapas de hasta 160x120 pixeles, e incluso se podría haber heco de 320x240.
amigos, bennu es increíble, yo he trabajado con distancias de hasta más de 300 pixeles... (creo que a 340 todavía va).
Los mapas de juegos de estrategia como Starcraft o Warcraft III tienen mapas de hasta 256x256 casillas (Creo que más no...), si el path_find de Bennu es capaz de resolver más que eso es una verdadera maravilla!
Se comentó en uno de los posts en los que se hablaba de path_find que el problema es que el camino que resuelve es único, y para varios procesos simultáneos es necesario "memorizar" cada camino, y eso hay que programarlo "a mano". Había incluso un ejemplito por ahí hecho, con una función que se llamaba avanza(), ¿Alguien tiene algo hecho en esa línea?
acabo de probar con 256x256, probe con un mapa de 258x258, poniendo el inicio en 1,1 (0,0 parece que no va), y el fin en (257,257), y funciona a la perfeccion... eso si, segun los obstaculos que se le pongan puede tardar demasiado, y la verdad que el path resuelto no siempre es el mas corto...
si alguien se anima a hacer algo optimo y preciso, sera bienvenido...
¿Desde 0,0 no funciona? lol
La semana anterior hice MILES de pruebas, siempre desde 0,0 y ya me extrañaba que no me resolvía ni mapas de 16x16 pixels! Probablemente sería ese mi fallo xD
Los algoritmos de búsqueda de caminos generalmente no garantizan que la solución vaya a ser óptima. Lo que he aprendido sobre IA en la universidad lo tengo un poquito oxidado, pero los algoritmos eran A, A+, A*... Cada uno con sus particularidades.
No creo que sea prioritaria la consecución del algoritmo que encuentre el camino óptimo, veo más importante la eficiencia. He hecho cuentas y resolver el árbol completo de posibles caminos tiene un coste computacional astronómico.
Quizá implementar diversos path_find, unos óptimos, otros rápidos, sea la solución... Si alguien se anima... Actualmente no puedo, quizá el próximo curso que estaré metido con otros temas de IA en la universidad pueda ponerme a mirar algo.
si, al probar no me iba 0,0, pero la verdad no tengo tiempo de revisar el codigo para ver que pasaba...
todos andamos en lo mismo: "falta de tiempo"