ActionTowerDefense/ActionTowerDefense/Assets/Scripts/Characters/AttackController.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using Sirenix.OdinInspector;
using System.Linq;

//攻击所附带的状态
public enum AttackEffect
{
    //控制
    FloatState = 0,      //漂浮
    BlowUp = 1,          //击飞
    ShotDown = 2,        //击落
    Stun = 3,            //击晕

    //非控制
    Armor = 100,              //穿甲
    ChangeDamage = 101,       //更改攻击力
    Vulnerable = 102,       //易伤
    SustainedInjury = 103,    //持续伤害
    Burn = 104,               //灼烧
    //中毒
    //麻痹
}

[Serializable]
public class AttackInfo
{
    public int damage;
    public Vector3 attackDir;
    public AttackEffect[] attackEffect;

    //漂浮
    [Serializable]
    public struct FloatState
    {
        public float time;          //漂浮时间
        public Vector2 upTime;      //上升最大耗时
        public Vector2 backSpeed;   //往后退的速度
        public Vector2 rotateSpeed; //旋转速度
        public Vector2 height;      //上升高度
    }
    private bool ShowFloatStateValue()
    {
        return attackEffect.Contains(AttackEffect.FloatState);
    }
    [Header("漂浮")]
    [ShowIf("ShowFloatStateValue")]
    public FloatState floatState;

    //击飞
    [Serializable]
    public struct BlowUp
    {
        public Vector3 dir; //击打的方向
        public float force; //击打的力
        public float time;  //落地后眩晕时间
    }
    private bool ShowBlowUpValue()
    {
        return attackEffect.Contains(AttackEffect.BlowUp);
    }
    [Header("击飞")]
    [ShowIf("ShowBlowUpValue")]
    public BlowUp blowUp;

    //击落
    [Serializable]
    public struct ShotDown
    {
        public Vector3 dir; //击打的方向
        public float force; //击打的力
        public float time; //落地后眩晕时间
    }
    private bool ShowShotDownValue()
    {
        return attackEffect.Contains(AttackEffect.ShotDown);
    }
    [Header("击落")]
    [ShowIf("ShowShotDownValue")]
    public ShotDown shotDown;

    //击晕
    [Serializable]
    public struct Stun
    {
        public float time;  //击晕时间
    }
    private bool ShowStunValue()
    {
        return attackEffect.Contains(AttackEffect.Stun);
    }
    [Header("击晕")]
    [ShowIf("ShowStunValue")]
    public Stun stun;

    //穿甲
    [Serializable]
    public struct Armor
    {
        public float rate;  //穿甲率
    }
    private bool ShowArmorValue()
    {
        return attackEffect.Contains(AttackEffect.Armor);
    }
    [Header("穿甲")]
    [ShowIf("ShowArmorValue")]
    public Armor armor;

    //增加和减少攻击力
    [Serializable]
    public struct ChangeDamage
    {
        public float rate;  //增加或减少攻击倍率
    }
    private bool ShowChangeDamageValue()
    {
        return attackEffect.Contains(AttackEffect.ChangeDamage);
    }
    [Header("更改攻击力")]
    [ShowIf("ShowChangeDamageValue")]
    public ChangeDamage changeDamage;

    //持续伤害
    [Serializable]
    public struct SustainedInjury
    {
        public float damage;    //每次造成的伤害数值
    }
    private bool ShowSustainedInjuryValue()
    {
        return attackEffect.Contains(AttackEffect.SustainedInjury);
    }
    [Header("持续伤害")]
    [ShowIf("ShowSustainedInjuryValue")]
    public SustainedInjury sustainedInjury;

    public void CopyTo(AttackInfo ai)
    {
        ai.damage = damage;
        ai.attackDir = attackDir;
        ai.blowUp = blowUp;
        ai.shotDown = shotDown;
        ai.stun = stun;
        ai.armor = armor;
        ai.changeDamage = changeDamage;
        ai.sustainedInjury = sustainedInjury;
    }
}
public class AttackController : MonoBehaviour
{
    //攻击类型
    public enum AttackType
    {
        Melee = 0,      //近战
        Shoot = 1,      //射击
        Special = 2,    //非普攻

        Dash = 3,       //英灵刺客，后面请删掉
    }

    [System.Serializable]
    public struct SpineAniKey
    {
        public string aniName;
        public List<AttackKeyType> keys;
    }

    public enum KeyType
    {
        AttackStart,
        AttackEnd,
    }

    [System.Serializable]
    public struct AttackKeyType
    {
        public int attackMethod;
        public KeyType attackType;
        public string startKeyName;
        public float startKeyTime;
        public KeyType endType;
        public string endKeyName;
        public float endKeyTime;
    }

