Vertical Collisions and Floors

Fundamentals of Vertical Collision in Platformers

In 2D platformer development, vertical physics is the cornerstone upon which the entire interactive experience rests. While horizontal movement governs progression and stage exploration, vertical movement dictates gravity, jumping, falling, and the character's sense of weight. A flawed vertical collision system instantly breaks player immersion: falling through floors (a phenomenon known technically as 'tunneling'), characters visibly sinking several pixels into the ground before stopping, or jumps clipping unexpectedly through solid ceilings.

In GameMaker, the 2D coordinate space follows a convention that every developer must master from day one: the vertical axis (Y) increases downwards. The coordinate origin (0, 0) is located at the top-left corner of the Room. Consequently, any positive value added to vertical velocity moves the instance downward (toward the floor), while any negative value moves it upward (toward the ceiling or sky). This inverted orientation relative to the traditional Cartesian plane directly shapes the logic and mathematical calculations behind collision checks.

The Discrete Movement Problem and the Predictive Solution

Game engines execute their main loop frame by frame. If a character accumulates a vertical velocity of 12 pixels per frame due to gravity and you simply write 'y += vspd;', the engine does not smoothly sweep the character across those 12 pixels over time; instead, it 'teleports' the instance 12 pixels down on the very next frame. If a solid floor sits just 4 pixels below the character's feet, the instance will end up embedded 8 pixels deep inside the block.

To prevent this issue, 2D game programmers use an industry-standard technique known as 'predictive collision resolution with contact approach'. Instead of moving the instance first and checking for collisions afterward, the algorithm evaluates the intended future position ('y + vspd') beforehand. If a solid obstacle is detected at that destination, direct movement is halted, and a fine-stepping loop moves the character pixel by pixel until it rests flush against the surface, after which residual velocity is canceled.

Mathematical Breakdown of the Vertical Approach Algorithm

Vertical collision logic relies on two core GameMaker functions: 'place_meeting()' and 'sign()'. The 'place_meeting(x, y, obj)' function takes the calling instance's collision mask, hypothetically positions it at the provided (x, y) coordinates, and checks whether that placement overlaps with any instance of the specified object. It returns a boolean ('true' or 'false') without altering the instance's actual position.

Meanwhile, the mathematical function 'sign(val)' inspects the sign of a numeric value: returning 1 if positive, -1 if negative, and 0 if zero. In this context, 'sign(vspd)' is an indispensable tool because it collapses the direction of vertical movement into a unit vector of exactly one pixel: 1 downward when falling, and -1 upward when ascending during a jump.

// Algorithmic structure of predictive vertical collision
if (place_meeting(x, y + vspd, obj_bloque))
{
    // While there is no collision one pixel ahead in the direction of velocity
    while (!place_meeting(x, y + sign(vspd), obj_bloque))
    {
        y = y + sign(vspd); // Step exactly one pixel toward the surface
    }
    
    vspd = 0; // Fully cancel accumulated vertical velocity
}

// If there is no collision, or once the exact position is resolved, apply movement
y = y + vspd;

The behavior of the 'while' loop deserves close attention. A 'while' loop repeats its internal statements as many times as necessary within the exact same frame before GameMaker renders anything to the screen. If a character falls at 8 pixels per frame and the floor is 3 pixels away, the initial condition 'place_meeting(x, y + 8, obj_bloque)' evaluates to true. The 'while' loop checks 'y + 1' (empty) and steps 1 pixel; checks 'y + 2' (empty) and steps another pixel; checks 'y + 3' (contacts the floor). Detecting contact one pixel ahead, the loop stops immediately. The character's position is snapped flush to the edge of the floor, and 'vspd' is set to 0, ensuring gravity will not push the character into solid geometry on the next frame.

Floors and Ceilings: Unified Handling with sign()

One of the greatest strengths of this algorithm is its mathematical symmetry. Beginners often make the mistake of writing one code block for floors ('if vspd > 0') and a completely separate one for ceilings ('if vspd < 0'). This duplication introduces bugs and makes maintenance tedious. By leveraging 'sign(vspd)', the exact same snippet seamlessly handles both scenarios with millimeter precision:

1. When falling ('vspd > 0'): 'sign(vspd)' equals +1. The loop nudges the character downward until touching the top surface of the floor block, setting 'vspd = 0'. The player lands cleanly, and gravity stops pulling them into the void.

2. When jumping ('vspd < 0'): 'sign(vspd)' equals -1. The loop pushes the character upward until their head touches the underside of the ceiling block. At that moment, setting 'vspd = 0' instantly cancels upward jump momentum. On the next frame, gravity adds positive velocity again, causing the character to begin falling naturally right after bonking their head—just like in classic retro platformers.

Complete Integration into the Player Object

To ensure technical consistency across our platformer project, we will integrate vertical collisions alongside the horizontal collisions and basic gravity system covered previously. All variables must first be declared in the Create event of the player object ('obj_jugador'), guaranteeing they exist in memory before any script reads or modifies them.

// ========================================================
// OBJECT: obj_jugador
// EVENT: Create
// ========================================================

// Horizontal movement variables
hspd = 0;             // Current horizontal speed in pixels per frame
move_speed = 3.5;     // Maximum lateral movement speed

// Vertical movement and physics variables
vspd = 0;             // Current vertical speed in pixels per frame
grv = 0.25;           // Gravity acceleration applied per frame
jump_speed = -6.5;    // Initial jump impulse (negative moves upward)
vspd_max = 9.0;       // Terminal falling velocity

With variables properly initialized, the Step event will centralize input handling, physics acceleration, and sequential collision resolution. The execution order within the Step event is critical: first read player input, then calculate target velocities (including gravitational acceleration), resolve horizontal collisions, resolve vertical collisions, and finally apply movement.

// ========================================================
// OBJECT: obj_jugador
// EVENT: Step
// ========================================================

// 1. KEYBOARD INPUT CAPTURE
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. HORIZONTAL MOVEMENT CALCULATION
var _move = _key_right - _key_left;
hspd = _move * move_speed;

// 3. APPLY GRAVITY
// Gravity increases downward speed until terminal velocity is reached
vspd = vspd + grv;
if (vspd > vspd_max)
{
    vspd = vspd_max;
}

// 4. HORIZONTAL COLLISION RESOLUTION
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. VERTICAL COLLISION RESOLUTION (FLOORS AND CEILINGS)
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;

Notice that movement is strictly divided into two distinct phases: the X axis is resolved and applied first ('x = x + hspd'), followed by the Y axis ('y = y + vspd'). This separation of axes (Orthogonal Axis Separation) is essential. If you attempted to evaluate diagonals simultaneously with 'place_meeting(x + hspd, y + vspd, obj_bloque)', the character would snag on corners or freeze when walking flush against a vertical wall while standing on the floor.