Unreal Engine: Implementando IA Básica con Behaviour Trees y EQS para Enemigos

🚀 Introducción a la IA en Unreal Engine con Behaviour Trees y EQS

Crear enemigos convincentes y desafiantes es fundamental para la inmersión en cualquier videojuego. En Unreal Engine, tenemos herramientas potentes como los Behaviour Trees (Árboles de Comportamiento) y el Environmental Query System (EQS) que nos permiten diseñar inteligencias artificiales sofisticadas y dinámicas sin necesidad de escribir mucho código complejo. Este tutorial te llevará de la mano para implementar una IA básica de enemigo que patrulla, detecta al jugador y lo persigue.

¿Qué son los Behaviour Trees? 🌳

Los Behaviour Trees son una forma jerárquica y modular de organizar la lógica de comportamiento de la IA. Piensa en ellos como un diagrama de flujo de decisiones y acciones que la IA ejecuta. Permiten crear comportamientos complejos a partir de unidades más pequeñas y manejables, facilitando la depuración y expansión.

¿Qué es el Environmental Query System (EQS)? 🗺️

EQS es un sistema de consulta de entorno que permite a la IA evaluar el mundo del juego y tomar decisiones informadas. Por ejemplo, puede encontrar la mejor cobertura, un punto de flanqueo, o determinar si un área es segura. EQS utiliza 'generadores' y 'pruebas' para calificar ubicaciones y objetos en el entorno, devolviendo los mejores resultados para que la IA actúe sobre ellos.

🛠️ Configuración Inicial del Proyecto y Actor de IA

Antes de sumergirnos en la lógica, necesitamos configurar nuestro proyecto y el personaje que actuará como enemigo.

Paso 1: Crear un Nuevo Proyecto y Personaje Básico

1. Crea un nuevo proyecto de Unreal Engine: Usa la plantilla de Third Person o First Person para tener un jugador y un nivel básico.
2. Crea un Blueprint de Personaje para el Enemigo:
   • Haz clic derecho en el Content Browser > Blueprint Class.
   • Selecciona Character como clase padre y nómbralo BP_EnemyCharacter.
   • Abre BP_EnemyCharacter y asigna un Mesh (por ejemplo, SK_Mannequin) y un Anim Blueprint (ABP_Manny o ABP_Quinn_C) en el Skeletal Mesh Component.
   • Ajusta la cápsula de colisión y la posición del Mesh si es necesario.

Paso 2: Crear el AI Controller y el Blackboard

La IA necesita un controlador para ejecutar su lógica y un Blackboard para almacenar los datos que utilizará. El Blackboard es esencialmente una pizarra donde la IA escribe y lee información.

1. Crea un AI Controller para el Enemigo:

   • Haz clic derecho en el Content Browser > Blueprint Class.
   • Busca AIController y selecciónalo. Nómbralo AIC_Enemy.

2. Crea un Blackboard Asset:

   • Haz clic derecho en el Content Browser > Artificial Intelligence > Blackboard.
   • Nómbralo BB_Enemy.
   • Abre BB_Enemy y añade las siguientes claves:
     • TargetActor (Tipo: Object, Clase: Actor) - Para almacenar la referencia al jugador.
     • SelfActor (Tipo: Object, Clase: Actor) - Para almacenar la referencia al propio enemigo.
     • LocationToMoveTo (Tipo: Vector) - Para almacenar la ubicación a la que el enemigo debe moverse.
     • HasLineOfSight (Tipo: Boolean) - Para saber si el enemigo tiene línea de visión con el jugador.

3. Asigna el AI Controller al Personaje Enemigo:

   • Abre BP_EnemyCharacter.
   • En Details panel, busca Pawn y en la sección AI Controller Class, selecciona AIC_Enemy.
   • Marca Auto Possess AI como Placed in World or Spawned.

🧠 Creando el Behaviour Tree (Árbol de Comportamiento)

El Behaviour Tree será el corazón de la lógica de nuestro enemigo. Definiremos cómo patrulla, detecta y persigue al jugador.

Paso 3: Crear el Behaviour Tree

1. Crea un Behaviour Tree Asset:

   • Haz clic derecho en el Content Browser > Artificial Intelligence > Behavior Tree.
   • Nómbralo BT_Enemy.

2. Asigna el Blackboard al Behaviour Tree:

   • Abre BT_Enemy.
   • En el panel Details, busca Blackboard Asset y selecciona BB_Enemy.

