Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

Cual es la mejor manera de manejar el comportamiento de la IA de mi juego * Tiene…

  1. User

    Cual es la mejor manera de manejar el comportamiento de la IA de mi juego

    • Tiene establecido un radio de deteccion de enemigos
    • Tiene una distancia maxima en la que puede perseguir un enemigo tomando en cuenta su posicion inicial dada por el jugador
    • Si detecta un enemigo corre a perseguirlo, no persigue a un enemigo mas lejos del area de persecucion
    • Si los enemigos estan mas lejos del area de persecucion entonces se regresa a su posicion inicial

    Inicialmente los soldados perseguian a todos los enemigos y no existia area de persecucion, sin embargo los jugadores se quejaron de que no protegian el area asignada y sentian que los soldados actuaban por su propia cuenta Ahora siente que es raro porque aunque los enemigos esten cerca de ellos dado que estan fuera del area de persecucion a veces los dejan pasar, entonces quieor que me digas cual es la mejor forma de maejar esto basandote en lo que hacen otros juegos

  2. Assistant

    Manejar el comportamiento de la IA en juegos es un desafío, ya que debe equilibrar la lógica interna del juego con las expectativas de los jugadores. Aquí te presento algunas estrategias basadas en prácticas comunes en el desarrollo de juegos:

    1. Ajuste del Radio de Detección: Asegúrate de que el radio de detección sea lo suficientemente amplio como para reflejar la amenaza real que representan los enemigos. Puedes ajustar dinámicamente este radio en función de la cantidad de enemigos o su tipo. Por ejemplo, enemigos más peligrosos podrían ser detectados desde más lejos.

    2. Zona de Patrullaje Flexible: Permite que la IA pueda marcar un "punto de interés" temporal fuera del área de persecución si hay una actividad enemiga significativa. Esto puede ser limitado a situaciones específicas, como cuando varios enemigos cruzan una línea imaginaria o si el jugador está bajo ataque.

    3. Prioridades de Amenaza: Haz que tus soldados evalúen amenazas basadas en criterios específicos, como la cercanía, el tipo o el comportamiento del enemigo. Pueden romper las reglas de la persecución si la amenaza es significativa, lo que añade realismo a su comportamiento.

    4. Comportamiento de Alerta y Conmutación de Estados: Implementa un sistema de estados que permita que los soldados se activen en un modo de "alerta" al detectar enemigos cerca del límite del área de persecución. En este estado, pueden acercarse ligeramente al borde para evaluar mejor la situación y reaccionar de manera más proactiva si es necesario.

    5. Reacción en Cadena o Coordinada: Si un soldado detecta al enemigo, podría alertar a los soldados cercanos para expandir el radio de persecución temporalmente. Esta coordinación puede simular un comportamiento más cohesivo y realista.

    6. Feedback del Jugador: Permite a los jugadores ajustar el comportamiento de la IA mediante comandos simples, como órdenes de priorizar la defensa sobre la persecución, o viceversa. Esto le da al jugador más control y puede ayudar a alinear la IA con las expectativas de juego.

    7. Revisión de UI/UX: A veces, la sensación de que la IA actúa de manera "rara" puede ser mitigada mejorando la comunicación visual o auditiva. Asegúrate de que los jugadores entiendan por qué la IA toma ciertas decisiones mediante indicadores visuales o mensajes en el juego.

    Cada uno de estos enfoques puede ajustarse y probarse hasta que encuentres un balance que se adapte a tu juego y que mantenga a los jugadores satisfechos. Además, el feedback directo de los testers o la comunidad puede ofrecerte valiosas ideas para refinar el comportamiento de la IA.

  3. User

    Completa el update de la clase

    using System; using System.Collections; using Game.Systems; using Game.Systems.Buildings; using MoreMountains.Feedbacks; using Pathfinding; using Pathfinding.RVO; using TMPro; using Tools; using UnityEngine; using Random = UnityEngine.Random;

    namespace Game.ImprovedAI {
    public class SoldierController : UnitBase { [SerializeField] private GameObject unitDeathPrefab;

        [SerializeField] private float detectionRadius = 1f;  // Detection radius for overlap sphere
        [SerializeField] private float maxMovementRadius = 12f;  // Detection radius for overlap sphere
       
        [SerializeField] private float attackDamage;
        [SerializeField] private float attackRate;
        [SerializeField] private float maxRadioForGeneral = 3f;
        [SerializeField] private float radioAroundGeneral = 0.5f;
        
        [SerializeField] private bool drawSphere = false; 
        
        [SerializeField] private bool initializeOnStart;
        [SerializeField] private ParticleSystem spawnParticles;
        [SerializeField] private MMF_Player attackSound;
    
        
    
        private IAstarAI ai;
        private RVOController rvoController;
        
        private float nextTimeToAct = 0f; // Stores the next time we should perform the action
        private GameObject currentTarget;
        private float intervalSeconds = 0.5f; // Interval in seconds next Update
        private float nextAttackTime;
        [SerializeField] private Vector3 lastCommandedPosition;
        private Coroutine currentSoundCoroutine;
    
    
        [SerializeField] private AIState aiState;
        
        
        //Checar si esta muy lejos del comandante
        //Moverse a una posicion random alrededor de el pero permitiendo ataques
        //Si se forza el movimiento ignorar todo lo demas
    
        private void Start()
        {
            if (initializeOnStart)
            {
                Init(null);
            }
        }
    
    
        public void Init(SoldierCamp soldierGenerator, Vector3 position = default, bool keepPosition = false)
        {
            building = soldierGenerator;
            ai = GetComponent<IAstarAI>();
            rvoController = GetComponent<RVOController>();
            state = CharacterState.Idle;
            unitHealth = GetComponent<UnitHealth>();
            unitHealth.Init(GameManager.Instance.ArmyStats.SoldierHealth);
            animationController = GetComponent<AnimationStateController>();
            unitHealth.ClearSubscriptions();
            unitHealth.OnZeroHealth += Die;
            aiState = AIState.Idle;
            unitType = UnitType.Soldier;
            ai.isStopped = false;
            //rvoController.locked = false;
            
            worldCanvas = GameObject.FindGameObjectWithTag("CanvasWorldSpace");
            if (healthBar == null)
            {
                healthBar = Instantiate(healthBarObject, transform.position + healthBarOffset, healthBarObject.transform.rotation,
                    worldCanvas.transform).GetComponent<HealthBar>();
            }
    
            healthBar.transform.rotation = healthBarObject.transform.rotation;
            EnableHealthBar(false);
    
            if (keepPosition)
            {
                lastCommandedPosition = transform.position;
            }
            
            if (lastCommandedPosition == Vector3.zero)
            {
                if (position != default)
                {
                    lastCommandedPosition = position;
                    MoveTo(position);
                }
                else
                {
                    lastCommandedPosition = transform.position;
                }
            }
            else
            {
                MoveTo(lastCommandedPosition);
            }
            
            GameManager.Instance.VillagerTracker.AddSoldier(this);
            PlaySpawnParticles();
        }
    
        private void Update()
        {
            if(ai == null) return;
    
            healthBar.SetHealth(unitHealth.GetHealthPercentage());
            healthBar.transform.position = transform.position + healthBarOffset;
            
            //Si lo quitas el soldado se queda parado porque anda parando las corutinas
            if (Time.time >= nextTimeToAct)
            {
                if (aiState == AIState.FollowingOrder)
                {
                    if (!ai.pathPending && ai.reachedEndOfPath)
                    {
                        state = CharacterState.Idle;
                        aiState = AIState.Idle;
                    }
                    else if (float.IsPositiveInfinity(ai.remainingDistance))
                    {
                        var nearest = AstarPath.active.GetNearest (ai.destination, NNConstraint.Walkable);
                        ai.destination = nearest.position;
                    }
                    else
                    {
                        return;
                    }
                }
                
                // Detect and prioritize targets
                if (aiState != AIState.Attacking)
                {
                    currentTarget = DetectTargets();
                    
                    //Si no hay target desoues de 5 segundos entonces se mueve al last commanded position
                    
                    if (currentTarget != null)
                    {
                        StopAllCoroutines();
                        StartCoroutine(MoveToAttackTarget(currentTarget));
                    }
                    else
                    {
                        //if (GameManager.Instance.gameState == GameManager.GameState.Day)
                        //{
                            MoveLastCommandedPosition();
                        //}
                    }
                    
                    if (ai.reachedEndOfPath)
                    {
                        state = CharacterState.Idle;
                        aiState = AIState.Idle;
                    }
                }
                
                
                nextTimeToAct = Time.time + intervalSeconds;
            }
    
        }
        
        private GameObject DetectTargets()
        {
            //Quitamos overlap Capsule porque detection radius no funciona como tu creias
            Collider[] hitColliders = Physics.OverlapSphere(transform.position,
                detectionRadius, targetLayer, QueryTriggerInteraction.Collide);
            Transform nearestTarget = null;
            float closestDistanceSqr = Mathf.Infinity;
            Vector3 currentPosition = transform.position;
            Collider nearestCollider = null;
            
            foreach (Collider hitCollider in hitColliders)
            {
                if(hitCollider.GetComponent<ObjectHealth>().isDestroyed 
                   || hitCollider.gameObject.CompareTag("AirEnemy")
                   || Vector3.Distance(hitCollider.gameObject.transform.position, lastCommandedPosition) > maxMovementRadius) 
                    continue;
                
                Vector3 directionToTarget = hitCollider.transform.position - currentPosition;
                float dSqrToTarget = directionToTarget.sqrMagnitude;
                if (dSqrToTarget < closestDistanceSqr)
                {
                    closestDistanceSqr = dSqrToTarget;
                    nearestTarget = hitCollider.transform;
                    nearestCollider = hitCollider;
                }
            }
    
    
            if (nearestTarget != null)
                return nearestTarget.gameObject;
            return null;
        }
        
        private IEnumerator MoveToAttackTarget(GameObject target)
        {
            //rvoController.locked = false;
            // Move towards the target
            MoveTo(target.transform.position);
            ai.SearchPath();
            aiState = AIState.MovingToAttack;
    
            while (ai.pathPending ||!ai.reachedEndOfPath)
            {
                // Check distance to the target
                if (target == null || target.GetComponent<ObjectHealth>().isDestroyed)
                {
                    //MoveLastCommandedPosition();
                    yield break;
                }
                yield return null; // Wait until the next frame
            }
            
            StartCoroutine(AttackTarget(target));
    
    
             // Ensure this method exists in your class
        }
    
        private IEnumerator AttackTarget(GameObject target)
        {
            
            //rvoController.locked = true;
    
            bool isDestroyed = false;
    
            float nextDamageTime = float.MaxValue;
            
            while (!isDestroyed && target != null && target.activeSelf && Vector3.Distance(transform.position, target.transform.position) < 2f)
            {
                aiState = AIState.Attacking;
                
                Vector3 targetDirection = ai.endOfPath - transform.position;
                Vector3 newDirection = Vector3.RotateTowards(transform.forward, targetDirection, 20 * Time.deltaTime, 0.0f);
                transform.rotation = Quaternion.LookRotation(newDirection);
    
                if (Time.time >= nextDamageTime)
                {
                    var unitHealth = target.transform.GetComponent<UnitHealth>();
                    if (unitHealth != null)
                    {
                        unitHealth.TakeDamage(GameManager.Instance.ArmyStats.SoldierAttack);
                        isDestroyed = unitHealth.isDestroyed;
                    }
                    nextDamageTime = float.MaxValue;
                }
                
                // Check if it’s time to attack
                if (Time.time >= nextAttackTime)
                {
                    // Attack logic here
                    // Apply damage to the target
                    // Assume target has a method called TakeDamage with damage parameter
    
                    animationController.SetAnimation(UnitBase.CharacterState.Attacking);
                    nextDamageTime = Time.time + animationController.animator.GetCurrentAnimatorStateInfo(0).length / 2;
                    // Update nextAttackTime
                    nextAttackTime = Time.time + attackRate;
                    
                    AnimationMethodCallerUtility.CallMethodAtTime(this, animationController.animator,
                        "Attacking",
                        0.5f, () =>
                        {
                            attackSound.PlayFeedbacks();
                        }, false);
                    
                }
    
                yield return null;
            }
            
            //rvoController.locked = false;
            currentTarget = null;
            state = CharacterState.Idle;
            aiState = AIState.Idle;
        }
        
        
        private void MoveLastCommandedPosition()
        {
            if (Vector3.Distance(lastCommandedPosition, transform.position) > 0.5f)
            {
                aiState = AIState.LookingForPosition;
                MoveTo(lastCommandedPosition);
            }
        }
    
        public override void MoveTo(Vector3 destination, bool isCommand = false)
        {
            //Debug.Log("Moving to " + destination);
            if (isCommand)
            {
                StopAllCoroutines();
                aiState = AIState.FollowingOrder;
                lastCommandedPosition = destination;
            }
            ai.destination = destination;
            (ai as AIBase)?.rvoDensityBehavior.ClearDestinationReached();
            ai.SearchPath();
    
            state = CharacterState.Walking;
        }
        
        public override void TeleportLastCommandedPosition()
        {
            aiState = AIState.LookingForPosition;
            Teleport(lastCommandedPosition);
            finalPosition = transform.position;
        }
        
        private void Teleport(Vector3 destination, bool isCommand = false)
        {
            //Debug.Log("Moving to " + destination);
            if (isCommand)
            {
                aiState = AIState.FollowingOrder;
                lastCommandedPosition = destination;
            }
            ai.Teleport(destination);
            state = CharacterState.Walking;
        }
    
        public override void RestoreMaxHealth()
        {
            base.RestoreMaxHealth();
            unitHealth.Init(GameManager.Instance.ArmyStats.SoldierHealth);
        }
    
        private void Die(object sender, EventArgs e)
        {
            state = CharacterState.Dead;
            ai.isStopped = true;
            Instantiate(unitDeathPrefab, transform.position, transform.rotation);
            gameObject.SetActive(false);
    
            if (GameManager.Instance.ResurrectionManager.HasAltarsAvailable())
            {
                gameObject.SetActive(false);
                GameManager.Instance.ResurrectionManager.AddSoldier(this);
                EnableHealthBar(false);
            }
            else
            {
                GameManager.Instance.VillagerTracker.RemoveSoldier(this);
                Destroy(gameObject);
                Destroy(healthBar.gameObject);
            }
            
            
        }
    
        public void PlaySpawnParticles()
        {
            spawnParticles.Play();
        }
    
        private void OnDisable()
        {
            if(unitHealth != null) unitHealth.OnZeroHealth -= Die;
        }
        
        void OnDrawGizmos()
        {
            if (drawSphere)
            {
                Gizmos.DrawWireSphere(transform.position, detectionRadius);
            }
        }
    }
    

    }

  4. Assistant

    Para completar la implementación del método Update en tu clase SoldierController, podemos realizar algunas mejoras en la lógica de detección y comportamiento de la IA. Aquí hay algunas sugerencias para mejorar el comportamiento de tu soldado, teniendo en cuenta el problema que describiste previamente:

    1. Verificar Proximidad al Comandante: Implementa un comportamiento para que el soldado se mantenga cerca del "comandante" si se aleja demasiado.

    2. Agregar un Estado de Alerta para Enemigos Cercanos Fuera del Radio de Persecución: Así se puede prolongar una vigilancia mientras los enemigos permanecen cerca, pero fuera del rango de ataque inmediato, para evitar ignorarlos.

    3. Ajustar Comportamiento Dependiendo de la Distancia del Comandante: Esto puede permitir que el soldado se mueva más libremente si está cerca de su posición original pero mantenga la disciplina y el retorno cuando esté muy alejado.

    Basándonos en estas ideas, podemos ajustar el Update como sigue:

    private void Update()
    {
        if (ai == null) return;
    
        healthBar.SetHealth(unitHealth.GetHealthPercentage());
        healthBar.transform.position = transform.position + healthBarOffset;
    
        if (Time.time >= nextTimeToAct)
        {
            switch (aiState)
            {
                case AIState.FollowingOrder:
                    HandleFollowingOrderState();
                    break;
    
                case AIState.Idle:
                case AIState.MovingToAttack:
                    currentTarget = DetectTargets();
                    if (currentTarget != null)
                    {
                        StopAllCoroutines();
                        StartCoroutine(MoveToAttackTarget(currentTarget));
                    }
                    else if (Vector3.Distance(transform.position, lastCommandedPosition) > maxMovementRadius)
                    {
                        MoveLastCommandedPosition();
                    }
                    else
                    {
                        aiState = AIState.Alert;
                        DetectNearbyThreats();
                    }
                    break;
    
                case AIState.Attacking:
                    break;
    
                case AIState.Alert:
                    DetectNearbyThreats();
                    if (currentTarget == null && Vector3.Distance(transform.position, lastCommandedPosition) > maxMovementRadius)
                    {
                        MoveLastCommandedPosition();
                    }
                    break;
            }
            
            nextTimeToAct = Time.time + intervalSeconds;
        }
    }
    
    private void HandleFollowingOrderState()
    {
        if (!ai.pathPending && ai.reachedEndOfPath)
        {
            state = CharacterState.Idle;
            aiState = AIState.Idle;
        }
        else if (float.IsPositiveInfinity(ai.remainingDistance))
        {
            var nearest = AstarPath.active.GetNearest(ai.destination, NNConstraint.Walkable);
            ai.destination = nearest.position;
        }
    }
    
    private void DetectNearbyThreats()
    {
        Collider[] nearbyEnemies = Physics.OverlapSphere(transform.position, detectionRadius, targetLayer);
        foreach (var enemy in nearbyEnemies)
        {
            // Si el enemigo está más cerca que maxMovementRadius, entonces considerarlo como una potencial amenaza
            if (Vector3.Distance(enemy.transform.position, lastCommandedPosition) <= maxMovementRadius)
            {
                currentTarget = enemy.gameObject;
                StartCoroutine(MoveToAttackTarget(currentTarget));
                break;
            }
        }
    }
    

    Explicación de los Cambios:

    • Estados de la IA: He reorganizado la lógica usando un switch basado en aiState para hacer que sea más manejable y extensible.
    • El Estado Alert: Introducido para manejar situaciones donde los enemigos están cerca pero fuera del alcance inmediato. Esto permite que el soldado entre en un estado de vigilancia sin necesidad de perseguir inmediatamente.
    • DetectNearbyThreats: Una nueva función que se encarga de la vigilancia activa para detectar enemigos cercanos dentro de su capacidad de actuación, pero no necesariamente en el rango de ataque.

    Puedes ajustar cómo el soldado debería comportarse exactamente en cada estado de acuerdo con las necesidades de tu juego o las expectativas de los jugadores.

  5. User

    No, era completarlo con el comentario que esta ahi, no con lo que pusiste //Si no hay target desoues de 5 segundos entonces se mueve al last commanded position

  6. Assistant

    Para implementar la lógica que sugeriste, puedes completar el método Update añadiendo un temporizador que rastree el tiempo transcurrido desde la última detección de un objetivo. Si no se detecta ningún objetivo después de 5 segundos, el soldado se moverá a su "última posición ordenada". Aquí tienes cómo podrías hacer esto:

    private float noTargetDetectionTime = 0f; // Temporizador para rastrear el tiempo sin detectar un objetivo
    
    private void Update()
    {
        if (ai == null) return;
    
        healthBar.SetHealth(unitHealth.GetHealthPercentage());
        healthBar.transform.position = transform.position + healthBarOffset;
    
        // Actualizar el temporizador para el tiempo sin objetivo
        if (currentTarget == null)
        {
            noTargetDetectionTime += Time.deltaTime;
        }
        else
        {
            noTargetDetectionTime = 0f; // Reiniciar el temporizador si se encuentra un objetivo
        }
    
        if (Time.time >= nextTimeToAct)
        {
            if (aiState == AIState.FollowingOrder)
            {
                if (!ai.pathPending && ai.reachedEndOfPath)
                {
                    state = CharacterState.Idle;
                    aiState = AIState.Idle;
                }
                else if (float.IsPositiveInfinity(ai.remainingDistance))
                {
                    var nearest = AstarPath.active.GetNearest(ai.destination, NNConstraint.Walkable);
                    ai.destination = nearest.position;
                }
                else
                {
                    return;
                }
            }
    
            // Detectar y priorizar objetivos
            if (aiState != AIState.Attacking)
            {
                currentTarget = DetectTargets();
    
                // Si no hay target después de 5 segundos, moverse a la última posición ordenada
                if (currentTarget != null)
                {
                    StopAllCoroutines();
                    StartCoroutine(MoveToAttackTarget(currentTarget));
                }
                else if (noTargetDetectionTime >= 5f) // Si han pasado 5 segundos sin detectar un objetivo
                {
                    MoveLastCommandedPosition();
                }
    
                if (ai.reachedEndOfPath)
                {
                    state = CharacterState.Idle;
                    aiState = AIState.Idle;
                }
            }
            
            nextTimeToAct = Time.time + intervalSeconds;
        }
    }
    

    Explicación:

    • noTargetDetectionTime: Este campo mantiene un contador para almacenar cuánto tiempo ha pasado desde que se detectó un objetivo por última vez.
    • Actualización del Temporizador: Se incrementa noTargetDetectionTime si currentTarget es null. Si se detecta un objetivo, reseteamos este temporizador a cero.
    • Mover Después de 5 Segundos: Si han pasado 5 segundos sin detectar un objetivo (noTargetDetectionTime >= 5f), el soldado se moverá a lastCommandedPosition.

    Con este enfoque, puedes manejar la lógica de mover al soldado de vuelta a su posición ordenada si no encuentra ningún objetivo en un tiempo determinado. Esto mantiene al soldado activo y en movimiento, mejorando el comportamiento en el juego.

  7. User

    Este es el metodo detect targets, necesito que el metodo me diga tambien cuando detecto enemigos pero estan fuera de maxMovementRadious o cuando no detecto nada

    private GameObject DetectTargets() { //Quitamos overlap Capsule porque detection radius no funciona como tu creias Collider[] hitColliders = Physics.OverlapSphere(transform.position, detectionRadius, targetLayer, QueryTriggerInteraction.Collide); Transform nearestTarget = null; float closestDistanceSqr = Mathf.Infinity; Vector3 currentPosition = transform.position; Collider nearestCollider = null;

            foreach (Collider hitCollider in hitColliders)
            {
                if(hitCollider.GetComponent<ObjectHealth>().isDestroyed 
                   || hitCollider.gameObject.CompareTag("AirEnemy")
                   || Vector3.Distance(hitCollider.gameObject.transform.position, lastCommandedPosition) > maxMovementRadius) 
                    continue;
                
                Vector3 directionToTarget = hitCollider.transform.position - currentPosition;
                float dSqrToTarget = directionToTarget.sqrMagnitude;
                if (dSqrToTarget < closestDistanceSqr)
                {
                    closestDistanceSqr = dSqrToTarget;
                    nearestTarget = hitCollider.transform;
                    nearestCollider = hitCollider;
                }
            }
    
    
            if (nearestTarget != null)
                return nearestTarget.gameObject;
            return null;
        }
    
  8. Assistant

    Para lograr que el método DetectTargets no solo devuelva el objetivo más cercano dentro del rango de acción, sino también indique si hay enemigos fuera de maxMovementRadius o si no detectó enemigos, podrías modificarlo para devolver un objeto de un tipo personalizado que incluya tanto el objetivo como el estado de detección. Aquí hay una forma de hacerlo:

    1. Crea una estructura o clase para devolver múltiples estados de detección, incluyendo el objetivo más cercano, la presencia de enemigos fuera del rango de movimiento y si no se detectó ningún enemigo.
    2. La estructura puede tener campos para estos estados, facilitando el trabajo con la IA.

    Primero, define una clase para el resultado de la detección:

    public class DetectionResult
    {
        public GameObject NearestTarget { get; set; }
        public bool HasEnemiesBeyondMaxRadius { get; set; }
        public bool NoEnemiesDetected { get; set; }
    }
    

    Después, modifica el método DetectTargets para que use esta clase:

    private DetectionResult DetectTargets()
    {
        Collider[] hitColliders = Physics.OverlapSphere(transform.position, detectionRadius, targetLayer, QueryTriggerInteraction.Collide);
        Transform nearestTarget = null;
        float closestDistanceSqr = Mathf.Infinity;
        Vector3 currentPosition = transform.position;
        bool hasEnemiesBeyondMaxRadius = false;
        bool anyEnemiesDetected = false;
    
        foreach (Collider hitCollider in hitColliders)
        {
            anyEnemiesDetected = true; // Si entra al ciclo, hay al menos un enemigo en el radio de detección
    
            var objectHealth = hitCollider.GetComponent<ObjectHealth>();
            // Verificar si el enemigo está destruido o si es un tipo ignorado
            if (objectHealth.isDestroyed || hitCollider.gameObject.CompareTag("AirEnemy"))
                continue;
    
            float distanceToCommandedPosition = Vector3.Distance(hitCollider.gameObject.transform.position, lastCommandedPosition);
            if (distanceToCommandedPosition > maxMovementRadius)
            {
                hasEnemiesBeyondMaxRadius = true; // Marca si hay enemigos fuera del rango de movimiento
                continue;
            }
    
            Vector3 directionToTarget = hitCollider.transform.position - currentPosition;
            float dSqrToTarget = directionToTarget.sqrMagnitude;
            if (dSqrToTarget < closestDistanceSqr)
            {
                closestDistanceSqr = dSqrToTarget;
                nearestTarget = hitCollider.transform;
            }
        }
    
        return new DetectionResult
        {
            NearestTarget = nearestTarget ?.gameObject,
            HasEnemiesBeyondMaxRadius = hasEnemiesBeyondMaxRadius,
            NoEnemiesDetected = !anyEnemiesDetected
        };
    }
    

    Cómo usarlo:

    • Usa DetectionResult para obtener información completa sobre el resultado de la detección en la lógica principal del método Update.
    • Puedes verificar cada uno de los campos del DetectionResult para ejecutar acciones específicas según la situación detectada.

    Al hacerlo, tu lógica de IA puede volverse más adaptativa, gestionando no solo los objetivos presentes, sino también escenarios donde los enemigos están fuera de rango o no hay enemigos presentes.

  9. User

    Completa el metodo DetectTargets tomando en cuenta el inevitable radius

    using System; using System.Collections; using Game.Systems; using Game.Systems.Buildings; using MoreMountains.Feedbacks; using Pathfinding; using Pathfinding.RVO; using TMPro; using Tools; using UnityEngine; using Random = UnityEngine.Random;

    namespace Game.ImprovedAI {
    public class SoldierController : UnitBase { [SerializeField] private GameObject unitDeathPrefab;

        [SerializeField] private float detectionRadius = 1f;  // Detection radius for overlap sphere
        [SerializeField] private float maxMovementRadius = 12f;  // Detection radius for overlap sphere
        [SerializeField] private float inevitableRadius = 1f;  // Detection radius for overlap sphere
       
        [SerializeField] private float attackDamage;
        [SerializeField] private float attackRate;
        [SerializeField] private float maxRadioForGeneral = 3f;
        [SerializeField] private float radioAroundGeneral = 0.5f;
        
        [SerializeField] private bool drawSphere = false; 
        
        [SerializeField] private bool initializeOnStart;
        [SerializeField] private ParticleSystem spawnParticles;
        [SerializeField] private MMF_Player attackSound;
    
        
    
        private IAstarAI ai;
        private RVOController rvoController;
        
        private float nextTimeToAct = 0f; // Stores the next time we should perform the action
        private GameObject currentTarget;
        private float intervalSeconds = 0.5f; // Interval in seconds next Update
        private float nextAttackTime;
        [SerializeField] private Vector3 lastCommandedPosition;
        private Coroutine currentSoundCoroutine;
        private float noTargetDetectionTime = 0f;
    
    
        [SerializeField] private AIState aiState;
        
        
        //Checar si esta muy lejos del comandante
        //Moverse a una posicion random alrededor de el pero permitiendo ataques
        //Si se forza el movimiento ignorar todo lo demas
    
        private void Start()
        {
            if (initializeOnStart)
            {
                Init(null);
            }
        }
    
    
        public void Init(SoldierCamp soldierGenerator, Vector3 position = default, bool keepPosition = false)
        {
            building = soldierGenerator;
            ai = GetComponent<IAstarAI>();
            rvoController = GetComponent<RVOController>();
            state = CharacterState.Idle;
            unitHealth = GetComponent<UnitHealth>();
            unitHealth.Init(GameManager.Instance.ArmyStats.SoldierHealth);
            animationController = GetComponent<AnimationStateController>();
            unitHealth.ClearSubscriptions();
            unitHealth.OnZeroHealth += Die;
            aiState = AIState.Idle;
            unitType = UnitType.Soldier;
            ai.isStopped = false;
            //rvoController.locked = false;
            
            worldCanvas = GameObject.FindGameObjectWithTag("CanvasWorldSpace");
            if (healthBar == null)
            {
                healthBar = Instantiate(healthBarObject, transform.position + healthBarOffset, healthBarObject.transform.rotation,
                    worldCanvas.transform).GetComponent<HealthBar>();
            }
    
            healthBar.transform.rotation = healthBarObject.transform.rotation;
            EnableHealthBar(false);
    
            if (keepPosition)
            {
                lastCommandedPosition = transform.position;
            }
            
            if (lastCommandedPosition == Vector3.zero)
            {
                if (position != default)
                {
                    lastCommandedPosition = position;
                    MoveTo(position);
                }
                else
                {
                    lastCommandedPosition = transform.position;
                }
            }
            else
            {
                MoveTo(lastCommandedPosition);
            }
            
            GameManager.Instance.VillagerTracker.AddSoldier(this);
            PlaySpawnParticles();
        }
    
        private void Update()
        {
            if(ai == null) return;
    
            healthBar.SetHealth(unitHealth.GetHealthPercentage());
            healthBar.transform.position = transform.position + healthBarOffset;
            
            if (currentTarget == null)
            {
                noTargetDetectionTime += Time.deltaTime;
            }
            else
            {
                noTargetDetectionTime = 0f; // Reiniciar el temporizador si se encuentra un objetivo
            }
            
            //Si lo quitas el soldado se queda parado porque anda parando las corutinas
            if (Time.time >= nextTimeToAct)
            {
                if (aiState == AIState.FollowingOrder)
                {
                    if (!ai.pathPending && ai.reachedEndOfPath)
                    {
                        state = CharacterState.Idle;
                        aiState = AIState.Idle;
                    }
                    else if (float.IsPositiveInfinity(ai.remainingDistance))
                    {
                        var nearest = AstarPath.active.GetNearest (ai.destination, NNConstraint.Walkable);
                        ai.destination = nearest.position;
                    }
                    else
                    {
                        return;
                    }
                }
                
                // Detect and prioritize targets
                if (aiState != AIState.Attacking)
                {
                    var detectionResult = DetectTargets();
    
                    if (detectionResult != null)
                    {
                        currentTarget = detectionResult.NearestTarget;
                    }
                    
                    //Si no hay target desoues de 5 segundos entonces se mueve al last commanded position
                    
                    if (currentTarget != null)
                    {
                        StopAllCoroutines();
                        StartCoroutine(MoveToAttackTarget(currentTarget));
                    }
                    else if (noTargetDetectionTime >= 5f || detectionResult.NoEnemiesDetected) // Si han pasado 5 segundos sin detectar un objetivo
                    {
                        MoveLastCommandedPosition();
                    }
                    
                    if (ai.reachedEndOfPath)
                    {
                        state = CharacterState.Idle;
                        aiState = AIState.Idle;
                    }
                }
                
                
                nextTimeToAct = Time.time + intervalSeconds;
            }
    
        }
        
        private DetectionResult DetectTargets()
        {
            Collider[] hitColliders = Physics.OverlapSphere(transform.position, detectionRadius, targetLayer, QueryTriggerInteraction.Collide);
            Transform nearestTarget = null;
            float closestDistanceSqr = Mathf.Infinity;
            Vector3 currentPosition = transform.position;
            bool hasEnemiesBeyondMaxRadius = false;
            bool anyEnemiesDetected = false;
    
            foreach (Collider hitCollider in hitColliders)
            {
                anyEnemiesDetected = true; // Si entra al ciclo, hay al menos un enemigo en el radio de detección
    
                var objectHealth = hitCollider.GetComponent<ObjectHealth>();
                // Verificar si el enemigo está destruido o si es un tipo ignorado
                if (objectHealth.isDestroyed || hitCollider.gameObject.CompareTag("AirEnemy"))
                    continue;
    
                //Si esta abajo del inevitableradius entonces si es un target valido
    
                float distanceToCommandedPosition = Vector3.Distance(hitCollider.gameObject.transform.position, lastCommandedPosition);
                if (distanceToCommandedPosition > maxMovementRadius)
                {
                    hasEnemiesBeyondMaxRadius = true; // Marca si hay enemigos fuera del rango de movimiento
                    continue;
                }
    
                Vector3 directionToTarget = hitCollider.transform.position - currentPosition;
                float dSqrToTarget = directionToTarget.sqrMagnitude;
                if (dSqrToTarget < closestDistanceSqr)
                {
                    closestDistanceSqr = dSqrToTarget;
                    nearestTarget = hitCollider.transform;
                }
            }
    
            return new DetectionResult
            {
                NearestTarget = nearestTarget ?.gameObject,
                HasEnemiesBeyondMaxRadius = hasEnemiesBeyondMaxRadius,
                NoEnemiesDetected = !anyEnemiesDetected
            };
        }
        
        private IEnumerator MoveToAttackTarget(GameObject target)
        {
            //rvoController.locked = false;
            // Move towards the target
            MoveTo(target.transform.position);
            ai.SearchPath();
            aiState = AIState.MovingToAttack;
    
            while (ai.pathPending ||!ai.reachedEndOfPath)
            {
                // Check distance to the target
                if (target == null || target.GetComponent<ObjectHealth>().isDestroyed)
                {
                    //MoveLastCommandedPosition();
                    yield break;
                }
                yield return null; // Wait until the next frame
            }
            
            StartCoroutine(AttackTarget(target));
    
    
             // Ensure this method exists in your class
        }
    
        private IEnumerator AttackTarget(GameObject target)
        {
            
            //rvoController.locked = true;
    
            bool isDestroyed = false;
    
            float nextDamageTime = float.MaxValue;
            
            while (!isDestroyed && target != null && target.activeSelf && Vector3.Distance(transform.position, target.transform.position) < 2f)
            {
                aiState = AIState.Attacking;
                
                Vector3 targetDirection = ai.endOfPath - transform.position;
                Vector3 newDirection = Vector3.RotateTowards(transform.forward, targetDirection, 20 * Time.deltaTime, 0.0f);
                transform.rotation = Quaternion.LookRotation(newDirection);
    
                if (Time.time >= nextDamageTime)
                {
                    var unitHealth = target.transform.GetComponent<UnitHealth>();
                    if (unitHealth != null)
                    {
                        unitHealth.TakeDamage(GameManager.Instance.ArmyStats.SoldierAttack);
                        isDestroyed = unitHealth.isDestroyed;
                    }
                    nextDamageTime = float.MaxValue;
                }
                
                // Check if it’s time to attack
                if (Time.time >= nextAttackTime)
                {
                    // Attack logic here
                    // Apply damage to the target
                    // Assume target has a method called TakeDamage with damage parameter
    
                    animationController.SetAnimation(UnitBase.CharacterState.Attacking);
                    nextDamageTime = Time.time + animationController.animator.GetCurrentAnimatorStateInfo(0).length / 2;
                    // Update nextAttackTime
                    nextAttackTime = Time.time + attackRate;
                    
                    AnimationMethodCallerUtility.CallMethodAtTime(this, animationController.animator,
                        "Attacking",
                        0.5f, () =>
                        {
                            attackSound.PlayFeedbacks();
                        }, false);
                    
                }
    
                yield return null;
            }
            
            //rvoController.locked = false;
            currentTarget = null;
            state = CharacterState.Idle;
            aiState = AIState.Idle;
        }
        
        
        private void MoveLastCommandedPosition()
        {
            if (Vector3.Distance(lastCommandedPosition, transform.position) > 0.5f)
            {
                aiState = AIState.LookingForPosition;
                MoveTo(lastCommandedPosition);
            }
        }
    
        public override void MoveTo(Vector3 destination, bool isCommand = false)
        {
            //Debug.Log("Moving to " + destination);
            if (isCommand)
            {
                StopAllCoroutines();
                aiState = AIState.FollowingOrder;
                lastCommandedPosition = destination;
            }
            ai.destination = destination;
            (ai as AIBase)?.rvoDensityBehavior.ClearDestinationReached();
            ai.SearchPath();
    
            state = CharacterState.Walking;
        }
        
        public override void TeleportLastCommandedPosition()
        {
            aiState = AIState.LookingForPosition;
            Teleport(lastCommandedPosition);
            finalPosition = transform.position;
        }
        
        private void Teleport(Vector3 destination, bool isCommand = false)
        {
            //Debug.Log("Moving to " + destination);
            if (isCommand)
            {
                aiState = AIState.FollowingOrder;
                lastCommandedPosition = destination;
            }
            ai.Teleport(destination);
            state = CharacterState.Walking;
        }
    
        public override void RestoreMaxHealth()
        {
            base.RestoreMaxHealth();
            unitHealth.Init(GameManager.Instance.ArmyStats.SoldierHealth);
        }
    
        private void Die(object sender, EventArgs e)
        {
            state = CharacterState.Dead;
            ai.isStopped = true;
            Instantiate(unitDeathPrefab, transform.position, transform.rotation);
            gameObject.SetActive(false);
    
            if (GameManager.Instance.ResurrectionManager.HasAltarsAvailable())
            {
                gameObject.SetActive(false);
                GameManager.Instance.ResurrectionManager.AddSoldier(this);
                EnableHealthBar(false);
            }
            else
            {
                GameManager.Instance.VillagerTracker.RemoveSoldier(this);
                Destroy(gameObject);
                Destroy(healthBar.gameObject);
            }
            
            
        }
    
        public void PlaySpawnParticles()
        {
            spawnParticles.Play();
        }
    
        private void OnDisable()
        {
            if(unitHealth != null) unitHealth.OnZeroHealth -= Die;
        }
        
        void OnDrawGizmos()
        {
            if (drawSphere)
            {
                Gizmos.DrawWireSphere(transform.position, detectionRadius);
            }
        }
    }
    

    }

    public class DetectionResult { public GameObject NearestTarget { get; set; } public bool HasEnemiesBeyondMaxRadius { get; set; } public bool NoEnemiesDetected { get; set; } }

  10. Assistant

    Para completar el método DetectTargets considerando el inevitableRadius, puedes modificar la lógica existente para priorizar los enemigos dentro de este radio inevitable. Esta configuración garantizará que cualquier enemigo dentro de este radio se considere un objetivo prioritario, incluso si están fuera de los otros radios definidos. A continuación te proporciono la implementación con estas consideraciones:

    private DetectionResult DetectTargets()
    {
        Collider[] hitColliders = Physics.OverlapSphere(transform.position, detectionRadius, targetLayer, QueryTriggerInteraction.Collide);
        Transform nearestTarget = null;
        float closestDistanceSqr = Mathf.Infinity;
        Vector3 currentPosition = transform.position;
        bool hasEnemiesBeyondMaxRadius = false;
        bool anyEnemiesDetected = false;
        float inevitableTargetDistanceSqr = inevitableRadius * inevitableRadius;
    
        foreach (Collider hitCollider in hitColliders)
        {
            anyEnemiesDetected = true; // Si entra al ciclo, hay al menos un enemigo en el radio de detección
    
            var objectHealth = hitCollider.GetComponent<ObjectHealth>();
            // Verificar si el enemigo está destruido o si es un tipo ignorado
            if (objectHealth == null || objectHealth.isDestroyed || hitCollider.gameObject.CompareTag("AirEnemy"))
                continue;
    
            Vector3 directionToTarget = hitCollider.transform.position - currentPosition;
            float dSqrToTarget = directionToTarget.sqrMagnitude;
    
            // Priorizar enemigos dentro del inevitableRadius
            if (dSqrToTarget <= inevitableTargetDistanceSqr)
            {
                nearestTarget = hitCollider.transform;
                break; // Salir temprano si el objetivo está dentro del inevitableRadius
            }
    
            // Verificar si el enemigo está fuera del rango máximo de movimiento
            float distanceToCommandedPosition = Vector3.Distance(hitCollider.gameObject.transform.position, lastCommandedPosition);
            if (distanceToCommandedPosition > maxMovementRadius)
            {
                hasEnemiesBeyondMaxRadius = true; // Marca si hay enemigos fuera del rango de movimiento
                continue;
            }
    
            // Si no se encuentra en el inevitableRadius, busca el más cercano
            if (dSqrToTarget < closestDistanceSqr)
            {
                closestDistanceSqr = dSqrToTarget;
                nearestTarget = hitCollider.transform;
            }
        }
    
        return new DetectionResult
        {
            NearestTarget = nearestTarget ?.gameObject,
            HasEnemiesBeyondMaxRadius = hasEnemiesBeyondMaxRadius,
            NoEnemiesDetected = !anyEnemiesDetected
        };
    }
    

    Explicación de las modificaciones:

    1. Verificación del Inevitable Radius: Se prioriza la detección de enemigos dentro del inevitableRadius (si se encuentra un enemigo aquí, se selecciona automáticamente como nearestTarget y se rompe el bucle).

    2. Alternativa a la Detección dentro del Rango Efectivo: Si ningún enemigo está dentro del inevitableRadius, se siguen buscando objetivos en el detectionRadius, asegurando que estos estén lo más cercano posible al soldado y dentro de maxMovementRadius.

    3. Manejo de Estados de Detección: Este enfoque también permite determinar si existen enemigos fuera del maxMovementRadius o si no se detectaron enemigos.

    Esta implementación hace que la IA del soldado sea más reactiva y sensible a amenazas inmediatas, como aquellos enemigos que son una amenaza dentro del inevitable radius en cualquier situación.