OneShotOneKill/Assets/Script/InGame/Actor/MobActor.cs

using CodeStage.AntiCheat.ObscuredTypes;
using System.Collections;
using UnityEngine;

public enum eMobState { Move, Attack, KnockBack, Die }

public class MobActor : MonoBehaviour
{
    public MobShields m_MobShields;
    public GameObject go_stun;

    bool bBoss;
    MonsterTableData m_Data;
    float FenceY, m_attackTimer;
    eMobState m_State = eMobState.Move;
    Animator m_Animator;
    HUD_HP m_HUD_HP;
    Vector3 v3_knockBack;
    float t_knockback, f_stunTime;

    private void OnValidate()
    {
        m_MobShields = GetComponentInChildren<MobShields>();
        go_stun = transform.Find("Stun_loop").gameObject;
    }

    string poolKey;
    IngameMgr owner;
    public void SetOwner(IngameMgr mgr, string key)
    {
        owner = mgr;
        poolKey = key;
    }
    public void Die()
    {
        owner.ReturnMob(this);
    }

    public string GetPoolKey()
    {
        return poolKey;
    }

    ObscuredInt _Attack; public int m_Attack { get { return _Attack; } set { _Attack = value; _Attack.RandomizeCryptoKey(); } }
    ObscuredInt _HP; public int m_HP { get { return _HP; } set { _HP = value; _HP.RandomizeCryptoKey(); } }

    private void Awake()
    {
        var srs = GetComponentsInChildren<SpriteRenderer>(true);
        for (int i = 0; i < srs.Length; i++)
            srs[i].sortingOrder -= 5;
        m_Animator = GetComponentInChildren<Animator>();
    }

    private void Update()
    {
        float distToFence = transform.position.y - FenceY;

        switch (m_State)
        {
            case eMobState.Move:
                if (f_stunTime > 0) return;

                if (distToFence <= m_Data.f_AttackRange)
                    OnEnterAttack();
                else
                    Move();
                break;

            case eMobState.KnockBack:
                t_knockback += Time.deltaTime;
                transform.position = Vector3.Lerp(transform.position, v3_knockBack, t_knockback);
                if (t_knockback >= 1f)
                    m_State = eMobState.Move;
                break;

            case eMobState.Attack:
                if (f_stunTime > 0) return;

                if (distToFence <= m_Data.f_AttackRange)
                    Attack();
                else
                    m_State = eMobState.Move;
                break;
        }

        if (f_stunTime > 0)
        {
            if (!go_stun.activeInHierarchy) go_stun.SetActive(true);
            f_stunTime -= Time.deltaTime;
            if (f_stunTime <= 0)
            {
                go_stun.SetActive(false);
            }
        }
    }

    public void Set(bool isboss, MonsterTableData data, float fenceY)
    {
        gameObject.SetActive(true);
        go_stun.SetActive(false);
        if (m_HUD_HP == null)
            m_HUD_HP = DSUtil.Get_Clone<HUD_HP>("HUD/HUD_HP", IngameMgr.Ins.tf_hudparent);

        m_State = eMobState.Move;
        m_Data = data;
        FenceY = fenceY;
        m_attackTimer = m_Data.f_AttackDelay;
        f_stunTime = 0f;

        bBoss = isboss;
        var curstagedata = IngameMgr.Ins.Get_CurStageTData();
        m_Attack = m_Data.n_DefaultAttack + (bBoss ? curstagedata.n_DefaultBossAttack : curstagedata.n_DefaultEnemyAttack);
        m_HP = m_Data.n_DefaultHp + (bBoss ? curstagedata.n_DefaultBossHp : curstagedata.n_DefaultEnemyHp);
        (m_HUD_HP.transform as RectTransform).anchoredPosition = Vector2.one * 10000f;
        m_HUD_HP.Set(transform, m_HP);
        m_MobShields.Set(data, bBoss);
    }

    void Move()
    {
        transform.position += Vector3.down * Time.deltaTime * m_Data.f_MoveSpeed;
    }

    public bool IsBossMob() {  return bBoss; }

    void OnEnterAttack()
    {
        m_State = eMobState.Attack;

        // 이동 정지 시점 보정 (너무 파고들지 않게)
        Vector3 pos = transform.position;
        pos.y = FenceY + m_Data.f_AttackRange;
        transform.position = pos;

        // 애니메이션, 공격 쿨타임 초기화 등
    }

    void Attack()
    {
        m_attackTimer -= Time.deltaTime;
        if (m_attackTimer > 0f)
            return;

        m_attackTimer = m_Data.f_AttackDelay;

        //m_Animator.speed = 2f;
        m_Animator.SetTrigger("att");
        StartCoroutine(Co_AttackProjectile());
    }

    IEnumerator Co_AttackProjectile()
    {
        yield return new WaitForSeconds(1f);

        ProjectileMgr.Ins.Shoot_Projectile(new ProjectileData
        {
            ActorType = eActor.Mob,
            m_Data = table_projectile.Ins.Get_Data(m_Data.n_ProjectileID),
            tf_Start = transform,
            Dmg = m_Attack,
            Ignore_WallHP = false,
        });
    }

    public void Get_Dmg(ProjectileData data)
    {
        m_HP -= data.Dmg;
        m_HUD_HP.Set(m_HP);
        if (m_HP <= 0)
        {
            if (m_State == eMobState.Die) return;

            m_State = eMobState.Die;
            IngameMgr.Ins.Add_MobKill(m_Data.n_DropExp);
            gameObject.SetActive(false);

            if (data.ActorType == eActor.PC)
            {
                var explosionlv = IngameMgr.Ins.Get_SkillLv(eSkillType.Explosion);
                if (explosionlv > 0)
                {
                    var tdata = table_skill.Ins.Get_Data(eSkillType.Explosion);
                    var unit = IngameMgr.Ins.Get_CurUnitTData();
                    var dmg = unit.n_DefaultAttack + (int)IngameMgr.Ins.Get_SkillValue(eSkillType.AttackUp);
                    var totaldmg = dmg = (int)(dmg * tdata.f_ExplosionDmg);
                    totaldmg += (int)(dmg * (tdata.f_ExplosionDmgPerLv * (explosionlv - 1)));

                    ProjectileMgr.Ins.Shoot_Projectile(new ProjectileData
                    {
                        ActorType = data.ActorType,
                        Dmg = totaldmg,
                        m_Data = table_projectile.Ins.Get_Data(3002),
                        tf_Start = transform,
                    });
                }
            }
        }
        else if (!bBoss)
        {
            if (data.m_Data != null)
            {
                var knockbackdist = data.m_Data.f_KnockbackDistance + IngameMgr.Ins.Get_SkillValue(eSkillType.Knockback);

                if (knockbackdist > 0)
                {
                    m_State = eMobState.KnockBack;
                    v3_knockBack = transform.position + new Vector3(0f, knockbackdist);
                    t_knockback = 0f;
                }
            }

            f_stunTime += IngameMgr.Ins.Get_SkillValue(eSkillType.Stun);
        }
    }

    public void Off()
    {
        gameObject.SetActive(false);
        m_HUD_HP.gameObject.SetActive(false);
    }
}