3. Estructura Básica del Behaviour Tree:

   • El nodo raíz es Root.
   • Desde Root, arrastra y suelta para crear un nodo Selector. Los Selector intentan ejecutar sus hijos de izquierda a derecha y se detienen en el primero que tiene éxito. Si uno de sus hijos tiene éxito, el Selector también tiene éxito. Si todos sus hijos fallan, el Selector falla.
   • Desde el Selector, arrastra y suelta para crear dos Sequence nodes. Los Sequence ejecutan sus hijos de izquierda a derecha y se detienen si uno falla. Si todos sus hijos tienen éxito, el Sequence tiene éxito.

Paso 4: Implementando la Detección del Jugador

Necesitamos que nuestro enemigo pueda detectar al jugador. Usaremos un Service para verificar constantemente la presencia del jugador y su línea de visión.

1. Crea un Blueprint Service:

   • Haz clic derecho en el Content Browser > Blueprint Class.
   • Busca BTService_BlueprintBase y selecciónalo. Nómbralo BTS_CheckForPlayer.

2. Lógica del Servicio BTS_CheckForPlayer:

   • Abre BTS_CheckForPlayer.
   • Sobrescribe la función Receive Tick AI.
   • Desde Owner Controller (del nodo Receive Tick AI), arrastra y suelta para obtener un Get Controlled Pawn. Conéctalo a SelfActor en el Blackboard (Set Blackboard Value as Object).
   • Desde Get Controlled Pawn, obten un Get Actor Location.
   • Desde Get Controlled Pawn, obten un Get Player Character y luego un Get Actor Location para el jugador.
   • Usa un LineTraceByChannel (o LineTraceForObjects) desde la ubicación del enemigo a la ubicación del jugador. Canal: Visibility.
   • Si el Line Trace golpea al jugador (compara el Hit Actor con el Get Player Character), entonces tenemos línea de visión.
   • Establece la clave TargetActor en el Blackboard con el Get Player Character si se detecta.
   • Establece la clave HasLineOfSight en el Blackboard según el resultado del Line Trace.
   • Usa un Branch para decidir si se establece TargetActor o si se borra (si el jugador no está visible o muy lejos).

3. Añade el Servicio al Behaviour Tree:

   • Abre BT_Enemy.
   • Selecciona el nodo Root (o el Selector principal).
   • En el panel Details, haz clic en Add Service y selecciona BTS_CheckForPlayer.
   • Ajusta la frecuencia de actualización del servicio (Interval). Por ejemplo, 0.5 segundos.

Paso 5: Implementando la Persecución del Jugador

Ahora que podemos detectar al jugador, haremos que el enemigo lo persiga.

1. Primer Sequence (Perseguir al Jugador):
   • En BT_Enemy, selecciona el primer Sequence.
   • Añade un Blackboard Decorator al Sequence. Configúralo para que tenga éxito solo si TargetActor Is Set y HasLineOfSight Is Equal to True.
   • Desde este Sequence, arrastra y suelta para crear un Move To task. Selecciona TargetActor como clave.
   • Desde el mismo Sequence, arrastra y suelta para crear un Wait task (para que espere un momento antes de volver a moverse, o un Attack task si tuvieras uno).

Paso 6: Implementando el Patrullaje

Si el enemigo no detecta al jugador, debe patrullar una serie de puntos o un área aleatoria.

1. Crea un Blueprint Task para Patrullar:

   • Haz clic derecho en el Content Browser > Blueprint Class.
   • Busca BTTask_BlueprintBase y selecciónalo. Nómbralo BTT_FindPatrolLocation.

2. Lógica del BTT_FindPatrolLocation:

   • Abre BTT_FindPatrolLocation.
   • Sobrescribe la función Receive Execute AI.
   • Desde Owner Controller, obtén Get Controlled Pawn y luego Get Actor Location.
   • Usa un Get Random Reachable Point in Radius (desde Navigation System o directamente del Pawn si tienes AI Navigation activado) alrededor de la ubicación actual del enemigo. Define un radio de patrulla (ej. 1000 unidades).
   • Si se encuentra una ubicación válida, establece la clave LocationToMoveTo en el Blackboard.
   • Llama a Finish Execute con éxito o fallo según si se encontró una ubicación.

3. Segundo Sequence (Patrullar):

   • En BT_Enemy, selecciona el segundo Sequence.
   • Añade un Blackboard Decorator al Sequence. Configúralo para que tenga éxito solo si TargetActor Is Not Set.
   • Desde este Sequence, arrastra y suelta para crear un BTT_FindPatrolLocation task.
   • Desde el mismo Sequence, arrastra y suelta para crear un Move To task. Selecciona LocationToMoveTo como clave.
   • Desde el mismo Sequence, arrastra y suelta para crear un Wait task. Por ejemplo, Wait 3 segundos.

🌍 Mejorando la Toma de Decisiones con EQS

EQS nos permitirá encontrar puntos de patrulla más inteligentes, cubrirse o flanquear al jugador. Para este tutorial, lo usaremos para encontrar un punto de patrulla aleatorio y accesible.

