Colisiones verticales y suelos

Fundamentos de la colisión vertical en juegos de plataformas

En el desarrollo de videojuegos de plataformas bidimensionales, la física vertical es el pilar sobre el cual descansa toda la experiencia interactiva del usuario. Mientras que el movimiento horizontal define el avance y la exploración a través del escenario, el movimiento vertical gobierna la gravedad, el salto, las caídas y la sensación de peso del personaje. Un sistema de colisiones verticales defectuoso rompe instantáneamente la inmersión del jugador: caídas que atraviesan el suelo (fenómeno conocido técnicamente como 'tunneling'), personajes que se hunden visiblemente varios píxeles dentro del piso antes de detenerse, o saltos que permiten atravesar techos sólidos de manera indeseada.

En GameMaker, el espacio de coordenadas bidimensional posee una convención que todo desarrollador debe dominar desde el primer día: el eje vertical (Y) crece en sentido descendente. El origen de coordenadas (0, 0) se localiza en la esquina superior izquierda de la sala (Room). En consecuencia, cualquier valor positivo aplicado a la velocidad vertical desplaza la instancia hacia abajo (hacia el suelo), mientras que cualquier valor negativo la desplaza hacia arriba (hacia el techo o las alturas del cielo). Esta orientación invertida con respecto al plano cartesiano geométrico tradicional influye directamente en las condiciones lógicas y los cálculos matemáticos de las colisiones.

El problema del movimiento discreto y la solución predictiva

Los motores de videojuegos ejecutan su ciclo principal cuadro a cuadro (frame a frame). Si un personaje posee una velocidad vertical acumulada de 12 píxeles por frame debido a la gravedad y el programador simplemente escribe 'y += vspd;', el motor no desplaza al personaje de manera continua a lo largo de esos 12 píxeles en el tiempo real del mundo, sino que lo 'teletransporta' 12 píxeles más abajo en el siguiente fotograma. Si el suelo sólido se encontraba a tan solo 4 píxeles por debajo de los pies del personaje, la instancia terminará incrustada 8 píxeles dentro del bloque.

Para evitar este error, se utiliza una técnica estándar en la programación de videojuegos 2D conocida como 'resolución predictiva con aproximación por contacto'. En lugar de mover primero la coordenada del objeto y verificar después si colisionó, el algoritmo evalúa de antemano la posición futura del objeto ('y + vspd'). Si se detecta un obstáculo sólido en dicha posición futura, se interrumpe el movimiento brusco y se ejecuta un bucle de aproximación fina que desplaza al personaje píxel a píxel hasta que queda exactamente al ras de la superficie, anulando a continuación la velocidad residual.

Análisis matemático del algoritmo de aproximación vertical

La lógica de colisión vertical se apoya en dos funciones nativas esenciales de GameMaker: 'place_meeting()' y 'sign()'. La función 'place_meeting(x, y, objeto)' toma la máscara de colisión de la instancia actual, la sitúa hipotéticamente en las coordenadas (x, y) suministradas, y comprueba si en esa posición colisionaría con alguna instancia del objeto especificado, retornando un valor booleano ('true' o 'false') sin modificar la posición real de la instancia.

Por su parte, la función matemática 'sign(val)' evalúa el signo del valor numérico que recibe como argumento: si el valor es positivo devuelve 1; si es negativo devuelve -1; y si es exactamente cero devuelve 0. En nuestro contexto, 'sign(vspd)' es una herramienta formidable, ya que condensa la dirección del movimiento vertical en un vector unitario de exactamente un píxel de magnitud: 1 hacia abajo cuando el personaje cae, y -1 hacia arriba cuando el personaje se eleva tras un salto.

// Estructura algorítmica de la colisión vertical predictiva
if (place_meeting(x, y + vspd, obj_bloque))
{
    // Mientras no exista colisión a un solo píxel en la dirección de la velocidad
    while (!place_meeting(x, y + sign(vspd), obj_bloque))
    {
        y = y + sign(vspd); // Avanzar un píxel exacto hacia la superficie
    }
    
    vspd = 0; // Detener por completo la velocidad vertical acumulada
}

// Si no hay colisión, o una vez resuelta la posición exacta, aplicar movimiento
y = y + vspd;

El funcionamiento del bucle 'while' merece una atención especial. Un bucle 'while' repite sus instrucciones internas tantas veces como sea necesario dentro del mismo fotograma antes de que GameMaker dibuje nada en pantalla. Si el personaje cae a 8 píxeles por frame y el suelo está a 3 píxeles, la condición inicial 'place_meeting(x, y + 8, obj_bloque)' se evalúa como verdadera. El bucle 'while' comprobará 'y + 1' (libre), avanzará 1 píxel; comprobará 'y + 2' (libre), avanzará otro píxel; comprobará 'y + 3' (contacto con el suelo). Al detectar el contacto a un píxel de distancia, el bucle se detiene de inmediato. La posición del personaje queda sellada al borde exacto del suelo y la velocidad vertical 'vspd' se establece en 0, evitando que en el siguiente fotograma la gravedad continúe sumando velocidad sobre una superficie sólida.

