Building a Functional Pause System

Architecture and Core Concepts of a Pause System

Pausing a video game might seem straightforward at first glance: simply 'stopping time.' However, in software development—and specifically within GameMaker's Game Loop—the engine never truly stops. It continues processing frames, dispatching events, and rendering graphics to the display. Halting the engine's execution loop entirely would cause the operating system to flag the game window as unresponsive or frozen, ignoring all user inputs.

There are two primary paradigms for building a pause system in 2D game engines:

1. **Conditional State Flags:** Wrapping all movement, collision, and animation logic in every game object inside a condition such as `if (!global.game_paused) { ... }`. While intuitive for small prototypes, this approach scales poorly and invites human error. Forgetting a single check on an enemy, projectile, or alarm timer causes that entity to keep updating while the rest of the game world stands frozen.

2. **Instance Deactivation with Surface Capture:** The standard, professional method in GameMaker. This technique temporarily suspends all active gameplay entities using built-in functions like `instance_deactivate_all()` or `instance_deactivate_region()`. Deactivated instances stop running their `Step`, `Alarm`, and `Collision` events immediately. Because deactivated instances also cease running their `Draw` events, we capture a visual snapshot of the screen into a dedicated `surface` buffer and draw it statically underneath an interactive overlay menu.

Throughout this lesson, we will implement this second method by creating a dedicated controller object: `obj_pausa`. This controller manages screen capture, instance freezing, overlay menu navigation, and the clean reactivation of all game entities.

Creating the Pause Controller: obj_pausa

To ensure our pause system works independently without interfering with level logic or the HUD systems created in earlier lessons, we will build a dedicated controller object named `obj_pausa`. This object can be marked persistent so it carries across rooms, or placed directly in each playable level.

Create a new object in GameMaker's Asset Browser, name it `obj_pausa`, and leave its sprite unassigned. Check the **Persistent** box if you want a single controller running across all gameplay rooms. Alternatively, place it manually on an `Instances` or `Controllers` layer in `rm_nivel_1`.

Initializing Variables in the Create Event

In the `Create` event of `obj_pausa`, declare the variables controlling the pause state, the reference handle for the screen capture surface, and the elements of the interactive floating menu.

/// @description Create Event of obj_pausa

// Pause state
esta_pausado = false;

// Surface handle for screen capture
surf_pausa = -1;

// Pause menu items
opciones = [
    "Resume",
    "Restart Level",
    "Main Menu"
];

// Current selected option index (0 is "Resume")
opcion_actual = 0;
total_opciones = array_length(opciones);

// Menu visual formatting
ancho_gui = display_get_gui_width();
alto_gui = display_get_gui_height();
separacion_lineas = 40;

// Input debounce timer to prevent unintentional rapid-fire scrolling
espera_entrada = 0;
tiempo_espera = 10;

Let's break down each variable's role:

Visual Capture and Deactivation in the Step Event

The `Step` event of `obj_pausa` drives the state changes. During normal gameplay, this event checks for the Escape key (`vk_escape`) or gamepad Start button. Once paused, the same event manages navigation through the menu options.

A critical nuance in GameMaker: when calling `instance_deactivate_all(true)`, the `true` argument (the `notme` parameter) tells the engine to deactivate every active instance **except** the calling instance (`obj_pausa`). This allows `obj_pausa` to continue executing its `Step` and `Draw GUI` events normally, capturing player input and rendering the menu overlay.

/// @description Step Event of obj_pausa

// 1. Detect toggle input
var _tecla_pausa = keyboard_check_pressed(vk_escape) || gamepad_button_check_pressed(0, gp_start);

if (_tecla_pausa)
{
    esta_pausado = !esta_pausado;
    
    if (esta_pausado)
    {
        // Get active render canvas dimensions
        var _w = surface_get_width(application_surface);
        var _h = surface_get_height(application_surface);
        
        // Allocate temporary surface and copy current frame buffer
        surf_pausa = surface_create(_w, _h);
        surface_copy(surf_pausa, 0, 0, application_surface);
        
        // Deactivate all gameplay instances, preserving only this controller
        instance_deactivate_all(true);
        
        // Reset cursor to default option
        opcion_actual = 0;
    }
    else
    {
        // Reactivate all entities upon unpausing
        instance_activate_all();
        
        // Free cached surface from VRAM if it exists
        if (surface_exists(surf_pausa))
        {
            surface_free(surf_pausa);
            surf_pausa = -1;
        }
    }
}

