Unreal Engine: Creación de un Sistema de Daño y Puntos de Golpe (HP) con Blueprint

🚀 Introducción al Sistema de Daño y HP en Unreal Engine

En el mundo del desarrollo de videojuegos, un sistema de daño y puntos de golpe (HP) es fundamental. Permite que los personajes (jugadores y enemigos) interactúen de forma significativa, añadiendo desafío, estrategia y realismo al juego. Sin un sistema así, los enfrentamientos serían meramente cosméticos o se basarían en mecánicas binarias de "golpear y destruir".

Este tutorial se centrará en construir un sistema flexible y modular utilizando Blueprints en Unreal Engine 5, lo que lo hace accesible incluso para aquellos con poca o ninguna experiencia en programación. Exploraremos cómo definir atributos, aplicar y recibir daño, gestionar la curación y, finalmente, cómo un personaje reacciona cuando sus puntos de golpe llegan a cero.

¿Por qué Blueprint? 🤔

Blueprint es el sistema de scripting visual de Unreal Engine. Es increíblemente potente y permite a los diseñadores y programadores prototipar y construir funcionalidades complejas sin escribir una sola línea de código. Para un sistema de daño y HP, Blueprint ofrece:

• Accesibilidad: Fácil de entender y visualizar el flujo lógico.
• Rapidez de Prototipado: Permite iterar rápidamente sobre mecánicas de juego.
• Modularidad: Facilita la creación de componentes reutilizables.

🛠️ Configuración Inicial: Atributos Básicos

El primer paso es definir los atributos esenciales que controlarán la salud de nuestros personajes. Necesitamos al menos dos variables clave: la salud actual y la salud máxima.

Creando un Componente de Salud 📦

Para hacer nuestro sistema reutilizable, crearemos un Actor Component llamado HealthComponent. De esta manera, cualquier Actor en nuestro juego (personajes, enemigos, objetos destructibles) podrá tener un sistema de salud simplemente añadiéndole este componente.

1. Crear Blueprint Componente:

   • Haz clic derecho en el Content Browser.
   • Selecciona Blueprint Class.
   • Expande All Classes y busca ActorComponent.
   • Nómbralo BP_HealthComponent.

2. Variables en BP_HealthComponent:

   • Abre BP_HealthComponent.
   • Crea las siguientes variables:
     • CurrentHealth (Tipo: Float, Valor por defecto: 100.0)
     • MaxHealth (Tipo: Float, Valor por defecto: 100.0)
   💡 Consejo: Usa `Float` en lugar de `Integer` para la salud para permitir valores de daño fraccionarios, lo que añade más granularidad al sistema.

3. Hacer Variables Editables:

   • Selecciona CurrentHealth y MaxHealth en el panel Details.
   • Marca el ojo al lado de cada variable para hacerlas Editable (aparecerán en el panel Details de cualquier Actor que use este componente).
   • Marca Replicated para CurrentHealth si planeas un juego multijugador. Esto asegura que la salud se sincronice entre clientes y el servidor.

💖 Implementando Lógica de Daño y Curación

Ahora que tenemos los atributos, necesitamos funciones para modificarlos. Añadiremos funciones para aplicar daño, curar y un evento para manejar la muerte.

Función: ApplyDamage 💥

Esta función será la encargada de reducir la salud del personaje.

1. Crear Función:

   • En BP_HealthComponent, en el panel My Blueprint, haz clic en + Function.
   • Nómbrala ApplyDamage.

2. Parámetros de la Función:

   • Haz clic en la función ApplyDamage.
   • En el panel Details, haz clic en + New Parameter para Inputs.
   • Nombra el parámetro DamageAmount (Tipo: Float).

3. Lógica de la Función:

   • Arrastra un Get CurrentHealth y un Get DamageAmount.
   • Usa un nodo Float - Float para restar DamageAmount de CurrentHealth.
   • Usa un nodo FMath::Max para asegurar que la salud nunca baje de cero (es decir, el mínimo será 0.0f). Conecta el resultado del Float - Float al A y 0.0 al B.
   • Arrastra un Set CurrentHealth y conecta el resultado de FMath::Max al input de CurrentHealth.
   • Después de Set CurrentHealth, añade una rama (Branch) para comprobar si CurrentHealth es igual a 0.0.
   • Si es True, el personaje ha muerto. Llamaremos a un evento.

