Precise Collisions with Tilemaps

Vertical Collision Resolution and Ground Detection

The vertical axis follows an analogous process, while incorporating gravity and the en_suelo (grounded) state. If vel_y > 0, the character is falling, meaning the evaluated edge is bbox_bottom. If the bottom edge touches a solid tile while descending:

• Snap the character downward until their feet rest flush on the tile surface. • Set vel_y = 0 to cancel accumulated downward gravitational momentum. • Set en_suelo = true, allowing the player to jump again.

Conversely, if vel_y < 0, the character is ascending during a jump and their top edge (bbox_top) hits a ceiling. In that moment, we zero out vel_y so downward gravity takes over immediately, preventing the character's head from penetrating the ceiling.

Complete Implementation in obj_jugador's Step Event

Below is the complete integration of the system. Notice how keyboard input, gravitational acceleration, tilemap edge collisions, and final coordinate updates are computed in sequence.

// ====================================================================
// RESOURCE: Objects -> obj_jugador
// EVENT: Step
// ====================================================================

// --------------------------------------------------------------------
// 1. KEYBOARD INPUT CAPTURE
// --------------------------------------------------------------------
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"));

// Calculated direction (-1, 0, 1)
var _dir = _tecla_der - _tecla_izq;
vel_x = _dir * vel_caminar;

// --------------------------------------------------------------------
// 2. GRAVITY APPLICATION AND JUMPING
// --------------------------------------------------------------------
vel_y += gravedad;

// Jump conditioned on standing on solid ground
if (en_suelo && _tecla_salto) {
    vel_y = fuerza_salto;
    en_suelo = false;
}

// Assume airborne until checked below
en_suelo = false;

// --------------------------------------------------------------------
// 3. HORIZONTAL TILEMAP COLLISION
// --------------------------------------------------------------------
if (vel_x != 0) {
    // Determine which edge to evaluate based on movement direction
    var _borde_x = (vel_x > 0) ? bbox_right : bbox_left;
    
    // Vertical points to evaluate along that edge (top, middle, and bottom)
    // Subtract 1 from the bottom (bbox_bottom - 1) to avoid false positives with the floor
    var _y_superior = bbox_top;
    var _y_medio    = (bbox_top + bbox_bottom) * 0.5;
    var _y_inferior = bbox_bottom - 1;
    
    // Check if the next position contains a solid tile
    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) {
        // Pixel-by-pixel snapping up to the wall
        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;
    }
}

// Apply resolved horizontal movement
x += vel_x;

// --------------------------------------------------------------------
// 4. VERTICAL TILEMAP COLLISION
// --------------------------------------------------------------------
if (vel_y != 0) {
    // Determine which vertical edge to evaluate (head or feet)
    var _borde_y = (vel_y > 0) ? bbox_bottom : bbox_top;
    
    // Horizontal points to evaluate across the character's width
    var _x_izq    = bbox_left;
    var _x_centro = (bbox_left + bbox_right) * 0.5;
    var _x_der    = bbox_right;
    
    // Check collision at the future vertical position
    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) {
        // Pixel-by-pixel snapping toward the vertical obstacle
        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;
        }
        
        // If falling and a collision occurs, solid ground has been reached
        if (vel_y > 0) {
            en_suelo = true;
        }
        
        vel_y = 0;
    }
}

// Apply resolved vertical movement
y += vel_y;

Pay close attention to a crucial technical detail in the horizontal check: when calculating _y_inferior, we use `bbox_bottom - 1` instead of `bbox_bottom`. If you evaluate the exact pixel of bbox_bottom during a horizontal check while standing on the floor, that coordinate overlaps with the top surface of the floor tile below, falsely registering an oncoming wall. Subtracting 1 pixel lifts the sensor just above the walking surface, ensuring smooth movement without snagging.

Direct Mathematical Grid Alignment (Loop Alternative)

The while loop for pixel snapping is intuitive and highly reliable for standard gameplay speeds. In professional 2D engines, however, there is also a direct mathematical approach: calculating the exact grid multiple where the collided cell starts. Because tiles have a constant size (such as 16x16 pixels), the top edge of a solid block always sits at an exact multiple of 16.

For example, if a character falls toward the floor and bbox_bottom would penetrate a cell, the snapped Y position for the sprite origin can be calculated by subtracting the offset between the origin and the bottom edge: `y = (tile_y * 16) - 1 - (bbox_bottom - y)`. For those getting started with GameMaker, the single-pixel stepping while loop (`sign(vel)`) presented above is the most straightforward and resilient against floating-point rounding quirks.

Tilemap Collisions vs. Solid Object Collisions

Now that both systems are in your game development toolkit, it is essential to understand when to use each as you move toward enemy AI and level design:

Hands-On Practice Exercises

Put what you have learned into practice with these three structured exercises for the retro platformer project:

Activity 1: Configure the Collision Layer and Retrieve Its ID. Open your project's main room. In the Layer Editor, make sure your terrain tile layer is named exactly "Tiles_Terreno" (case-sensitive). In the Create event of obj_jugador, add a check using show_debug_message() to print the value of mapa_colision to the console. Verification criterion: Pressing F5 to run the game should print an integer greater than or equal to 0 in the Output window. If it prints -1, the layer name is misspelled or does not exist.

Activity 2: Complete Migration and Removing Redundant Solid Instances. In the room editor, select and delete all instances of obj_suelo or obj_bloque placed during Module 5, leaving only the artwork painted onto the tile layer. Ensure that the Step event of obj_jugador contains the tilemap collision logic covered in this lesson. Verification criterion: The character should walk, jump, and collide with walls and floors just as solidly as before, but the debug overlay will show a dramatic drop in active instance count.

Activity 3: Ceiling Collision and Overhead Response. Place a floating platform using tiles at a height reachable by a full jump. Jump directly underneath it to test the behavior of the top sensor. Verification criterion: The character must immediately interrupt their upward climb the instant their head touches the bottom edge of the overhead tile and begin falling cleanly under gravity, without snagging or clipping through the platform.