Colosseum/Assets/_Game/Scripts/Enemy/EnemyBase.cs

using System;
using UnityEngine;
using Unity.Netcode;
using Colosseum.Stats;
using Colosseum.Combat;

namespace Colosseum.Enemy
{
    /// <summary>
    /// 적 캐릭터 기본 클래스.
    /// 네트워크 동기화, 스탯 관리, 대미지 처리를 담당합니다.
    /// </summary>
    public class EnemyBase : NetworkBehaviour, IDamageable
    {
        [Header("References")]
        [Tooltip("CharacterStats 컴포넌트 (없으면 자동 검색)")]
        [SerializeField] protected CharacterStats characterStats;
        [Tooltip("Animator 컴포넌트")]
        [SerializeField] protected Animator animator;
        [Tooltip("NavMeshAgent 또는 이동 컴포넌트")]
        [SerializeField] protected UnityEngine.AI.NavMeshAgent navMeshAgent;

        [Header("Data")]
        [SerializeField] protected EnemyData enemyData;



        // 네트워크 동기화 변수
        protected NetworkVariable<float> currentHealth = new NetworkVariable<float>(100f);
        protected NetworkVariable<float> currentMana = new NetworkVariable<float>(50f);
        protected NetworkVariable<bool> isDead = new NetworkVariable<bool>(false);

        // 플레이어 분리용 (레이어 의존 없이 CharacterController로 식별)
        private readonly Collider[] overlapBuffer = new Collider[8];

        // 점프 등 Y 루트모션 스킬 중 NavMeshAgent 비활성화 상태 추적
        private bool isAirborne = false;

        // 점프 타겟 이동
        private bool hasJumpTarget = false;
        private Vector3 jumpStartXZ;
        private Vector3 jumpTargetXZ;

        // 이벤트
        public event Action<float, float> OnHealthChanged; // currentHealth, maxHealth
        public event Action<float> OnDamageTaken; // damage
        public event Action OnDeath;

        // Properties
        public float CurrentHealth => currentHealth.Value;
        public float MaxHealth => characterStats != null ? characterStats.MaxHealth : 100f;
        public float CurrentMana => currentMana.Value;
        public float MaxMana => characterStats != null ? characterStats.MaxMana : 50f;
        public bool IsDead => isDead.Value;
        public CharacterStats Stats => characterStats;
        public EnemyData Data => enemyData;
        public Animator Animator => animator;

        public override void OnNetworkSpawn()
        {
            // 컴포넌트 참조 확인
            if (characterStats == null)
                characterStats = GetComponent<CharacterStats>();
            if (animator == null)
                animator = GetComponentInChildren<Animator>();
            if (navMeshAgent == null)
                navMeshAgent = GetComponent<UnityEngine.AI.NavMeshAgent>();

            // 서버에서 초기화
            if (IsServer)
            {
                InitializeStats();
            }

            // 클라이언트에서 체력 변화 감지
            currentHealth.OnValueChanged += OnHealthChangedInternal;
        }

        protected virtual void Update()
        {
            if (!IsServer || IsDead) return;

            OnServerUpdate();
        }

        /// <summary>
        /// 서버 Update 확장 포인트 (하위 클래스에서 override)
        /// </summary>
        protected virtual void OnServerUpdate() { }

        /// <summary>
        /// 보스와 플레이어가 겹치면 플레이어를 밀어냅니다.
        /// 점프 착지 포함, 항상 실행됩니다.
        /// </summary>
        private void LateUpdate()
        {
            if (!IsServer || IsDead) return;

            float separationDist = navMeshAgent != null
                ? Mathf.Max(navMeshAgent.stoppingDistance, navMeshAgent.radius + 0.5f)
                : 1f;

            int count = Physics.OverlapSphereNonAlloc(transform.position, separationDist, overlapBuffer);
            for (int i = 0; i < count; i++)
            {
                if (!overlapBuffer[i].TryGetComponent<CharacterController>(out var cc)) continue;

                Vector3 toPlayer = overlapBuffer[i].transform.position - transform.position;
                toPlayer.y = 0f;
                float dist = toPlayer.magnitude;
                if (dist >= separationDist) continue;

                // 플레이어를 보스 바깥으로 밀어냄
                Vector3 pushDir = dist > 0.001f ? toPlayer.normalized : transform.forward;
                cc.Move(pushDir * (separationDist - dist));

                // 보스가 이동 중이었으면 정지 (플레이어 안으로 더 진입하지 않도록)
                if (navMeshAgent != null && !isAirborne && navMeshAgent.velocity.sqrMagnitude > 0.01f)
                    navMeshAgent.isStopped = true;
            }
        }

