Control de volumen y ajustes de audio

Control de volumen y ajustes de audio en GameMaker

En las clases anteriores aprendiste a importar e invocar efectos de sonido mediante funciones como audio_play_sound, así como a estructurar bucles musicales y generar partículas dinámicas para enriquecer la estética retro de nuestro juego de plataformas 2D. Sin embargo, un apartado sonoro de calidad comercial exige algo más que la simple reproducción de pistas: requiere que el usuario final tenga el control total sobre los niveles de intensidad acústica de su experiencia. No todas las pantallas, auriculares o preferencias de los jugadores son idénticas, y la ausencia de controles de volumen es una de las deficiencias más señaladas en las pruebas de experiencia de usuario.

El objetivo de esta lección es dotar a nuestro proyecto de una arquitectura de audio robusta, modular y personalizable. Exploraremos la jerarquía del sonido en GameMaker, aprenderemos a manipular la ganancia general (volumen maestro) y a segmentar la mezcla entre música de fondo y efectos especiales. Finalmente, conectaremos este sistema lógico con elementos visuales e interactivos en el evento Draw GUI, permitiendo al jugador modificar el volumen mediante barras deslizantes y selectores intuitivos.

El concepto de ganancia (Gain) y la jerarquía de mezcla

En el desarrollo de software y la ingeniería de audio digital, el término técnico para designar el volumen relativo de una señal es «ganancia» (gain). En GameMaker, la ganancia no se expresa en decibelios ni en valores porcentuales directos del 0 al 100, sino como un número en punto flotante que suele oscilar entre 0.0 y 1.0:

Para gestionar una mezcla equilibrada en un videojuego comercial, nunca alteramos cada archivo de forma aislada sin un marco común. Establecemos una jerarquía que procesa la señal de audio a través de diferentes etapas antes de enviarla a los altavoces físicos del dispositivo del usuario.

Tal como ilustra el esquema, el volumen final que percibe el oído humano es el resultado de multiplicar las ganancias consecutivas. Si el sonido de un salto (`snd_salto`) se emite con ganancia 0.8, el canal de efectos (SFX) está calibrado al 0.5 y el volumen maestro general se encuentra al 0.5, la ganancia final real de ese salto será 0.8 * 0.5 * 0.5 = 0.2 (es decir, el 20% de su volumen original). Comprender esta multiplicación en cascada evita errores comunes de saturación o silenciamientos involuntarios.

Funciones nativas de control de ganancia en GML

GameMaker ofrece un conjunto de funciones especializadas para intervenir en cada nivel de esta jerarquía. A continuación, revisamos las herramientas esenciales que utilizaremos en la programación del sistema:

1. **Control maestro:** La función `audio_master_gain(gain)` determina el techo absoluto de volumen de toda la aplicación. Acepta un valor real entre 0.0 y 1.0. Al modificarla, todo sonido generado por cualquier función de GameMaker se ajustará de manera inmediata y proporcional.

2. **Control por recurso o instancia:** La función `audio_sound_gain(index, gain, time)` permite cambiar el volumen de un recurso específico (`snd_salto`) o de una instancia de sonido en ejecución (el identificador numérico devuelto por `audio_play_sound`). Su tercer parámetro, `time`, define el tiempo de interpolación en milisegundos, permitiendo transiciones suaves (fades) sin saltos bruscos.

3. **Control mediante Grupos de Audio (Audio Groups):** En proyectos medianos y avanzados, GameMaker permite agrupar sonidos en el IDE bajo 'Audio Groups' independientes (por ejemplo, `audiogroup_default`, `audiogroup_music`, etc.). Mediante `audio_group_set_gain(group, gain, time_ms)`, es posible alterar simultáneamente todos los sonidos asignados a ese grupo con una sola línea de código.

💡 Consejo técnico: Aunque los Audio Groups representan una excelente práctica para proyectos extensos con streaming en disco, en esta lección implementaremos un gestor híbrido basado en variables globales y control por instancias de audio. Esto garantiza total compatibilidad educativa sin requerir configuraciones complejas de precarga de memoria en el IDE para alumnos que dan sus primeros pasos.

Diseño del objeto gestor: obj_controlador_audio

Para asegurar que las preferencias sonoras del jugador persistan entre los diferentes niveles de nuestro juego de plataformas (desde la pantalla de título hasta la cueva subterránea), crearemos un objeto controlador persistente. Este objeto centralizará el estado de los canales y servirá de intermediario para cualquier petición sonora del juego.

