Ensamblaje del nivel principal y pantallas de transición

El flujo de juego y la arquitectura de pantallas

Hasta este punto del curso has construido mecánicas aisladas: un personaje con control físico preciso, colisiones con plataformas y tilemaps, enemigos que patrullan, monedas coleccionables, barras de vida e interfaces dibujadas en el evento Draw GUI. Sin embargo, un videojuego comercial no se compone de elementos desconectados o pruebas técnicas que se ejecutan directamente desde el editor; requiere un flujo integral (game flow) estructurado y coherente.

El flujo de juego describe el viaje continuo que experimenta el usuario desde que arranca la aplicación hasta que la cierra. Para que el jugador sienta una experiencia acabada, el software debe gestionar transiciones limpias: arrancar en una sala técnica de inicialización, presentar un menú principal funcional, dar paso al nivel jugable ensamblado con todos sus elementos interactivos y desembocar en pantallas de resolución (victoria o Game Over) que permitan reiniciar el ciclo sin fallos de memoria ni variables huérfanas.

En GameMaker, este recorrido se organiza mediante una secuencia ordenada de Rooms (salas) y objetos de control persistentes. Si cambiamos abruptamente de sala con una llamada directa e instantánea a la función interna room_goto(), el corte visual resulta tosco, interrumpe la inmersión y puede provocar artefactos gráficos si la nueva sala tarda un par de fotogramas en cargar sus texturas. Por esta razón, el ensamblaje profesional exige una capa intermedia de transición visual que enmascare el cambio de estado.

Planificación y jerarquía de Rooms en el gestor de recursos

El primer paso consiste en auditar el panel de recursos de GameMaker (Asset Browser). El orden en que las salas aparecen dentro de la sección 'Rooms' en el gestor de salas define la sala de inicio por defecto del proyecto. Aunque en desarrollo solemos ejecutar directamente la sala en la que estamos trabajando, la versión final compilada siempre ejecutará la primera sala listada de arriba hacia abajo.

Para este videojuego completo, estableceremos una estructura estricta compuesta por cinco salas esenciales:

La sala rm_init tiene una duración de exactamente un fotograma. Su única misión es ejecutar el código de arranque en el evento Create de un objeto inicializador global y, de inmediato, llamar al menú principal. Esta técnica evita que declaremos variables globales repetitivas dentro de salas que se visitarán múltiples veces.

El sistema de transición visual: obj_transition

Para ejecutar transiciones suaves mediante un fundido a negro (fade out / fade in), crearemos un objeto controlador persistente llamado obj_transition. Un objeto persistente (Persistent marcado en sus propiedades) no se destruye al cambiar de sala; viaja intacto entre escenas conservando sus variables y estados activos.

El gestor de transición funcionará bajo una máquina de estados sencilla de tres fases: inactivo (idle), oscureciendo la pantalla actual (fade out) y aclarando la nueva pantalla (fade in). Utilizaremos el evento Draw GUI para dibujar un rectángulo negro que cubra toda la superficie de la interfaz, independientemente del movimiento o posición de la cámara del juego.

Crea el objeto obj_transition en tu Asset Browser, marca su casilla 'Persistent' y programa el siguiente bloque en su evento Create:

// Evento Create de obj_transition
// Control del fundido visual
alpha = 0;
fade_speed = 0.04;
target_room = noone;

// Estados: 0 = inactivo, 1 = oscureciendo (fade out), 2 = aclarando (fade in)
transition_state = 0;

// Asegurar que el objeto no se duplique si ya existe uno en memoria
if (instance_number(obj_transition) > 1) {
    instance_destroy();
}

El siguiente paso es programar la lógica de avance temporal en el evento Step. Cuando la transición se active (estado 1), el valor de alpha aumentará progresivamente. En el momento exacto en que la pantalla quede completamente negra (alpha >= 1), invocaremos la función room_goto() para cambiar la escena detrás del velo oscuro y cambiaremos al estado 2 para comenzar a aclarar la nueva escena:

