XiuXianGame/Assets/Scripts/GameLogic/Combat/Hero/CombatHeroSkillControl.cs

using System.Collections.Generic;
using Common.Utility.CombatEvent;
using Excel2Json;
using Fort23.Core;
using Fort23.Mono;
using Fort23.UTool;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.CombatType;
using GameLogic.Combat.Hero.Turntable;
using GameLogic.Combat.Skill;
using GameLogic.Hero;
using GameLogic.Player;
using UnityEngine;


namespace GameLogic.Combat.Hero
{
    public class CombatHeroSkillControl : CombatHeroSkillControlBasic
    {
        /// <summary>
        /// 技能指令，0表示没有技能；
        /// </summary>
        private BetterList<SkillBasic> SkillCommands = new BetterList<SkillBasic>();

        public SkillBasic[] GetSkillQueue()
        {
            return SkillCommands.ToArray(true);
        }

        public int useSkillCount
        {
            get { return SkillCommands.size; }
        }

        /// <summary>
        /// 当前能使用的技能
        /// </summary>
        public SkillBasic currUseSkill;


        /// <summary>
        /// 大道技能
        /// </summary>
        public SkillBasic taoismSkillBasic;
        // public float NormalAttSpeedScale;


        // public BetterList<SkillSlots>
        // public BetterList<SkillBasic> _skillQueue = new BetterList<SkillBasic>();
        // public BetterList<SkillBasic> _removeSkillBasic = new BetterList<SkillBasic>();

        // private float _removeTime;

        public SkillTurntable SkillTurntable;


        protected override async CTask ProInit()
        {
            SkillTurntable = new SkillTurntable();
            SkillTurntable.Init(10, this, _combatHeroEntity);
            if (_combatHeroEntity.IsEnemy)
            {
                await SetNewSkill(_combatHeroEntity.CurrCombatHeroInfo.unLockSkills.ToArray());
            }
            else
            {
                await SetNewSkill(PlayerManager.Instance.GongFaControl.allUseSkill);
            }

            InitTaoismSkill(_combatHeroEntity.CurrCombatHeroInfo.TaoismSkillId);
        }

        public void InitTaoismSkill(int TaoismSkillId)
        {
            if (taoismSkillBasic != null)
            {
                taoismSkillBasic.Dispose();
            }

            int id = TaoismSkillId;
            if (id != 0)
            {
                SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(id);

                SkillBasic skillBasic = SkillScriptManager.Instance.CreateSkillBasic(skillConfig);
                if (skillBasic == null)
                {
                    return;
                }

                SkillInfo skillInfo = new SkillInfo(id, 1);
                skillBasic.InitSkillConfig(_combatHeroEntity, skillInfo);
                taoismSkillBasic = skillBasic;
                // _combatHeroEntity.CurrCombatHeroInfo.SetSkillAttSpeed(skillConfig.addcd+SkillTurntable.skillAddSkillCd);
                TaoismSkillAlterEventData taoismSkillAlterEventData = TaoismSkillAlterEventData.Create();
                taoismSkillAlterEventData.CombatHeroEntity = _combatHeroEntity;
                CombatEventManager.Instance.Dispatch(CombatEventType.TaoismSkillAlter, taoismSkillAlterEventData);
            }

            if (!_combatHeroEntity.IsEnemy)
            {
                float cd = _combatHeroEntity.CurrCombatHeroInfo.powerUpConfig.MaxActiveGongfaNum *
                    PlayerManager.Instance.gameConstantConfig.BasicCDperSkill / 1000;
                _combatHeroEntity.CurrCombatHeroInfo.SetSkillAttSpeed(
                    cd + SkillTurntable.skillAddSkillCd);
            }
            else
            {
                float cd = (SkillTurntable.skillCount * PlayerManager.Instance.gameConstantConfig.BasicCDperSkill) /
                           1000;
                _combatHeroEntity.CurrCombatHeroInfo.SetSkillAttSpeed(
                    cd + SkillTurntable.skillAddSkillCd);
            }
        }

        public override async CTask SetNewSkill(SkillInfo[] allSkill)
        {
            await SkillTurntable.SetNewSkill(allSkill);
        }

        public SkillBasic GetSkillQueueForIndex(int index)
        {
            return SkillTurntable.GetSkillQueueForIndex(index);
        }


        public void AddCommandSkill(SkillBasic skill)
        {
            if (_combatHeroEntity.isZhanZhuang)
            {
                return;
            }

            skill.DelayUseSkillCd = 0.5f;

            SkillCommands.Add(skill);
        }

        public void RemoveCommandSkill(SkillBasic skill)
        {
            SkillCommands.Remove(skill);
        }

        public void ClearCommandSkill()
        {
            SkillCommands.Clear();
        }

        public void UseSkillFinish(SkillBasic skill)
        {
            if (skill == null)
            {
                return;
            }

            SkillTurntable.UseSkillFinish(skill);
        }

        public void UseSkill(SkillBasic skill)
        {
            CombatUseSkillEventData combatUseSkillEventData = CombatUseSkillEventData.Create();
            combatUseSkillEventData.useSkill = skill;
            CombatEventManager.Instance.Dispatch(CombatEventType.UseSkill, combatUseSkillEventData);
            currUseSkill = skill;
            skill.UseSkill();
        }

        /// <summary>
        /// 判断是否有技能可释放
        /// </summary>
        /// <returns></returns>
        public SkillBasic CanReleaseSkill()
        {
            if (_combatHeroEntity.IsControl())
            {
                return null;
            }

            if (!_combatHeroEntity.IsEnemy && _combatHeroEntity.CombatAIBasic.currFocusTarget is BannerHero)
            {
                return null;
            }

            // SkillBasic skillBasic = null;
            for (int i = 0; i < SkillCommands.size; i++)
            {
               
                if (!SkillCommands[i].IsCanUse())
                {
                    continue;
                }

                return SkillCommands[i];
            }

            return null;
        }


        protected override void ProUpdate(float t)
        {
            if (CombatController.currActiveCombat.IsFightState)
            {
                float speed = _combatHeroEntity.CurrCombatHeroInfo.GetAttSpeed;
                float angle = 360 / (1.0f / speed);
                SkillTurntable.Update(t, angle * t);
            }

            if (taoismSkillBasic != null)
            {
                taoismSkillBasic.CombatUpdate(t);
            }
        }


        public virtual void Dispose()
        {
            _combatHeroEntity = null;

            currUseSkill = null;
        }

        public virtual void ProDormancyObj()
        {
            for (int i = 0; i < allSkill.size; i++)
            {
                SkillBasic skillBasic = allSkill[i];
                CObjectPool.Instance.Recycle(skillBasic);
            }

            allSkill.Clear();
            SkillCommands.Clear();
        }
    }
}