Evento: OnDeath 💀

Necesitamos una forma de notificar a otros Blueprints cuando este personaje muere. Usaremos un Event Dispatcher.

1. Crear Event Dispatcher:

   • En BP_HealthComponent, en el panel My Blueprint, bajo Event Dispatchers, haz clic en +.
   • Nómbralo OnDeath.

2. Llamar al Evento:

   • En la función ApplyDamage, después del Set CurrentHealth y la rama que comprueba si CurrentHealth es 0.0f.
   • Si la condición de la rama es True, arrastra desde el pin True y busca Call OnDeath.

Función: Heal ❤️‍🩹

Esta función aumentará la salud del personaje, sin superar el MaxHealth.

1. Crear Función:

   • En BP_HealthComponent, crea una nueva función llamada Heal.

2. Parámetros:

   • Añade un parámetro de input llamado HealAmount (Tipo: Float).

3. Lógica:

   • Arrastra un Get CurrentHealth y un Get HealAmount.
   • Usa un nodo Float + Float para sumar HealAmount a CurrentHealth.
   • Usa un nodo FMath::Min para asegurar que la salud nunca supere MaxHealth. Conecta el resultado de Float + Float al A y Get MaxHealth al B.
   • Arrastra un Set CurrentHealth y conecta el resultado de FMath::Min.

🖥️ Integración con un Personaje (Player/Enemy)

Ahora que tenemos el BP_HealthComponent, vamos a añadirlo a un personaje y hacer que interactúe con él.

Añadir el Componente al Personaje 🚶

Para este ejemplo, usaremos el ThirdPersonCharacter por defecto de Unreal Engine.

1. Abrir Personaje Blueprint:

   • Abre BP_ThirdPersonCharacter (o tu Blueprint de personaje/enemigo).
   • En la pestaña Components, haz clic en + Add.
   • Busca BP_HealthComponent y selecciónalo. Puedes renombrarlo a HealthComp para mayor brevedad.

2. Configurar Valores Iniciales:

   • Con HealthComp seleccionado, en el panel Details, verás CurrentHealth y MaxHealth.
   • Puedes ajustarlos aquí si no quieres los valores por defecto.

Suscribirse al Evento OnDeath ☠️

Cuando el personaje muera, queremos que haga algo (por ejemplo, reproducir una animación, destruir el actor, mostrar una pantalla de game over).

1. En BP_ThirdPersonCharacter, en el Event Graph:
   • Selecciona HealthComp en la pestaña Components.
   • Haz clic derecho en un espacio vacío del Event Graph.
   • Busca Assign OnDeath (HealthComp) y haz clic.
   • Esto creará un nodo Assign OnDeath y un Custom Event (normalmente llamado OnDeath).
   • Desde este Custom Event, puedes añadir la lógica de muerte. Por ejemplo:
     • Print String (mensaje "¡El personaje ha muerto!").
     • Disable Input (para el jugador).
     • Destroy Actor (si es un enemigo).

Recibir Daño desde el Exterior 🥊

Un personaje necesita una forma de recibir daño de otras fuentes (proyectiles, ataques cuerpo a cuerpo, caídas).

1. Usando Any Damage Event:

   • En BP_ThirdPersonCharacter, haz clic derecho en el Event Graph y busca Event AnyDamage.
   • Este evento se dispara cuando el Actor recibe daño a través de la función ApplyDamage de Unreal (generalmente llamada por proyectiles, colisiones, etc.).
   • Desde el pin Damage del Event AnyDamage:
     • Arrastra desde HealthComp y busca ApplyDamage.
     • Conecta el pin Damage del Event AnyDamage al DamageAmount del ApplyDamage del HealthComp.
   🔥 Importante: Para que `Event AnyDamage` funcione, la fuente de daño debe llamar a la función `ApplyDamage` (por ejemplo, `K2_ApplyDamage` en C++ o el nodo `Apply Damage` de Blueprint).

