Pantallas de victoria y derrota (Game Over)

Introducción: Cerrando el bucle principal del juego

Todo videojuego cuenta con un ciclo de retroalimentación fundamental: el jugador interactúa con las mecánicas, supera desafíos o comete errores y, finalmente, alcanza un desenlace. Hasta este punto del curso, nuestro proyecto cuenta con un personaje capaz de desplazarse, saltar, colisionar con enemigos, recibir daño, perder vidas y recolectar objetos, además de contar con un HUD informativo y un menú principal. Sin embargo, cuando la salud o las vidas llegan a cero, o cuando se alcanza el final del recorrido, el juego no ofrece una conclusión formal.

Las pantallas de fin de partida cumplen dos funciones esenciales: proporcionan una conclusión narrativa y psicológica inmediata al esfuerzo del jugador, y gestionan técnicamente la transición del estado de la aplicación. En esta lección aprenderás a estructurar de forma limpia y profesional las pantallas de derrota (*Game Over*) y de victoria (*Victory*), utilizando salas dedicadas (*rooms*), eventos de dibujo de interfaz (`Draw GUI`), controladores de teclado y un reinicio riguroso de las variables globales para garantizar que cada partida comience en un estado predecible y libre de errores.

Estructura de salas y recursos necesarios

Para implementar estas pantallas mantendremos una separación arquitectónica estricta. En lugar de superponer interfaces complejas dentro del mismo nivel, utilizaremos salas independientes. Esto garantiza que todos los enemigos, proyectiles, partículas y cálculos físicos del nivel se descarguen de la memoria RAM automáticamente al salir de la sala de juego.

En el *Asset Browser*, crearemos los siguientes recursos dentro de sus respectivas carpetas:

💡 Recuerda que en GameMaker las salas se configuran con un tamaño de vista predeterminado. Para asegurar consistencia visual, asigna a 'rm_gameover' y 'rm_victory' las mismas dimensiones base que definiste para la resolución de pantalla en las lecciones anteriores (por ejemplo, 640x360 o 1280x720).

Condición de derrota: Redirección hacia Game Over

En el Módulo 7 implementamos el sistema de vidas mediante la variable global `global.player_lives`. Cuando el jugador entra en contacto letal con un enemigo o cae en un precipicio, pierde una vida. Si aún le quedan vidas, el personaje reaparece en el punto de control (*checkpoint*). No obstante, cuando las vidas caen a cero o menos, debe activarse la secuencia de derrota definitiva.

Para evitar un salto de pantalla instantáneo y abrupto que desoriente al jugador, es una buena práctica de diseño introducir una breve pausa o retardo temporal utilizando una alarma (*Alarm*). Esto permite que la animación de muerte o el sonido de derrota se reproduzcan antes de abandonar el nivel.

Abramos el objeto del jugador, `obj_player`, y revisemos la función o fragmento de código donde se procesa la pérdida de vida dentro del evento **Step** o en el método de daño personalizado:

// Fragmento dentro de obj_player -> Evento Step o función de daño
if (hp <= 0 && !is_dead)
{
    is_dead = true;
    global.player_lives -= 1;
    
    // Detenemos el movimiento horizontal y vertical
    hsp = 0;
    vsp = 0;
    
    // Verificamos si aún quedan vidas disponibles
    if (global.player_lives > 0)
    {
        // Si quedan vidas, disparamos la alarma de reaparición (1 segundo = 60 steps)
        alarm[0] = 60;
    }
    else
    {
        // Si se agotaron las vidas, disparamos la alarma hacia la pantalla de Game Over
        alarm[1] = 90;
    }
}

A continuación, añadimos el evento **Alarm 1** en `obj_player` con la instrucción encargada de efectuar el cambio de sala:

/// Evento: Alarm 1 en obj_player
// Cambiamos de forma segura a la sala de derrota
room_goto(rm_gameover);

Condición de victoria: El objeto meta

Para la condición de victoria crearemos un objeto de llegada, `obj_goal`. Este objeto representará un poste de meta, un cofre o una puerta que, al hacer contacto con la caja de colisión del jugador, desencadena la victoria.

