El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Proyecto 2: Creación de un NPC con Toma de Decisiones

Siguiente ►
►

En este proyecto, vamos a crear un NPC (Non-Player Character) que pueda tomar decisiones utilizando diferentes técnicas de IA que hemos aprendido en los módulos anteriores. Este proyecto se centrará en la implementación de un NPC que pueda navegar por el entorno, tomar decisiones basadas en su estado y reaccionar a eventos en tiempo real.

Objetivos del Proyecto

  1. Implementar un NPC que pueda navegar por el entorno.
  2. Utilizar Máquinas de Estados Finite (FSM) para la toma de decisiones.
  3. Integrar Árboles de Decisión para decisiones más complejas.
  4. Combinar Behavior Trees para comportamientos avanzados.
  5. Probar y depurar el comportamiento del NPC.

Requisitos Previos

Antes de comenzar, asegúrate de tener conocimientos básicos en:

  • Programación en C# (o el lenguaje de tu motor de juego preferido).
  • Uso de un motor de juego como Unity o Unreal Engine.
  • Conceptos básicos de IA en videojuegos, navegación y toma de decisiones.

Paso 1: Configuración del Proyecto

1.1 Crear un Nuevo Proyecto en Unity

  1. Abre Unity y crea un nuevo proyecto 3D.
  2. Configura la escena básica con un terreno y algunos obstáculos.

1.2 Importar Assets Necesarios

  1. Importa los assets necesarios, como modelos de personajes, animaciones y NavMesh.
  2. Asegúrate de tener un modelo de NPC y algunos objetos para que el NPC interactúe.

Paso 2: Implementación de Navegación

2.1 Configurar NavMesh

  1. Crear el NavMesh:

    • Selecciona el terreno y ve a Window > AI > Navigation.
    • Marca el terreno como "Walkable" y haz clic en "Bake" para generar el NavMesh.

  2. Configurar el NPC:

    • Añade un componente NavMeshAgent al NPC.
    • Ajusta las propiedades del NavMeshAgent como velocidad, radio y altura.
using UnityEngine;
using UnityEngine.AI;

public class NPCNavigation : MonoBehaviour
{
    public Transform[] waypoints;
    private NavMeshAgent agent;
    private int currentWaypointIndex = 0;

    void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        agent.SetDestination(waypoints[currentWaypointIndex].position);
    }

    void Update()
    {
        if (agent.remainingDistance < agent.stoppingDistance)
        {
            currentWaypointIndex = (currentWaypointIndex + 1) % waypoints.Length;
            agent.SetDestination(waypoints[currentWaypointIndex].position);
        }
    }
}

Explicación del Código

  • NavMeshAgent: Componente que permite al NPC navegar por el NavMesh.
  • waypoints: Array de puntos de destino para el NPC.
  • SetDestination: Método que establece el próximo punto de destino del NPC.

Paso 3: Implementación de Máquinas de Estados Finite (FSM)

3.1 Crear Estados Básicos

  1. Define los estados del NPC, como Idle, Patrol y Chase.
  2. Crea un script para manejar los estados.
public enum NPCState
{
    Idle,
    Patrol,
    Chase
}

public class NPCFSM : MonoBehaviour
{
    public NPCState currentState;
    public Transform player;
    public float chaseDistance = 5.0f;
    private NavMeshAgent agent;

    void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        currentState = NPCState.Idle;
    }

    void Update()
    {
        switch (currentState)
        {
            case NPCState.Idle:
                Idle();
                break;
            case NPCState.Patrol:
                Patrol();
                break;
            case NPCState.Chase:
                Chase();
                break;
        }
    }

    void Idle()
    {
        // Implementar comportamiento de Idle
        if (Vector3.Distance(transform.position, player.position) < chaseDistance)
        {
            currentState = NPCState.Chase;
        }
    }

    void Patrol()
    {
        // Implementar comportamiento de Patrol
    }

    void Chase()
    {
        agent.SetDestination(player.position);
        if (Vector3.Distance(transform.position, player.position) > chaseDistance)
        {
            currentState = NPCState.Patrol;
        }
    }
}

Explicación del Código

  • NPCState: Enum que define los posibles estados del NPC.
  • currentState: Variable que almacena el estado actual del NPC.
  • Idle, Patrol, Chase: Métodos que implementan el comportamiento de cada estado.

Paso 4: Integración de Árboles de Decisión

4.1 Crear un Árbol de Decisión

  1. Define las condiciones y acciones para el árbol de decisión.
  2. Implementa el árbol de decisión en el script del NPC.
public class DecisionTree
{
    public bool CheckPlayerInRange(Transform npc, Transform player, float range)
    {
        return Vector3.Distance(npc.position, player.position) < range;
    }

    public void Execute(NPCFSM npcFSM)
    {
        if (CheckPlayerInRange(npcFSM.transform, npcFSM.player, npcFSM.chaseDistance))
        {
            npcFSM.currentState = NPCState.Chase;
        }
        else
        {
            npcFSM.currentState = NPCState.Patrol;
        }
    }
}

Explicación del Código

  • CheckPlayerInRange: Método que verifica si el jugador está dentro del rango de persecución.
  • Execute: Método que ejecuta el árbol de decisión y cambia el estado del NPC.

Paso 5: Combinación con Behavior Trees

5.1 Implementar Behavior Trees

  1. Define los nodos y hojas del Behavior Tree.
  2. Implementa el Behavior Tree en el script del NPC.
public class BehaviorTree
{
    public void Execute(NPCFSM npcFSM)
    {
        // Implementar lógica del Behavior Tree
    }
}

Explicación del Código

  • BehaviorTree: Clase que define la estructura del Behavior Tree.
  • Execute: Método que ejecuta el Behavior Tree y cambia el comportamiento del NPC.

Paso 6: Pruebas y Depuración

6.1 Probar el Comportamiento del NPC

  1. Ejecuta el juego y observa el comportamiento del NPC.
  2. Ajusta los parámetros y corrige errores según sea necesario.

6.2 Depuración

  1. Utiliza herramientas de depuración para identificar y corregir errores.
  2. Asegúrate de que el NPC reaccione correctamente a los eventos y tome decisiones adecuadas.

Conclusión

En este proyecto, hemos creado un NPC que puede navegar por el entorno y tomar decisiones utilizando diferentes técnicas de IA. Hemos implementado Máquinas de Estados Finite (FSM), Árboles de Decisión y Behavior Trees para lograr un comportamiento complejo y realista. Asegúrate de probar y ajustar continuamente el comportamiento del NPC para mejorar su rendimiento y realismo.

Resumen

  • Configuración del Proyecto: Creación de un nuevo proyecto en Unity y configuración del NavMesh.
  • Implementación de Navegación: Uso de NavMeshAgent para la navegación del NPC.
  • Máquinas de Estados Finite (FSM): Implementación de estados básicos como Idle, Patrol y Chase.
  • Árboles de Decisión: Integración de un árbol de decisión para decisiones más complejas.
  • Behavior Trees: Combinación con Behavior Trees para comportamientos avanzados.
  • Pruebas y Depuración: Pruebas y ajustes del comportamiento del NPC.

Con estos conocimientos, estás listo para crear NPCs más complejos y realistas en tus propios proyectos de videojuegos. ¡Buena suerte!

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados