Implementación de vidas y barra de salud

Mecánica de pérdida de vida y reaparición (Respawn)

Cuando `salud_actual` alcanza el valor cero, el ciclo de vida del personaje ha concluido. En lugar de destruir la instancia mediante `instance_destroy()`, lo cual rompería las referencias de la cámara o detendría la ejecución de scripts asociados a ese objeto, llevaremos a cabo una reaparición controlada:

1. Descontar una vida del contador global (`vidas -= 1`). 2. Teletransportar inmediatamente al personaje a las coordenadas almacenadas en `origen_x` y `origen_y`. 3. Cancelar todas las fuerzas acumuladas de inercia (`velocidad_x = 0`, `velocidad_y = 0`) para evitar que el avatar caiga o se mueva descontroladamente al aparecer. 4. Restablecer la salud a su valor tope (`salud_actual = salud_maxima`). 5. Conceder un período breve de invulnerabilidad de cortesía para que el jugador no reciba daño instantáneo si reaparece cerca de una amenaza. 6. Comprobar si las vidas han llegado a cero. Si es así, se desencadena el estado de derrota o se reinicia el nivel.

Añade la siguiente comprobación en el evento Step de `obj_jugador`, inmediatamente después del cálculo de daño:

/// @description Comprobación de muerte, pérdida de vida y reaparición

if (salud_actual <= 0)
{
    vidas -= 1;
    
    if (vidas > 0)
    {
        // Reaparición en el punto de control u origen
        x = origen_x;
        y = origen_y;
        
        // Frenar completamente cualquier inercia de movimiento
        velocidad_x = 0;
        velocidad_y = 0;
        
        // Restaurar salud completa para el nuevo intento
        salud_actual = salud_maxima;
        
        // Otorgar inmunidad temporal breve tras el respawn
        es_invulnerable = true;
        tiempo_invulnerable = duracion_invulnerable;
    }
    else
    {
        // Se agotaron todas las vidas de la partida
        // Por ahora reiniciamos la sala; en el Módulo 8 implementaremos la pantalla de Game Over
        room_restart();
    }
}

Representación visual: Dibujando la barra de salud

Aunque en el próximo módulo (Módulo 8) profundizaremos exhaustivamente en la capa de interfaz de usuario con el evento Draw GUI, resulta indispensable contar desde este momento con una respuesta visual inmediata sobre el estado de la salud en la propia pantalla de juego. Existen dos métodos principales para representar la salud del jugador de manera temprana: una barra flotante que persigue al personaje en el espacio del mundo mediante el evento Draw tradicional, o una barra fija en pantalla mediante primitivas geométricas.

Implementaremos una barra de salud flotante situada justo encima de la cabeza del avatar. Para ello, crearemos el evento Draw en `obj_jugador`. Es primordial recordar una regla de oro en GameMaker: **si colocas código en el evento Draw de un objeto, GameMaker dejará de dibujar el sprite predeterminado de manera automática**. Por lo tanto, la primera instrucción que siempre debemos escribir en el evento Draw es `draw_self()`, la cual se encarga de renderizar el sprite habitual antes de pintar los elementos decorativos encima.

/// @description Evento Draw de obj_jugador: renderizado del sprite y barra flotante

// 1. Dibujar el sprite del personaje respetando su animación y alfa
draw_self();

// 2. Parámetros geométricos de la barra flotante
var _ancho_barra = 32;
var _alto_barra = 4;
var _desplazamiento_y = 20; // Píxeles por encima del origen del sprite

// Coordenadas calculadas en torno a la posición del jugador
var _x1 = x - (_ancho_barra / 2);
var _y1 = y - sprite_yoffset - _desplazamiento_y;
var _x2 = x + (_ancho_barra / 2);
var _y2 = _y1 + _alto_barra;

// 3. Dibujar el fondo oscuro de la barra (vida faltante / contenedor)
draw_set_color(c_black);
draw_rectangle(_x1 - 1, _y1 - 1, _x2 + 1, _y2 + 1, false);

// 4. Calcular el ancho de la porción verde proporcional a la salud restante
var _porcentaje = salud_actual / salud_maxima;
var _x_vida = _x1 + (_ancho_barra * _porcentaje);

// 5. Determinar color dinámico: verde si está sano, amarillo si está herido, rojo en crítico
var _color_salud = c_lime;
if (_porcentaje <= 0.25)
{
    _color_salud = c_red;
}
else if (_porcentaje <= 0.5)
{
    _color_salud = c_yellow;
}

