Unreal Engine: Creación de un Sistema de Caza y Recolección Dinámico con Interacciones Contextuales y Blueprint

🎯 Introducción al Sistema de Caza y Recolección en Unreal Engine

Los sistemas de caza y recolección son pilares fundamentales en muchos géneros de videojuegos, desde los survival y crafting hasta los RPGs de mundo abierto. Permiten a los jugadores interactuar con el entorno de manera significativa, recolectar recursos para la supervivencia, la fabricación o la progresión del personaje. En Unreal Engine, podemos construir estos sistemas de forma robusta y flexible utilizando Blueprints, aprovechando la potencia visual y la facilidad de implementación que nos ofrece el motor.

En este tutorial, exploraremos cómo diseñar y construir un sistema de caza y recolección dinámico. Cubriremos desde la configuración de los objetos interactivos, la lógica de recolección, hasta la integración con un sistema de inventario básico. Nos centraremos en la creación de interacciones contextuales, donde la acción del jugador cambia según el objeto con el que interactúa y las herramientas que posee. ¡Prepárate para dar vida a tus mundos y hacer que tus jugadores sientan la emoción de la supervivencia!

🛠️ Configuración Inicial del Proyecto

Para empezar, necesitaremos un proyecto base en Unreal Engine. Puedes usar una plantilla de 'Third Person' o 'First Person' para tener un personaje controlable y un entorno básico. Asegúrate de que tu proyecto sea un proyecto de Blueprint si prefieres no usar C++ en este tutorial. Si ya tienes un proyecto en marcha, ¡perfecto!

📂 Estructura de Carpetas Recomendada

Mantener tu proyecto organizado es crucial para la escalabilidad y el mantenimiento. Te sugiero la siguiente estructura para los archivos que crearemos:

• Content/Gameplay/Resources/ (Para los objetos interactivos como árboles, rocas, plantas)
• Content/Gameplay/Actors/ (Para el actor de interacción genérico)
• Content/Gameplay/Interfaces/ (Para las interfaces de interacción)
• Content/UI/ (Si eventualmente agregamos UI para el inventario o mensajes)

🧩 Crear la Interfaz de Interacción (BPI_Interactable)

La base de nuestro sistema contextual será una interfaz de Blueprint. Esto nos permitirá tener diferentes tipos de objetos que respondan a una misma llamada de interacción, pero cada uno a su manera. Así, nuestro personaje solo necesita saber que un objeto es 'interactuable', sin importar si es un árbol, una roca o una planta.

1. En tu carpeta Content/Gameplay/Interfaces/, haz clic derecho y selecciona Blueprints > Blueprint Interface. Nómbralo BPI_Interactable.
2. Abre BPI_Interactable. Verás una lista de funciones.
3. Haz clic en + New Function y nómbrala Interact. Esta función no necesitará ninguna entrada o salida por ahora. Guardamos y cerramos.

Esta interfaz será implementada por todos los actores con los que queramos interactuar. Cuando el jugador intente interactuar con un objeto, simplemente llamaremos a la función Interact en él, y el objeto sabrá cómo responder.

🌳 Creando Recursos Recolectables (Árbol, Roca, Planta)

Ahora vamos a crear los actores que representarán nuestros recursos en el mundo. Para simplificar, crearemos un Blueprint genérico BP_ResourceBase del que heredarán nuestros recursos específicos.

📦 Blueprint Base de Recurso (BP_ResourceBase)

