Integración completa de audio, HUD y lógica de juego

Introducción: La orquestación de los subsistemas del videojuego

A lo largo de los módulos anteriores, has desarrollado componentes esenciales de forma aislada: el movimiento y las colisiones del jugador, el comportamiento de patrulla y ataque de los enemigos, el dibujo de estadísticas en la interfaz de usuario (HUD) mediante el evento Draw GUI, y la reproducción de pistas musicales y efectos de sonido (SFX). Aunque cada una de estas piezas puede funcionar correctamente por separado dentro de una sala de pruebas, el verdadero reto del desarrollo de videojuegos radica en lograr que todos estos subsistemas interactúen entre sí de manera coherente, fluida y robusta.

Un videojuego no se percibe como una experiencia acabada si al recibir daño la barra de vida no reacciona al instante, si el efecto sonoro de impacto se reproduce con retraso, o si la música continúa sonando con el mismo volumen e intensidad tras la derrota del personaje. En esta lección aprenderás a integrar y sincronizar la lógica de juego, la interfaz gráfica y el audio en una sola estructura unificada. Verificaremos que el flujo de información viaje sin fisuras desde los eventos físicos y de control hasta las salidas audiovisuales que percibe el usuario final.

Arquitectura de comunicación: Centralización frente a dispersión

Uno de los errores más frecuentes entre los desarrolladores principiantes es dispersar la lógica de presentación a lo largo de decenas de objetos. Por ejemplo, colocar código de dibujo de vida dentro del propio jugador (`obj_player`), reproducir la música de fondo directamente desde el evento Create de cada moneda (`obj_coin`), o reiniciar la sala (`room_restart()`) desde múltiples colisiones sin orden aparente. Este patrón, conocido coloquialmente como 'código espagueti', provoca comportamientos impredecibles: sonidos que se solapan hasta distorsionar el mezclador, elementos del HUD que se duplican al cambiar de sala y variables que no se sincronizan tras reiniciar una partida.

Para evitar este desorden, utilizaremos un patrón de arquitectura centralizado donde cada elemento asume una responsabilidad única y bien delimitada:

💡 Regla de oro de la integración: Los objetos del mundo (como monedas o pinchos) solo informan qué ha ocurrido. El gestor global actualiza los datos, y los objetos especializados de salida (HUD y Audio) traducen ese nuevo estado en imágenes y sonidos.

Configuración del controlador central: `obj_game_manager`

El objeto `obj_game_manager` debe ser marcado como **Persistent** (persistente) en el inspector de propiedades de GameMaker. Esto garantiza que una sola instancia del controlador sobreviva al paso entre niveles, pantallas de menú y salas de transición. A continuación, revisamos su inicialización completa.

// ====================================================================
// OBJETO: obj_game_manager
// EVENTO: Create
// PROPÓSITO: Inicializar el estado global persistente del juego
// ====================================================================

// Asegurar que no existan duplicados si se vuelve a instanciar
if (instance_number(obj_game_manager) > 1) {
    instance_destroy();
    exit;
}

// Variables de estado del jugador y partida
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;

// Variables de flujo y transición
global.game_paused = false;
global.level_timer = 0;
global.current_checkpoint_x = -1;
global.current_checkpoint_y = -1;

// Identificador de la música actual para evitar reinicios innecesarios
global.current_bgm = noone;

// Configuración del tamaño virtual de la interfaz GUI (1920x1080 estándar)
display_set_gui_size(1920, 1080);

Con el estado centralizado en variables globales accesibles pero modificadas mediante reglas claras, podemos gestionar el inicio de cada sala usando el evento **Room Start**. Este evento se encarga de reubicar al jugador si existe un punto de control y de asegurar que la música de fondo adecuada comience a reproducirse sin reinicios molestos si la pista de la sala entrante es idéntica a la anterior.

// ====================================================================
// OBJETO: obj_game_manager
// EVENTO: Room Start
// PROPÓSITO: Sincronizar posición, música y persistencia al cargar un nivel
// ====================================================================

// 1. Reposicionamiento del jugador según checkpoint activo
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. Comprobación y reproducción de música de fondo por sala
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;
}

// Solo cambiamos la pista musical si es distinta a la que ya está sonando
if (_desired_bgm != noone && global.current_bgm != _desired_bgm) {
    // Detener música previa si existe
    if (global.current_bgm != noone) {
        audio_stop_sound(global.current_bgm);
    }
    
    // Reproducir la nueva pista en bucle con prioridad media
    audio_play_sound(_desired_bgm, 100, true);
    global.current_bgm = _desired_bgm;
}

Integración del subsistema de audio con las acciones mecánicas

El audio no debe limitarse a sonar 'cuando algo choca'; debe enriquecer la respuesta del juego ante los comandos del jugador. Cuando el sistema de audio está deficientemente integrado, suele ocurrir el problema de repetición descontrolada: una moneda activa su sonido tantas veces como frames dura la colisión, o el paso del personaje satura los canales de audio provocando chasquidos digitales.

