Comunidad Game Maker

Se me ocurren varias formas de resolver esto:
Las instancias del objeto personaje se podrían destruir al colisionar con el objeto meta, y el objeto meta evaluaría esto en el evento step [gml]if( instance_number(personaje) == 0 ) room_goto_next();[/gml]

Otra opción es que el objeto meta lleve un contador de las veces que colisiona un personaje colisiona con éste, pero presiento
que ésta es la forma más complicada.

También se podría activar una variable en las instancias del objeto personaje al colisionar con la meta, y el objeto meta tendría algo así en su evento Step:
[gml]
global.pasarnivel = true;
with( obPersonaje ) global.pasarnivel = global.pasarnivel and meta; //meta es una variable
if( global.pasarnivel ) room_goto_next();
[/gml]

Al principio me hizo reír la temática del juego, después me pareció que el salto es un poco incómodo y no se ve realista, y que el juego está en una etapa muy temprana, rápidamente se vuelve aburrido. Me gustaría que se pudiera aumentar o disminuir levemente la velocidad y que hubiera diferentes powerups.

Para que no atraviese los objetos sólidos debes agregar código (o una acción) al evento colisión con ese objeto, o usar un código que indique cómo reaccionar ante una colisión con ese objeto, el hecho de marcar la casilla "solid" no implica que el objeto no será atravesable.

http://gmc.yoyogames.com/index.php?showtopic=643640

Tengo la sensación de que esto es un bug o depende de la versión de :GMS:. Yo tengo la versión 1.3 y usé exactamente el mismo código, el resultado es diferente, la parte blanca aparece en los bordes de la máscara de colisión del sprite rojo, y no en medio como en tu caso, al modificar la máscara de colisión el resultado no cambia.

La solución que encontré es dibujar los elementos en el orden inverso; primero el sprite rojo y luego la máscara de recorte, y en vez de usar "draw_circle_color" usé un sprite con forma circular, si no tampoco funciona.

Hice otras pruebas y si quieres usar texturas o máscaras con "anti-alias" (suavizadas) es mejor usar draw_set_blend_mode_ext( bm_one, bm_zero );, en vez de draw_clear_alpha(0,0);. Las pruebas están en el ejemplo adjunto.

En :GM8: el código funciona sin problemas.

Fuera de un if, "==" se puede usar como un operador que sirve para comparar, ejemplo:
[gml]
c = (a == b); //asignar el valor 0 ó 1
c += (a == b); //sumar 0 ó 1
[/gml]

Yo prefiero usar "==" dentro de los ifs para visualizar rápidamente que estoy haciendo una comparación.

Pues lo mejor es trabajar sólo con PNG y usar colores indexados.

Al importar las imágenes a  :GMS: o crearlas con el editor integrado se convierten a PNG de 24 bits (cada pixel pesa 24 bits), siempre quedarán pesadas aunque estén optimizadas desde antes de importarlas.

Ya hice pruebas y es posible reducir el peso de la imágenes dentro de las carpetas de proyecto con un programa optimizador, como PNGMosnter, PNGOptimizer o Riot.

PNGMonster me gusta más porque es el más sencillo de usar, Riot permite muchos ajustes, PNGOptimizer da buenos resultados pero no sobrescribe los archivos, por lo que se tienen que borrar los originales y cambiar el nombre a los nuevos.

Es exactamente como dice Silver_light, uso esas funciones porque el código queda más reducido; la expresión
[gml]v_ang = min( v_ang+a_ang, 3.5 );[/gml]
es equivalente a
[gml]
v_ang += a_ang;
if( v_ang > 3.5 ) v_ang = 3.5;
[/gml]
se mantiene el valor de v_ang dentro del límite y el código de dos líneas se hace en una. También se puede usar la función clamp, pero uso min y max porque sólo necesito 2 argumentos y el código es compatible con versiones anteriores a  :GMS:

Lo que yo entiendo es que el cambio de velocidad debe ser gradual. Si quieres que la aceleración sólo sea lineal define un valor para la variable friction, ejemplo: [gml]friction = 0.2[/gml]
Si también quieres que la aceleración sea angular y quieres que la aceleración lineal sea más agradable, usa un código como éste:
[gml]
///EVENTO CREATE: Inicializar

