몬스터 시스템

using UnityEngine;
using UnityEngine.UI;

// 몬스터 체력바 설정 클래스
public class MonsterHpBar : MonoBehaviour
{
    public Image healthBar;  // 체력바로 사용할 Image
    private Monster target;     // 이 체력바가 표시할 몬스터

   Transform player;    // 플레이어를 바라보도록 설정하기 위해서 플레이어를 받아옴

    private void Awake()
    {
        player = GameObject.FindWithTag("Player").transform;    // 플레이어를 태그를 통해 찾아옴
    }

    private void Start()
    {
        transform.gameObject.SetActive(false);  // 처음 시작할 때 비활성화
    }

    // 체력바가 표시될 몬스터 설정 함수
    public void SetTarget(Monster target)  
    {
        this.target = target;            // 매개변수로 넘어온 몬스터를 타겟으로 설정
        healthBar.fillAmount = 1.0f;  // 초기 체력은 100%
    }

    // 체력을 업데이트하는 함수
    public void UpdateHealthBar(float healthPercent)    
    {
        healthBar.fillAmount = healthPercent;
    }

    void Update()
    {   
        if (target == null) Destroy(healthBar);  // 만약 타겟(몬스터)이 없으면, 체력바를 생성하지 않음

        if (player != null) // 만약 플레이어가 Null이 아니면,
        {
            Vector3 lookPosition = player.position; // 체력바들이 플레이어를 바라보도록
            lookPosition.y = transform.position.y;  // 체력바들의 y값(위아래)는 움직이지 않도록.
            transform.LookAt(lookPosition);         // 최종 벡터값을 바라보도록 설정
        }
    }
}

using UnityEngine;
using UnityEngine.AI;

public class Monster : MonoBehaviour
{
    public static Monster instance;

    public enum State
    {
        IDLE =0,
        MOVE,
        CHASE,
        ATTACK,
        DAMAGED,
        RETURN,
        DIE
    };

    public State state;

    public bool isDie;
    public bool isRaidMonster = false;

    public string monsterName;
    public float maxHp;

    [Header("[ 몬스터 스테이터스 ]")]
    public float curHp;
    public float speed;
    public float atk;

    [Header("[ 몬스터 범위관련 ]")]
    public float chaseDist;    //플레이어 인지해서 추적 시작 범위
    public float attackDist;   //몬스터가 플레이어 공격 시작 범위
    public float maxChaseDist; //몬스터 최대 이동 거리(이 거리 밖으로 나가면 원위치)

    public NavMeshAgent agent;
    public GameObject hpBar;


    private void Awake()
    {
        instance = this;
    }

    public void CreateHealthBar(float y)
    {
        // 체력바를 몬스터의 자식으로 인스턴스화
        hpBar = Instantiate(Resources.Load<GameObject>("Prefabs/MonsterHpBar"), transform.position, Quaternion.identity);
        hpBar.transform.SetParent(this.transform, false);

        hpBar.gameObject.SetActive(false);

        hpBar.transform.localPosition = new Vector3(0, y, 0);             // 몬스터의 머리 위에 위치 조정
        hpBar.transform.localScale = new Vector3(0.005f, 0.005f, 0.005f); // 적절한 스케일 조정

        hpBar.GetComponent<MonsterHpBar>().SetTarget(this);               // 이 몬스터를 체력바에 연결
    }

    public void UpdateHpBar()
    {
        hpBar.GetComponent<MonsterHpBar>().UpdateHealthBar(curHp / maxHp);  // 맞았을 때, 체력 업데이트 
    }

    public void HpBarActive(float? distance)
    {
            if (distance != null && distance <= 15) hpBar.SetActive(true);
            else hpBar.SetActive(false);
    }

    public void GetDamage(int n)
    {
        UpdateHpBar();
        curHp -= n;
        state = State.DAMAGED;
    }