1. En Content/Gameplay/Actors/, haz clic derecho y selecciona Blueprint Class. Elige Actor como clase padre y nómbralo BP_ResourceBase.
2. Abre BP_ResourceBase. En la sección Class Settings del Details Panel, haz clic en Add bajo Interfaces y busca BPI_Interactable. Compila y guarda.
3. En la pestaña Components, añade un Static Mesh Component (nómbralo ResourceMesh) y un Box Collision Component (nómbralo InteractionVolume).
4. Ajusta el tamaño del InteractionVolume para que sea un poco más grande que el ResourceMesh. Esto facilitará la interacción.
5. En el Event Graph, implementa el evento Interact de la interfaz:
   • Haz clic derecho en el Event Graph y busca Event Interact bajo la sección Interfaces.
   • Por ahora, simplemente arrastra un cable desde el nodo Event Interact y añade un Print String con el texto: "Interacting with: " seguido de un Get Display Name del Self. Esto nos permitirá probar la interacción.
   • Añade una variable de tipo DataTable y nómbrala ResourceDataTable. La usaremos más adelante para definir qué recursos se obtienen.
   • Añade una variable ResourceTag de tipo FName. Esta etiqueta definirá el tipo de recurso (madera, piedra, etc.).
   • Añade una variable Health de tipo Float con un valor por defecto de 100.0. Este será el "estado" del recurso antes de ser recolectado.
   • Añade una variable RequiredToolTag de tipo FName. Por ejemplo, "Axe" para la madera, "Pickaxe" para la piedra. Inicialízalo a None.

Compila y guarda BP_ResourceBase.

🌳 Creando el Árbol (BP_TreeResource)

1. En Content/Gameplay/Resources/, haz clic derecho en BP_ResourceBase y selecciona Create Child Blueprint Class. Nómbralo BP_TreeResource.
2. Abre BP_TreeResource.
3. En el Details Panel, selecciona el componente ResourceMesh.
4. Asigna un Static Mesh de árbol. Puedes usar los que vienen con el paquete 'Starter Content' o buscar uno en el 'Quixel Bridge' (por ejemplo, SM_Tree si tienes el 'Starter Content').
5. Asegúrate de que el InteractionVolume envuelva correctamente el árbol.
6. En las variables por defecto, establece ResourceTag a "Wood" y RequiredToolTag a "Axe".

Compila y guarda BP_TreeResource.

🪨 Creando la Roca (BP_RockResource)

1. Repite el proceso: haz clic derecho en BP_ResourceBase y selecciona Create Child Blueprint Class. Nómbralo BP_RockResource.
2. Abre BP_RockResource.
3. Asigna un Static Mesh de roca (por ejemplo, SM_Rock si tienes el 'Starter Content').
4. Asegúrate de que el InteractionVolume envuelva correctamente la roca.
5. Establece ResourceTag a "Stone" y RequiredToolTag a "Pickaxe".

Compila y guarda BP_RockResource.

🌿 Creando la Planta (BP_PlantResource)

1. Crea un nuevo hijo de BP_ResourceBase, nómbralo BP_PlantResource.
2. Asigna un Static Mesh de planta. Puedes buscar SM_Bush o similar.
3. Establece ResourceTag a "Fiber" y RequiredToolTag a None (o "Hand" si quieres especificar que se recolecta a mano).

Compila y guarda BP_PlantResource.

Ahora puedes arrastrar estos actores (BP_TreeResource, BP_RockResource, BP_PlantResource) a tu nivel. ¡Ya tenemos objetos interactuables en nuestro mundo!

🚶 Configuración del Personaje para Interacción

Necesitamos que nuestro personaje pueda detectar objetos interactivos y llamar a la función Interact cuando el jugador pulse un botón. Modificaremos el ThirdPersonCharacter (o el que estés usando).

🔍 Detección de Objetos Interactivos

Para detectar objetos, podemos usar un Line Trace (raycast) o una Sphere Trace desde la cámara o el personaje.

1. Abre el Blueprint de tu personaje (ej. BP_ThirdPersonCharacter).
2. En el Event Graph, crea una nueva función, nómbrala TraceForInteractables.
3. Dentro de TraceForInteractables:
   • Necesitamos obtener la posición de la cámara y la dirección a la que apunta. Usa Get Player Camera Manager > Get Camera Location y Get Forward Vector.
   • Calcula el End Location del trace sumando el Camera Location + (Forward Vector * InteractionDistance). Crea una variable InteractionDistance de tipo Float (ej. 500 unidades).
   • Utiliza un nodo Line Trace By Channel. Configura Trace Start con el Camera Location y Trace End con el End Location calculado. Establece Trace Channel a Visibility. Activa Draw Debug Type a For Duration (para ver el rayo en el editor). Ignore Self para que no colisione con el propio personaje.
   • Desde el Out Hit del Line Trace, haz un Break Hit Result.
   • Arrastra desde Hit Actor y haz un Does Implement Interface para BPI_Interactable. Esto verificará si el actor golpeado es interactuable.
   • Guarda el Hit Actor en una variable CurrentInteractableActor (tipo Actor Reference). Si el trace no golpea nada o el objeto no implementa la interfaz, setea CurrentInteractableActor a None.