a_ang = 0.2; //aceleración angular
a_lin = 0.2; //aceleración linear

v_ang = 0; //velocidad angular
speed = 0; //velocidad linear

direction = 0;
[/gml]
[gml]
///EVENTO STEP: Movimiento

//Angular
if( keyboard_check(vk_left) ) { //si se presiona izquierda
    v_ang = min( v_ang+a_ang, 3.5 ); //cambiar v_ang hasta 3.5
}
else if( keyboard_check(vk_right) ) {//si se presiona derecha
    v_ang = max( v_ang-a_ang, -3.5 ); //cambiar v_ang hasta -3.5
}
else { //si no se presiona izquierda ni derecha
    if( v_ang < 0 ) v_ang = min( v_ang+a_ang, 0 ); //v_ang se hace cero
    if( v_ang > 0 ) v_ang = max( v_ang-a_ang, 0 ); //de forma gradual
}
direction += v_ang; //cambiar la deirección
image_angle = direction;

//Lineal
if( keyboard_check(vk_up) ) { //si se presiona arriba
    speed = min( speed+a_lin, 5 ); //aumentar speed hasta 5
} else { //si no se presiona arriba
    speed = max( speed-a_lin, 0 ); //disminuir speed hasta 0
}
[/gml]
Ajusta los valores de aceleración hasta que sean agradables.

Dime si he entendido bien, quieres que la torre dispare una bala hacia el enemigo, haciendo una predicción de la posición del enemigo para que siempre sea interceptado, además el enemigo se mueve usando una "path".

Creo que ese problema tiene varias soluciones, pero falta más información, ¿cómo es la vista del juego?, ¿con qué algoritmo se mueve la bala?

Usa un ciclo anidado:
[gml]
for( i=0; i<2; i+=1 )
{
    for( j=0; j<4; j+=1 )
    {
        draw_sprite( 64*i, 64*j, ... );
        draw_text( 64*i+16, 64*j+16, ... );
    }
}
[/gml]
Pero si los cuadros se deben comportar como botones, en vez de sólo dibujar los sprites, crea los botones como objetos o como scripts.

Tomando como un base un script que dibuja polígonos, hice uno que crea paths, adjunto un ejemplo.

Aquí hay un ejemplo de órbitas circulares: http://yal.cc/gamemaker-orbiting/, espero que te sirva.

Hacer un path circular a mano es algo complicado, con un script sencillo se puede aproximar mucho a una circunferencia, en la próxima respuesta lo presento.

Se puede dibujar así:
[gml]
draw_set_circle_precision( 7 );
draw_ellipse( x,y, x+32,y+32, outline );
[/gml]

CORRECCIÓN: El método anterior no funciona porque la precisión debe ser un número divisible entre 4.

Hice un script para dibujar polígonos regulares.
[gml]
/*
DIBUJAR UN POLIGONO REGULAR

Sintaxis
    poligono( x, y, n, r, angulo, contorno );

Argumentos
    x,y: centro del polígono
    n: número de lados
    r: radio
    angulo: ángulo del radio inicial
    contorno: (true) dibujar sólo contorno, (false) llenar polígono
   
Devuelve: nada
*/
var xx, yy, n, r, t, i;
xx = argument0; //centro
yy = argument1;
n = max( floor(argument2), 3 ); //por lo menos 3 lados
r = argument3; if( r <= 0 ) r = 1; //el radio no deber ser negativo ni cero
t = argument4; //ángulo

if( !argument5 ) {
    draw_primitive_begin( pr_trianglefan );
    draw_vertex( xx, yy );
}
else draw_primitive_begin( pr_linestrip );
for( i=0; i<=n; i++ )
{
    draw_vertex(
    xx + lengthdir_x(r,t),
    yy + lengthdir_y(r,t) );
    t -= 360/n;
}
draw_primitive_end();
[/gml]

Lee una historia o mira una película y piensa cómo convertirla en un juego. O platica con los que tienen juegos en progreso y ayúdales.