    public void GetDamage(float f)
    {
        curHp -= f;
        if (curHp > 0)
        {
            UpdateHpBar();
            state = State.DAMAGED;
        }
        else if (curHp <= 0)
        {
            state = State.DIE;
            if (hpBar) hpBar.GetComponent<MonsterHpBar>().UpdateHealthBar(0); ;
        }
    }

    // 레이드 관련
    public void KillCount(int n)
    {
        for (int i = 0; i < RegisterQuest.instance.registerQuest.Count; i++)
        {
            if (RegisterQuest.instance.registerQuest[i].questID == n)
            {
                RegisterQuest.instance.MonsterKill(monsterName);
            }
        }
    }

    public void MonsterKill()
    {
        if (!isRaidMonster)
        {
            spawnMonster.instance.KillCount(monsterName);
        }
    }
}

using UnityEngine;
using UnityEngine.AI;

public class Mushroom : Monster
{
    [Header("[ 몬스터 드랍템 ]")]
    [SerializeField] Item dropItemPrefabs;

    protected Animator anime;
    protected Transform target;

    protected Vector3 startPos;
    protected Vector3 patrolPos;

    protected float idleTimer;
    protected float idleDuration = 3f;
    protected bool isReturningToStart = false;

    protected bool isAtk;   // 공격 판정용

    protected void Awake()
    {
        anime = GetComponent<Animator>();
        agent = GetComponent<NavMeshAgent>();
        target = GameObject.FindWithTag("Player").transform;
        startPos = transform.position;
    }

    protected virtual void Start()
    {
        curHp = maxHp;
        state = State.MOVE;
        SetRandomPatrolPoint();
        CreateHealthBar(1.5f);
    }

    protected virtual void Update()
    {
        if (isDie) return;

        float distToPlayer = Vector3.Distance(transform.position, target.position);
        float distFromStart = Vector3.Distance(transform.position, startPos);

        HpBarActive(distToPlayer);

        switch (state)
        {
            case State.IDLE:
                UpdateIdle(distToPlayer);
                break;

            case State.MOVE:
                UpdatePatrol(distToPlayer);
                break;

            case State.CHASE:
                UpdateChase(distToPlayer, distFromStart);
                break;

            case State.ATTACK:
                UpdateAttack(distToPlayer, distFromStart);
                break;

            case State.RETURN:
                UpdateReturn();
                break;

            case State.DAMAGED:
                UpdateDamaged();
                break;

            case State.DIE:
                Die();
                break;
        }
    }

    // ───────────── 순찰 영역 ─────────────

    protected virtual void UpdateIdle(float dist)
    {
        if (dist <= chaseDist)
        {
            state = State.CHASE;
            return;
        }

        idleTimer -= Time.deltaTime;
        if (idleTimer <= 0f)
        {
            if (isReturningToStart)
            {
                // 시작 위치에서 대기 후 랜덤 지점으로
                isReturningToStart = false;
                SetRandomPatrolPoint();
            }
            else
            {
                // 랜덤 지점에서 대기 후 시작 위치로
                ReturnToStart();
            }
        }
    }

    protected void UpdatePatrol(float dist)
    {
        if (dist <= chaseDist)
        {
            state = State.CHASE;
            return;
        }

        if (!agent.pathPending &&
            agent.remainingDistance <= agent.stoppingDistance)
        {
            agent.isStopped = true;
            isReturningToStart = false;

            state = State.IDLE;
            idleTimer = idleDuration;
            Animation(true, false, false, false);
        }
    }

    protected void SetRandomPatrolPoint()
    {
        patrolPos = startPos + new Vector3(
            Random.Range(-5f, 5f),
            0,
            Random.Range(-5f, 5f)
        );

        agent.isStopped = false;
        agent.speed = speed;
        agent.SetDestination(patrolPos);

        state = State.MOVE;
        Animation(false, true, false, false);
    }

    protected virtual void UpdateReturn()
    {
        if (!agent.pathPending &&
            agent.remainingDistance <= agent.stoppingDistance)
        {
            agent.isStopped = true;

            // 정확한 위치 보정
            transform.position = startPos;

            state = State.IDLE;
            idleTimer = idleDuration;
            isReturningToStart = true;

            Animation(true, false, false, false);
        }
    }