En el evento **Create** de `obj_goal`, inicializamos una bandera booleana para evitar que la colisión se dispare múltiples veces en fotogramas sucesivos:

/// Evento: Create en obj_goal
triggered = false;

En el evento **Collision** de `obj_goal` con `obj_player`, gestionamos la victoria desactivando el control del personaje e iniciando una pequeña espera antes del cambio de sala:

/// Evento: Collision con obj_player en obj_goal
if (!triggered)
{
    triggered = true;
    
    // Congelamos al jugador para que no siga moviéndose
    other.can_move = false;
    other.hsp = 0;
    other.vsp = 0;
    
    // Iniciamos la alarma para realizar la transición
    alarm[0] = 60;
}

Y en el evento **Alarm 0** de `obj_goal`, ejecutamos la transición:

/// Evento: Alarm 0 en obj_goal
room_goto(rm_victory);

Construcción del controlador de derrota (obj_gameover_controller)

Una vez que el jugador llega a `rm_gameover`, necesitamos un objeto que presente la información en pantalla y escuche las órdenes del usuario (reintentar la partida o volver al menú inicial). Colocaremos una única instancia de `obj_gameover_controller` en la sala `rm_gameover`.

En su evento **Create**, definimos las opciones del menú de derrota y una variable de índice para navegar entre ellas:

/// Evento: Create en obj_gameover_controller
menu_options = ["REINTENTAR", "MENU PRINCIPAL"];
menu_index = 0;
menu_total = array_length(menu_options);

// Bloqueo de entrada para evitar lecturas indeseadas inmediatas
input_cooldown = 10;

En el evento **Step**, gestionamos la navegación por teclado (flechas arriba/abajo o W/S) y la confirmación mediante la tecla Enter o Espacio:

/// Evento: Step en obj_gameover_controller
if (input_cooldown > 0)
{
    input_cooldown -= 1;
    exit;
}

var key_up = keyboard_check_pressed(vk_up) || keyboard_check_pressed(ord("W"));
var key_down = keyboard_check_pressed(vk_down) || keyboard_check_pressed(ord("S"));
var key_select = keyboard_check_pressed(vk_enter) || keyboard_check_pressed(vk_space);

if (key_up)
{
    menu_index -= 1;
    if (menu_index < 0) menu_index = menu_total - 1;
}

if (key_down)
{
    menu_index += 1;
    if (menu_index >= menu_total) menu_index = 0;
}

if (key_select)
{
    switch (menu_index)
    {
        case 0:
            // Reintentar: Reiniciar estadísticas globales y cargar el primer nivel
            scr_restart_game_state();
            room_goto(rm_level_1);
            break;
            
        case 1:
            // Menú principal: Reiniciar estadísticas y volver a la sala de título
            scr_restart_game_state();
            room_goto(rm_menu);
            break;
    }
}

Para pintar el mensaje en pantalla, recurrimos al evento **Draw GUI**, garantizando que el texto se dibuje con independencia de cámaras o desplazamientos:

/// Evento: Draw GUI en obj_gameover_controller
var gui_w = display_get_gui_width();
var gui_h = display_get_gui_height();

// Fondo oscuro semitransparente sobre la sala
draw_set_color(c_black);
draw_set_alpha(0.85);
draw_rectangle(0, 0, gui_w, gui_h, false);
draw_set_alpha(1.0);

// Dibujamos el título principal
draw_set_halign(fa_center);
draw_set_valign(fa_middle);

draw_set_color(c_red);
draw_text_transformed(gui_w * 0.5, gui_h * 0.3, "GAME OVER", 2.0, 2.0, 0);

// Dibujamos las opciones de navegación
for (var i = 0; i < menu_total; i++)
{
    var opt_y = (gui_h * 0.55) + (i * 40);
    
    if (i == menu_index)
    {
        draw_set_color(c_yellow);
        draw_text(gui_w * 0.5, opt_y, "> " + menu_options[i] + " <");
    }
    else
    {
        draw_set_color(c_white);
        draw_text(gui_w * 0.5, opt_y, menu_options[i]);
    }
}

// Restauramos los alineamientos estándar de dibujo
draw_set_halign(fa_left);
draw_set_valign(fa_top);