Puertas y transición entre múltiples rooms

Introducción a la transición de niveles en GameMaker

En el desarrollo de videojuegos de plataformas 2D, la progresión espacial es el motor que mantiene el interés del jugador. Alcanzar el final de una sección, cruzar un umbral o abrir una compuerta debe sentirse como un logro claro y recompensado. En GameMaker, cada nivel, pantalla o menú se estructura dentro de un recurso denominado Room (sala). Por lo tanto, cambiar de nivel significa instruir al motor para que descargue los datos de la sala actual y cargue en memoria el contenido de la siguiente.

Aunque la acción de cambiar de sala puede resolverse con una única línea de código, hacerlo de manera descuidada genera problemas habituales: la pantalla se corta de forma abrupta, el personaje aparece en coordenadas incorrectas en el nuevo escenario o los datos acumulados (como monedas y vidas) se reinician involuntariamente. En esta lección diseñaremos una mecánica de cambio de nivel modular, elegante y reutilizable para todo nuestro proyecto, asegurando que el jugador pase de un escenario a otro mediante un elemento interactivo (puerta o meta) y una transición visual suave.

El ciclo de vida del cambio de Room

Cuando ejecutamos una orden de cambio de sala en GameMaker mediante GML Code, el motor realiza una serie de pasos críticos de limpieza y reconstrucción en el orden de ejecución de la escena:

1. Se activa el evento 'Other -> Room End' en todas las instancias activas que contengan este evento programado. 2. Todas las instancias que no estén marcadas como 'Persistent' (persistentes) son destruidas y liberadas de la memoria RAM. 3. Se descarga la estructura gráfica y las capas de tiles del room que abandonamos. 4. Se cargan los recursos visuales, capas de fondos y tilemaps del nuevo room. 5. Se crean las instancias definidas en las capas del nuevo room, ejecutando su respectivo evento 'Create'. 6. Se dispara el evento 'Other -> Room Start' en las instancias presentes.

💡 Es fundamental recordar que las variables comunes pertenecientes a una instancia (como 'x', 'y' o variables locales creadas en su evento Create) desaparecen cuando esa instancia es destruida al salir de la sala. Si queremos que un valor sobreviva al cambio de sala, debemos almacenarlo en una variable global o en un objeto gestor marcado como persistente.

Funciones esenciales de control de salas en GML

GameMaker ofrece un conjunto de funciones integradas para consultar y manipular el flujo de las salas. A continuación revisamos las más importantes que utilizaremos a lo largo de este módulo:

💡 Evita llamar directamente a 'room_goto_next()' sin comprobar si existe una sala posterior con 'room_next(room)'. Si intentas avanzar más allá del último nivel registrado en la lista de salas del proyecto, GameMaker arrojará un error fatal deteniendo el juego.

Diseño del objeto interactivo: obj_puerta

En lugar de crear un objeto puerta diferente para cada nivel ('obj_puerta_nivel1', 'obj_puerta_nivel2'), aplicaremos el principio de diseño modular: un único objeto 'obj_puerta' capaz de teletransportar al jugador a cualquier sala y a cualquier coordenada específica mediante variables configurables por instancia.

Comienza creando un sprite llamado 'spr_puerta'. Puede ser un marco de madera de 32x48 píxeles con una zona oscura en el interior, o un portal místico dibujado en el editor de sprites con dos o tres fotogramas para darle animación. Configura la máscara de colisión en modo rectángulo cerrado asegurando que cubra el área donde el jugador interactuará.

A continuación, crea el objeto 'obj_puerta', asígnale el sprite 'spr_puerta' y desmarca la casilla 'Solid' (queremos que el jugador pueda superponerse a la puerta sin chocar contra ella como si fuera un muro). En su evento Create, definiremos los valores por defecto:

// Recurso: obj_puerta
// Evento: Create

// Sala a la que enviará esta puerta (valor por defecto: ninguna sala específica)
destino_room = noone;

// Coordenadas donde aparecerá el jugador en la nueva sala
destino_x = 0;
destino_y = 0;