Pisos y techos: Unificación del tratamiento con sign()

Una de las mayores virtudes de este algoritmo es su simetría matemática. Muchas personas que comienzan a programar cometen el error de crear un bloque de código separado para detectar suelos ('if vspd > 0') y otro totalmente diferente para detectar techos ('if vspd < 0'). Esta duplicación es propensa a errores y complica el mantenimiento del proyecto. Gracias al uso de 'sign(vspd)', el mismo fragmento de código resuelve con idéntica precisión milimétrica ambos escenarios:

1. Cuando el personaje cae ('vspd > 0'): 'sign(vspd)' equivale a +1. El bucle empuja al personaje hacia abajo hasta tocar la parte superior del bloque del piso, fijando 'vspd = 0'. El jugador aterriza limpiamente y la gravedad deja de arrastrarlo hacia el abismo.

2. Cuando el personaje salta ('vspd < 0'): 'sign(vspd)' equivale a -1. El bucle empuja al personaje hacia arriba hasta que su cabeza hace contacto con la base inferior del bloque del techo. En ese instante, al hacer 'vspd = 0', la inercia ascendente del salto se cancela de golpe. En el siguiente fotograma, la gravedad comenzará a sumar su valor positivo, haciendo que el personaje comience a caer de forma natural inmediatamente después de golpearse la cabeza, tal como ocurre en los grandes clásicos de plataformas retro.

Integración completa en el objeto del jugador

Para asegurar la coherencia técnica de nuestro proyecto de plataformas, integraremos las colisiones verticales junto con las horizontales vistas en la clase anterior y el sistema de gravedad básica. Todas las variables deben declararse inicialmente en el evento Create del objeto del jugador ('obj_jugador'), garantizando que existan en la memoria antes de ser leídas o manipuladas.

// ========================================================
// OBJETO: obj_jugador
// EVENTO: Create
// ========================================================

// Variables de movimiento horizontal
hspd = 0;             // Velocidad horizontal actual en píxeles por frame
move_speed = 3.5;     // Rapidez máxima de desplazamiento lateral

// Variables de movimiento vertical y física
vspd = 0;             // Velocidad vertical actual en píxeles por frame
grv = 0.25;           // Fuerza de gravedad aplicada por frame
jump_speed = -6.5;    // Impulso inicial del salto (negativo hacia arriba)
vspd_max = 9.0;       // Velocidad terminal de caída libre

Con las variables debidamente inicializadas, el evento Step concentrará toda la lógica de captura de controles, suma de aceleraciones físicas y resolución secuencial de colisiones. El orden de las operaciones en el evento Step es fundamental: primero leemos la entrada del jugador, luego calculamos las velocidades deseadas (incluida la aceleración de gravedad), después resolvemos las colisiones horizontales, a continuación resolvemos las colisiones verticales, y finalmente aplicamos los movimientos.

// ========================================================
// OBJETO: obj_jugador
// EVENTO: Step
// ========================================================

// 1. CAPTURA DE ENTRADAS DEL TECLADO
var _key_left  = keyboard_check(vk_left) || keyboard_check(ord("A"));
var _key_right = keyboard_check(vk_right) || keyboard_check(ord("D"));
var _key_jump  = keyboard_check_pressed(vk_space) || keyboard_check_pressed(ord("W"));

// 2. CÁLCULO DE MOVIMIENTO HORIZONTAL
var _move = _key_right - _key_left;
hspd = _move * move_speed;

// 3. APLICACIÓN DE GRAVEDAD
// La gravedad incrementa la velocidad descendente hasta alcanzar la velocidad terminal
vspd = vspd + grv;
if (vspd > vspd_max)
{
    vspd = vspd_max;
}

// 4. RESOLUCIÓN DE COLISIÓN HORIZONTAL
if (place_meeting(x + hspd, y, obj_bloque))
{
    while (!place_meeting(x + sign(hspd), y, obj_bloque))
    {
        x = x + sign(hspd);
    }
    hspd = 0;
}
x = x + hspd;

// 5. RESOLUCIÓN DE COLISIÓN VERTICAL (PISOS Y TECHOS)
if (place_meeting(x, y + vspd, obj_bloque))
{
    while (!place_meeting(x, y + sign(vspd), obj_bloque))
    {
        y = y + sign(vspd);
    }
    vspd = 0;
}
y = y + vspd;

Observa con detenimiento que el movimiento se divide estrictamente en dos fases separadas: primero se resuelve y aplica el eje X ('x = x + hspd'), y posteriormente se resuelve y aplica el eje Y ('y = y + vspd'). Esta separación de ejes (Orthogonal Axis Separation) es indispensable. Si intentáramos evaluar simultáneamente la diagonal mediante 'place_meeting(x + hspd, y + vspd, obj_bloque)', el personaje se trabaría al rozar esquinas o caminar adyacente a una pared vertical mientras se encuentra apoyado en el piso.