Implementing Lives and a Health Bar

Introduction to Health and Lives in 2D Platformers

In classic 2D platformer development, player survival is almost always managed through two layers of persistence: short-term durability (health or hit points) and overall game persistence (lives or total attempts). While health dictates how many minor hits the avatar can withstand before momentarily falling, lives determine how many attempts the player gets to clear the stage before confronting a definitive Game Over screen.

In the previous lesson, we established collision detection between the player and patrolling enemies. However, if we simply restarted the room upon every hit or deducted health every single frame, the game would feel completely unfair or unplayable: because GameMaker runs its Step event 60 times per second by default, continuous contact for just half a second would inflict up to 30 damage ticks instantaneously. For this reason, a robust health system requires not only numeric deduction variables, but also a temporary invulnerability window (industry-standard 'invincibility frames' or 'i-frames') and a disciplined relocation or respawn routine.

Essential Variables for Health, Lives, and Position Tracking

To build this system without scattering global variables that make code maintenance difficult, we will keep state inside our player instance (`obj_jugador`), also storing the spatial coordinates where the character should rematerialize if defeated. Below are the core parameters that govern our survival logic:

It is critical to distinguish between `salud_maxima` and `salud_actual`. Hardcoding fixed values to refill health upon respawning is considered poor practice. If you later allow the player to purchase vitality upgrades or collect heart containers, modifying `salud_maxima` will automatically adapt all percentage calculations and healing routines without side effects.

Setting Up the Create Event in obj_jugador

Open your main player object, `obj_jugador`. In previous lessons, we declared movement variables like `velocidad_x`, `velocidad_y`, `gravedad`, and `fuerza_salto`. Now we will integrate the physical state and respawn variables at the bottom of the Create event to ensure the character spawns with all attributes ready from the very first frame the room loads.

/// @description Health, lives, and starting point initialization

// Physical resistance parameters
salud_maxima = 100;
salud_actual = salud_maxima;
vidas = 3;

// Temporary immunity control against continuous hits
es_invulnerable = false;
tiempo_invulnerable = 0;
duracion_invulnerable = 60; // Equivalent to 1 second if the room runs at 60 FPS

// Position tracking for respawn
origen_x = x;
origen_y = y;

By assigning `x` and `y` to `origen_x` and `origen_y`, GameMaker captures the exact coordinates where you placed the instance inside the Room Editor. This avoids arbitrary hardcoded coordinates, allowing you to position the player anywhere in the level via the visual editor without modifying a single line of code.

The Damage and Temporary Invulnerability Loop

A classic beginner mistake when programming enemy collisions is deducting damage directly inside the collision event without checking if the player is already in a hurt state. If you do this and the player bumps into an enemy dealing 25 damage, their health drops from 100 to 0 in just four frames (less than a tenth of a second), making it feel as if the enemy killed the player in a single hit.

To solve this, we use an immunity window. When an enemy hits the player, a structured sequence must execute: first, check that `es_invulnerable` is false; if it is, deduct the damage, toggle `es_invulnerable = true`, and initialize `tiempo_invulnerable = duracion_invulnerable`. For every frame while the timer remains above zero, any other damaging collision is completely ignored.

Step Event Update and Visual Feedback

In `obj_jugador`'s Step event, we decrement the invulnerability timer frame by frame until it reaches zero. Beyond pure numeric logic, providing immediate visual feedback is essential: players need to clearly see that their character is hurt and temporarily protected. In classic 8-bit and 16-bit retro games, this is achieved by toggling sprite transparency (the alpha channel) to create a rhythmic flashing effect.

Add the following code block inside the Step event of `obj_jugador`, placing it alongside the movement and gravity code created in earlier modules:

/// @description Invulnerability timer and flicker management

if (es_invulnerable)
{
    tiempo_invulnerable -= 1;
    
    // Visual flashing effect by modifying image_alpha every few frames
    if ((tiempo_invulnerable mod 8) < 4)
    {
        image_alpha = 0.3; // Semitransparent
    }
    else
    {
        image_alpha = 1.0; // Fully opaque
    }
    
    // Restore normal state once time runs out
    if (tiempo_invulnerable <= 0)
    {
        es_invulnerable = false;
        image_alpha = 1.0; // Ensure full final opacity
    }
}

Let's break down `(tiempo_invulnerable mod 8) < 4`. The `mod` (modulo) operator returns the remainder of integer division between the counter and 8. This generates a repeating cycle of integers from 0 to 7. As long as the remainder stays below 4, `image_alpha` drops to 0.3 (making the sprite nearly translucent); when it reaches 4 through 7, it returns to full opacity (1.0). The resulting effect is a clean, steady flicker without visual artifacts.

Enemy Collision and Damage Application

In the previous lesson, you learned how to detect collisions with `obj_enemigo_patrullero`. Now we will refine that detection so the enemy deals specific damage and applies a slight knockback impulse to separate both bodies and prevent them from getting stuck inside each other's collision masks.

Inside the Step event of `obj_jugador`, we will use the built-in function `instance_place(x, y, obj_enemigo_patrullero)`. This function returns the unique instance ID (`id`) of the specific enemy instance currently colliding with the player. If there is no collision, it returns the special keyword `noone`.

/// @description Contact detection with enemies and damage reception

var _enemigo = instance_place(x, y, obj_enemigo_patrullero);

if (_enemigo != noone and !es_invulnerable)
{
    // Get damage from enemy or apply a default value if undefined
    var _dano_recibido = 25;
    if (variable_instance_exists(_enemigo, "dano"))
    {
        _dano_recibido = _enemigo.dano;
    }
    
    // Apply damage and activate protection window
    salud_actual -= _dano_recibido;
    salud_actual = clamp(salud_actual, 0, salud_maxima);
    
    es_invulnerable = true;
    tiempo_invulnerable = duracion_invulnerable;
    
    // Slight knockback impulse
    velocidad_y = -4; // Involuntary upward jump
    if (x < _enemigo.x)
    {
        velocidad_x = -3; // Knockback to the left
    }
    else
    {
        velocidad_x = 3;  // Knockback to the right
    }
}

💡 The `clamp(val, min, max)` function is a staple in game programming: it constrains a numeric value so it never falls below a minimum nor exceeds an upper bound. Using `salud_actual = clamp(salud_actual, 0, salud_maxima);` guarantees that health never drops below zero or overflows past 100% when collecting healing pick-ups.