Hola :
Tengo un problema con el Centralizado de los Path en el View, me explico.
1) Al Crear el Objeto este crea un path de 6 puntos, elije las posiciones al azar dentro del View. El Path no esta Cerrado
EVENTO CREATE
//. Crear Path Random
myPath = path_add()
path_set_kind(myPath, true) //. Smooth Curves
path_set_closed(myPath, false) //. Path Cerrado
path_set_precision(myPath, 4)
PathTotal = 8
repeat PathTotal {
px = random(600)
py = random(600)
path_add_point(myPath, px, py, 100)
}
path_start(myPath, 8, 1, true)
2) Cuando el Objeto ha Alcanzado en recorrido del Path en un 0.49%, entonces
a) Toma los 3 últimos puntos del path, y los pone en la posición 0
b) Genera nuevos puntos, a partir de los 3 anteriores, para conservar la forma de la curva.
c) Se asegura que cada punto generado, no debe estar mas cerca en distancia, del valor situado en la variable radio=50
(para evitar curvas muy pronunciadas, valores mas grandes, el ciclo se quedara pegado, al no encontrar espacios suficientemente amplios para situar los puntos del path)
EVENTO DRAW
//. Path Draw Debug
min_x = 0
min_y = 0
max_x = 0
max_y = 0
path_width = 0
path_height = 0
radio = 50
for(n=0; n < PathTotal; n++){
px = path_get_point_x(myPath, n)
py = path_get_point_y(myPath, n)
//. Calcula el Ancho y Alto General del Path
min_x = min(px, min_x)
min_y = min(py, min_y)
max_x = max(px, max_x)
max_y = max(py, max_y)
path_width = max_x - min_x
path_height = max_y - min_y
//. Dibuja los Puntos del Path
draw_ellipse_color((px-4), (py-4), (px+4), (py+4),
c_blue, c_blue, c_black)
//draw_text((px -4), (py -20), string(n))
//. Radio entre los puntos
if(n < 3)then draw_set_color(c_purple) //. Los 3 Memorizados
else draw_set_color(c_yellow) //. Los 3 Nuevos
draw_circle(px, py, radio, true)
}
//. Dibuja los Limites del Ancho y Alto del Path
MargenX = (view_wview - path_width) / 2
MargenY = (view_hview - path_height) / 2
draw_rectangle(MargenX, MargenY, MargenX + path_width, MargenY + path_height, c_blue)
draw_path(myPath, 0, 0, true)
//. Chequea el Estado de avance en el Path (path de 6 puntos)
//. Se activa cuando el objeto ha avanzado casi un 50% del recorrido
if(path_position > 0.495) {
show_debug_message('position: ' + string(path_position))
//. Mueve en las posiciones 0,1,2 los valores de, 3,4,5
for(n=0; n < 3; n++){
vx = path_get_point_x(myPath, n+3)
vy = path_get_point_y(myPath, n+3)
path_change_point(myPath, n, vx, vy, 100)
show_debug_message('Path('+string(n)+'): ' + string(vx) + ','+ string(vy) )
}
//. Genera nuevas puntos a partir de la posición 3
for(n=3; n < PathTotal; n++) {
dist = 0
do {
px = random(600)
py = random(600)
//. Comprueba que los Radios de Cada punto no queden muy cerca "radio*2"
for(k=0; k < PathTotal; k++){
mx = path_get_point_x(myPath, k)
my = path_get_point_y(myPath, k)
dist = point_distance(px, py, mx, my)
if(dist < radio*2) { break }
}
} until(dist > radio*2)
show_debug_message('Coord('+string(n)+'): ' +string(px)+' , '+string(py) +' Dist: '+ string(dist) )
path_change_point(myPath, n, px, py, 100)
}
path_position = 0.00
path_start(myPath, 8, 1, true)
}
Pues bien si analizan el algoritmo, trabaja perfectamente, solo que el Path al momento de ser dibujado parece perder el Centro, por lo que la figura que lo sigue, da como un salto desde una posición a otra, y en realidad debiera continuar, un ciclo infinito, ya que se va creando un nuevo path, a partir de los últimos 3 puntos, que siempre se van conservando, hay alguna manera de centrar el path, en el view, hay alguien que analiza algoritmos ?
Gracias !!!
Saludos
???
El problema es ligeramente más complicado a si simplemente se descentraran los path, que de hecho no está ocurriendo.
Lo que ocurre es que, para empezar, las curvas en un path suavizado dependen de al menos los dos puntos anteriores en el path, cuando remplazas los tres puntos iniciales por los últimos tres puntos estas borrando la curva del nuevo primer punto, que cambia la forma de la parte del path que el objeto debería estar siguiendo.
Además, cuando cambias los puntos del path también estas enviando el objeto al inicio de dicho path con path_position = 0.00, la mayor parte del tiempo esa no será igual a la posición donde el objeto estaba antes del cambio de puntos.
Para solucionarlo debes evitar borrar la curva que el objeto está siguiendo en ese momento, sugeriría remplazar los puntos del path de uno en uno, en lugar de tres en tres, y luego debes escanear el path para encontrar la posición del path que coincide con la posición actual del objeto.
Hola:
Mira a ver si puedes echarme una mano, le introduje una modificación ...
la variable "last=2", indica la cantidad de puntos, de la cola del Path, que luego son transferidos, a la posición 0, y desde alli debe dibujar un nuevo path, todo este cambio ocurre cuando el objeto a recorrido, un 74% de la ruta del path, osea el Path se reconfigura antes de alcanzar la ultima curva, hecha por la incidencia de "last", numero de puntos ...
//. reguta el Estado del Path
if(path_position > 0.74) {
show_debug_message('position: ' + string(path_position))
last = 2
for(n=0; n < last; n++){
vx = path_get_point_x(myPath, (PathTotal -last) +n)
vy = path_get_point_y(myPath, (PathTotal -last) +n)
path_change_point(myPath, n, vx, vy, 100)
show_debug_message('Path('+string(n)+'): ' + string(vx) + ','+ string(vy) )
}
for(n=last; n < PathTotal; n++) {
dist = 0
do {
px = random(600)
py = random(600)
for(k=0; k < PathTotal; k++){
mx = path_get_point_x(myPath, k)
my = path_get_point_y(myPath, k)
dist = point_distance(px, py, mx, my)
if(dist < radio*2) { break }
}
} until(dist > radio*2)
show_debug_message('Coord('+string(n)+'): ' +string(px)+' , '+string(py)
+' Dist: '+ string(dist) )
path_change_point(myPath, n, px, py, 100)
}
path_position = 0.00
path_start(myPath, 8, 1, true)
}
Lo que estoy viendo la posibilidad es de crear un Segundo Path, que se inicia a partir de ultimo punto del primero, asi cuando alcanza el final del primer, Path, el objeto puede cantinuar el el Segundo, en el Mismo Punto en donde Terminó el Primero, cuando Termine el Segundo Path, comienze nuevamente el Primer Path, pero ahora generado a partir del ultimo punto del Segundo y Así sucesivamente, se van intercalando uno a uno ... no se si realmente resulte, es una idea, algún comentario u ocurrencia, se agradece !!!
Saludos !!!
Acá dejo el código con las correcciones que mencione:
//. Path Draw Debug
min_x = 0
min_y = 0
max_x = 0
max_y = 0
path_width = 0
path_height = 0
radio = 50
for(n=0; n < PathTotal; n++){
px = path_get_point_x(myPath, n)
py = path_get_point_y(myPath, n)
//. Calcula el Ancho y Alto General del Path
min_x = min(px, min_x)
min_y = min(py, min_y)
max_x = max(px, max_x)
max_y = max(py, max_y)
path_width = max_x - min_x
path_height = max_y - min_y
//. Dibuja los Puntos del Path
draw_ellipse_color((px-4), (py-4), (px+4), (py+4),
c_blue, c_blue, c_black)
//draw_text((px -4), (py -20), string(n))
//. Radio entre los puntos
if(n < 3)then draw_set_color(c_purple) //. Los 3 Memorizados
else draw_set_color(c_yellow) //. Los 3 Nuevos
draw_circle(px, py, radio, true)
}
//. Dibuja los Limites del Ancho y Alto del Path
MargenX = (view_wview - path_width) / 2
MargenY = (view_hview - path_height) / 2
draw_rectangle(MargenX, MargenY, MargenX + path_width, MargenY + path_height, c_blue)
draw_path(myPath, 0, 0, true)
//. Chequea el Estado de avance en el Path (path de 6 puntos)
//. Se activa cuando el objeto ha avanzado casi un 50% del recorrido
if(path_position > 0.495) {
show_debug_message('position: ' + string(path_position))
//. Mueve en las posiciones de todos los puntos un espacio hacia atras
for(n=0; n < PathTotal-1; n++){
vx = path_get_point_x(myPath, n+1)
vy = path_get_point_y(myPath, n+1)
path_change_point(myPath, n, vx, vy, 100)
show_debug_message('Path('+string(n)+'): ' + string(vx) + ','+ string(vy) )
}
//. Genera un nuevo último punto
dist = 0
do {
px = random(600)
py = random(600)
//. Comprueba que los Radios de Cada punto no queden muy cerca "radio*2"
for(k=0; k < PathTotal; k++){
mx = path_get_point_x(myPath, k)
my = path_get_point_y(myPath, k)
dist = point_distance(px, py, mx, my)
if(dist < radio*2) { break }
}
} until(dist > radio*2)
show_debug_message('Coord('+string(n)+'): ' +string(px)+' , '+string(py) +' Dist: '+ string(dist) )
path_change_point(myPath, n, px, py, 100)
//. Busca la nueva posicion en el path relativa a la anterior
n=0.15
do{
px = path_get_x(myPath,n)
py = path_get_y(myPath,n)
n+=0.0005
}until(n>=1 || ((round(x) == ceil(px) || round(x) == floor(px)) && (round(y) == ceil(py) || round(y) == floor(py))))
path_start(myPath, 8, 1, true)
path_position = n
}
Ahora mueve las posiciones de los puntos un lugar hacia atrás, lo que elimina el primer punto original, y luego genera un nuevo último punto.
Luego escanea el nuevo path para encontrar la posición correcta para continuar. Esta parte en particular, sin embargo, usa más fuerza bruta de la que me gustaría.
Por otro lado, la idea de tener dos paths intercambiándose sucesivamente debería funcionar sin problemas.
Hola :
Si estuve viendo la modificación, del código, en realidad funciona como debiera, sin perder el centro del path, (le agradezco, por el tiempo dedicado), ahora lo puedo usar en una especie de BOSS.
De todas maneras, voy a dejar la forma con los 2 Path que se intercambian ,,, ahí lo analizamos !!!
Gracias !!!