⌨️ Input de Interacción

Ahora, necesitamos asignar una tecla para la interacción y llamar a nuestra función de trace.

1. Ve a Edit > Project Settings > Input.
2. Bajo Action Mappings, añade un nuevo Action Mapping y nómbralo Interact. Asigna una tecla, por ejemplo, E.
3. En el Event Graph de tu personaje, busca Input Action Interact.
4. Desde el pin Pressed de Input Action Interact:
   • Llama a la función TraceForInteractables.
   • Después, haz un IsValid para CurrentInteractableActor.
   • Si es válido, arrastra desde CurrentInteractableActor y llama al Interact Message (esto es la función Interact de la interfaz).

Para que la detección de interactuables sea continua, puedes llamar a TraceForInteractables en el Event Tick de tu personaje, pero es más eficiente hacerlo cada cierto tiempo o solo cuando el jugador se mueve o el input de interacción es presionado. Por ahora, para simplificar, la llamaremos en el Interact Pressed.

Compila y guarda tu Blueprint de personaje. Ahora, cuando ejecutes el juego y apuntes a un árbol, una roca o una planta y pulses E, deberías ver el mensaje "Interacting with: BP_TreeResource_C_0" (o el nombre del recurso) en la pantalla.

📊 Data Tables para Recursos y Herramientas

Para manejar de manera eficiente los datos de los recursos que podemos recolectar (qué objeto da qué, la cantidad, el sonido, etc.) y las herramientas necesarias, utilizaremos Data Tables.

📝 Estructura de Datos para Recursos (FResourceData)

1. En Content/Gameplay/, haz clic derecho y selecciona Blueprints > Structure. Nómbrala FResourceData.
2. Abre FResourceData y añade las siguientes variables:
   • ItemTag (FName): Una etiqueta única para el recurso recolectado (ej. "WoodLog", "StoneChunk").
   • Amount (Int): La cantidad de este recurso que se obtiene (ej. 1, 2, 3).
   • MinAmount (Int): Cantidad mínima a obtener. (Por ejemplo, para un rango aleatorio)
   • MaxAmount (Int): Cantidad máxima a obtener.
   • RequiredToolTag (FName): La etiqueta de la herramienta necesaria (ej. "Axe", "Pickaxe").
   • DamagePerHit (Float): El daño que este recurso recibe por golpe de la herramienta correcta.
   • MeshToDrop (Static Mesh Reference): Un Static Mesh que podría caer al suelo al recolectar.
   • SoundOnHit (Sound Wave Reference): Sonido al golpear el recurso.
   • SoundOnDestroy (Sound Wave Reference): Sonido al destruir/recolectar el recurso.

Compila y guarda FResourceData.

📚 Data Table de Recursos (DT_Resources)

1. En Content/Gameplay/Data/, haz clic derecho y selecciona Miscellaneous > Data Table.
2. En el selector de Row Structure, busca y selecciona FResourceData.
3. Nómbrala DT_Resources.
4. Abre DT_Resources y añade filas para los diferentes tipos de recursos que obtendremos:

🛠️ Estructura de Datos para Herramientas (FToolData)

Vamos a crear una estructura similar para definir las herramientas.

1. En Content/Gameplay/, crea otra Structure y nómbrala FToolData.
2. Abre FToolData y añade:
   • ToolTag (FName): Etiqueta única para la herramienta (ej. "Axe", "Pickaxe", "Hand").
   • DamageBonus (Float): Daño adicional que la herramienta aplica (ej. 1.0 para el puño, 10.0 para un hacha básica).
   • Durability (Float): Durabilidad de la herramienta. (No la implementaremos en este tutorial, pero es buena idea tenerla).

