IdleRPG2024/Assets/_2_0Script/Creature/IVCharacter.cs

using DG.Tweening;
using UnityEngine;

public class IVCharacter : CreatureBase
{
    [SerializeField]
    protected Spine.Skeleton skeleton;
    [SerializeField]
    private AudioSource asNormalAttack;
    [SerializeField]
    private Transform colObj;

    [SerializeField] ParticleSystem[] attackEffects;

    private BoxCollider col;
    protected MeshRenderer mrendAnim;
    protected MaterialPropertyBlock mpbAnim;
    private int attackState = 0;

    protected override void Start()
    {
        base.Start();
        skeleton = skAnim.Skeleton;
        mrendAnim = skAnim.GetComponent<MeshRenderer>();
        mpbAnim = new MaterialPropertyBlock();
        mpbAnim.SetTexture(GlobalShaderProperty._mainTexPropertyID, mrendAnim.sharedMaterial.mainTexture);
        col = colObj.GetChild(0).GetComponent<BoxCollider>();
    }

    protected override void InitTween()
    {
        twcSummon = transform.DOScale(Global.V3_1, 1.1f).SetEase(Ease.OutQuad).OnComplete(SummonEnd).SetAutoKill(false).Pause();
        twcUnsummon = transform.DOScale(Global.V3_1, 1.1f).SetEase(Ease.InQuad).OnComplete(UnsummonEnd).SetAutoKill(false).Pause();
    }

    protected override void OnDie()
    {
        base.OnDie();
        if (bFriendly)
            battleMgr.DieFriendly();
        else
            battleMgr.DieEnemy(eCreatureClass.charEnemy, 0);
    }

    protected override void SearchTarget()
    {
        if (!IsBattleAvail())
        {
            return;
        }

        if (BattleMgr.Instance.BattlePause)
        {
            ChangeState(eState.idle);
            return;
        }

        fSearchTick = 0f;
        iTargetIndex = battleMgr.GetTargetIndex(bFriendly);
        if (iTargetIndex < 0)
        {
            ChangeState(eState.idle);
        }
        else
        {
            v3TargetPos = battleMgr.GetTargetPos(bFriendly, iTargetIndex);
            fTargetDistance = BattleMgr.SCalcDistance(transform.position, v3TargetPos);
            if (stackSkillAvail.Count > 0 && stackSkillAvail.Peek() == -1)
            {
                ChangeState(eState.move);
                stackSkillAvail.Pop();
            }
            else
            {
                fUseSkillRange = stackSkillAvail.Count > 0 ? battleMgr.GetSkillRange(stackSkillAvail.Peek()) : 0;
            }

            if (fTargetDistance <= fUseSkillRange)
            {
                ChangeState(eState.skill);
                CheckSkill();
            }

            if(animState == eState.rush)
            {
                if (!isdash)
                    CheckAttack();
                return;
            }

            if (fTargetDistance <= fRange)
            {
                CheckAttack();
            }
            else
            {
                ChangeState(eState.move);
            }
        }
    }

    public override void Summon(Vector3 v3pos, bool bfrontright)
    {
        base.Summon(v3pos, bfrontright);
        BattleMgr.SSetPetFront(bFriendly, IsLookRight);
        BattleMgr.SSetGuardianFront(bFriendly, IsLookRight);
    }

    public override void Summon()
    {
        if (bLoading)
        {
            bSummonNeed = true;
            return;
        }

        bDead = false;
        bSummon = true;
        bAttackable = false;
        fAttackTick = 0f;
        iTargetIndex = -1;
        v3TargetPos = Vector3.zero;
        fTargetDistance = 9999f;

        gameObject.SetActive(true);
        ChangeStateForce(eState.warp_in);
        BattleMgr.SRefreshCharCloth();
        twcSummon.Restart();

        if (bInitNeed)
        {
            bInitNeed = false;
            anState = skAnim.AnimationState;
        }

        BattleMgr.SSetPetFront(bFriendly, IsLookRight);
        BattleMgr.SSetGuardianFront(bFriendly, IsLookRight);
    }

    public override void Unsummon()
    {
        bSummon = true;
        bAttackable = false;
        ChangeStateForce(eState.warp_out);
    }

    protected override float MoveToTarget()
    {
        if (!bcoward)
        {
            if (fMovCalc <= 0f)
                return fTargetDistance;
        }

        Vector3 v3framepos = Vector3.MoveTowards(transform.position, v3TargetPos, fMovCalc * Time.deltaTime);

        v3framepos.z = v3framepos.y * 0.1f;

        v3framepos.x = Mathf.Clamp(v3framepos.x, minArea.x, maxArea.x);
        v3framepos.y = Mathf.Clamp(v3framepos.y, minArea.y, maxArea.y);

        fTargetDistance = Vector3.Distance(v3framepos, v3TargetPos);
        transform.position = v3framepos;
        ChangeFront();

        return fTargetDistance;
    }

