Comunidad Game Maker

Aquí está una buena guía para calcular los saltos: http://www.comunidadgm.org/articulos/como-medir-el-salto-de-tu-personaje-plataformero-(programacion)/

Si el personaje puede aterrizar a diferentes alturas, tal vez no sea conveniente tener una animación con tiempos exactos. La animación se podría basar en la velocidad vertical y en la distancia al piso, por ejemplo, cuando se inicia el salto la velocidad vertical tiene un valor absoluto grande y es negativa, aquí debe iniciar la primera parte de la animación; cuando se está alcanzando la altura máxima la velocidad sigue siendo negativa pero con valor absoluto pequeño, aquí se inicia la segunda parte de la animación (digamos que el personaje encoje las piernas); cuando la velocidad pasa a ser positiva el personaje está cayendo, en cierto valor se debe iniciar la tercera parte de la animación. Puede haber otras animaciones, por ejemplo, cuando la velocidad vertical es positiva y es muy grande el personaje se puede mostrar asustado porque la caída le causará daño, o si se está muy cerca del piso mostrar al personaje preparado para aterrizar.

Me puse a hacer pruebas y ahora veo que obtener piezas bien alineadas es un proceso laborioso. Ahora te comento cómo lo he logrado, lo hice con GIMP, no estoy acostumbrado a usar Photoshop, seguramente se puede usar el mismo procedimiento:

• Poner la imagen como fondo.
• Agregar una capa con el patrón de rompecabezas, con relleno blanco y contornos negros.
• Cambiar la mezcla de la capa a "multiplicar", así se ve la imagen de fondo y las líneas negras.
• Después se aumenta el tamaño de lienzo para tener espacio transparente alrededor de la imagen.
• Usar la herramienta de selección por color en la capa que tiene el dibujo de rompecabezas, y copiar la selección en una capa nueva, este paso se repite para todas las piezas.
• Se define una rejilla cuyas líneas principales pasan por los bordes de las piezas y con líneas secundarias que pasan por el centro de las piezas
• Con ayuda de la rejilla se recortan las capas, que contienen piezas individuales, en rectángulos del mismo tamaño.
• Finalmente las capas se exportan como imágenes individuales.

Podemos continuar con el código para arrastrar las piezas. Se me ocurre este método: En el evento Create del controlador se declara la variable global.seleccion = noone;, esa variable contiene el id de la pieza que se arrastra. En el objeto pieza, en el evento Left Pressed se escribe lo siguiente
[gml]
global.seleccion = id;
rx = mouse_x - x;
ry = mouse_y - y;
[/gml]
Si hay varias piezas bajo el puntero, la variable global.seleccion tendrá el id de la que está encima, de esa forma se no se seleccionan varias piezas a la vez. Las variables rx,ry guardan la posición relativa de la pieza a la posición del puntero en el momento de hacer click.
En el evento Step se agrega
[gml]
if( global.seleccion == id )
{
    depth = 0;
    x = mouse_x - rx;
    y = mouse_y - ry;
}
[/gml]
Si la pieza está seleccionada la profundidad se hace cero para que esté encima de las demás piezas (su profundidad normal debería ser mayor a cero), la posición x,y se desplaza al mover el puntero.
En el evento Left Released la pieza regresa a su profundidad normal y la variable global.seleccion se reinicia
[gml]
depth = 1;
global.seleccion = noone;
[/gml]

Algo muy importante, es decidir la forma de la máscara de colisión, que sirve para detectar cuándo se hace click en la pieza. Las opciones: son usar colisión precisa, usar una elipse o usar un rectángulo. La primera no me gusta porque requiere mucho procesamiento (depende de qué tan grande sea el sprite), la segunda es mejor pero es más fácil que las máscaras se empalmen, y la tercera es la que me gusta ya que requiere el menor procesamiento y se ajusta de forma aceptable al sprite.

Lo anterior lo he agregado a un ejemplo (que está adjunto). El ejemplo también tiene un código que hace que la pieza se pegue ("snap") a la posición correcta cuando está cerca. Está en el evento Step
[gml]
else if( point_distance(x,y,xstart,ystart) < 64 )
{
    x = xstart;
    y = ystart;
}
[/gml]