Compila y guarda FToolData.

📚 Data Table de Herramientas (DT_Tools)

1. Crea otra Data Table en Content/Gameplay/Data/, seleccionando FToolData como Row Structure.
2. Nómbrala DT_Tools.
3. Añade filas para tus herramientas básicas:

Ahora tenemos una base de datos de nuestros recursos y herramientas. Con esto, podemos hacer que nuestro sistema sea mucho más flexible y fácil de balancear.

🔄 Lógica de Recolección y Daño en el Recurso Base

Regresemos a BP_ResourceBase para implementar la lógica principal de recolección, aplicando el concepto de interacciones contextuales.

🔨 Actualizando el Evento Interact en BP_ResourceBase

1. Abre BP_ResourceBase. En el Event Graph, borra el Print String que teníamos.

2. El evento Interact necesitará información sobre quién está interactuando y qué herramienta usa. Modifica la función Interact en BPI_Interactable añadiendo un Input Parameter:

   • Instigator (Actor Reference): Quién está interactuando.
   • EquippedToolTag (FName): La etiqueta de la herramienta que el instigador tiene equipada.
   • Importante: Después de modificar la interfaz, vuelve a BP_ResourceBase y verás que el nodo Event Interact se ha actualizado con los nuevos pines. Si no se actualiza, bórralo y vuelve a añadirlo.

3. Dentro del Event Interact en BP_ResourceBase, implementa la siguiente lógica:

   • Verificar la herramienta correcta:
     • Obtén el RequiredToolTag de este recurso.
     • Compara el EquippedToolTag del Instigator con el RequiredToolTag del recurso (== nodo).
     • Usa un Branch con esta condición.
   • Si la herramienta es correcta (True):
     • Aplicar daño: Resta DamagePerHit (obtenido del DT_Resources usando ResourceTag como Row Name y EquippedToolTag para obtener el bonus de daño) a la variable Health.
     • Reproduce SoundOnHit (si existe).
     • Comprobar salud: Si Health es <= 0:
       • Llama a la función Destroy Resource (que crearemos a continuación).
   • Si la herramienta NO es correcta (False):
     • Puedes mostrar un Print String como "Necesitas un hacha para esto" o reproducir un sonido de "error".
     • También podríamos aplicar un daño reducido si el jugador usa las manos desnudas (ToolTag None). Para esto, tendrías que obtener DamageBonus de DT_Tools usando EquippedToolTag.

4. Función Destroy Resource:

   • Crea una nueva función en BP_ResourceBase, nómbrala DestroyResource.
   • Dentro de DestroyResource:
     • Obtén la fila de datos (FResourceData) de DT_Resources usando el ResourceTag de este recurso.
     • Generar recursos para el inventario: Genera un número aleatorio de ItemTag entre MinAmount y MaxAmount (Random Integer in Range).
     • Llama a una función en el Instigator (el jugador) para añadir estos ítems a su inventario (ej. AddToInventory - la implementaremos después).
     • Reproduce SoundOnDestroy (si existe).
     • Si MeshToDrop está asignado, puedes spawnear ese Static Mesh como un objeto pickeable en el mundo.
     • Finalmente, destruye el actor: Destroy Actor (Self).

Compila y guarda BP_ResourceBase.

➕ Mejoras en la Lógica de Daño (Opcional pero recomendado)

Podemos hacer el daño más dinámico dependiendo de la herramienta. Necesitamos que el Interact reciba el DamageBonus de la herramienta equipada.

1. Modifica BPI_Interactable de nuevo. Añade un parámetro ToolDamageBonus (Float) a la función Interact.
2. En BP_ResourceBase (Event Interact): Obtén el DamagePerHit de la FResourceData y multiplícalo por ToolDamageBonus. Este será el daño total aplicado a la Health.

🎒 Integración con un Inventario Básico

