Colosseum/Assets/_Game/Scripts/AI/BehaviorActions/Actions/SelectAlternateTargetByDistanceAction.cs

using System;
using System.Collections.Generic;

using Colosseum;
using Colosseum.Combat;
using Colosseum.Enemy;
using Colosseum.Player;

using Unity.Behavior;
using Unity.Properties;
using UnityEngine;

using Action = Unity.Behavior.Action;

/// <summary>
/// 현재 주 대상이 아닌 다른 원거리 대상을 선택합니다.
/// </summary>
[Serializable, GeneratePropertyBag]
[NodeDescription(
    name: "Select Alternate Target By Distance",
    story: "주 대상이 아닌 원거리 대상 선택",
    category: "Action",
    id: "1fe74f607036406c8857c1a23f42c8a2")]
public partial class SelectAlternateTargetByDistanceAction : Action
{
    [SerializeReference]
    public BlackboardVariable<GameObject> Target;

    [SerializeReference]
    public BlackboardVariable<float> MinRange = new BlackboardVariable<float>(0f);

    [SerializeReference]
    public BlackboardVariable<float> MaxRange = new BlackboardVariable<float>(0f);

    protected override Status OnStart()
    {
        BossBehaviorRuntimeState runtimeState = GameObject.GetComponent<BossBehaviorRuntimeState>();
        if (runtimeState == null)
            return Status.Failure;

        float minRange = Mathf.Max(0f, MinRange.Value);
        float maxRange = MaxRange.Value > 0f
            ? MaxRange.Value
            : (runtimeState.EnemyBase != null && runtimeState.EnemyBase.Data != null ? runtimeState.EnemyBase.Data.AggroRange : 20f);

        GameObject selectedTarget = SelectTarget(runtimeState, minRange, maxRange);
        if (selectedTarget == null)
            return Status.Failure;

        Target.Value = selectedTarget;
        runtimeState.SetCurrentTarget(selectedTarget);
        runtimeState.LogDebug(nameof(SelectAlternateTargetByDistanceAction), $"보조 대상 선택: {selectedTarget.name}");
        return Status.Success;
    }

    private GameObject SelectTarget(BossBehaviorRuntimeState runtimeState, float minRange, float maxRange)
    {
        PlayerNetworkController[] players = UnityEngine.Object.FindObjectsByType<PlayerNetworkController>(FindObjectsSortMode.None);
        if (players == null || players.Length == 0)
            return null;

        GameObject primaryTarget = ResolvePrimaryTarget(runtimeState);
        List<GameObject> validTargets = new List<GameObject>();

        for (int i = 0; i < players.Length; i++)
        {
            PlayerNetworkController player = players[i];
            if (player == null || player.IsDead || !player.gameObject.activeInHierarchy)
                continue;

            GameObject candidate = player.gameObject;
            if (candidate == primaryTarget)
                continue;

            if (!IsValidHostileTarget(candidate))
                continue;

            float distance = TargetSurfaceUtility.GetHorizontalSurfaceDistance(GameObject.transform.position, candidate);
            if (distance < minRange || distance > maxRange)
                continue;

            validTargets.Add(candidate);
        }

        if (validTargets.Count == 0)
        {
            if (primaryTarget != null && IsValidHostileTarget(primaryTarget))
            {
                float primaryDistance = TargetSurfaceUtility.GetHorizontalSurfaceDistance(GameObject.transform.position, primaryTarget);
                if (primaryDistance >= minRange && primaryDistance <= maxRange)
                    return primaryTarget;
            }

            return null;
        }

        int randomIndex = UnityEngine.Random.Range(0, validTargets.Count);
        return validTargets[randomIndex];
    }

    private GameObject ResolvePrimaryTarget(BossBehaviorRuntimeState runtimeState)
    {
        EnemyBase enemyBase = runtimeState.EnemyBase;
        GameObject currentTarget = runtimeState.CurrentTarget;
        float aggroRange = enemyBase != null && enemyBase.Data != null ? enemyBase.Data.AggroRange : Mathf.Infinity;
        GameObject highestThreatTarget = enemyBase != null
            ? enemyBase.GetHighestThreatTarget(currentTarget, null, aggroRange)
            : null;

        if (highestThreatTarget != null)
            return highestThreatTarget;

        PlayerNetworkController[] players = UnityEngine.Object.FindObjectsByType<PlayerNetworkController>(FindObjectsSortMode.None);
        GameObject nearestTarget = null;
        float nearestDistance = float.MaxValue;
        for (int i = 0; i < players.Length; i++)
        {
            PlayerNetworkController player = players[i];
            if (player == null || player.IsDead || !player.gameObject.activeInHierarchy)
                continue;

            GameObject candidate = player.gameObject;
            if (!IsValidHostileTarget(candidate))
                continue;

            float distance = TargetSurfaceUtility.GetHorizontalSurfaceDistance(GameObject.transform.position, candidate);
            if (distance > aggroRange || distance >= nearestDistance)
                continue;

            nearestDistance = distance;
            nearestTarget = candidate;
        }

        return nearestTarget;
    }

    private bool IsValidHostileTarget(GameObject candidate)
    {
        if (candidate == null || !candidate.activeInHierarchy)
            return false;

        if (Team.IsSameTeam(GameObject, candidate))
            return false;

        IDamageable damageable = candidate.GetComponent<IDamageable>();
        return damageable == null || !damageable.IsDead;
    }
}