        /// <summary>
        /// 점프 타겟 설정. UseSkillAction에서 jumpToTarget 스킬 시전 시 호출합니다.
        /// </summary>
        public void SetJumpTarget(Vector3 targetPos)
        {
            jumpTargetXZ = new Vector3(targetPos.x, 0f, targetPos.z);
            hasJumpTarget = true;
        }

        /// <summary>
        /// 보스 스킬 루트모션이 플레이어 방향으로 진입하는 것을 차단합니다.
        /// Y 루트모션이 필요한 스킬(점프 등)은 NavMeshAgent를 비활성화하고 직접 이동합니다.
        /// jumpToTarget 스킬은 XZ를 대상 위치로 lerp합니다.
        /// </summary>
        private void OnAnimatorMove()
        {
            if (!IsServer || animator == null || navMeshAgent == null) return;

            var skillCtrl = GetComponent<Colosseum.Skills.SkillController>();
            bool needsYMotion = skillCtrl != null
                && skillCtrl.IsPlayingAnimation
                && !skillCtrl.IsInEndAnimation
                && skillCtrl.UsesRootMotion
                && !skillCtrl.IgnoreRootMotionY;

            Vector3 deltaPosition = animator.deltaPosition;

            if (needsYMotion)
            {
                // Y 루트모션 필요: NavMeshAgent 비활성화 후 transform 직접 이동
                if (navMeshAgent.enabled)
                {
                    navMeshAgent.enabled = false;
                    isAirborne = true;
                    jumpStartXZ = new Vector3(transform.position.x, 0f, transform.position.z);
                }

                if (hasJumpTarget)
                {
                    // XZ: 애니메이션 진행도에 따라 목표 위치로 lerp
                    float t = Mathf.Clamp01(animator.GetCurrentAnimatorStateInfo(0).normalizedTime);
                    Vector3 newXZ = Vector3.Lerp(jumpStartXZ, jumpTargetXZ, t);
                    transform.position = new Vector3(newXZ.x, transform.position.y + deltaPosition.y, newXZ.z);
                }
                else
                {
                    // jumpToTarget 없으면 기존처럼 애니메이션 루트모션 그대로 적용
                    transform.position += deltaPosition;
                }
            }
            else
            {
                // 착지 후 NavMeshAgent 복원
                if (isAirborne)
                {
                    isAirborne = false;
                    if (hasJumpTarget)
                    {
                        // lerp가 1.0에 못 미쳐도 착지 시 정확한 위치로 스냅
                        transform.position = new Vector3(jumpTargetXZ.x, transform.position.y, jumpTargetXZ.z);
                    }
                    hasJumpTarget = false;
                    navMeshAgent.enabled = true;
                    navMeshAgent.Warp(transform.position);
                }

                // XZ 차단: 플레이어 방향으로의 이동 방지 (일반 이동 중에만)
                float blockRadius = Mathf.Max(navMeshAgent.stoppingDistance, navMeshAgent.radius + 0.5f);
                int count = Physics.OverlapSphereNonAlloc(transform.position, blockRadius, overlapBuffer);
                for (int i = 0; i < count; i++)
                {
                    if (!overlapBuffer[i].TryGetComponent<CharacterController>(out _)) continue;

                    Vector3 toPlayer = overlapBuffer[i].transform.position - transform.position;
                    toPlayer.y = 0f;
                    if (toPlayer.sqrMagnitude < 0.0001f) continue;

                    Vector3 deltaXZ = new Vector3(deltaPosition.x, 0f, deltaPosition.z);
                    if (Vector3.Dot(deltaXZ, toPlayer.normalized) > 0f)
                    {
                        deltaPosition.x = 0f;
                        deltaPosition.z = 0f;
                    }
                }

                navMeshAgent.Move(deltaPosition);
            }

            if (animator.deltaRotation != Quaternion.identity)
                transform.rotation *= animator.deltaRotation;
        }

