Victory and Game Over Screens

Introduction: Closing the Core Game Loop

Every video game features a fundamental feedback loop: the player interacts with core mechanics, overcomes challenges or makes mistakes, and ultimately reaches an outcome. Up to this point in the course, our project features a character that can run, jump, collide with enemies, take damage, lose lives, and collect items, alongside a functional HUD and a main menu. However, when health or lives hit zero, or when reaching the end of the stage, the game offers no formal conclusion.

End-of-game screens serve two vital purposes: they provide immediate narrative and psychological closure to the player's effort, and they technically manage the application's state transitions. In this lesson, you will learn how to structure clean, professional Game Over and Victory screens using dedicated rooms, `Draw GUI` events, keyboard-driven controllers, and a rigorous reset of global variables to ensure every run begins in a predictable, bug-free state.

Room Structure and Required Assets

To implement these screens, we will maintain strict architectural separation. Rather than overlaying complex UI layers directly over the active stage, we will use dedicated rooms. This ensures that all enemies, projectiles, particles, and physics calculations from the level are automatically cleared from RAM upon leaving the gameplay room.

In the Asset Browser, create the following resources within their respective asset folders:

💡 Remember that GameMaker rooms use a configured default viewport size. To maintain visual consistency, assign 'rm_gameover' and 'rm_victory' the exact same base dimensions defined for your game resolution in previous lessons (for example, 640x360 or 1280x720).

Defeat Condition: Redirecting to Game Over

In Module 7, we implemented the lives counter using the global variable `global.player_lives`. When the player takes fatal damage from an enemy or falls into a pit, they lose one life. If lives remain, the character respawns at the latest checkpoint. However, when lives drop to zero or below, the final defeat sequence must trigger.

To prevent an abrupt room jump that disorients the player, good game design calls for introducing a short delay using an Alarm. This brief pause allows any death animation or sound effect to complete before leaving the level.

Open `obj_player` and locate the code block handling life deductions within the **Step** event or your custom damage script:

// Snippet inside obj_player -> Step Event or damage function
if (hp <= 0 && !is_dead)
{
    is_dead = true;
    global.player_lives -= 1;
    
    // Stop horizontal and vertical movement
    hsp = 0;
    vsp = 0;
    
    // Check if remaining lives are still available
    if (global.player_lives > 0)
    {
        // If lives remain, trigger respawn alarm (1 second = 60 steps)
        alarm[0] = 60;
    }
    else
    {
        // If out of lives, trigger alarm transitioning to Game Over
        alarm[1] = 90;
    }
}

Next, add the **Alarm 1** event in `obj_player` with the instruction responsible for executing the room transition:

/// Event: Alarm 1 in obj_player
// Safely transition to the game over room
room_goto(rm_gameover);

Victory Condition: The Goal Object

For the victory condition, we create an endpoint object: `obj_goal`. This object represents a flagpole, portal, or chest that triggers stage completion upon contact with the player's bounding box.

In the **Create** event of `obj_goal`, initialize a boolean flag to avoid triggering the collision multiple times across consecutive frames:

/// Event: Create in obj_goal
triggered = false;

In the **Collision** event between `obj_goal` and `obj_player`, handle victory by disabling character input and initiating a short delay before changing rooms:

/// Event: Collision with obj_player in obj_goal
if (!triggered)
{
    triggered = true;
    
    // Freeze player input and motion
    other.can_move = false;
    other.hsp = 0;
    other.vsp = 0;
    
    // Start alarm to trigger the transition
    alarm[0] = 60;
}

Then, in the **Alarm 0** event of `obj_goal`, execute the room transition:

/// Event: Alarm 0 in obj_goal
room_goto(rm_victory);

Building the Game Over Controller (obj_gameover_controller)

Once the player lands in `rm_gameover`, we need an object to render UI elements and listen for player inputs (to retry the level or head back to the main menu). Place a single instance of `obj_gameover_controller` in `rm_gameover`.

In its **Create** event, define the menu choices and an index variable for navigation:

/// Event: Create in obj_gameover_controller
menu_options = ["RETRY", "MAIN MENU"];
menu_index = 0;
menu_total = array_length(menu_options);

// Input cooldown to prevent accidental immediate presses
input_cooldown = 10;

In the **Step** event, handle keyboard navigation (Up/Down arrow keys or W/S) and selection via Enter or Space:

/// Event: Step in obj_gameover_controller
if (input_cooldown > 0)
{
    input_cooldown -= 1;
    exit;
}

var key_up = keyboard_check_pressed(vk_up) || keyboard_check_pressed(ord("W"));
var key_down = keyboard_check_pressed(vk_down) || keyboard_check_pressed(ord("S"));
var key_select = keyboard_check_pressed(vk_enter) || keyboard_check_pressed(vk_space);

if (key_up)
{
    menu_index -= 1;
    if (menu_index < 0) menu_index = menu_total - 1;
}

if (key_down)
{
    menu_index += 1;
    if (menu_index >= menu_total) menu_index = 0;
}

if (key_select)
{
    switch (menu_index)
    {
        case 0:
            // Retry: Reset global stats and load the first level
            scr_restart_game_state();
            room_goto(rm_level_1);
            break;
            
        case 1:
            // Main Menu: Reset stats and return to the title screen
            scr_restart_game_state();
            room_goto(rm_menu);
            break;
    }
}

To render the interface on screen, use the **Draw GUI** event, ensuring text draws consistently regardless of camera movement or zoom levels:

/// Event: Draw GUI in obj_gameover_controller
var gui_w = display_get_gui_width();
var gui_h = display_get_gui_height();

// Semi-transparent dark overlay across the room
draw_set_color(c_black);
draw_set_alpha(0.85);
draw_rectangle(0, 0, gui_w, gui_h, false);
draw_set_alpha(1.0);

// Draw main title
draw_set_halign(fa_center);
draw_set_valign(fa_middle);

draw_set_color(c_red);
draw_text_transformed(gui_w * 0.5, gui_h * 0.3, "GAME OVER", 2.0, 2.0, 0);

// Draw menu choices
for (var i = 0; i < menu_total; i++)
{
    var opt_y = (gui_h * 0.55) + (i * 40);
    
    if (i == menu_index)
    {
        draw_set_color(c_yellow);
        draw_text(gui_w * 0.5, opt_y, "> " + menu_options[i] + " <");
    }
    else
    {
        draw_set_color(c_white);
        draw_text(gui_w * 0.5, opt_y, menu_options[i]);
    }
}

// Restore default draw alignments
draw_set_halign(fa_left);
draw_set_valign(fa_top);