Para evitar esto, implementaremos funciones modulares que controlen la ganancia, el tono (*pitch*) y la concurrencia. Crearemos un script denominado `scr_audio_effects` que encapsule estas reglas operativas.

// ====================================================================
// SCRIPT: scr_audio_effects
// PROPÓSITO: Funciones auxiliares para la ejecución controlada de SFX
// ====================================================================

/// @function play_sfx(_sound_id, _priority, _pitch_variation)
/// @param {Asset.GMSound} _sound_id Identificador del sonido importado
/// @param {Real} _priority Prioridad en el mezclador (1 a 100)
/// @param {Real} _pitch_variation Variación aleatoria de tono (ej: 0.1)
function play_sfx(_sound_id, _priority, _pitch_variation) {
    var _instance = audio_play_sound(_sound_id, _priority, false);
    
    if (_pitch_variation > 0) {
        // Generar un tono ligeramente aleatorio para evitar monotonía auditiva
        var _random_pitch = random_range(1.0 - _pitch_variation, 1.0 + _pitch_variation);
        audio_sound_pitch(_instance, _random_pitch);
    }
    
    return _instance;
}

A continuación, observa cómo integramos esta llamada en la lógica del jugador al saltar y al recibir daño, garantizando que el audio responda con exactitud al cambio de estado interno.

// ====================================================================
// OBJETO: obj_player
// EVENTO: Step (Fragmento correspondiente a salto y aterrizaje)
// ====================================================================

// Comprobación de suelo antes del movimiento vertical
var _was_on_ground = on_ground;
on_ground = place_meeting(x, y + 1, obj_solid);

// Detección de impacto contra el suelo (aterrizaje)
if (!_was_on_ground && on_ground) {
    play_sfx(snd_land, 40, 0.15);
    // Crear partículas de polvo en los pies del jugador
    instance_create_layer(x, bbox_bottom, "Effects", obj_dust_impact);
}

// Ejecución de salto mediante botón de acción
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);
}

Sincronización del HUD con las variables globales

El HUD debe actuar como un espejo inmediato de lo que ocurre en la lógica, pero con técnicas de pulido visual para que la interfaz se sienta viva. En lugar de limitarse a imprimir un texto plano que cambia de forma brusca, agregaremos dos técnicas básicas de amortiguación visual en `obj_hud`:

1. **Escalado elástico del contador de monedas**: Cada vez que el jugador recolecta una moneda, el icono o texto del contador aumenta su escala momentáneamente y regresa con suavidad a su tamaño original. 2. **Parpadeo de la barra o corazones de vida**: Cuando el jugador recibe daño, el indicador visual de salud parpadea en color rojo o cambia su transparencia para alertar visualmente del impacto.

// ====================================================================
// OBJETO: obj_hud
// EVENTO: Create
// PROPÓSITO: Inicializar variables locales de animación del HUD
// ====================================================================

// Factores de escala para efecto de rebote en textos e iconos
coin_scale = 1.0;
score_display = global.player_score;

// Posición base de la interfaz (en coordenadas del GUI layer)
gui_margin_x = 40;
gui_margin_y = 40;
heart_spacing = 48;

En el evento **Step** de `obj_hud`, actualizamos suavemente los valores numéricos y amortiguamos las escalas hacia su valor de reposo (1.0) utilizando interpolación lineal (`lerp`).

// ====================================================================
// OBJETO: obj_hud
// EVENTO: Step
// PROPÓSITO: Actualizar animaciones visuales de la interfaz de usuario
// ====================================================================

// Interpolar suavemente el puntaje mostrado hacia el puntaje real
score_display = lerp(score_display, global.player_score, 0.15);

// Retornar la escala del icono de moneda a 1.0 tras una recogida
coin_scale = lerp(coin_scale, 1.0, 0.1);

// Si el jugador acaba de sumar una moneda en este frame, disparamos el rebote
if (global.coin_just_collected) {
    coin_scale = 1.5;
    global.coin_just_collected = false;
}

Posteriormente, en el evento **Draw GUI**, dibujamos los corazones de vida, el contador de monedas animado y el puntaje utilizando funciones estándar de renderizado de fuentes y sprites.

// ====================================================================
// OBJETO: obj_hud
// EVENTO: Draw GUI
// PROPÓSITO: Renderizar todos los elementos de pantalla sobre el juego
// ====================================================================

// 1. DIBUJAR VIDAS (Corazones)
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;
    
    // Si el índice es menor que la vida actual, dibujamos corazón lleno
    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. DIBUJAR CONTADOR DE MONEDAS CON ESCALADO DINÁMICO
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. DIBUJAR PUNTAJE
var _score_text = "PUNTOS: " + string(ceil(score_display));
draw_set_halign(fa_right);
draw_text(display_get_gui_width() - gui_margin_x, gui_margin_y, _score_text);

// Restablecer alineación de texto estándar
draw_set_halign(fa_left);
draw_set_valign(fa_top);