ActionTowerDefense/ActionTowerDefense/Assets/Scripts/Boss/Boss.cs

using Spine.Unity;
using Spine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using TMPro;
using Sirenix.OdinInspector;

public enum AttackCategories
{
    A = 0,
    B = 1,
    C = 2,
}

public class Boss : MoveCharacter
{
    private enum ChangeRoomState
    {
        none,
        disappear,
        teleport,
        createRoom,
    }

    //(主要针对受击状态等)
    public enum BossState
    {
        normal = 0,
        weak = 1,
        invincible = 2,
        rise = 3,       //从weak回到normal时回升高度
    }

    [Space(30)]
    [Header("Boss属性")]
    [Header("当前索敌是对塔还是对玩家")]
    public TargetType curTarget;
    [HideInInspector]
    public PlayerController pc;

    [Header("idle动画")]
    public string[] idleAniNames;
    public int[] weight;

    [Header("Boss攻击规律")]
    public string circulate;                //循环配置
    private int len;
    public AttackCategories[] categories;   //循环大类
    private AttackCategories curCategory;   //当前攻击大类
    private int curCategoryID;
    public float minInterval, maxInterval;  //间隔时间
    public float curInterval;

    [FoldoutGroup("角色信息")]
    public BossState bossState;
    private BossState oldState;
    /*[LabelText("耐力值")]
    public int totalPatience;               //初始耐力值上限
    private int curPatience;                //当前耐力值
    public UIHP uiPatience;                 //耐力值的条
    [LabelText("每次的上限值缩减量")]
    public float[] delPorpotation;
    private int curDelPorID;
    private int curTotalPatience;           //当前耐力值上限
    private bool noNeedChange;              //耐力值到底了，不用再缩减了*/
    [LabelText("虚弱时长")]
    public float weakTime;
    private float pastWeakTime;

    [Header("boss独立房间")]
    [LabelText("boss的独立空间")]
    public GameObject bossRoom;
    private GameObject bossRoomIns;
    private int startHP;            //开始计数的血量
    private ChangeRoomState rs;
    private bool isToBossRoom;      //要切换到boss空间中
    private bool isInBossRoom;      //在boss空间中
    [LabelText("切换到boss空间的血量扣除值")]
    public float toBossNeedHP;
    [LabelText("切换到boss空间的次数")]
    public int toBossTime;
    [LabelText("切换回原空间所需的时间")]
    public float toOrigNeedTime;
    private float changeBackTime;
    [LabelText("切换到原空间所需的血量")]
    public float toOrigNeedHP;
    //动画时长
    [LabelText("消失动画时长")]
    public float disappearAniTime;
    [LabelText("消失时长")]
    public float disappearTime;
    [LabelText("制造房间动画时长")]
    public float createRoomTime;
    [LabelText("出现后多久切换房间")]
    public float changeRoomTime;
    private float changeAniTime;

    private AttributeStatus status;

    public override void Init()
    {
        //确保组件不丢失
        if (!ani)
        {
            ani = GetComponentInChildren<Animator>();
        }
        if (!mecanim)
        {
            mecanim = GetComponentInChildren<SkeletonMecanim>();
        }
        if (!meshRenderer)
        {
            meshRenderer = mecanim.GetComponent<MeshRenderer>();
        }

        //玩家
        pc = PlayersInput.instance[0];

        nowCanFly = canFly;

        //血量重置
        hp = totalHp;
        startHP = totalHp;
        uiHp.Show(hp, totalHp);
        ChangeState(CharacterState.Idle);
        curInterval = Random.Range(minInterval, maxInterval);
        /*
        //耐力条
        curTotalPatience = totalPatience;
        curPatience = curTotalPatience;
        uiPatience.Show(curPatience, curTotalPatience);*/

        //特殊状态脚本
        status = beHitTrigger.GetComponent<AttributeStatus>();
    }

    public virtual void Start()
    {
        len = circulate.Length;
        int cur = 0;
        categories = new AttackCategories[len];
        foreach(char c in circulate)
        {
            switch (c)
            {
                case 'A':
                    categories[cur] = AttackCategories.A;
                    break;
                case 'B':
                    categories[cur] = AttackCategories.B;
                    break;
                case 'C':
                    categories[cur] = AttackCategories.C;
                    break;
                default:
                    break;
            }
            cur++;
        }
        curCategory = categories[0];
    }

    public override void BeHit(AttackController.AttackMethod attackMethod, Character attackFrom, int damage = -1)
    {
        switch (bossState)
        {
            //有耐力值
            case BossState.normal:
                base.BeHit(attackMethod, attackFrom, damage);
                /*//打耐力条
                int damageData;
                if (damage == -1)
                {
                    damageData = attackInfo.damage;
                }
                else
                {
                    damageData = damage;
                }
                curPatience -= damageData;
                //耐力值打完了，该次溢出伤害不记录，进入weak状态
                if (curPatience <= 0)
                {
                    curPatience = 0;
                    ChangeBossState(BossState.weak);
                }
                uiPatience.Show(curPatience, curTotalPatience);*/
                break;
            //耐力值破
            case BossState.weak:
                base.BeHit(attackMethod, attackFrom, damage);
                if (hp > 0)
                {
                    JudgeIfChangeBG();
                }
                break;
            //霸体
            case BossState.invincible:
                break;
        }
    }

