Tengo el clásico sistema de pathfinding que enseñan en el 99% de los tutoriales
[gml]///AI_init(width,height,precise)
precise = argument[2];
width = argument[0];
height = argument[1];
_grid = mp_grid_create(0,0,ceil(room_width/argument[0])
,ceil(room_height/argument[1]),argument[0],argument[1]);
_path = path_add();
_obstacles = ds_list_create();
mp_grid_add_instances(_grid,obj_wall,precise);
_priorityGrid = ds_grid_create(width,height);
[/gml]
y
[gml]///AI_patrol(x,y,allowDiagonal,speed)
if !mp_grid_path(_grid,_path,x,y,argument[0],argument[1],argument[2]) {
//show_debug_message("Path could not be computed")
return false;
}
else{
path_start(_path,0.6,path_action_reverse,true)
return true;
}[/gml]
me funciona bien pero... solo si pongo una speed >= 1... si pongo una speed < 1 por ejemplo 0.6 pues ya no funciona cuando ha de dirigirse hacia abajo y/o derecha, sin embargo arriba y/o izquierda sí funca... me topé con el mismo problema con más velocidad cuando implementé estos scripts en el evento step, entonces lo cambié a un bucle de 2 steps en una alarm y se arregló, hasta ahora que lo estoy intentando con menos velocidad.
Antes que comentéis lo que me imagino, la razón por la que la quiero poner en bucle es porque mi juego, a parte de que el pathfinding lo hago para los enemigos sigan al player (y el player obviamente se mueve xd), también he de resetear a tiempo real los obstáculos, ya que es un juego estilo minecraft y las paredes, agua, etc (obstáculos) pueden cambiar en cualquier momento.
Cómo soluciono esto? me encantaría poner enemigos lentos :(
una solucion que te puede ayudar es descomponer el path en sus puntos
primero tendrias que obtener todos los puntos con path_get_number() y luego ir enlistando uno a uno con path_get_point_x y path_get_point_y
de ahi en vez de usar path_start podrias usar cualquier otra funcion para dirigirte a las coordenadas a la velocidad que se te antoje
salu3
algo así?
[gml]var _pointsx = ds_list_create();
var _pointsy = ds_list_create();
for ( var i=0;i<path_get_number(argument[0]);i++ ) {
ds_list_add(_pointsx,path_get_point_x(argument[0],i) );
ds_list_add(_pointsy,path_get_point_y(argument[0],i) );
}[/gml]
a partir de aquí no se me ocurre cómo seguir, desconozco mucho tanto las funciones path como las de ds_ xDD
si asi va bien, ahí ya tenes los puntos del path, no te olvides de borrar la ds_list cuando ya no haga falta
ahora deberías ir obteniendo punto por punto e ir moviendo la instancia en plan:
1 obtengo el primer punto
2 si la distancia es mayor a 0, me muevo hacia ese punto
3 si la distancia es igual a 0, obtengo otro punto
4 repetir hasta que ya no queden puntos
y asi te vas moviendo sin usar path_start, imagino que con move_towards_point, total el camino ya está calculado, no deberian haber obstaculos sino bueno, los calculas de nuevo :v
ya tengo mis vars de spd, hsp, vsp y dir PROPIAS, con el ípico bucle que aplica el movimiento
[gml]for ( var i=0;i<abs(hsp);++i )
if place_free( x+sign(hsp),y )
&& !place_meeting( x+sign(hsp),y,owater )
&& !place_meeting( x+sign(hsp),y,oswamp )
x += sign(hsp)*min( 1,abs(hsp) );
else {
if hsp != 0 {
dir = irandom(359);
get_hsp();
}
}
for ( var i=0;i<abs(vsp);++i ) {
if place_free( x,y+sign(vsp) )
&& !place_meeting( x,y+sign(vsp),owater )
&& !place_meeting( x,y+sign(vsp),oswamp )
y += sign(vsp)*min( 1,abs(vsp) );
else {
if vsp != 0 {
dir = irandom(359);
get_vsp();
}[/gml]
[gml]///get_hsp()
hsp = dcos(dir)*spd;[/gml]
[gml]///get_hsp()
hsp = -dsin(dir)*spd;[/gml]
no podría aprovechar esas vars simplemente asignando la dir con point_direction?
Y no acabo de comprender lo de sacar punto por punto, insisto que cada 2 steps (o 1 si es posible), se reinicia todo, entonces, no podría ahorrarme el for y pillar simplemente el primer x,y (que no sé si ser´el 0 o el 1) y aplicar la dir y la spd y ya está?
si el caso es que solo necesitas el siguiente punto entonces si, no necesitas almacenar todos jajaja solo sacás 1, y si, podes aprovechar la variable de direccion combinandola con point_direction, en teoria deberia funcionar
parecía que si funcaba pero no, pasa lo mismo o algo parecido, con 0.6 parece que oc, con 0.8 va mal para según qué dirección
[gml]///path_start_alt(ind,speed)
var _xx = path_get_point_x(argument[0],1);
var _yy = path_get_point_y(argument[0],1);
dir = point_direction(x,y,_xx,_yy);
spd = argument[1];[/gml]