Sigue estos pasos en tu proyecto:

1. En el **Asset Browser**, haz clic derecho sobre la carpeta **Objects** y selecciona **Create -> Object**. 2. Asigna al objeto el nombre exacto `obj_controlador_audio`. 3. Marca la casilla de verificación **Persistent** (Persistente). Esto garantiza que el objeto no se destruya al cambiar de room con `room_goto()`.

A continuación, inicializaremos las variables de configuración en el evento **Create** de `obj_controlador_audio`. Usaremos variables globales para que cualquier otro objeto del juego (como el jugador al saltar o un enemigo al recibir daño) pueda consultar el estado del audio en caso de necesitarlo.

// Evento Create de obj_controlador_audio

// 1. Evitar duplicados si volvemos a la room inicial
if (instance_number(obj_controlador_audio) > 1) {
    instance_destroy();
    exit;
}

// 2. Variables maestras de ganancia (rango 0.0 a 1.0)
global.volumen_maestro = 0.8;
global.volumen_musica  = 0.7;
global.volumen_sfx     = 1.0;

// Variable para rastrear la música ambiental activa actualmente
global.musica_actual_instancia = noone;
global.musica_actual_asset     = noone;

// Aplicar inmediatamente la ganancia maestra al motor
audio_master_gain(global.volumen_maestro);

// Variables de interfaz para interacción con sliders en pantalla
slider_seleccionado = -1; // -1: ninguno, 0: maestro, 1: musica, 2: sfx

// Dimensiones y márgenes de los controles visuales en GUI
gui_slider_ancho = 200;
gui_slider_alto  = 16;

El control de duplicados mediante `instance_number(obj_controlador_audio) > 1` es una técnica indispensable. Al configurar una instancia como persistente, si el jugador reinicia la partida o vuelve al menú principal donde se colocó originalmente el objeto, GameMaker crearía una segunda copia idéntica. Destruir de inmediato cualquier instancia secundaria previene solapamientos acústicos y fallos en la memoria.

Creación de funciones de reproducción seguras y modulares

Para que el volumen de los efectos sonoros y de la música responda fielmente a las variables que acabamos de declarar, no debemos llamar directamente a `audio_play_sound` de forma dispersa con valores arbitrarios. Es una excelente práctica de desarrollo crear funciones personalizadas (scripts) encargadas de aplicar la ganancia adecuada en el instante exacto de la reproducción.

Crea un nuevo Script en el Asset Browser y nómbralo `scr_audio_sistema`. Escribe el siguiente código modular en su interior:

/// @function reproducir_sfx(sound_asset, prioridad)
/// @description Reproduce un efecto sonoro aplicando la ganancia global de SFX.
/// @param {Asset.GMSound} _asset Identificador del sonido a reproducir
/// @param {Real} _prioridad Prioridad de reproducción (ej. 1 a 10)
function reproducir_sfx(_asset, _prioridad) {
    var _instancia = audio_play_sound(_asset, _prioridad, false);
    
    // Aplicar la ganancia calculada inmediatamente a la instancia recién creada
    audio_sound_gain(_instancia, global.volumen_sfx, 0);
    
    return _instancia;
}

/// @function reproducir_musica(sound_asset, tiempo_fade_ms)
/// @description Gestiona el cambio de música de fondo con soporte para fundido.
/// @param {Asset.GMSound} _asset Recurso musical a reproducir en bucle
/// @param {Real} _tiempo_fade_ms Tiempo de transición en milisegundos
function reproducir_musica(_asset, _tiempo_fade_ms) {
    // Si la música solicitada ya está sonando, no hacemos nada
    if (global.musica_actual_asset == _asset && audio_is_playing(global.musica_actual_instancia)) {
        return;
    }
    
    // Si hay una música previa sonando, detenemos o hacemos fade out
    if (audio_is_playing(global.musica_actual_instancia)) {
        audio_sound_gain(global.musica_actual_instancia, 0, _tiempo_fade_ms);
        // Nota: El motor detendrá la pista gradualmente
    }
    
    // Iniciar la nueva pista con volumen 0 para entrar suavemente
    global.musica_actual_asset = _asset;
    global.musica_actual_instancia = audio_play_sound(_asset, 100, true);
    audio_sound_gain(global.musica_actual_instancia, 0, 0);
    
    // Transición al volumen de música configurado
    audio_sound_gain(global.musica_actual_instancia, global.volumen_musica, _tiempo_fade_ms);
}