Paso 7: Creando un Query EQS para Puntos de Patrulla

1. Crea un EQS Context:

   • Haz clic derecho en el Content Browser > Blueprint Class.
   • Busca EnvQueryContext_BlueprintBase y selecciónalo. Nómbralo EQSContext_SelfActorLocation.
   • Abre EQSContext_SelfActorLocation. Sobrescribe Provide Context y desde Querier, obten Get Controlled Pawn y luego Get Actor Location. Establece esta ubicación como la salida del contexto (Resulting Location).

2. Crea un EQS Query:

   • Haz clic derecho en el Content Browser > Artificial Intelligence > Environment Query.
   • Nómbralo EQS_PatrolPoints.
   • Abre EQS_PatrolPoints.
     • Generador: Añade un Simple Grid generator.
       • Grid Size: 500 (o un valor adecuado para tu nivel).
       • Space Between: 200.
       • Center: Selecciona EQSContext_SelfActorLocation.
     • Prueba (Test): Añade un Pathfinding Batch test.
       • Context: EQSContext_SelfActorLocation.
       • Query Param: Item.
       • Score Multiplier: 1.
       • Scoring Equation: Linear.
       • Weight: 1.
       • Esto asegura que los puntos generados sean accesibles por el enemigo.

Paso 8: Integrando EQS en el Behaviour Tree

Modificaremos la tarea BTT_FindPatrolLocation para usar EQS.

1. Modifica BTT_FindPatrolLocation:
   • Abre BTT_FindPatrolLocation.
   • Reemplaza el nodo Get Random Reachable Point in Radius por un nodo Run EQS Query.
   • En Run EQS Query, selecciona EQS_PatrolPoints como Query Template.
   • Query Owner: Self.
   • Run Mode: Best Item.
   • Query Result Set BlackBoard Value: Selecciona LocationToMoveTo.
   • Conecta la salida de Run EQS Query a Finish Execute con éxito o fallo.

🏃 Ejecutando y Depurando la IA

Una vez que todo está configurado, es hora de probar y depurar.

Paso 9: Colocar el Enemigo en el Nivel

1. Arrastra una instancia de BP_EnemyCharacter desde el Content Browser a tu nivel.

Paso 10: Iniciar la Simulación y Depurar

1. Haz clic en Play para iniciar el juego.
2. Mientras el juego está en ejecución, selecciona tu BP_EnemyCharacter en el World Outliner.
3. En la barra de herramientas del editor, busca el botón Debug y selecciona AI Debugger.
4. También puedes abrir el Behaviour Tree Editor (BT_Enemy) y verás la ejecución en tiempo real, con los nodos activos resaltados.
5. Para depurar EQS, abre EQS_PatrolPoints y haz clic en Debug en la barra de herramientas. Verás los puntos generados y sus calificaciones.

Posibles Problemas y Soluciones:

• El enemigo no se mueve:
  • Verifica que el Nav Mesh Bounds Volume cubra el área.
  • Asegúrate de que el AI Controller esté asignado y Auto Possess AI esté configurado.
  • Revisa los Blackboard Decorators para asegurarte de que las condiciones se cumplan.
• El enemigo no detecta al jugador:
  • Verifica la lógica de BTS_CheckForPlayer, especialmente el LineTrace.
  • Asegúrate de que TargetActor se esté estableciendo correctamente en el Blackboard.
• EQS no genera puntos:
  • Comprueba que el Nav Mesh Bounds Volume esté presente y actualizado (P en el editor para visualizarlo).
  • Asegúrate de que el EQSContext_SelfActorLocation esté retornando la ubicación correcta.

✨ Mejoras y Pasos Futuros

Esta es solo la punta del iceberg. Puedes expandir esta IA de muchas maneras:

• Comportamientos de ataque: Añade una tarea Attack al Behaviour Tree cuando el jugador esté cerca.
• Comportamientos defensivos: Usa EQS para encontrar cobertura o puntos de retirada.
• Percepción avanzada: Implementa AI Perception para detección de visión, audición, etc., y actualiza el Blackboard en consecuencia.
• Patrullas por waypoints: Crea una lista de Actors en el nivel y haz que la IA los visite secuencialmente.
• Estados de IA: Implementa estados como Idle, Patrol, Chase, Attack, Flee y transiciones entre ellos usando decoradores y servicios.
• Interacciones complejas: Permite que los enemigos se comuniquen entre sí o reaccionen a eventos del mundo.

Con estas bases, tienes un punto de partida sólido para crear enemigos con comportamientos complejos y atractivos en tus juegos de Unreal Engine. ¡Experimenta y diviértete construyendo tu propia legión de IAs!