// Evento Step de obj_transition
switch (transition_state) {
    case 1: // Fase de oscurecimiento (Fade Out)
        alpha += fade_speed;
        if (alpha >= 1) {
            alpha = 1;
            if (target_room != noone && room_exists(target_room)) {
                room_goto(target_room);
            }
            transition_state = 2; // Pasar a fase de aclarado en la nueva sala
        }
        break;
        
    case 2: // Fase de aclarado (Fade In)
        alpha -= fade_speed;
        if (alpha <= 0) {
            alpha = 0;
            target_room = noone;
            transition_state = 0; // Regresar a inactivo
        }
        break;
        
    case 0: // Inactivo
    default:
        alpha = 0;
        break;
}

Para pintar el fundido sobre cualquier elemento visual del juego, emplearemos el evento Draw GUI. Al utilizar las funciones de dibujo de interfaz gráfica, nos desligamos de las coordenadas del mundo y de las matrices de la cámara:

// Evento Draw GUI de obj_transition
if (alpha > 0) {
    var _gui_w = display_get_gui_width();
    var _gui_h = display_get_gui_height();
    
    draw_set_color(c_black);
    draw_set_alpha(alpha);
    draw_rectangle(0, 0, _gui_w, _gui_h, false);
    
    // Reiniciar los valores de dibujo por defecto para no afectar otros objetos
    draw_set_alpha(1.0);
    draw_set_color(c_white);
}

Para hacer este sistema accesible desde cualquier script o evento de cualquier objeto del proyecto, encapsularemos la llamada de transición dentro de una función global de conveniencia. Crea un Script llamado scr_transitions y añade:

/// @function transition_to(_target)
/// @description Inicia una transicion suave hacia la sala indicada.
/// @param {Asset.GMRoom} _target Sala de destino.
function transition_to(_target) {
    if (instance_exists(obj_transition)) {
        with (obj_transition) {
            if (transition_state == 0) {
                target_room = _target;
                transition_state = 1;
            }
        }
    } else {
        // Fallback de seguridad si no se creo obj_transition
        room_goto(_target);
    }
}

💡 Regla fundamental de dibujo en GML: cada vez que modifiques draw_set_alpha() o draw_set_color(), debes restaurar sus valores predeterminados (1.0 y c_white) al finalizar el bloque. De lo contrario, todos los objetos que se dibujen después heredarán la transparencia o el tinte, provocando fallos visuales en el HUD y en los sprites de los personajes.

Ensamblaje del nivel principal: capas, actores y desencadenantes

Habiendo programado el puente visual, pasamos al ensamblaje del nivel interactivo dentro de rm_level_1. En lecciones anteriores configuraste tilemaps y colocaste instancias individuales para pruebas. Ahora integraremos el escenario completo mediante una estructura estricta de capas (Room Layers) que garantice el orden visual correcto y optimice el rendimiento.

Abre rm_level_1 y configura en el inspector de capas el siguiente apilamiento jerárquico, de arriba (capa superior visual) hacia abajo (capa más profunda):

Para conectar el nivel con la pantalla de victoria o el siguiente nivel, necesitamos un objeto meta interactivo. Crearemos obj_door (o meta de nivel) con un sprite identificable de puerta o bandera brillante. Este objeto detectará cuando el jugador lo toque y activará el paso al desenlace.

En el evento Collision de obj_door con obj_player, implementamos la verificación:

// Evento Collision de obj_door con obj_player
// Si el jugador llega a la meta, bloqueamos su entrada y pasamos a victoria
with (other) {
    can_move = false;
    hsp = 0;
    vsp = 0;
}

// Reproducir efecto de sonido de victoria si esta importado
if (audio_exists(snd_stage_clear)) {
    audio_play_sound(snd_stage_clear, 10, false);
}

// Iniciar la transicion a la pantalla de victoria
transition_to(rm_win);