        public override void OnNetworkDespawn()
        {
            currentHealth.OnValueChanged -= OnHealthChangedInternal;
        }

        /// <summary>
        /// 스탯 초기화 (서버에서만 실행)
        /// </summary>
        protected virtual void InitializeStats()
        {
            if (enemyData != null && characterStats != null)
            {
                enemyData.ApplyBaseStats(characterStats);
            }

            // NavMeshAgent 속도 설정
            if (navMeshAgent != null && enemyData != null)
            {
                navMeshAgent.speed = enemyData.MoveSpeed;
                navMeshAgent.angularSpeed = enemyData.RotationSpeed;
            }

            currentHealth.Value = MaxHealth;
            currentMana.Value = MaxMana;
            isDead.Value = false;
        }

        /// <summary>
        /// 대미지 적용 (서버에서 실행)
        /// </summary>
        public virtual float TakeDamage(float damage, object source = null)
        {
            if (!IsServer || isDead.Value)
                return 0f;

            float actualDamage = Mathf.Min(damage, currentHealth.Value);
            currentHealth.Value = Mathf.Max(0f, currentHealth.Value - actualDamage);

            OnDamageTaken?.Invoke(actualDamage);

            // 대미지 피드백 (애니메이션, 이펙트 등)
            OnTakeDamageFeedback(actualDamage, source);

            if (currentHealth.Value <= 0f)
            {
                HandleDeath();
            }

            return actualDamage;
        }

        /// <summary>
        /// 대미지 피드백 (애니메이션, 이펙트)
        /// </summary>
        protected virtual void OnTakeDamageFeedback(float damage, object source)
        {
            if (animator != null)
            {
                animator.SetTrigger("Hit");
            }
        }

        /// <summary>
        /// 체력 회복 (서버에서 실행)
        /// </summary>
        public virtual float Heal(float amount)
        {
            if (!IsServer || isDead.Value)
                return 0f;

            float oldHealth = currentHealth.Value;
            currentHealth.Value = Mathf.Min(MaxHealth, currentHealth.Value + amount);
            float actualHeal = currentHealth.Value - oldHealth;

            return actualHeal;
        }

        /// <summary>
        /// 사망 애니메이션 재생 (모든 클라이언트에서 실행)
        /// </summary>
        [Rpc(SendTo.Everyone)]
        private void PlayDeathAnimationRpc()
        {
            if (animator != null)
            {
                // EnemyAnimationController 비활성화 (더 이상 애니메이션 제어하지 않음)
                var animController = GetComponent<EnemyAnimationController>();
                if (animController != null)
                {
                    animController.enabled = false;
                }

                // 모든 트리거 리셋
                animator.ResetTrigger("Attack");
                animator.ResetTrigger("Skill");
                animator.ResetTrigger("Hit");
                animator.ResetTrigger("Jump");
                animator.ResetTrigger("Land");
                animator.ResetTrigger("Die");

                // 즉시 Die 상태로 전환 (다른 애니메이션 중단)
                animator.Play("Die", 0, 0f);
            }
        }

        /// <summary>
        /// 사망 처리 (서버에서 실행)
        /// </summary>
        protected virtual void HandleDeath()
        {
            isDead.Value = true;

            // 실행 중인 스킬 즉시 취소
            var skillController = GetComponent<Colosseum.Skills.SkillController>();
            if (skillController != null)
            {
                skillController.CancelSkill();
            }

            // 모든 클라이언트에서 사망 애니메이션 재생
            PlayDeathAnimationRpc();

            if (navMeshAgent != null)
            {
                navMeshAgent.isStopped = true;
            }

            OnDeath?.Invoke();

            Debug.Log($"[Enemy] {name} died!");
        }

        /// <summary>
        /// 리스폰
        /// </summary>
        public virtual void Respawn()
        {
            if (!IsServer) return;

            isDead.Value = false;
            InitializeStats();

            if (navMeshAgent != null)
            {
                navMeshAgent.isStopped = false;
            }

            if (animator != null)
            {
                animator.Rebind();
            }
        }

        // 체력 변화 이벤트 전파
        private void OnHealthChangedInternal(float oldValue, float newValue)
        {
            OnHealthChanged?.Invoke(newValue, MaxHealth);
        }
    }
}