Full Integration of Audio, HUD, and Gameplay Logic

Introduction: Orchestrating Game Subsystems

Throughout the previous modules, you built essential components in isolation: player movement and collisions, enemy patrol and attack behaviors, stats rendering on the user interface (HUD) via the Draw GUI event, and music and sound effect (SFX) playback. While each of these parts can run perfectly inside an isolated test room, the real challenge of game development lies in making all these subsystems interact cohesively, smoothly, and reliably.

A game never feels polished if taking damage doesn't immediately reflect on the health bar, if impact sounds play with noticeable latency, or if background music continues blasting at full volume after the player is defeated. In this lesson, you will learn how to integrate and synchronize gameplay logic, the user interface, and audio into a single, unified architecture. We will ensure data flows seamlessly from physics and input events down to the audiovisual feedback delivered to the player.

Communication Architecture: Centralization vs. Dispersion

One of the most common pitfalls for novice developers is scattering presentation logic across dozens of game objects—for instance, putting UI draw calls inside `obj_player`, starting background music directly inside the Create event of an `obj_coin`, or calling `room_restart()` from random collision events. This anti-pattern, colloquially termed 'spaghetti code', produces unpredictable bugs: overlapping sounds that clip the audio mixer, duplicate HUD elements across room transitions, and desynchronized variables upon restarting a session.

To avoid this chaos, we adopt a centralized architectural pattern where every element carries a single, well-defined responsibility:

💡 Golden rule of integration: In-world objects (such as coins or hazards) merely notify what happened. The global manager updates the authoritative data, and dedicated output objects (HUD and Audio) translate that new state into visuals and sound.

Setting Up the Central Controller: `obj_game_manager`

Flag `obj_game_manager` as **Persistent** in the GameMaker Object Inspector. This ensures that a single controller instance survives room transitions between levels, title screens, and game over states. Below is its initial setup.

// ====================================================================
// OBJECT: obj_game_manager
// EVENT: Create
// PURPOSE: Initialize persistent global game state
// ====================================================================

// Prevent duplicate instances if the manager is spawned again
if (instance_number(obj_game_manager) > 1) {
    instance_destroy();
    exit;
}

// Player and session state variables
global.player_max_hp = 3;
global.player_hp = global.player_max_hp;
global.player_lives = 3;
global.player_score = 0;
global.coins_collected = 0;
global.target_coins_for_life = 50;

// Flow and transition variables
global.game_paused = false;
global.level_timer = 0;
global.current_checkpoint_x = -1;
global.current_checkpoint_y = -1;

// Track active BGM to prevent unnecessary restarts
global.current_bgm = noone;

// Lock virtual GUI resolution (standard 1080p canvas)
display_set_gui_size(1920, 1080);

With state centralized in globally accessible variables modified through clean rules, we can orchestrate room transitions using the **Room Start** event. This event relocates the player when an active checkpoint exists and ensures appropriate background music plays without restarting if the incoming room uses the same track.

// ====================================================================
// OBJECT: obj_game_manager
// EVENT: Room Start
// PURPOSE: Synchronize player position, music, and persistence per room
// ====================================================================

// 1. Reposition player to active checkpoint if valid
if (instance_exists(obj_player)) {
    if (global.current_checkpoint_x != -1 && global.current_checkpoint_y != -1) {
        obj_player.x = global.current_checkpoint_x;
        obj_player.y = global.current_checkpoint_y;
    }
}

// 2. Determine and route room-specific background music
var _desired_bgm = noone;

switch (room) {
    case rm_title:
        _desired_bgm = snd_bgm_title;
        break;
    case rm_level_1:
    case rm_level_2:
        _desired_bgm = snd_bgm_level;
        break;
    case rm_victory:
        _desired_bgm = snd_bgm_victory;
        break;
    case rm_gameover:
        _desired_bgm = snd_bgm_gameover;
        break;
}

// Only switch tracks if the target track differs from the active one
if (_desired_bgm != noone && global.current_bgm != _desired_bgm) {
    // Stop previous music track if playing
    if (global.current_bgm != noone) {
        audio_stop_sound(global.current_bgm);
    }
    
    // Play new track looping with normal priority
    audio_play_sound(_desired_bgm, 100, true);
    global.current_bgm = _desired_bgm;
}

Binding the Audio Subsystem to Gameplay Mechanics

Audio should never be an afterthought triggered blindly 'whenever something hits something else'; it needs to actively reinforce game feel and player input. When an audio system is poorly integrated, common artifacts arise: a coin pickup plays its audio clip on every single collision frame, or footsteps saturate mixer channels, resulting in audible clicks and popping.

To prevent this, we write modular helper functions that manage gain, pitch modulation, and concurrency. We'll declare a utility script named `scr_audio_effects` to encapsulate sound execution rules.

// ====================================================================
// SCRIPT: scr_audio_effects
// PURPOSE: Helper functions for controlled SFX playback
// ====================================================================

