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

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class YuMenGuan : Boss
{
    public enum AttackMethods
    {
        none = 0,
        move = 1,           //移动
        shockWave1 = 2,     //单手砸地，两侧冲击波
        shockWave2 = 3,     //双手砸地，两侧冲击波*3
        laser = 4,          //眼睛激光
        block = 5,          //砖头怪
        blackHand = 6,      //黑手
    }

    public enum PoolType
    {
        wave1 = 0,
        wave2 = 1,
        block = 2,
    }

    [System.Serializable]
    public struct AttackAssignment
    {
        public AttackMethods attack;
        public int weight;              //权重
    }

    [System.Serializable]
    public struct BossAttackType
    {
        public AttackCategories category;
        public AttackAssignment[] attacks;
    }

    [Header("攻击配置")]
    public BossAttackType[] attackConfigurations;
    private AttackMethods curAttackType;

    [Header("移动")]
    public float maxMoveDis, minMoveDis;
    private float curMoveDis;
    private float hasMoveDis;
    private float origMoveX;
    private bool isAttackWalk;          //作为随机到的攻击而移动
    private Character otherTarget;

    [Header("冲击波")]
    public GameObject wave1;
    public GameObject wave2;
    public AttackInfo wave1Damage;
    public AttackInfo[] wave2Damage;
    public Transform wave1pos;
    public Transform wave2pos;
    public float launchDelayTime1, launchDelayTime1loop, launchDelayTime2;
    public float[] waveEnlargeScale;
    public Vector3 wave1Size;
    public Vector3[] wave2Size;
    public float[] intervalTime;          //三连冲击波，每个冲击波发射的间隔时间
    private List<Bullet> wave1Pool = new List<Bullet>();
    private List<Bullet> wave2Pool = new List<Bullet>();
    private int[] hasNum;               //池中已有的数量
    private List<Bullet> usedWave1 = new List<Bullet>();
    private List<Bullet> usedWave2 = new List<Bullet>();
    private int curWaveIndex = 0;
    private List<Bullet> transit = new List<Bullet>();  //中转
    private int shockWaveTimes;         //连续n次单手冲击波
    private bool isContinuous;          //连续多次单手冲击波
    public int maxShockTimes, minShockTimes;
    public float wave1aniTime, wave1loopTime;
    public float wave2aniTime;
    public float waveEndTime;
    private float waveTime;             //冲击波进行时长
    private bool isWave1;               //冲击波1进行中
    private bool isWave2;               //冲击波2进行中
    private bool isEndWave;

    [Header("眼睛激光")]
    public EyeLaser laser;
    public Transform eye;               //从哪里射出
    public GameObject weakEye;          //哪个弱点被打爆后不再发射
    public float waitTime;              //蓄力多久后开始发射激光

    [Header("砖头怪")]
    public int minBlocks, maxBlocks;
    public float aniTime;
    private int curBlocks;
    public GameObject block;
    public float minX, maxX;

    public override void Start()
    {
        base.Start();
        hasNum = new int[3];
        laser.headPos = eye;
    }

    //判断冲击波池中是否有多余的冲击波，没有则实例化新的
    private void ExpandPool(PoolType id, int num)
    {
        int need = num - hasNum[(int)id];
        if (need <= 0)
        {
            return;
        }
        GameObject prefab = null;
        List<Bullet> pool = null;
        List<Bullet> used = null;
        switch (id)
        {
            case PoolType.wave1:
                prefab = wave1;
                pool = wave1Pool;
                used = usedWave1;
                break;
            case PoolType.wave2:
                prefab = wave2;
                pool = wave2Pool;
                used = usedWave2;
                break;
            case PoolType.block:
                break;
            default:
                break;
        }
        foreach(Bullet b in used)
        {
            if (!b.gameObject.activeSelf)
            {
                transit.Add(b);
                pool.Add(b);
                need -= 1;
                hasNum[(int)id] += 1;
            }
        }
        for (int i = 0; i < need; i++)
        {
            GameObject g;
            g = Instantiate(prefab, Vector3.zero, new Quaternion(0, 0, 0, 0), null);
            g.SetActive(false);
            pool.Add(g.GetComponent<Bullet>());
            hasNum[(int)id] += 1;
        }
        foreach (Bullet bu in transit)
        {
            used.Remove(bu);
            transit = new List<Bullet>();
        }
    }

    //移动逻辑，作为随出来的移动时移动一定距离；作为无目标移动时始终捕捉是否有可攻击目标进入范围，有则切出移动状态
    public override void OnMove()
    {
        if (isAttackWalk && (!targetCharacter || targetCharacter.isDie))
        {
            CheckTarget();
        }
        if (Vector2.Distance(bodyTrans.position, targetCharacter.transform.position) <= 0.5f)
        {
            canMove = false;
            rb.velocity = new Vector3(0, 0, 0);
        }
        Vector3 dir;
        dir = bodyTrans.position.x <= targetCharacter.transform.position.x ? Vector3.right : Vector3.left;
        if (dir.x * bodyTrans.localScale.x > 0)
        {
            Turn();
        }
        rb.velocity = dir * moveSpeed;
        hasMoveDis = bodyTrans.position.x - origMoveX;
        if (isAttackWalk)
        {
            if (hasMoveDis >= curMoveDis)
            {
                isAttackWalk = false;
                EndCurAttackState(false);
            }
        }
        else
        {
            otherTarget = searchTrigger.GetMinDisTarget(targetTypes, canHitFly);
            if (otherTarget != null)
            {
                EndCurAttackState(false);
            }
        }
    }

    public override void Update()
    {
        base.Update();
        if (isWave1)
        {
            ContinueShockWave(0);
        }
        if (isWave2)
        {
            ContinueShockWave(1);
        }
    }

    //移动前逻辑
    public override void ToMove()
    {
        ChangeState(CharacterState.Run);
        curMoveDis = Random.Range(minMoveDis, maxMoveDis);
        origMoveX = bodyTrans.position.x;
        curTarget = TargetType.Tower;
        CheckTarget();
        ani.Play("yumenguan_walk", 0, 0);
    }

    //发射冲击波2号（3连）
    private void ToLaunchWave2()
    {
        LaunchWave(1, curWaveIndex);
        curWaveIndex++;
        if (curWaveIndex == 3)
        {
            curWaveIndex = 0;
        }
    }

    //发射冲击波1号
    private void ToLaunchWave1()
    {
        LaunchWave(0, 0);
    }

    //发射冲击波
    private void LaunchWave(int id, int index)
    {
        Vector3 dir = Vector3.zero;
        Vector3 dir1 = Vector3.left;
        Vector3 dir2 = Vector3.right;
        Bullet wv1, wv2;
        switch (id)
        {
            case 0:
                ExpandPool(PoolType.wave1, 2);
                wv1 = wave1Pool[hasNum[id] - 1];
                wv2 = wave1Pool[hasNum[id] - 2];
                wv1.transform.localScale = wave1Size;
                wv2.transform.localScale = wave1Size;
                wave1Pool.Remove(wv1);
                wave1Pool.Remove(wv2);
                usedWave1.Add(wv1);
                usedWave1.Add(wv2);
                wv1.GetComponent<WaveShockDir>().IsLeft = true;
                wv2.GetComponent<WaveShockDir>().IsLeft = false;
                wv1.GetComponent<WaveShockDir>().scale = waveEnlargeScale[curStateId];
                wv2.GetComponent<WaveShockDir>().scale = waveEnlargeScale[curStateId];
                wv1.GetComponent<WaveShockDir>().CheckTurn();
                wv2.GetComponent<WaveShockDir>().CheckTurn();
                wv1.BeShoot(this, wave1pos.position, dir1, wave1Damage.damage, wave1Damage.force, wave1Damage.changeHurt, wave1Damage.repelValue, false);
                wv2.BeShoot(this, wave2pos.position, dir2, wave1Damage.damage, wave1Damage.force, wave1Damage.changeHurt, wave1Damage.repelValue, false);
                wv1.transform.right = dir;
                wv2.transform.right = dir;
                break;
            case 1:
                ExpandPool(PoolType.wave2, 2);
                wv1 = wave2Pool[hasNum[id] - 1];
                wv2 = wave2Pool[hasNum[id] - 2];
                wv1.transform.localScale = wave2Size[index];
                wv2.transform.localScale = wave2Size[index];
                wave2Pool.Remove(wv1);
                wave2Pool.Remove(wv2);
                usedWave2.Add(wv1);
                usedWave2.Add(wv2);
                wv1.GetComponent<WaveShockDir>().IsLeft = true;
                wv2.GetComponent<WaveShockDir>().IsLeft = false;
                wv1.GetComponent<WaveShockDir>().scale = waveEnlargeScale[curStateId];
                wv2.GetComponent<WaveShockDir>().scale = waveEnlargeScale[curStateId];
                wv1.GetComponent<WaveShockDir>().CheckTurn();
                wv2.GetComponent<WaveShockDir>().CheckTurn();
                wv1.BeShoot(this, wave1pos.position, dir1, wave2Damage[index].damage, wave2Damage[index].force, wave2Damage[index].changeHurt, wave2Damage[index].repelValue, false);
                wv2.BeShoot(this, wave2pos.position, dir2, wave2Damage[index].damage, wave2Damage[index].force, wave2Damage[index].changeHurt, wave2Damage[index].repelValue, false);
                wv1.transform.right = dir;
                wv2.transform.right = dir;
                break;
            default:
                break;
        }
        hasNum[id] -= 2;
    }

    //连续发射冲击波
    private void ContinueShockWave(int id)
    {
        waveTime += Time.deltaTime;
        switch (id)
        {
            case 0:
                if (!isEndWave && ((!isContinuous && waveTime >= wave1aniTime)
                || (isContinuous && waveTime >= wave1loopTime)))
                {
                    waveTime = 0;
                    if (shockWaveTimes > 0)
                    {
                        shockWaveTimes--;
                        isContinuous = true;
                        ShockWave(0);
                    }
                    else
                    {
                        ani.Play("yumenguan_smash_r_end", 0, 0);
                        isEndWave = true;
                    }
                }
                if (isEndWave && waveTime >= waveEndTime)
                {
                    isWave1 = false;
                    isEndWave = false;
                    isContinuous = false;
                    waveTime = 0;
                    EndCurAttackState(true);
                }
                break;
            case 1:
                if (waveTime >= wave2aniTime + waveEndTime)
                {
                    isWave2 = false;
                    waveTime = 0;
                    EndCurAttackState(true);
                }
                break;
            default:
                break;
        }
    }

    //冲击波攻击
    public void ShockWave(int id)
    {
        switch (id)
        {
            case 0:
                if (!isContinuous)
                {
                    isWave1 = true;
                    waveTime = 0;
                    ani.Play("yumenguan_smash_r", 0, 0);
                    Invoke("ToLaunchWave1", launchDelayTime1);
                }
                else
                {
                    waveTime = 0;
                    ani.Play("yumenguan_smash_r_loop", 0, 0);
                    Invoke("ToLaunchWave1", launchDelayTime1loop);
                }
                break;
            case 1:
                waveTime = 0;
                ani.Play("yumenguan_smash_double", 0, 0);
                Invoke("ToLaunchWave2", launchDelayTime2);
                Invoke("ToLaunchWave2", intervalTime[curStateId] + launchDelayTime2);
                Invoke("ToLaunchWave2", intervalTime[curStateId] * 2 + launchDelayTime2);
                isWave2 = true;
                break;
            default:
                break;
        }
    }

    public void ShootEyeLaser()
    {
        curTarget = TargetType.Player;
        CheckTarget();
        laser.endPos = targetCharacter.transform;
        laser.DrawLine();
        laser.gameObject.SetActive(true);
    }

    public void BlocksOut()
    {
        curBlocks = Random.Range(minBlocks, maxBlocks);
        for(int i = curBlocks; i > 0; i--)
        {
            Vector3 pos = new Vector3(transform.position.x + Random.Range(minX, maxX), -2, 0);
            Instantiate(block, pos, new Quaternion(0, 0, 0, 0), null);
        }
        EndCurAttackState(true);
    }

    //攻击
    public override void Attack()
    {
        switch (curAttackType)
        {
            case AttackMethods.move:
                ToMove();
                break;
            case AttackMethods.shockWave1:
                shockWaveTimes = Random.Range(minShockTimes, maxShockTimes);
                ShockWave(0);
                break;
            case AttackMethods.shockWave2:
                ShockWave(1);
                break;
            case AttackMethods.laser:
                ani.Play("yumenguan_eyelight", 0, 0);
                Invoke("ShootEyeLaser", waitTime);
                break;
            case AttackMethods.block:
                ani.Play("yumenguan_smash_double", 0, 0);
                Invoke("BlocksOut", aniTime);
                break;
            default:
                break;
        }
    }

    //根据当前大类随机攻击方式
    public override void RandomAttackType(AttackCategories cate)
    {
        AttackAssignment[] attack = attackConfigurations[(int)cate].attacks;
        switch (cate)
        {
            case AttackCategories.A:
                searchTrigger.enabled = true;
                otherTarget = null;
                otherTarget = searchTrigger.GetMinDisTarget(targetTypes, canHitFly);
                if (otherTarget == null)
                {
                    isAttackWalk = false;
                    curAttackType = AttackMethods.move;
                }
                else
                {
                    curAttackType = RandomAttack(attackConfigurations[0].attacks);
                    if (curAttackType == AttackMethods.move)
                    {
                        isAttackWalk = true;
                    }
                }
                break;
            case AttackCategories.B:
                if (weakEye.activeSelf)
                {
                    curAttackType = RandomAttack(attackConfigurations[1].attacks);
                }
                else
                {
                    curAttackType = AttackMethods.block;
                }
                break;
            default:
                break;
        }
    }

    //在某个大类里按权重随机返回一个攻击类型
    public AttackMethods RandomAttack(AttackAssignment[] attackAssigns)
    {
        int weight = 0;
        AttackMethods last = new AttackMethods();
        foreach(AttackAssignment a in attackAssigns)
        {
            weight += a.weight;
        }
        int result = Random.Range(0, weight);
        foreach(AttackAssignment a in attackAssigns)
        {
            last = a.attack;
            result -= a.weight;
            if (result < 0)
            {
                return a.attack;
            }
        }
        return last;
    }
}