📊 Interfaz de Usuario (UI) para la Salud

Mostrar la salud actual al jugador es crucial. Usaremos UMG (Unreal Motion Graphics) para crear una barra de salud.

Creando la Barra de Salud 💚

1. Crear Widget Blueprint:

   • Haz clic derecho en el Content Browser.
   • Selecciona User Interface -> Widget Blueprint.
   • Elige User Widget y nómbralo WBP_HealthBar.

2. Diseño del Widget:

   • Abre WBP_HealthBar.
   • Arrastra un Progress Bar desde la paleta de User Created al Canvas Panel.
   • Configura su Anchors a la esquina superior izquierda, Position X/Y y Size X/Y para que tenga un tamaño y posición adecuados.
   • Puedes cambiar el Fill Color and Opacity a verde.

3. Binding de la Barra de Progreso:

   • Con el Progress Bar seleccionado, en el panel Details, busca la propiedad Percent.
   • Haz clic en el botón Bind y selecciona Create Binding.
   • Esto creará una nueva función en el Graph del widget (GetPercent_XXXX).

4. Lógica del Binding:

   • En esta nueva función, necesitamos obtener la salud del personaje.
   • Primero, necesitamos una referencia a nuestro personaje. En el Event Construct del WBP_HealthBar:
     • Usa Get Player Character.
     • Cast To BP_ThirdPersonCharacter.
     • Promueve el resultado a una variable (PlayerRef).
   • Luego, en la función GetPercent_XXXX:
     • Arrastra PlayerRef.
     • Desde PlayerRef, arrastra y busca Get HealthComp.
     • Desde HealthComp, arrastra y busca Get CurrentHealth y Get MaxHealth.
     • Divide CurrentHealth por MaxHealth (Float / Float).
     • Conecta el resultado al Return Value del nodo Return.

Mostrar la Barra de Salud en el Juego 🎮

1. En BP_ThirdPersonCharacter (o tu PlayerController / HUD Blueprint):

   • En el Event BeginPlay:
     • Create Widget (Clase: WBP_HealthBar, Owning Player: Get Player Controller).
     • Promueve el resultado a una variable (HealthBarRef).
     • Desde HealthBarRef, arrastra y busca Add To Viewport.
   💡 Consejo: Considera crear el HUD en el `PlayerController` o un `HUD` Blueprint específico para una mejor organización, especialmente en juegos complejos.

✨ Eventos Personalizados y Comunicación

Para un sistema de salud más robusto, es útil tener eventos que se disparen cuando la salud cambia, no solo cuando el personaje muere. Esto permite que otros sistemas reaccionen a estos cambios (por ejemplo, efectos visuales de sangre, sonidos de dolor, actualizaciones de la UI).

Event Dispatcher: OnHealthChanged 🔄

1. Crear Event Dispatcher:

   • En BP_HealthComponent, en el panel My Blueprint, bajo Event Dispatchers, haz clic en +.
   • Nómbralo OnHealthChanged.

2. Parámetros del Dispatcher:

   • Añade un parámetro NewHealth (Tipo: Float) y HealthDelta (Tipo: Float). HealthDelta puede indicar cuánto cambió la salud y si fue positivo o negativo.

3. Llamar al Evento en ApplyDamage y Heal:

   • En ApplyDamage, después del Set CurrentHealth (pero antes de la rama de muerte):
     • Calcula HealthDelta (OldHealth - NewHealth).
     • Llama Call OnHealthChanged, pasando CurrentHealth como NewHealth y el HealthDelta calculado.
   • En Heal, después del Set CurrentHealth:
     • Calcula HealthDelta (NewHealth - OldHealth).
     • Llama Call OnHealthChanged, pasando CurrentHealth como NewHealth y el HealthDelta calculado.

Suscribirse a OnHealthChanged (Ejemplo: HUD) 🔔