Bueno, por ahora sólo elige una nave al azar, falta programar el seguimiento y el ataque. En tu juego ¿los niveles son armados con el editor de rooms? en ese caso la forma de elegir una nave al azar debe ser ligeramente diferente, pues se deben tomar en cuenta las naves que ya están creadas.

¿Quieres hacer un juego con físicas similares a las de Angry Birds?

Si es así, programarlo todo desde cero es mucho trabajo, mejor usa una extensión de física para GM8 (http://www.gmtoolbox.com/), ésta me da confianza: http://www.maartenbaert.be/extremephysics/.

Si no, el movimiento parabólico es fácil de hacer; el personaje debe tener 2 componentes de la velocidad, una horizontal que es constante, y una vertical que es afectada por la gravedad. Supongo que has leído algún tutorial para un juego de plataformas, el principio es el mismo. Para hacer el movimiento puedes usar las variables hspeed, vspeed, gravity y gravity_direction (o crear tus propias variables).
Tal vez el mayor problema es hacer que el aterrizaje se ajuste a una cuadrícula de 24x24, puede haber muchas formas de resolverlo, una forma es ajustar la velocidad horizontal cuando se esté acercando al piso y otra es hacer los lanzamientos sólo con velocidades que causen un aterrizaje en las posiciones que quieres. Es más complicado si el personaje puede aterrizar a diferentes alturas.
Aquí hay unos códigos que te pueden servir: http://www.comunidadgm.org/preguntas-y-respuestas/hacer-un-canon/, recuerdo que hay otros temas parecidos en el foro, usa el buscador.

Sería bueno que des más detalles del juego que quieres hacer para ver qué método es mejor.

Se llaman polinomios aritméticos, y además, creo que los ejemplos que has puesto no se pueden considerar como polinomios aritméticos porque intervienen variables, sería mejor llamarles "expresiones algebraicas".
Hace tiempo quería programar un intérprete algebraico en GM, pero pronto me aburrí y abandoné el proyecto. Encontré algo que es similar a lo que pretendía hacer, pero no lo he estudiado a fondo, tal vez te sirva: http://www.gmlscripts.com/forums/viewtopic.php?id=1890.
¿Qué tipo de solución quieres obtener?

El ciclo i se repite tres veces y genera las piezas (P0,P1,P2). El ciclo j hace que el ciclo i se repita otras dos veces y entonces genera las piezas (P3,P4,P5) y después (P6,P7,P8), todas en orden.

Estas son mis sugerencias para el juego.

Lo primero es tener las piezas bien alineadas. Cada sub-imagen de los sprites debe tener una forma parecida a la imagen siguiente

el rectángulo interno es la forma básica de la pieza y el borde sirve para colocar las protuberancias (la mayor parte del borde queda vacía). El sprite debe tener dimensiones pares (alto y ancho), de esa forma el origen puede quedar exactamente al centro.

Al final se tendría un sprite con sub-imágenes como estas


Hay que ver qué separaciones se tienen en la rejilla (imaginaria) que contiene las piezas.

Las distancias deben ser iguales a las dimensiones del rectángulo base de las piezas, los bordes del sprite no se toman en cuenta porque se empalman.

Si hay nueve piezas, se posicionarán en nueve puntos ordenados como se muestra (el orden puede ser diferente).


Vamos a crear un nivel de prueba. Lo primero es mostrar el rompecabezas armado y después desordenarlo. Se deben crear 2 objetos; uno es el objeto pieza y el otro es el objeto controlador (los nombres quedan a tu elección).
El objeto controlador se va a encargar de crear y acomodar la piezas, en su evento Create puede ir este código
[gml]
//Inicializar variables
dx = //distancia horizontal
dy = //distancia vertical
imagen = //sprite que contiene las piezas

//Ciclos para crear las piezas
k = 0; //contador de sub-imagen
for( j=0; j<3; j++ ) //ciclo vertical
for( i=0; i<3; i++ ) //ciclo horizontal
{
    with instance_create( i*dx+x, j*dy+y, obj_pieza )
    {
        sprite_index = other.imagen;
        image_index  = other.k;
    }
    k ++;
}
[/gml]
[Pregunta si no entiendes el código]

Después se tienen que dispersar la piezas, eso puede suceder al terminar la cuenta de un temporizador, o se puede agregar un botón que disperse las piezas.
Se me ocurren dos formas de dispersar las piezas: alrededor del cuadro original o a un lado del cuadro original. Las posiciones finales pueden estar predefinidas o pueden ser aleatorias.

¿Cómo quieres hacer la dispersión?

Nos vemos luego.

El error significa que la variable pieceSelected no está declarada en el objeto obj_PuzzlePiece, ¿has borrado algún código de ese objeto?, tal vez se declara en otro objeto (controlador) que no has agregado a la room.

¿Qué forma tienen las piezas del rompecabezas? Si son cuadradas o rectangulares se podrían dividir usando surfaces, aunque lo mejor es dividirla desde antes y guardar todas las partes como sub-imágenes de un sprite. Si tienen forma repetitiva (como de "jigsaw") también se podrían recortar en surfaces usando unos srpites como máscaras de recorte, pero en este caso también es mejor recortarlas desde antes. Si tienen formas irregulares o aleatorias serían útiles las primitivas.

También falta saber cómo son los controles o la mecánica del juego. Las piezas se podrían mover entre rieles, o se podrían mover libremente, incluso rotar.

¿En verdad usas GM5?, eso es algo fuera de lo común. Yo nunca he usado esa versión, espero que los códigos sean compatibles.

Bien, al ejecutar el código anterior cada instancia tiene una variable enemigo que contiene el id de la nave a la que debe seguir. El método para seguir puede ser de diferentes formas dependiendo del movimiento de la nave, por ejemplo, la nave podría girar rápidamente y tener una aceleración instantánea (éste es el método más fácil de programar) o podría acelerar lentamente hasta alcanzar su rapidez máxima y tardar un tiempo en dar una vuelta completa, también podría tener algún tipo de planificación de movimiento y evitar obstáculos, ¿cómo es el comportamiento de tus naves?

Si las naves son creadas con un objeto controlador, se pueden guardar los ids en dos arreglos (uno para cada bando):
[gml]
//Guardar ids
for( i=0; i<100; i+=1 )
{
    ids_bando1 = instance_create( x,y, obj_nave );
    ids_bando2 = instance_create( x,y, obj_nave );
    //x,y pueden ser aleatorias
}
//Asignar id del enemigo
for( i=0; i<100; i+=1 )
{
    ids_bando1.enemigo = ids_bando2[irandom(99)];
    ids_bando2.enemigo = ids_bando1[irandom(99)];
}
[/gml]
Con el código anterior varias instancias pueden tener el mismo enemigo y no corresponderse entre sí, formando cadenas de enemigos.

Dime si te agrada el método. Luego muestro otros métodos.

Otra forma sería incrementar el contador en el evento Step y que el incremento sea cada vez mayor, ejemplo:
[gml]
///Step
incremento ++;
contador += incremento;
if( contador > puntuacion )
{
    contador = puntuacion;
    incremento = 0;
    //...
}
[/gml]

Aquí un ejemplo de barra animada: http://www.comunidadgm.org/preguntas-y-respuestas/texturizar-un-draw_roundrect()-con-un-sprite-(solucionado)

La mayoría de los cubemaps que se pueden encontrar en internet son fotografías o renders de un escenario 3D. Para hacer uno similar necesitas tener una cámara profesional o saber modelar bien en un software 3D, los mapas hechos a mano por lo general representan el cielo (skybox), aunque hay algunos programas ligeros que permiten generar un skybox de forma automática (sólo he usado spacescape).
Para hacer un cubemap completamente a mano es necesario saber dibujar muy bien en perspectiva, y comparado con un mapa esférico, debe ser más fácil dibujar en el cubo porque hay menos distorsión.
Algo que podría simplificar el dibujo es crear un escenario 3D con formas básicas (cubos, cilindros, esferas, ...) que representen los objetos que se quieren colocar en esa posición, después hacer seis capturas para formar el cubemap y editar a mano las capturas, detallando los objetos.

Buen script shaq145, es genial.
Hice unas pruebas y noté que los eventos del teclado se siguen detectando mientras se ejecuta el script, cuando termina la pausa se ejecutan las acciones del teclado, hay que tener cuidado con eso.

También se puede escribir así:
[gml]
///sleep2( ms );
var tf = current_time + floor(argument0); //tiempo final
while( current_time < tf ){/*hacer nada hasta llegar al tiempo final*/}
[/gml]