    [System.Serializable]
    public struct AttackMethod
    {
        [Header("起手式id=0，行军式id>=1")]
        public int id;
        [Header("攻击名称")]
        public string attackName;
        [Header("攻击类型")]
        public AttackType attackType;
        [Header("攻击特效")]
        public GameObject attackEffect;
        [Header("攻击参数")]
        public AttackInfo attackInfo;
        public AttackTrigger attackTrigger;
        [Header("攻击距离")]
        public float attackDistance;
        [ShowIf("needToChange")]
        public float maxAttackDis, minAttackDis;
        public bool needToChange;
        [Header("目标")]
        public List<TargetType> targetTypes;
        public bool canHitFly;
        public int armorPiercing;               //穿甲率
        [Header("远程单位")]
        [ShowIf("attackType",AttackType.Shoot)]
        public GameObject bulletPrefab;         //子弹
        [ShowIf("attackType", AttackType.Shoot)]
        public List<Transform> shootPos;        //子弹发射位置
        [ShowIf("attackType", AttackType.Shoot)]
        public bool shootTrack;                 //是否初始时瞄准目标
        [ShowIf("attackType", AttackType.Shoot)]
        public bool shootAlwaysTrack;           //是否始终追踪
        [Header("特殊攻击")]
        [ShowIf("attackType", AttackType.Special)]
        public GameObject skillPrefab;
        [HideInInspector]
        public SpecialSkills skill;
    }

    private Character owner;

    [Header("所有攻击帧事件及时间")]
    public List<SpineAniKey> attackKeys;
    public List<float> keyTimes;                    //所有的帧事件时间
    [DisplayOnly]
    public float attackTime;                        //攻击剩余时间
    [HideInInspector]
    public float attackKeyCount;                    //攻击进行时间
    [HideInInspector]
    public float nextStartKeyTime, nextEndKeyTime;
    [HideInInspector]
    public int curKeyNum;                           //当前锁定到第几个帧事件

    [Header("攻击类型")]
    public AttackType attackType;

    [Header("攻击参数")]
    [DisplayOnly]
    public int curDamage;
    [HideInInspector]
    public bool canHitFly;
    [HideInInspector]
    public int armorPiercing;                       //穿甲率
    [HideInInspector]
    public AttackInfo attackInfo;
    [HideInInspector]
    public GameObject addAttackEffect;
    [HideInInspector]
    public SpecialSkills skill;
    [HideInInspector]
    public GameObject attackEffect;
    [HideInInspector]
    public Dictionary<string, GameObject> effects;
    [HideInInspector]
    public GameObject effect;
    [HideInInspector]
    public float attackDistance;

    [Header("攻击范围")]
    [HideInInspector]
    public AttackTrigger attackTrigger;
    [HideInInspector]
    public bool isAttackTriggerOn = false;          //当前Attack Trigger是否开启

    [Header("远程单位")]
    [HideInInspector]
    public GameObject bulletPrefab;                 //子弹
    [HideInInspector]
    public List<Transform> shootPos;                //子弹发射位置
    [HideInInspector]
    public bool shootTrack = false;                 //是否初始时瞄准目标
    [HideInInspector]
    public bool shootAlwaysTrack = false;           //是否始终追踪

    [Header("目标")]
    [HideInInspector]
    public List<TargetType> targetTypes;
    [DisplayOnly]
    public List<Character> beTargetCharacter = new List<Character>(); //被哪些锁定
    //public float getDistanceOffset = 0f;

    [Header("攻击模式")]
    public AttackMethod[] attackMethod;
    [DisplayOnly]
    public AttackMethod curAttackMethod;

    public void Init()
    {
        owner = GetComponent<Character>();
        if (attackMethod.Length > 0)
        {
            attackInfo = attackMethod[0].attackInfo;
            curDamage = attackInfo.damage;
        }
        effects = new Dictionary<string, GameObject>();
        for (int i = 0; i < attackMethod.Length; i++)
        {
            if (attackMethod[i].needToChange)
            {
                attackMethod[i].attackDistance = UnityEngine.Random.Range(attackMethod[i].minAttackDis, 
                    attackMethod[i].maxAttackDis);
            }
        }
    }

    private void OnEnable()
    {
        if (attackTrigger != null)
        {
            attackTrigger.gameObject.SetActive(false);
        }
    }

    public void ChooseAttack(int id)
    {
        //默认起手式只使用一次，id=0为起手式
        curAttackMethod = attackMethod[id];
        attackType = curAttackMethod.attackType;
        canHitFly = curAttackMethod.canHitFly;
        armorPiercing = curAttackMethod.armorPiercing;
        attackInfo = curAttackMethod.attackInfo;
        curDamage = attackInfo.damage;
        attackTrigger = curAttackMethod.attackTrigger;
        bulletPrefab = curAttackMethod.bulletPrefab;
        shootPos = curAttackMethod.shootPos;
        shootTrack = curAttackMethod.shootTrack;
        shootAlwaysTrack = curAttackMethod.shootAlwaysTrack;
        targetTypes = curAttackMethod.targetTypes;
        if (attackType == AttackType.Special && skill == null)
        {
            curAttackMethod.skill= Instantiate(curAttackMethod.skillPrefab, owner.bodyTrans.position, 
                new Quaternion(0, 0, 0, 0), owner.bodyTrans).GetComponent<SpecialSkills>();
            skill = curAttackMethod.skill;
            skill.owner = owner;
        }
        attackEffect = curAttackMethod.attackEffect;
        attackDistance = curAttackMethod.attackDistance;
    }