    protected void ReturnToStart()
    {
        state = State.RETURN;

        agent.isStopped = false;
        agent.speed = speed * 2f;
        agent.SetDestination(startPos);

        Animation(false, false, true, false);
    }

    // ───────────── 전투 영역 ─────────────

    protected void UpdateChase(float dist, float distFromStart)
    {
        // 최대 추적 거리 도달 즉시 복귀
        if (distFromStart >= maxChaseDist - 0.1f)
        {
            ReturnToStart();
            return;
        }

        if (dist > chaseDist)
        {
            ReturnToStart();
            return;
        }

        if (dist <= attackDist)
        {
            state = State.ATTACK;
            agent.isStopped = true;
            Animation(false, false, false, true);
            return;
        }

        agent.isStopped = false;
        agent.speed = speed * 1.5f;
        agent.SetDestination(target.position);
        LookAtTarget(target.position, 10f);
        Animation(false, false, true, false);
    }

    protected virtual void UpdateAttack(float dist, float distFromStart)
    {
        if (distFromStart >= maxChaseDist - 0.1f || dist > chaseDist)
        {
            ReturnToStart();
            return;
        }

        if (dist > attackDist)
        {
            state = State.CHASE;
            return;
        }

        LookAtTarget(target.position, 15f);
    }

    // ───────────── 피격 / 사망 ─────────────

    protected virtual void UpdateDamaged()
    {
        anime.SetTrigger("Damage");

        if (curHp <= 0)
            state = State.DIE;
        else 
            state = isRaidMonster ? State.IDLE : State.CHASE;
    }

    protected virtual void Die()
    {
        anime.SetTrigger("Die");
        agent.isStopped = true;
        isDie = true;

        UiManager_.instance.DropItem(dropItemPrefabs, 3);
        KillCount(4);
        MonsterKill();

        Destroy(gameObject, 1f);
    }

    // ───────────── 플레이어 공격 판정 ─────────────

    protected virtual void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            isAtk = true;
        }
    }

    protected virtual void OnTriggerStay(Collider other) 
    {
        if (other.CompareTag("Player")) isAtk = true;
    }

    protected virtual void OnTriggerExit(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            isAtk = false;
        }
    }

    public void PlayerDamage()   // 공격 애니메이션 이벤트
    {
        if (isAtk)
        {
            StatusManager.instance.CurrentHp -= atk;
        }
    }

    // ───────────── 공통 ─────────────

    protected void Animation(bool idle, bool walk, bool run, bool attack)
    {
        anime.SetBool("Idle", idle);
        anime.SetBool("Walk", walk);
        anime.SetBool("Run", run);
        anime.SetBool("Attack", attack);
    }

    protected void LookAtTarget(Vector3 targetPos, float rotSP)
    {
        Vector3 dir = targetPos - transform.position;
        dir.y = 0;

        Quaternion rot = Quaternion.LookRotation(dir);
        transform.rotation = Quaternion.Slerp(
            transform.rotation,
            rot,
            Time.deltaTime * rotSP
        );
    }

    // ───────────── 레이드 관련 ─────────────

    void TargetSet(GameObject obj)
    {
        isRaidMonster = true;
        target = obj.transform;
        chaseDist = 125;
        maxChaseDist = 125;
    }
}

using System.Collections;
using UnityEngine;

public class MushroomBoss : Mushroom
{
    [Header("[ 스킬 관리 ]")]
    public bool skillFlip; // 스킬 번갈아 쓰기용
    public BossSkill[] skills;

    private Coroutine recoveryCoroutine;

    protected override void Start()
    {
        base.Start();
        CreateHealthBar(2.5f);
    }

    protected override void Update()
    {
        if (isDie) return;

        UpdateCooltime();
        base.Update();
    }