/// @function actualizar_volumenes_en_tiempo_real()
/// @description Actualiza el volumen maestro y los sonidos continuos activos.
function actualizar_volumenes_en_tiempo_real() {
    // 1. Actualizar el volumen general del motor
    audio_master_gain(global.volumen_maestro);
    
    // 2. Si hay música activa en bucle, actualizar su ganancia sin esperar a una nueva pista
    if (audio_is_playing(global.musica_actual_instancia)) {
        audio_sound_gain(global.musica_actual_instancia, global.volumen_musica, 0);
    }
}

Con estas funciones preparadas, actualizar nuestro código de clases pasadas se vuelve una tarea trivial y segura:

• En lugar de escribir `audio_play_sound(snd_salto, 1, false);` en el jugador, invocaremos `reproducir_sfx(snd_salto, 1);`. • Al recolectar una moneda o derrotar a un enemigo, utilizaremos `reproducir_sfx(snd_moneda, 2);`. • Al cargar un nivel o pantalla de juego, iniciaremos la atmósfera mediante `reproducir_musica(snd_musica_nivel_1, 1000);` para lograr una entrada suave de un segundo.

Construcción de la interfaz de usuario en Draw GUI

Para que los ajustes sean accesibles al jugador, necesitamos una interfaz gráfica que visualice los tres canales (Maestro, Música y SFX) y permita regularlos tanto con el ratón como con entradas digitales. En el Módulo 8 aprendimos que el evento **Draw GUI** dibuja de forma estática sobre la pantalla, independientemente de los desplazamientos de la cámara o las dimensiones de la room del juego.

Implementaremos barras de ajuste interactivo (sliders) directamente mediante código vectorial y primitivas de GameMaker (`draw_rectangle`, `draw_set_color`), prescindiendo de la necesidad inmediata de crear sprites complejos. Esto permite probar el funcionamiento lógico con agilidad matemática pura.

Abramos de nuevo el objeto `obj_controlador_audio` y añadamos el evento **Draw GUI**:

// Evento Draw GUI de obj_controlador_audio

// Coordenadas base en pantalla
var _base_x = 100;
var _base_y = 120;
var _espaciado_y = 60;

// Configuración visual de textos
draw_set_font(-1); // Usar la tipografía predeterminada
draw_set_halign(fa_left);
draw_set_valign(fa_middle);

// Título del panel de configuración de audio
draw_set_color(c_white);
draw_text(_base_x, _base_y - 40, "AJUSTES DE AUDIO (Arrastra con el raton):");

// Estructura de datos temporal para procesar los tres canales en un bucle limpio
var _canales = [
    { nombre: "Volumen Maestro: ", valor: global.volumen_maestro },
    { nombre: "Musica BGM:       ", valor: global.volumen_musica },
    { nombre: "Efectos SFX:      ", valor: global.volumen_sfx }
];

for (var i = 0; i < array_length(_canales); i++) {
    var _y_pos = _base_y + (i * _espaciado_y);
    var _nombre = _canales[i].nombre;
    var _val = _canales[i].valor;
    var _porcentaje_texto = string(round(_val * 100)) + "%";
    
    // 1. Dibujar etiqueta identificativa y porcentaje numérico
    draw_set_color(c_yellow);
    draw_text(_base_x, _y_pos - 15, _nombre + _porcentaje_texto);
    
    // 2. Dibujar fondo de la barra del slider (Gris oscuro)
    draw_set_color(c_dkgray);
    draw_rectangle(_base_x, _y_pos, _base_x + gui_slider_ancho, _y_pos + gui_slider_alto, false);
    
    // 3. Dibujar porción llena de la barra según el volumen actual (Verde cian)
    var _ancho_relleno = gui_slider_ancho * _val;
    draw_set_color(c_aqua);
    draw_rectangle(_base_x, _y_pos, _base_x + _ancho_relleno, _y_pos + gui_slider_alto, false);
    
    // 4. Dibujar borde exterior de la barra (Blanco)
    draw_set_color(c_white);
    draw_rectangle(_base_x, _y_pos, _base_x + gui_slider_ancho, _y_pos + gui_slider_alto, true);
    
    // 5. Dibujar tirador móvil (Knob indicador)
    var _tirador_x = _base_x + _ancho_relleno;
    draw_set_color(c_white);
    draw_rectangle(_tirador_x - 3, _y_pos - 4, _tirador_x + 3, _y_pos + gui_slider_alto + 4, false);
}

// Restaurar color por defecto al terminar el renderizado
draw_set_color(c_white);