Colisiones precisas con Tilemaps

Resolución de colisiones verticales y detección de suelo

Para el eje vertical el procedimiento es análogo, pero incorpora la interacción con la gravedad y el estado en_suelo. Si vel_y > 0 el personaje está cayendo, lo que significa que el borde evaluado es bbox_bottom. Si el borde inferior toca una celda sólida al descender:

• Aproximamos al jugador hacia abajo hasta que sus pies reposen exactamente sobre la superficie del tile. • Establecemos vel_y = 0 para cancelar la fuerza de caída acumulada por la gravedad. • Cambiamos en_suelo = true, permitiendo que el jugador vuelva a ejecutar la acción de salto.

Por el contrario, si vel_y < 0 el personaje está ascendiendo en un salto y su borde superior (bbox_top) impacta contra un techo. En ese instante cancelamos vel_y poniéndola a 0 para que empiece a caer inmediatamente, evitando que la cabeza atraviese el techo.

Implementación completa en el evento Step de obj_jugador

A continuación presentamos la integración completa del sistema. Observa cómo se calculan las lecturas del teclado, la aceleración por gravedad, las colisiones por bordes contra el Tilemap y finalmente el desplazamiento definitivo de las coordenadas x e y.

// ====================================================================
// RECURSO: Objetos -> obj_jugador
// EVENTO: Step
// ====================================================================

// --------------------------------------------------------------------
// 1. CAPTURA DE ENTRADAS DEL TECLADO
// --------------------------------------------------------------------
var _tecla_izq   = keyboard_check(vk_left)  || keyboard_check(ord("A"));
var _tecla_der   = keyboard_check(vk_right) || keyboard_check(ord("D"));
var _tecla_salto = keyboard_check_pressed(vk_space) || keyboard_check_pressed(ord("W"));

// Dirección calculada (-1, 0, 1)
var _dir = _tecla_der - _tecla_izq;
vel_x = _dir * vel_caminar;

// --------------------------------------------------------------------
// 2. APLICACIÓN DE GRAVEDAD Y SALTO
// --------------------------------------------------------------------
vel_y += gravedad;

// Salto condicionado a estar en contacto con el suelo
if (en_suelo && _tecla_salto) {
    vel_y = fuerza_salto;
    en_suelo = false;
}

// Asumimos inicialmente que no estamos en el suelo hasta comprobarlo abajo
en_suelo = false;

// --------------------------------------------------------------------
// 3. COLISIÓN HORIZONTAL CON EL TILEMAP
// --------------------------------------------------------------------
if (vel_x != 0) {
    // Definimos qué borde evaluar según la dirección del movimiento
    var _borde_x = (vel_x > 0) ? bbox_right : bbox_left;
    
    // Puntos verticales a evaluar en dicho borde (superior, centro e inferior)
    // Restamos 1 al pie (bbox_bottom - 1) para evitar falsos positivos con el suelo
    var _y_superior = bbox_top;
    var _y_medio    = (bbox_top + bbox_bottom) * 0.5;
    var _y_inferior = bbox_bottom - 1;
    
    // Verificamos si en la posición siguiente hay un tile sólido
    var _colision_h = es_celda_solida(mapa_colision, _borde_x + vel_x, _y_superior) ||
                      es_celda_solida(mapa_colision, _borde_x + vel_x, _y_medio)    ||
                      es_celda_solida(mapa_colision, _borde_x + vel_x, _y_inferior);
                      
    if (_colision_h) {
        // Aproximación píxel a píxel hasta el muro
        var _paso_h = sign(vel_x);
        while (!es_celda_solida(mapa_colision, _borde_x + _paso_h, _y_superior) &&
               !es_celda_solida(mapa_colision, _borde_x + _paso_h, _y_medio)    &&
               !es_celda_solida(mapa_colision, _borde_x + _paso_h, _y_inferior)) {
            x += _paso_h;
            _borde_x += _paso_h;
        }
        vel_x = 0;
    }
}

// Aplicamos el movimiento horizontal resuelto
x += vel_x;

