Comunidad Game Maker

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.

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.

Creo que lo que eams quiere es que la cadena no sea solo parte del personaje, sino una entidad en si misma, como en Spelunky.

Lo que debes hacer es tomar en cuenta la posición del personaje con respecto a la bola y limitar su movimiento apropiadamente mientras cambias el de la bola, si el personaje se mueve muy lejos de la bola a la derecha mueves la bola a la derecha para mantener una distancia minima entre ellos.

Te dejo un ejemplo muy básico, te mueves con las flechas, cuando tocas la bola quedas encadenado a ella.

En serio, solo pon screen_redraw() antes del sleep en tu código original.

Pon screen_redraw() antes del sleep para dibujar el estado actual del juego antes de la espera.

Puedes usar este script:

///scr_sleep(millisecs)
var Tiempo, Pasado, Espera;

Tiempo = current_time;
Pasado = 0;
Espera = argument0;
while( Espera > Pasado ){
Pasado = current_time - Tiempo;
}

Sim embargo, y esto es importante, no lo recomiendo para esperas largas, el script lo que hace es colocar el programa en un ciclo que dura lo que tu le específicas, esto aumenta considerablemente el uso de procesador durante la duración de la espera y si el ciclo tarda mucho el programa sera marcado como No Responde.

No puedes usar juegos de GM8 en móviles, para hacerlo necesitas GameMaker Studio y el modulo apropiado que depende del OS de tu móvil.

Haces click en el icono + justo al lado de Global Game Settings, saldrá una ventana nueva, presionas install, sale otra ventana nueva, presionas install, se abrirá una ventana donde puedes buscar el archivo .gex de la extensión, lo seleccionas, le das abrir, le das a OK y listo, el paquete de extensión está instalado.

Luego deberás activarlo para usarlo con tu juego, simplemente debes seleccionarlo en la ventana de extensiones y darle click a la flecha para pasarlo de paquetes instalados a paquetes activados.

Es un caso de mala comunicación, Game Circle no es de Google, es de Amazon, y Iros te da instrucciones sobre la mecánica de un juego porque si de pura casualidad se busca Circle Game de Google por google el primer resultado es un juego hecho en html5.

El servicio de google se llama justamente Google Services, y en el manual del GMS puedes encontrar las funciones que necesitas, busca en Achievements and Leaderboards.

El sitio que deja Elvis es para registro de prueba de copyright, para registrar el nombre de un juego de manera que nadie más lo pueda usar en sus propios proyectos necesitas un trademark.

El derecho de autor, o copyright, es un derecho automático que todo autor recibe inmediatamente sobre cualquier propiedad intelectual que le pertenezca, pruebas de Copyright, como el sitio que ha dejado Elvis o registros gubernamentales son herramientas que ayudan a la defensa de dicho derecho de ser necesario. Sin embargo, el copyright no protege aspectos como el nombre dado a la obra o ideas implementadas en la obra, para ello necesitas un trademark o una patente, respectivamente.

Los trademarks son marcas que identifican a un individuo o grupo, físico o jurídico, pueden ser nombres, frases, lemas, logos, etc., y contrario a los derechos de autor no son inherentes a la creación de una obra intelectual. Deben ser registrados con la entidad apropiada de tu país.

Multiplicar por -1 invierte la distancia a 0, así que si la escala x primero es 1 se vuelve -1, y si es -1 se vuelve 1.

En xscale en lugar de -1 pon image_xscale*-1, eso revertirá la dirección actual del sprite en lugar de ponerle una dirección especifica.

Técnicamente se destruyen, pero no ejecutan evento de destrucción, es más como si simplemente dejaran de existir.

La próxima vez que se cargue el room estará como si fuera la primera vez que se visita, a menos por supuesto que se tomen medidas para hacer cambios en la room antes de regresar a ella.

Hablando en términos generales existen dos clases de variables, las locales y las globales, las variables locales son las que simplemente declaras por nombre, y solo existen dentro de la instancia donde fue creada, lo que significa que al destruir la instancia se destruye la variable.

Variable = 0

En cambio, una vez declaradas, las variables globales son reconocidas por todas las instancias y solo son destruidas cuando se finaliza el juego.

Las variables globales deben ser declaradas como tales, ya sea poniendo global. antes del nombre de la variable, o con la declaración de variables globalvar:

globalvar Vida, Magia, Nivel;
Vida = 100;
Magia = 10;
Nivel =1;
global.Puntuacion = 0;

Ahora atento que la cosa se complica un poco, una variable declarada dentro de un globalvar no necesita ser llamada con el global. antes de su nombre, pero puede hacerse, una variable declarada con global. debe siempre ser llamada con global.

Ademas el nombre de las variables declaradas con globalvar queda reservado, y no puede utilizarse para variables locales, pues el código pensará que te estas refiriendo a la variable global. En cambio variables declaradas con el global. pueden tener el mismo nombre que variables locales.

Existen metodos para evitar esto, pero como estas empezando no quiero que se te complique mucho esto.

En resumidas cuentas, si quieres una variable que deba ser declarada en el room1 y pueda ser leida en el room2 debes usar una variable global.

No, cuando abandonas una room las instancias en ella no siguen existiendo, a menos que la room sea persistente en cuyo caso su estado se guarda para ser accedido cuando se vuelva a la room, o la instancia sea persistente en cuyo caso, como ya te dijo Mgbu, será movida a la nueva room.

En ningún caso las instancias que queden en la room anterior seguirán ejecutando sus eventos, ni robando poder del procesador en ninguna forma.