    public virtual void Attack()
    {
    }

    public virtual void OnAttack()
    {
    }

    //攻击时被强制切换状态，清空所有遗留在外的技能
    //如：水诡释放黑伞时被击晕，黑伞消失
    public virtual void ClearAllSkills()
    {
    }

    //切换boss状态(主要针对受击状态等)
    public void ChangeBossState(BossState bs)
    {
        if (bs == bossState)
        {
            return;
        }
        oldState = bossState;
        switch (bossState)
        {
            case BossState.weak:
                //计算当前耐力值上限缩减程度
                rb.constraints = RigidbodyConstraints.FreezeRotation | RigidbodyConstraints.FreezePositionZ | RigidbodyConstraints.FreezePositionY;
                /*float curDelPor = delPorpotation[curDelPorID];
                if (curDelPorID < delPorpotation.Length - 1)
                {
                    curDelPorID++;
                }
                else
                {
                    noNeedChange = true;
                }
                if (!noNeedChange)
                {
                    //调整耐力值UI长度
                    uiPatience.ChangeLength(curDelPor);
                    //调整耐力值上限
                    curTotalPatience = (int)(totalPatience * curDelPor);
                }
                //将当前耐力值重置为新上限
                curPatience = curTotalPatience;
                //重置耐力条
                uiPatience.Show(curPatience, curTotalPatience);*/
                //清空特殊状态
                status.OutSpecialState();
                //飞行
                nowCanFly = canFly;
                //播放roar动画
                ani.Play("roar", 0, 0);
                break;
        }
        bossState = bs;
        switch (bs)
        {
            case BossState.weak:
                ClearAllSkills();
                ani.Play("fall", 0, 0);
                rb.constraints = RigidbodyConstraints.FreezeRotation | RigidbodyConstraints.FreezePositionZ;
                ChangeState(CharacterState.Idle);
                pastWeakTime = weakTime;
                nowCanFly = false;
                rb.useGravity = true;
                break;
            case BossState.rise:
                if (oldState != BossState.weak)
                {
                    int randomAni = RandomWithWeight(weight);
                    ani.Play(idleAniNames[randomAni], 0, 0);
                }
                rb.velocity = Vector3.zero;
                flyHeight = Random.Range(minFlyHeight, maxFlyHeight);
                break;
        }
        ani.speed = 1;
    }

    private void OnBossState()
    {
        switch (bossState)
        {
            case BossState.weak:
                pastWeakTime -= Time.deltaTime;
                if (pastWeakTime <= 0)
                {
                    ChangeBossState(BossState.rise);
                }
                break;
            case BossState.rise:
                if (AdjustHeight())
                {
                    ChangeBossState(BossState.normal);
                }
                break;
        }
    }

    public override void ChangeState(CharacterState newState)
    {
        if (state == newState || newState == CharacterState.FramePause)
        {
            return;
        }
        switch (state)
        {
            case CharacterState.Attack:
                ClearAllSkills();
                break;
            case CharacterState.Run:
                rb.velocity = Vector3.zero;
                break;
            default:
                break;
        }
        state = newState;
        switch (newState)
        {
            case CharacterState.Idle:
                if (bossState != BossState.weak)
                {
                    int randomAni = RandomWithWeight(weight);
                    ani.Play(idleAniNames[randomAni], 0, 0);
                }
                break;
            case CharacterState.Run:
                ToMove();
                break;
            case CharacterState.Die:
                ani.Play("die", 0, 0);
                gameObject.SetActive(false);
                break;
            case CharacterState.Attack:
                if (!isToBossRoom)
                {
                    Attack();
                }
                break;
            default:
                break;
        }
    }

    public override void OnState()
    {
        switch (state)
        {
            case CharacterState.Idle:
                if (isToBossRoom)
                {
                    OnChangeBG();
                }
                else if (bossState != BossState.weak)
                {
                    curInterval -= Time.deltaTime;
                    if (curInterval <= 0)
                    {
                        RandomAttackState();
                    }
                }
                break;
            case CharacterState.Run:
                OnMove();
                break;
            case CharacterState.Attack:
                OnAttack();
                break;
            case CharacterState.HitStun:
                hitFeedbackSystem.HitStunUpdate();
                break;
            case CharacterState.SpecialStatus_Float:
                attributeStatus.SpecialStateEffect(SpecialState.FloatState);
                break;
            case CharacterState.SpecialStatus_BlowUp:
                attributeStatus.SpecialStateEffect(SpecialState.BlownUp);
                break;
            case CharacterState.SpecialStatus_ShotDown:
                attributeStatus.SpecialStateEffect(SpecialState.ShotDown);
                break;
            case CharacterState.SpecialStatus_Weak:
                attributeStatus.SpecialStateEffect(SpecialState.Weak);
                break;
            default:
                break;
        }
        if (isInBossRoom)
        {
            changeBackTime += Time.deltaTime;
            if (changeBackTime >= toOrigNeedTime)
            {
                ChangeBG(false);
                changeBackTime = 0;
            }
        }
        OnBossState();
    }