// 2. Menu navigation logic while paused
if (esta_pausado)
{
    // Vertical navigation inputs
    var _arriba = keyboard_check_pressed(vk_up) || keyboard_check_pressed(ord("W")) || gamepad_button_check_pressed(0, gp_padu);
    var _abajo = keyboard_check_pressed(vk_down) || keyboard_check_pressed(ord("S")) || gamepad_button_check_pressed(0, gp_padd);
    var _seleccionar = keyboard_check_pressed(vk_enter) || keyboard_check_pressed(vk_space) || gamepad_button_check_pressed(0, gp_face1);
    
    // Wrap-around vertical cursor movement
    if (_arriba)
    {
        opcion_actual -= 1;
        if (opcion_actual < 0)
        {
            opcion_actual = total_opciones - 1;
        }
    }
    
    if (_abajo)
    {
        opcion_actual += 1;
        if (opcion_actual >= total_opciones)
        {
            opcion_actual = 0;
        }
    }
    
    // Execute selected action
    if (_seleccionar)
    {
        switch (opcion_actual)
        {
            case 0: // Resume
                esta_pausado = false;
                instance_activate_all();
                if (surface_exists(surf_pausa))
                {
                    surface_free(surf_pausa);
                    surf_pausa = -1;
                }
                break;
                
            case 1: // Restart Level
                esta_pausado = false;
                instance_activate_all();
                if (surface_exists(surf_pausa))
                {
                    surface_free(surf_pausa);
                    surf_pausa = -1;
                }
                room_restart();
                break;
                
            case 2: // Main Menu
                esta_pausado = false;
                instance_activate_all();
                if (surface_exists(surf_pausa))
                {
                    surface_free(surf_pausa);
                    surf_pausa = -1;
                }
                room_goto(rm_menu);
                break;
        }
    }
}

💡 Golden Rule of GameMaker: Whenever you restart a room with room_restart() or navigate away with room_goto() from a paused state, you MUST call instance_activate_all() and free your surfaces first. If a room changes while instances are deactivated, GameMaker skips their Destroy and Clean Up events, causing memory leaks and broken logic in persistent systems.

Rendering the Overlay Menu in Draw GUI

The visual presentation of the pause state consists of three layered elements rendered in the `Draw GUI` event:

1. **The Frozen Frame Buffer:** The cached surface (`surf_pausa`). Without rendering this, the screen would clear to black or flicker, since game instances are no longer running their normal draw routines. 2. **The Darkening Dimmer:** A semi-transparent black rectangle (around 50% to 65% alpha) overlaid on the frozen image to soften the background and maximize text contrast. 3. **The Menu Panel and Options:** A centered frame displaying the 'PAUSE' header and selectable options, highlighting the current selection with accent colors or bracket indicators.

/// @description Draw GUI Event of obj_pausa

// Exit early if the game is not paused
if (!esta_pausado) exit;

// Fetch up-to-date GUI canvas dimensions
var _gui_w = display_get_gui_width();
var _gui_h = display_get_gui_height();

// 1. RENDER FROZEN BACKGROUND SURFACE
// Always verify that the surface handle is valid in GPU memory
if (surface_exists(surf_pausa))
{
    // Stretch surface across the GUI resolution
    draw_surface_stretched(surf_pausa, 0, 0, _gui_w, _gui_h);
}
else
{
    // Fallback solid background if surface was reclaimed by the OS
    draw_set_color(c_dkgray);
    draw_rectangle(0, 0, _gui_w, _gui_h, false);
}

// 2. DARKENING OVERLAY
draw_set_color(c_black);
draw_set_alpha(0.65);
draw_rectangle(0, 0, _gui_w, _gui_h, false);
draw_set_alpha(1.0); // Reset alpha channel immediately

// 3. FLOATING MENU BOX
var _caja_w = 400;
var _caja_h = 280;
var _centro_x = _gui_w * 0.5;
var _centro_y = _gui_h * 0.5;

var _x1 = _centro_x - (_caja_w * 0.5);
var _y1 = _centro_y - (_caja_h * 0.5);
var _x2 = _centro_x + (_caja_w * 0.5);
var _y2 = _centro_y + (_caja_h * 0.5);

// Panel background
draw_set_color(make_color_rgb(25, 25, 40));
draw_rectangle(_x1, _y1, _x2, _y2, false);

// Outer border
draw_set_color(make_color_rgb(180, 180, 220));
draw_rectangle(_x1, _y1, _x2, _y2, true);

// Inner detail border
draw_rectangle(_x1 + 4, _y1 + 4, _x2 - 4, _y2 - 4, true);

// 4. LABELS AND OPTIONS
// Configure text alignment
draw_set_halign(fa_center);
draw_set_valign(fa_middle);

// Header label
draw_set_color(c_yellow);
draw_text_transformed(_centro_x, _y1 + 45, "- PAUSED -", 1.5, 1.5, 0);

// Render selectable options
var _inicio_opciones_y = _y1 + 120;

for (var i = 0; i < total_opciones; i++)
{
    var _pos_y = _inicio_opciones_y + (i * separacion_lineas);
    
    if (i == opcion_actual)
    {
        // Highlighted selection
        draw_set_color(c_white);
        
        // Selection cursor indicators
        var _texto_opcion = "> " + opciones[i] + " <";
        draw_text(_centro_x, _pos_y, _texto_opcion);
    }
    else
    {
        // Inactive options
        draw_set_color(c_gray);
        draw_text(_centro_x, _pos_y, opciones[i]);
    }
}

// Reset global drawing state to prevent side effects on other objects
draw_set_halign(fa_left);
draw_set_valign(fa_top);
draw_set_color(c_white);