    // ───────────── 순찰 로직 ─────────────
    protected override void UpdateIdle(float dist)
    {
        if (dist <= chaseDist) StopRecovery();
        base.UpdateIdle(dist);
    }

    protected override void UpdateReturn()
    {
        // 부모 로직 실행 (도착 체크)
        bool wasReturning = state == State.RETURN;
        base.UpdateReturn();

        // 방금 도착해서 IDLE로 바뀌었다면 회복 시작
        if (wasReturning && state == State.IDLE)
        {
            StartRecovery();
        }
    }

    // ───────────── 전투 및 복귀 로직 ─────────────
    protected override void UpdateAttack(float dist, float distFromStart)
    {
        if (isDie || state == State.DIE) return;

        base.UpdateAttack(dist, distFromStart);

        // 스킬 사용 시도, 실패 시 기본 공격 애니메이션
        if (!TryUseSkill())
        {
            anime.SetTrigger("Attack");
        }
    }


    // ───────────── 보스 특화 로직 (회복/스킬) ─────────────
    void StartRecovery()
    {
        if (recoveryCoroutine == null && curHp < maxHp)
        {
            recoveryCoroutine = StartCoroutine(RecoveryHpRoutine());
        }
    }

    void StopRecovery()
    {
        if (recoveryCoroutine != null)
        {
            StopCoroutine(recoveryCoroutine);
            recoveryCoroutine = null;
        }
    }

    IEnumerator RecoveryHpRoutine()
    {
        while (curHp < maxHp)
        {
            yield return new WaitForSeconds(5f);
            curHp = Mathf.Min(curHp + 10f, maxHp); // 5초당 10씩 회복
            UpdateHpBar();
        }
        recoveryCoroutine = null;
    }

    private bool TryUseSkill()
    {
        // 현재 체력 상황에 따라 사용 가능한 스킬 활성화
        if (curHp <= maxHp * 0.6f) skills[0].useAble = true;
        if (curHp <= maxHp * 0.3f) skills[1].useAble = true;

        int idx = skillFlip ? 1 : 0;

        // 선택된 스킬이 준비되지 않았다면 반대쪽 스킬 체크
        if (!skills[idx].IsReady() || !skills[idx].useAble)
        {
            idx = 1 - idx;
        }

        if (skills[idx].useAble && skills[idx].IsReady())
        {
            skills[idx].UseSkill();
            anime.SetTrigger(skills[idx].skillName);
            skillFlip = !skillFlip; // 다음엔 다른 스킬 시도
            return true;
        }
        return false;
    }

    void UpdateCooltime()
    {
        foreach (var s in skills) 
            if (s.useAble) s.UpdateCooldown();
    }

    // ───────────── 애니메이션 이벤트/판정 ─────────────
    public void UseJumpSkill()
    {
        if (isDie) return;
        if (Vector3.Distance(transform.position, target.position) <= 3f)
            StatusManager.instance.CurrentHp -= skills[0].damage;
    }

    public void UseKickSkill()
    {
        if (isDie) return;
        if (isAtk)
            StatusManager.instance.CurrentHp -= skills[1].damage;
    }


    // ───────────── 피격 및 공통 ─────────────
    protected override void UpdateDamaged()
    {
        StopRecovery(); // 맞으면 회복 중단
        anime.SetTrigger("Damage");
        state = (curHp <= 0) ? State.DIE : State.CHASE;
    }

    protected override void Die()
    {
        if (isDie) return;

        isDie = true;
        state = State.DIE;

        StopAllCoroutines();
        StopRecovery();

        agent.isStopped = true;
        agent.ResetPath();

        // 기존 트리거 제거
        anime.ResetTrigger("Attack");
        anime.ResetTrigger("Damage");

        foreach (var s in skills)
            anime.ResetTrigger(s.skillName);

        Animation(false, false, false, false);
        anime.CrossFade("Die", 0.1f);

        spawnMonster.instance.KillBoss(monsterName);
        Destroy(gameObject, 2f);
    }
}