    public virtual void ToMove()
    {
    }

    public virtual void OnMove()
    {
    }

    //根据当前大类随机攻击方式
    public virtual void RandomAttackType(AttackCategories cate)
    {
    }

    public void RandomAttackState()
    {
        switch (curCategory)
        {
            case AttackCategories.A:
                RandomAttackType(AttackCategories.A);
                break;
            case AttackCategories.B:
                RandomAttackType(AttackCategories.B);
                break;
            default:
                break;
        }
        curCategoryID++;
        if (curCategoryID == len)
        {
            curCategoryID = 0;
        }
        curCategory = categories[curCategoryID];
        ChangeState(CharacterState.Attack);
    }

    public void EndCurAttackState(bool hasIntervalTime)
    {
        //和下一个动作有没有间隔
        if (hasIntervalTime)
        {
            curInterval = Random.Range(minInterval, maxInterval);
        }
        ChangeState(CharacterState.Idle);
        ChangeBossState(BossState.rise);
    }
    
    //权重随机
    //传入权重int[]，返回第random组
    public int RandomWithWeight(int[] weight)
    {
        int all = 0;
        foreach(int i in weight)
        {
            all += i;
        }
        int a = Random.Range(0, all);
        int b = 0;
        for(int i = 0; i < weight.Length - 1; i++)
        {
            b += weight[i];
            if (a < b)
            {
                return i;
            }
        }
        return weight.Length - 1;
    }

    private void ToChangeRoom(ChangeRoomState crs)
    {
        //消失前动画-消失动画-瞬移特效-出现动画-制造房间动画
        if (rs == crs)
        {
            return;
        }
        rs = crs;
        switch (rs)
        {
            case ChangeRoomState.none:
                break;
            case ChangeRoomState.disappear:
                ani.Play("roar", 0, 0);
                startHP = hp;
                break;
            case ChangeRoomState.teleport:  //瞬移
                //ani.Play("", 0, 0);
                bodyTrans.gameObject.SetActive(false);
                break;
            case ChangeRoomState.createRoom:
                transform.position = pc.transform.position;
                bodyTrans.gameObject.SetActive(true);
                ani.Play("roar", 0, 0);
                ChangeBG(true);
                break;
            default:
                break;
        }
    }
    
    private void OnChangeBG()
    {
        switch (rs)
        {
            case ChangeRoomState.disappear:
                changeAniTime += Time.deltaTime;
                if (changeAniTime >= disappearAniTime)
                {
                    ToChangeRoom(ChangeRoomState.teleport);
                    changeAniTime = 0;
                }
                break;
            case ChangeRoomState.teleport:
                changeAniTime += Time.deltaTime;
                if (changeAniTime >= disappearTime)
                {
                    ToChangeRoom(ChangeRoomState.createRoom);
                    changeAniTime = 0;
                }
                break;
            case ChangeRoomState.createRoom:
                changeAniTime += Time.deltaTime;
                if (changeAniTime >= createRoomTime)
                {
                    ToChangeRoom(ChangeRoomState.none);
                    changeAniTime = 0;
                    isToBossRoom = false;
                    ChangeState(CharacterState.Idle);
                    ChangeBossState(BossState.rise);
                }
                break;
            default:
                break;
        }
    }

    //拉入boss房间（通过切换bg实现）
    private void ChangeBG(bool isToBossBG)
    {
        if (isToBossBG)
        {
            isInBossRoom = true;
            if (!bossRoomIns)
            {
                bossRoomIns = Instantiate(bossRoom);
            }
            bossRoomIns.SetActive(true);
            GameManager.instance.chapterBG.SetActive(false);
        }
        else
        {
            isInBossRoom = false;
            bossRoomIns.SetActive(false);
            GameManager.instance.chapterBG.SetActive(true);
        }
        pc.foot.trigGroundList.Clear();
        startHP = hp;
        ChangeBossState(BossState.invincible);
    }

    //判断是否要切换boss房间
    private void JudgeIfChangeBG()
    {
        if (isToBossRoom)       //换房间中
        {
            return;
        }
        if (isInBossRoom)
        {
            if (startHP - hp >= toOrigNeedHP)
            {
                ani.Play("roar", 0, 0);
                isToBossRoom = true;
                ChangeBG(false);
            }
            return;
        }
        if (toBossTime <= 0)    //boss是否还有转房间次数
        {
            return;
        }
        if (startHP - hp >= toBossNeedHP)
        {
            toBossTime--;
            isToBossRoom = true;
            ChangeState(CharacterState.Idle);
            ToChangeRoom(ChangeRoomState.disappear);
        }
    }
}