    public override void MoveToDir(Vector2 moveVec)
    {
        switch (animState)
        {
            case eState.warp_in:
            case eState.warp_out:
            case eState.die:
            case eState.rush:
                return;
        }

        Vector3 v3framepos = Vector3.MoveTowards(transform.position, transform.position + (Vector3)moveVec, fMovCalc * Time.deltaTime);
        v3framepos.z = v3framepos.y * 2f;

        v3framepos.x = Mathf.Clamp(v3framepos.x, minArea.x, maxArea.x);
        v3framepos.y = Mathf.Clamp(v3framepos.y, minArea.y, maxArea.y);
        //v3framepos.z = Mathf.Clamp(v3framepos.z, minArea.z, maxArea.z);

        transform.position = v3framepos;
        ChangeLookDirection(moveVec);
    }

    public override void CheckAttack()
    {
        if (bStun)
            return;

        if (bAttackable && iTargetIndex >= 0)
        {
            ChangeFront();

            if (SoundMgr.EfcOn)
                asNormalAttack.Play();

            if(attackEffects.Length > attackState && attackEffects[attackState] != null)
                attackEffects[attackState].Play();

            switch(attackState)
            {
                case 0:
                    ChangeState(eState.attack);
                    attackState = 1;
                    break;
                case 1:
                    ChangeState(eState.attack2);
                    attackState = 2;
                    break;
                case 2:
                    ChangeState(eState.attack3);
                    attackState = 0;
                    break;
            }

            skAnim.timeScale = 1.0f * motionSpeed;

            backAllowed = 1;
        }
        else
        {
            ChangeState(eState.idle);
        }
    }

    public override void CheckSkill()
    {
        if (bStun)
            return;

        if (stackSkillAvail.Count > 0 && iTargetIndex >= 0)
        {
            int iskillid = stackSkillAvail.Peek();
            if (!BattleMgr.GetAuto() && iskillid != BattleMgr.GetUseSkillid())
            {
                stackSkillAvail.Pop();
                return;
            }
            int iskillused = battleMgr.UseSkill(bFriendly, iskillid, transform, iTargetIndex, battleMgr.GetTrfTarget(bFriendly, iTargetIndex), fCrtDamCalc, iCrtRateCalc, biAtkCalc);
            if (iskillused > 0)
            {
                stackSkillAvail.Pop();
                return;
            }
            if (iskillused == -2)
            {
                ChangeState(eState.move);
                return;
            }
            if (iskillused < 0)
            {
                stackSkillAvail.Pop();
            }
        }
    }

    #region Ani Event
    public override void AttackDamage()
    {
        if (BattleMgr.Instance.BattlePause || bSummon || bDead) return;

        if (bFriendly)
        {
            colObj.position = battleMgr.GetTargetPos(bFriendly, iTargetIndex);
            battleMgr.DamageToEnemyTargets(col.bounds, iTargetIndex,3, biAtkCalc, fCrtDamCalc, iCrtRateCalc, shake : 0.3f, ivibrato : 0);
        }
        else
        {
            battleMgr.DamageToFriendly(biAtkCalc, fCrtDamCalc, iCrtRateCalc);
        }
    }
    #endregion Ani Event


    #region Costume & Color
    public void SetCostume(Texture2D tx2d)
    {
        if (tx2d == null) return;

        mpbAnim.SetTexture(GlobalShaderProperty._mainTexPropertyID, tx2d);
        for (int i = 0; i < mrendAnim.sharedMaterials.Length; i++)
        {
            if (mrendAnim.sharedMaterials[i] == GameProperty.Instance.PlayerCharacterMaterial)
            {
                mrendAnim.SetPropertyBlock(mpbAnim, i);
                break;
            }
        }
    }

    public string GetCosInfo()
    {
        string str = FormatString.CombineAllString("mpb[", (mpbAnim.GetTexture(GlobalShaderProperty._mainTexPropertyID) == null ? "null" : mpbAnim.GetTexture(GlobalShaderProperty._mainTexPropertyID).name), "]:",
            mrendAnim.sharedMaterials[0].name, "::", mrendAnim.sharedMaterials[0].shader.name, ":::",
            (mrendAnim.sharedMaterials[0].mainTexture == null ? "null" : mrendAnim.sharedMaterials[0].mainTexture.name));
        return str;
    }

    public void SetWeapon(Spine.Skin skincustom)
    {
        if (skincustom == null)
            return;

        skeleton.SetSkin(skincustom);
        skeleton.SetSlotsToSetupPose();
        skAnim.Update(0f);
    }

    public Spine.Skeleton GetSkeleton()
    {
       return skeleton;
    }
    #endregion Costume & color
}