// 6. Dibujar el relleno de salud actual
if (salud_actual > 0)
{
    draw_set_color(_color_salud);
    draw_rectangle(_x1, _y1, _x_vida, _y2, false);
}

// 7. Restaurar el color base de dibujo para no alterar otros elementos gráficos
draw_set_color(c_white);

Examinemos con atención el cálculo geométrico. Al restar `sprite_yoffset`, nos aseguramos de que sin importar dónde hayas fijado el punto de anclaje (origen) del sprite del personaje (en el centro, en la base de los pies o en la esquina superior izquierda), la barra siempre se dibujará con precisión 20 píxeles por encima del borde superior real del cuerpo. Adicionalmente, el cambio condicional de color (`c_lime`, `c_yellow`, `c_red`) añade una advertencia intuitiva al jugador conforme su situación se vuelve crítica.

Ejemplo práctico guiado: Demostración de impacto y reaparición

Con el fin de verificar que todas las piezas encajan a la perfección, sigue este procedimiento de prueba estructurado dentro del entorno de desarrollo:

1. Abre la sala principal del proyecto (`Room1` o `rm_nivel_1`). 2. Coloca una instancia de `obj_jugador` en una plataforma segura a la izquierda del escenario. 3. Coloca una instancia de `obj_enemigo_patrullero` en la misma plataforma, permitiéndole patrullar hacia la derecha. 4. Ejecuta el juego pulsando F5 (o el botón de reproducción verde en la barra superior). 5. Camina intencionalmente hacia el enemigo para provocar el primer impacto. Observa cómo el jugador sale despedido levemente hacia arriba y hacia la izquierda, su sprite comienza a parpadear con semitransparencia y la barra sobre su cabeza disminuye un tercio de su longitud cambiando a color verde o amarillo. 6. Intenta colisionar nuevamente contra el enemigo mientras el parpadeo continúe activo. Podrás comprobar que el cuerpo del enemigo no te causa más daño durante ese segundo de gracia. 7. Permite que el parpadeo finalice y recibe dos impactos adicionales. Tan pronto como la salud desciende a cero, la instancia desaparece del lugar de la caída y reaparece instantáneamente en la posición original donde iniciaste la sala, con la barra de salud completamente regenerada al 100% y con una vida menos en su registro interno.

Ejercicios prácticos

A continuación, dispones de tres actividades progresivas para consolidar lo aprendido, reforzar la escritura en GML Code y resolver problemas comunes del desarrollo de mecánicas:

<strong>Ejercicio 1: Zona de caída mortal (muerte por precipicio)</strong> En la mayoría de juegos de plataformas, si el jugador cae al vacío fuera de la pantalla, no debe flotar indefinidamente ni sufrir daño fraccionado: debe perder una vida al instante y reaparecer de inmediato. Escribe una comprobación condicional en el evento Step de `obj_jugador` que evalúe si la posición vertical `y` supera la altura máxima de la sala (`room_height + 32`). En caso afirmativo, reduce su `salud_actual` directamente a 0 para forzar el protocolo de respawn. <em>Criterio de corrección:</em> Al dejar caer deliberadamente al personaje por un agujero entre plataformas, debe reaparecer en `origen_x` y `origen_y` con una vida descontada, sin generar errores de ejecución.

<strong>Ejercicio 2: Marcador numérico de vidas flotante</strong> Modifica el evento Draw de `obj_jugador` para que, justo a la derecha de la barra rectangular de salud, se dibuje un texto con la cantidad de vidas restantes utilizando la función nativa `draw_text(x, y, string)`. Recuerda configurar `draw_set_color(c_white)` antes de dibujar el texto para asegurar su legibilidad. <em>Criterio de corrección:</em> En pantalla debe visualizarse un texto claro como 'x 3' o 'Vidas: 3' que acompañe a la barra y disminuya a 'x 2' y 'x 1' cada vez que el personaje sufra un colapso de salud.

<strong>Ejercicio 3: Puntos de control manuales (Preámbulo de Checkpoints)</strong> Declara en el evento Step una tecla de depuración rápida (por ejemplo, la barra espaciadora o la tecla 'C') que, al ser presionada mediante `keyboard_check_pressed(ord("C"))`, actualice los valores de `origen_x` y `origen_y` con la posición actual del jugador (`origen_x = x; origen_y = y;`). <em>Criterio de corrección:</em> Tras avanzar a una plataforma lejana y pulsar la tecla 'C', al morir contra un enemigo o caer al vacío el jugador no debe regresar al inicio del nivel, sino reaparecer exactamente en el nuevo punto donde activó el guardado manual.