    public void SetNextKeyTimes()
    {
        if (curKeyNum < keyTimes.Count)
        {
            nextStartKeyTime = keyTimes[curKeyNum];
            nextEndKeyTime = keyTimes[curKeyNum + 1];
            curKeyNum += 2;
        }
    }

    public virtual void Attack_summon()
    {
        owner.ani.Play("attack_summon", 0, 0);
        if (attackType == AttackType.Shoot)
        {
            attackTrigger.isShoot = true;
            attackTrigger.type = AttackTrigger.attackType.summon;
        }
        attackTime = owner.totalAttack_summonTime;
        attackKeyCount = 0;
        keyTimes = new List<float>();
        foreach (SpineAniKey sak in attackKeys)
        {
            if (sak.aniName == "attack_summon")
            {
                foreach (AttackKeyType akt in sak.keys)
                {
                    keyTimes.Add(akt.startKeyTime);
                    keyTimes.Add(akt.endKeyTime);
                }
                break;
            }
        }
        curKeyNum = 0;
        SetNextKeyTimes();

        switch (attackType)
        {
            case AttackType.Melee:
                attackTrigger.attackInfo = attackInfo;
                break;
            default:
                break;
        }
        owner.ChangeState(CharacterState.Attack);
    }

    public virtual void Attack_march(int id)
    {
        if (attackEffect != null)
        {
            if (effects.ContainsKey(attackEffect.name))
            {
                effect = effects[attackEffect.name];
                effect.SetActive(true);
            }
            else
            {
                effects[attackEffect.name] = Instantiate(attackEffect, owner.bodyTrans);
                effect = effects[attackEffect.name];
                effect.SetActive(true);
            }
        }
        Vector3 leftDir = owner.GetMoveDir();
        if (leftDir.x > 0.3f)
        {
            if (owner.bodyTrans.localScale.x > 0)
            {
                owner.Turn();
            }
        }
        else if (leftDir.x < -0.3f)
        {
            if (owner.bodyTrans.localScale.x < 0)
            {
                owner.Turn();
            }
        }
        ChooseAttack(id);
        owner.ani.Play("attack_march", 0, 0);
        if (attackType == AttackType.Shoot)
        {
            attackTrigger.isShoot = true;
            attackTrigger.type = AttackTrigger.attackType.march;
        }
        if (attackType == AttackType.Special)
        {
            skill.Attack();
        }

        attackTime = owner.totalAttack_marchTime;
        attackKeyCount = 0;
        keyTimes = new List<float>();
        foreach (SpineAniKey sak in attackKeys)
        {
            if (sak.aniName == "attack_march")
            {
                foreach (AttackKeyType akt in sak.keys)
                {
                    keyTimes.Add(akt.startKeyTime);
                    keyTimes.Add(akt.endKeyTime);
                    break;
                }
            }
        }
        curKeyNum = 0;
        SetNextKeyTimes();
        attackTrigger.attackInfo = attackInfo;
        owner.ChangeState(CharacterState.Attack);
    }

    public virtual void AttackShootEvent(int attackId, int shootId)
    {
        GameObject bulletObj = PoolManager.Instantiate(bulletPrefab);
        Bullet bullet = bulletObj.GetComponent<Bullet>();
        Vector3 attackDir = attackInfo.attackDir.normalized;
        if (owner.bodyTrans.localScale.x < 0)
        {
            attackDir.x = -attackDir.x;
        }
        if (attackId == 1 && owner.Attack_summonShootCanTransmit)
        {
            bullet.canTransmit = true;
        }
        bullet.BeShoot(owner, shootPos[shootId].position, attackDir, shootTrack, 
            shootAlwaysTrack, owner.attackTarget ? owner.attackTarget : null);
    }

    public void JudgeTriggerOnOff()
    {
        attackTime -= Time.deltaTime;
        attackKeyCount += Time.deltaTime;
        if (!isAttackTriggerOn && attackKeyCount >= nextStartKeyTime && attackKeyCount <= nextEndKeyTime)
        {
            isAttackTriggerOn = true;
            attackTrigger.gameObject.SetActive(true);
        }
        else if (isAttackTriggerOn && attackKeyCount >= nextEndKeyTime)
        {
            isAttackTriggerOn = false;
            attackTrigger.gameObject.SetActive(false);
            SetNextKeyTimes();
        }
    }
}