Aunque el binding de la barra de salud funciona, usar OnHealthChanged puede ser más eficiente, ya que la UI solo se actualiza cuando la salud realmente cambia, en lugar de cada frame.

1. Modificar WBP_HealthBar:

   • En el Event Graph del WBP_HealthBar (después de obtener PlayerRef en Event Construct):
     • Desde PlayerRef, Get HealthComp.
     • Desde HealthComp, busca Assign OnHealthChanged.
     • Esto creará un Custom Event (por ejemplo, OnHealthChanged_Event) con los parámetros NewHealth y HealthDelta.
     • Dentro de este evento, puedes actualizar manualmente el Percent de tu Progress Bar usando Set Percent (Progress Bar). Calcula el porcentaje como NewHealth / MaxHealth.
   📌 Nota: Puedes usar tanto el binding como el evento, pero el evento ofrece más control para animaciones o efectos específicos cuando la salud cambia.

🎯 Pruebas y Depuración

Un sistema robusto requiere pruebas exhaustivas. Aquí hay algunas ideas para verificar que todo funciona correctamente.

Simulación de Daño y Curación 🧪

1. Botones de Prueba en la UI:

   • Crea un WBP_Debug simple con dos botones: "Aplicar Daño" y "Curar".
   • Al hacer clic en "Aplicar Daño", llama a ApplyDamage en tu personaje con un valor fijo.
   • Al hacer clic en "Curar", llama a Heal.
   • Añade este WBP_Debug a la pantalla como hiciste con WBP_HealthBar.

2. Volúmenes de Daño:

   • Crea un Blueprint Class basado en Actor.
   • Añade un Box Collision a este Actor.
   • En el Event Graph, en Event Overlap (On Component Begin Overlap), Cast To BP_ThirdPersonCharacter.
   • Desde el personaje, Get HealthComp y llama a ApplyDamage cada segundo, por ejemplo, usando un Timer by Event.

3. Comandos de Consola:

   • Puedes crear Custom Events en tu personaje que simulen daño o curación y vincularlos a comandos de consola para pruebas rápidas.
   • Por ejemplo, en BP_ThirdPersonCharacter, crea un Custom Event llamado DEBUG_TakeDamage.
   • Desde este evento, llama a HealthComp->ApplyDamage(20.0f).
   • En los detalles del Custom Event, marca Call In Editor y Expose To Cinematics. También puedes hacer clic derecho en el evento y seleccionar Add to Console Command (esto requiere que el juego esté en modo Play In Editor o Standalone).

Consideraciones Avanzadas 🌌

• Tipos de Daño: Implementar una DamageType enumera y/o clases para aplicar diferentes efectos según el tipo de daño (fuego, veneno, físico).
• Resistencias/Vulnerabilidades: Añadir un DataTable o Struct para definir cómo reacciona un personaje a diferentes tipos de daño.
• Invulnerabilidad Temporal: Después de recibir daño, un personaje puede ser invulnerable por un corto período (Timer en HealthComponent).
• Pooling de Efectos: En lugar de Destroy Actor para la muerte, usar un sistema de Object Pooling para reutilizar los cuerpos de los enemigos o efectos.
• Guardar/Cargar: Asegurarse de que CurrentHealth se guarde y cargue correctamente en tu sistema de guardado de juego.

✅ Conclusión

Has llegado al final de este tutorial sobre cómo crear un sistema de daño y puntos de golpe en Unreal Engine usando Blueprints. Hemos cubierto desde la configuración inicial de atributos hasta la integración con la interfaz de usuario y consideraciones avanzadas. Este sistema es una base sólida para cualquier juego y se puede expandir para adaptarse a mecánicas más complejas.

Recuerda que la práctica es clave. Experimenta con las configuraciones, añade nuevos efectos y personaliza el sistema para que se adapte perfectamente a la visión de tu juego. ¡Ahora tienes las herramientas para hacer que tus personajes sean vulnerables y puedan luchar por su supervivencia!

¡Felicidades por construir un sistema tan crucial para tu juego! Sigue explorando las posibilidades que Unreal Engine te ofrece.