Para que la recolección sea útil, necesitamos un lugar donde guardar los ítems. Implementaremos un sistema de inventario muy básico en nuestro personaje.

📦 Estructura de Ítem (FInventoryItem) y Data Table para Ítems

Para definir los ítems que se añaden al inventario, crearemos otra Structure y Data Table.

1. Crea una Structure en Content/Gameplay/ llamada FInventoryItem.

2. Añade:

   • ItemTag (FName): La etiqueta única del ítem (ej. "WoodLog", "StoneChunk").
   • DisplayName (Text): Nombre para la UI (ej. "Tronco de Madera").
   • Description (Text): Descripción del ítem.
   • Icon (Texture 2D Reference): Icono para la UI.
   • MaxStackSize (Int): Cuántos ítems pueden acumularse en un solo slot (ej. 99).
   • IsStackable (Bool): Si el ítem puede apilarse.
   • ToolType (FName): Si es una herramienta, qué tipo de herramienta (ej. "Axe").

3. Crea una Data Table en Content/Gameplay/Data/ llamada DT_Items, con FInventoryItem como Row Structure.

4. Añade entradas para WoodLog, StoneChunk, Fiber, BasicAxe, BasicPickaxe, etc.

🎒 Lógica de Inventario en el Personaje

1. Abre el Blueprint de tu personaje (BP_ThirdPersonCharacter).

2. Crea una variable Inventory de tipo Map (Mapa).

   • La Key Type será FName (para ItemTag).
   • La Value Type será Int (para la cantidad de ítems).

3. Crea una función, nómbrala AddToInventory.

   • Entradas: ItemTag (FName), Amount (Int).
   • Dentro de la función:
     • Haz un Map Find en Inventory con ItemTag para ver si el ítem ya existe.
     • Si existe: Obtén la cantidad actual, súmale Amount, y luego haz un Map Set con el ItemTag y la nueva cantidad.
     • Si no existe: Haz un Map Add con el ItemTag y el Amount.
     • Puedes añadir un Print String para confirmar que se añadió el ítem (ej. "Added " + Amount + " " + ItemTag + " to inventory.").

4. Crea una variable EquippedTool de tipo FName (con un valor por defecto de "Hand"). Esta representará la herramienta actualmente equipada.

🔄 Conectando el Recurso al Inventario

1. Regresa a la función DestroyResource en BP_ResourceBase.
2. Cuando vayas a añadir el ítem al inventario, en lugar de un Print String o un SpawnActor, arrastra desde el pin Instigator y haz un Cast To BP_ThirdPersonCharacter.
3. Desde el pin As BP Third Person Character, llama a la función AddToInventory que acabamos de crear, pasándole el ItemTag y la cantidad aleatoria calculada.

Compila y guarda ambos Blueprints.

Ahora, cuando "destruyas" un árbol, deberías ver los mensajes de que los troncos de madera se han añadido a tu inventario. ¡Progreso!

🔧 Implementando Herramientas y Equipamiento (Mínimo)

Para que nuestro sistema de RequiredToolTag funcione, el personaje necesita poder "equipar" herramientas.

🧰 Función EquipTool en el Personaje

1. En el Blueprint de tu personaje, crea una nueva función EquipTool.
   • Entrada: ToolItemTag (FName).
   • Dentro de la función:
     • Obtén la FInventoryItem de DT_Items usando ToolItemTag como Row Name.
     • Asegúrate de que el ítem sea realmente una herramienta (ToolType no sea None).
     • Si es una herramienta, setea la variable EquippedTool a ToolItemTag.
     • Puedes mostrar un Print String como "Equipped: " + DisplayName.

⚔️ Usando la Herramienta Equipada en la Interacción