// --------------------------------------------------------------------
// 4. COLISIÓN VERTICAL CON EL TILEMAP
// --------------------------------------------------------------------
if (vel_y != 0) {
    // Definimos qué borde vertical evaluar (cabeza o pies)
    var _borde_y = (vel_y > 0) ? bbox_bottom : bbox_top;
    
    // Puntos horizontales a evaluar a lo largo del ancho del personaje
    var _x_izq    = bbox_left;
    var _x_centro = (bbox_left + bbox_right) * 0.5;
    var _x_der    = bbox_right;
    
    // Comprobamos colisión en la posición vertical futura
    var _colision_v = es_celda_solida(mapa_colision, _x_izq,    _borde_y + vel_y) ||
                      es_celda_solida(mapa_colision, _x_centro, _borde_y + vel_y) ||
                      es_celda_solida(mapa_colision, _x_der,    _borde_y + vel_y);
                      
    if (_colision_v) {
        // Aproximación píxel a píxel hacia el obstáculo vertical
        var _paso_v = sign(vel_y);
        while (!es_celda_solida(mapa_colision, _x_izq,    _borde_y + _paso_v) &&
               !es_celda_solida(mapa_colision, _x_centro, _borde_y + _paso_v) &&
               !es_celda_solida(mapa_colision, _x_der,    _borde_y + _paso_v)) {
            y += _paso_v;
            _borde_y += _paso_v;
        }
        
        // Si íbamos cayendo y colisionamos, tocamos el suelo firme
        if (vel_y > 0) {
            en_suelo = true;
        }
        
        vel_y = 0;
    }
}

// Aplicamos el movimiento vertical resuelto
y += vel_y;

Fíjate con atención en un detalle técnico de vital importancia presente en el chequeo horizontal: cuando calculamos _y_inferior, usamos `bbox_bottom - 1` en lugar de `bbox_bottom`. Si evalúas el píxel exacto de bbox_bottom durante una comprobación horizontal mientras estás parado en el suelo, ese punto coincidirá con la superficie superior del bloque de tierra, interpretando erróneamente que una pared te bloquea el paso hacia adelante. Restar 1 píxel eleva el sensor justo por encima de la superficie de apoyo, garantizando que el personaje pueda caminar sin atascarse.

Alineación matemática directa por cuadrícula (Alternativa a los bucles)

El bucle while para el ajuste fino de píxeles (snapping) es sumamente intuitivo y muy seguro para velocidades estándar de juego. No obstante, en motores 2D profesionales existe una alternativa matemática directa: calcular exactamente en qué múltiplo de la cuadrícula comienza la celda colisionada. Dado que los tiles tienen un tamaño constante (por ejemplo, 16x16 píxeles), el borde superior de un bloque sólido siempre se encuentra en una coordenada múltiplo exacto de 16.

Por ejemplo, si un personaje cae hacia el suelo y su bbox_bottom penetraría en una celda, la posición ajustada Y donde debe reposar el origen del sprite puede calcularse restando la distancia relativa entre el origen y el borde inferior: `y = (tile_y * 16) - 1 - (bbox_bottom - y)`. Para quienes comienzan en GameMaker, el método de bucle while con paso de un píxel (`sign(vel)`) presentado arriba es el más confiable y resistente a fallos de redondeo de punto flotante.

Ventajas comparativas frente al sistema de objetos sólidos

Ahora que tienes ambos sistemas en tu caja de herramientas de desarrollo, resulta esencial entender cuándo emplear cada uno conforme avances hacia los módulos de enemigos y diseño de niveles:

Ejercicios prácticos de consolidación

Lleva a la práctica lo aprendido completando las siguientes tres actividades estructuradas sobre el proyecto del juego retro de plataformas que venimos construyendo:

Actividad 1: Configurar la capa de colisiones y recuperar el identificador. Abre la Room principal de tu proyecto. En el editor de capas, asegúrate de que tu capa de terreno se llame rigurosamente "Tiles_Terreno" (o el nombre que prefieras, respetando mayúsculas y minúsculas). En el evento Create de obj_jugador, añade una comprobación con show_debug_message() que imprima en la consola el valor de mapa_colision. Criterio de comprobación: Al pulsar F5 y ejecutar el juego, la ventana de salida debe mostrar un número entero mayor o igual a 0. Si muestra -1, la capa no existe o está mal escrita.

Actividad 2: Migración completa y eliminación de instancias sólidas redundantes. En la Room del juego, selecciona y elimina todas las instancias de obj_suelo u obj_bloque que habías colocado en el Módulo 5, dejando únicamente el arte pintado en la capa de mosaicos. Asegúrate de que el evento Step de obj_jugador tenga el código de colisión por Tilemap explicado en esta lección. Criterio de comprobación: El personaje debe caminar, saltar y detenerse contra paredes y pisos exactamente con la misma solidez que antes, pero ahora la pestaña de depuración mostrará una drástica reducción en la cantidad de instancias vivas.

Actividad 3: Detección y respuesta al chocar con el techo. Añade una plataforma suspendida en el aire con tus tiles a una altura alcanzable con un salto completo. Salta directamente debajo de ella para evaluar el comportamiento del sensor superior. Criterio de comprobación: El personaje debe interrumpir de golpe su ascenso en el instante exacto en que la cabeza toca el tile inferior del techo y comenzar a descender limpiamente por efecto de la gravedad, sin quedarse congelado ni atravesar el obstáculo.