// Control para evitar activaciones múltiples en fotogramas sucesivos
activada = false;

GameMaker permite sobreescribir estas variables en cada instancia individual colocada en el escenario. Al situar una copia de 'obj_puerta' en una habitación, puedes hacer doble clic en ella dentro del editor de salas, presionar 'Variables' y asignar allí el nombre de la sala destino (por ejemplo, 'rm_nivel_2') y las coordenadas exactas de llegada. También puedes hacerlo mediante código de creación de instancia en la propia sala.

Detección de activación: Colisión e interactividad

En los juegos clásicos de plataformas encontramos dos filosofías para cruzar una puerta: cruzarla automáticamente al tocarla (ideal para metas de fin de fase o salidas de tuberías) o presionar una tecla de interacción como la flecha hacia arriba o la tecla 'W' estando frente a ella. Implementaremos la segunda opción, ya que ofrece mayor control al jugador y evita accidentes si este retrocede cerca del umbral.

// Recurso: obj_puerta
// Evento: Step

// Si la puerta ya fue usada, no comprobamos nada más
if (activada) exit;

// Verificamos si el jugador está colisionando con la puerta
if (place_meeting(x, y, obj_jugador))
{
    // Leemos si el jugador presiona la tecla de acción / flecha arriba
    var tecla_entrar = keyboard_check_pressed(vk_up) || keyboard_check_pressed(ord("W"));
    
    if (tecla_entrar)
    {
        // Validamos que la sala de destino exista en el proyecto
        if (destino_room != noone && room_exists(destino_room))
        {
            activada = true;
            
            // Guardamos las coordenadas deseadas en variables globales
            global.jugador_spawn_x = destino_x;
            global.jugador_spawn_y = destino_y;
            global.aplicar_spawn = true;
            
            // Creamos el efecto de transición en lugar de cambiar de golpe
            var trans = instance_create_depth(0, 0, -9999, obj_transicion_fade);
            trans.sala_objetivo = destino_room;
        }
        else
        {
            show_debug_message("Aviso: La puerta en (" + string(x) + ", " + string(y) + ") no tiene una sala de destino válida asignada.");
        }
    }
}

Control del punto de aparición en la nueva Room

Un error muy común entre principiantes es asumir que el personaje mantendrá mágicamente su posición o que la sala sabrá automáticamente dónde ponerlo. Si tu objeto 'obj_jugador' no es persistente, cuando 'rm_nivel_2' se cargue, el jugador nacerá en la posición exacta donde fue colocado dentro del editor de esa sala.

Para resolver esto sin complicaciones de punteros de memoria, utilizamos el patrón de 'Variables Globales de Aparición' ('global.jugador_spawn_x' y 'global.jugador_spawn_y'). Inicializamos estas variables en el objeto de control del juego o en un script de arranque global, y luego instruimos al jugador para que lea dichas coordenadas al iniciar cualquier nivel nuevo.

En el evento 'Create' de nuestro objeto controlador global (por ejemplo, 'obj_game_manager'), definimos las variables:

// Recurso: obj_game_manager
// Evento: Create

global.jugador_spawn_x = -1;
global.jugador_spawn_y = -1;
global.aplicar_spawn = false;

Luego, en el objeto 'obj_jugador', agregamos el evento 'Other -> Room Start' (Otros -> Inicio de Room). Este evento se dispara automáticamente cada vez que una nueva sala comienza a ejecutarse:

// Recurso: obj_jugador
// Evento: Other -> Room Start

// Verificamos si la puerta previa solicitó reposicionar al jugador
if (global.aplicar_spawn)
{
    x = global.jugador_spawn_x;
    y = global.jugador_spawn_y;
    
    // Restablecemos el indicador para no alterar posiciones en reinicios normales
    global.aplicar_spawn = false;
    
    // Reiniciamos las velocidades acumuladas para evitar salir disparado
    hspeed = 0;
    vspeed = 0;
    if (variable_instance_exists(id, "vel_x")) vel_x = 0;
    if (variable_instance_exists(id, "vel_y")) vel_y = 0;
}