1. Vuelve al Input Action Interact en tu personaje.
2. Cuando llamas al Interact Message en el CurrentInteractableActor, ahora necesitas pasar el EquippedTool de tu personaje como el EquippedToolTag y también el ToolDamageBonus.
3. Para obtener el ToolDamageBonus:
   • Obtén la FInventoryItem de DT_Items usando EquippedTool como Row Name.
   • Obtén el ToolType de esa FInventoryItem. (Si el EquippedTool es "Hand", el ToolType será None).
   • Obtén la FToolData de DT_Tools usando este ToolType (o "Hand" si es None).
   • Pasa el DamageBonus de esa FToolData al pin ToolDamageBonus del Interact Message.

Compila y guarda tu personaje Blueprint.

✨ Pulido y Mejoras Adicionales

Nuestro sistema ya es funcional, pero siempre hay espacio para mejoras y pulido.

🔊 Feedback Visual y Sonoro

• Sonidos: Asegúrate de asignar sonidos de golpe y destrucción en tus DT_Resources.
• Partículas: Puedes añadir Particle System Components a BP_ResourceBase o spawnear Particle Systems al golpear o destruir el recurso. Por ejemplo, chispas para la roca, hojas para el árbol.
• Animaciones: El personaje podría tener una animación de "corte de hacha" o "pico" al interactuar. Esto requeriría una Montage y llamarla en el Input Action Interact antes de la llamada al Interact Message.
• Feedback de UI: Mostrar un pequeño mensaje "+3 Wood Log" o un icono flotante sobre el recurso.

📈 Reaparición de Recursos

Los recursos recolectados actualmente desaparecen para siempre. Para un juego de supervivencia, es común que reaparezcan.

1. En BP_ResourceBase, en la función DestroyResource, en lugar de Destroy Actor, puedes Set Actor Hidden In Game a True y Set Actor Enable Collision a False.
2. Inicia un Timer By Event después de un retardo (ej. 300 segundos).
3. Cuando el temporizador expire, el evento del temporizador puede Set Actor Hidden In Game a False, Set Actor Enable Collision a True, y resetear la Health del recurso a su valor inicial.

🔄 Variaciones de Recursos

Considera tener diferentes niveles de recursos (ej. "Madera Dura", "Piedra de Hierro"), cada uno con su propia entrada en DT_Resources y quizás requiriendo herramientas de mayor nivel.

🏃 Limitaciones de Inventario

Nuestro inventario actual es ilimitado. Puedes añadir límites por peso o por número de slots para hacer el juego más desafiante. Esto implicaría modificar la función AddToInventory para verificar si hay espacio antes de añadir ítems.

🌐 Multijugador (Consideraciones)

Si tu juego es multijugador, la interacción y la recolección deben replicarse. BP_ResourceBase necesitaría estar configurado como Replicated y las funciones de daño y destrucción deberían ejecutarse en el servidor (Run On Server).

// En BP_ResourceBase
// Event BeginPlay: Guardar la salud inicial y visibilidad
InitialHealth = Health;
InitialVisibility = ResourceMesh.IsVisible();

// Funcion ResetResource (llamada por Timer)
Set Hidden in Game (ResourceMesh, False);
Set Collision Enabled (ResourceMesh, CollisionEnabled);
Health = InitialHealth;

// Funcion DestroyResource (modificada)
Set Hidden in Game (ResourceMesh, True);
Set Collision Enabled (ResourceMesh, NoCollision);
Start Timer By Event (ResetResource, RespawnTimeVariable, False);
// ... lógica de añadir al inventario ...

✅ Conclusión

¡Felicidades! Has construido un sistema de caza y recolección dinámico y extensible en Unreal Engine utilizando Blueprints. Hemos cubierto la detección de interacción, la lógica contextual basada en herramientas, el uso de Data Tables para la configuración de recursos y herramientas, y una integración básica con un sistema de inventario.

Este sistema proporciona una base sólida sobre la cual puedes construir mecánicas más complejas, como la crafteo, la progresión de habilidades relacionadas con la recolección, y un inventario visual con UI. La clave ha sido el uso de interfaces y Data Tables, que permiten una gran flexibilidad y escalabilidad para tu proyecto. ¡Ahora sal y haz que tus jugadores exploren, recolecten y sobrevivan en tus mundos de Unreal Engine!

Nivel de Dificultad: Intermedio