/// @function play_sfx(_sound_id, _priority, _pitch_variation)
/// @param {Asset.GMSound} _sound_id Sound asset identifier
/// @param {Real} _priority Mixer priority level (1 to 100)
/// @param {Real} _pitch_variation Random pitch offset range (e.g., 0.1)
function play_sfx(_sound_id, _priority, _pitch_variation) {
    var _instance = audio_play_sound(_sound_id, _priority, false);
    
    if (_pitch_variation > 0) {
        // Apply slight pitch variance to avoid repetitive acoustic fatigue
        var _random_pitch = random_range(1.0 - _pitch_variation, 1.0 + _pitch_variation);
        audio_sound_pitch(_instance, _random_pitch);
    }
    
    return _instance;
}

Next, see how we integrate this helper directly into the player's movement and landing logic, ensuring audio triggers only on distinct state changes.

// ====================================================================
// OBJECT: obj_player
// EVENT: Step (Jump and landing evaluation snippet)
// ====================================================================

// Cache prior grounded state before vertical evaluation
var _was_on_ground = on_ground;
on_ground = place_meeting(x, y + 1, obj_solid);

// Ground impact detection (landing)
if (!_was_on_ground && on_ground) {
    play_sfx(snd_land, 40, 0.15);
    // Spawn dust impact particles beneath player feet
    instance_create_layer(x, bbox_bottom, "Effects", obj_dust_impact);
}

// Jump execution on input press while grounded
if (key_jump_pressed && on_ground) {
    v_speed = jump_strength;
    play_sfx(snd_jump, 60, 0.08);
    instance_create_layer(x, bbox_bottom, "Effects", obj_dust_jump);
}

Synchronizing the HUD with Global Variables

The HUD must mirror the underlying game state with zero latency, but it should also use visual polish techniques so the interface feels dynamic rather than static. Rather than drawing raw numbers that abruptly change, we implement two core 'game juice' animations in `obj_hud`:

1. **Elastic Scale Bounce on Pickups**: Whenever the player collects a coin, the coin icon pops up in scale and smoothly springs back to its rest size. 2. **Health Indicator Flash**: When the player takes damage, health hearts or bars briefly flash red or toggle opacity to communicate immediate danger.

// ====================================================================
// OBJECT: obj_hud
// EVENT: Create
// PURPOSE: Initialize local animation and interpolation variables
// ====================================================================

// Scale factors for bounce/pulse visual effects
coin_scale = 1.0;
score_display = global.player_score;

// Base interface margins (in GUI layer coordinates)
gui_margin_x = 40;
gui_margin_y = 40;
heart_spacing = 48;

In the **Step** event of `obj_hud`, we interpolate displayed numerical values and damp transform scales back to resting dimensions (1.0) using linear interpolation (`lerp`).

// ====================================================================
// OBJECT: obj_hud
// EVENT: Step
// PURPOSE: Update UI animation curves and interpolated values
// ====================================================================

// Smoothly interpolate displayed score toward authoritative score
score_display = lerp(score_display, global.player_score, 0.15);

// Damp coin icon scale back to 1.0 after a bounce
coin_scale = lerp(coin_scale, 1.0, 0.1);

// If a coin was collected this frame, trigger the scale pop
if (global.coin_just_collected) {
    coin_scale = 1.5;
    global.coin_just_collected = false;
}

Next, in the **Draw GUI** event, we render the life hearts, animated coin counter, and rolling score display using standard font and sprite drawing functions.

// ====================================================================
// OBJECT: obj_hud
// EVENT: Draw GUI
// PURPOSE: Render all UI elements to the screen overlay
// ====================================================================

// 1. DRAW HEALTH HEARTS
for (var i = 0; i < global.player_max_hp; i++) {
    var _heart_x = gui_margin_x + (i * heart_spacing);
    var _heart_y = gui_margin_y;
    
    // Render full or empty heart sprite depending on current health
    if (i < global.player_hp) {
        draw_sprite(spr_hud_heart_full, 0, _heart_x, _heart_y);
    } else {
        draw_sprite(spr_hud_heart_empty, 0, _heart_x, _heart_y);
    }
}

// 2. DRAW COIN COUNTER WITH DYNAMIC SCALE POP
var _coin_icon_x = gui_margin_x;
var _coin_icon_y = gui_margin_y + 60;

draw_sprite_ext(
    spr_hud_coin, 
    0, 
    _coin_icon_x, 
    _coin_icon_y, 
    coin_scale, 
    coin_scale, 
    0, 
    c_white, 
    1.0
);

draw_set_font(fnt_hud);
draw_set_color(c_white);
draw_set_halign(fa_left);
draw_set_valign(fa_middle);

var _coin_str = "x " + string(global.coins_collected);
draw_text_transformed(_coin_icon_x + 36, _coin_icon_y, _coin_str, coin_scale, coin_scale, 0);

// 3. DRAW SCORE COUNTER
var _score_text = "SCORE: " + string(ceil(score_display));
draw_set_halign(fa_right);
draw_text(display_get_gui_width() - gui_margin_x, gui_margin_y, _score_text);

// Reset text alignment defaults
draw_set_halign(fa_left);
draw_set_valign(fa_top);