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

using System;
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.Skill;
using UnityEngine;

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

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




        public float NormalAttSpeedScale;

  

        private BetterList<SkillBasic> _skillQueue = new BetterList<SkillBasic>();

        // private BetterList<SkillBasic> _skillQueue = new BetterList<SkillBasic>();
        private int _currUseQueueIndex = 0;

        protected override async CTask ProInit()
        {
            NormalAttSpeedScale = 2;
            CTaskAwaitBuffer cTaskAwaitBuffer = new CTaskAwaitBuffer();

            List<int> skillId = _combatHeroEntity.CurrCombatHeroInfo.unLockSkills;
            if (skillId != null)
            {
                for (int i = 0; i < skillId.Count; i++)
                {
                    SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(skillId[i]);
                    SkillBasic skillBasic = AddSkill(skillConfig);
                    if (skillBasic == null)
                    {
                        continue;
                    }

                    _skillQueue.Add(skillBasic);
                    if (!string.IsNullOrEmpty(skillConfig.scriptName))
                    {
                        cTaskAwaitBuffer.AddTask(AssetBundleLoadManager.Instance.LoadAssetAsyncTask<TextAsset>(
                            skillConfig.timelineName + ".txt",
                            delegate(AssetHandle handle)
                            {
                                if (handle != null)
                                {
                                    TextAsset textAsset = handle.AssetObject<TextAsset>();
                                    TimeLienData timeLienData = JsonManager.FromJson<TimeLienData>(textAsset.text);
                                    timeLienData.DeserializeData();
                                    handle.Release();
                                    _combatHeroEntity.combatHeroTimeLineControl.AddTimeLienData(timeLienData);
                                }
                            }));
                    }
                }
            }

            await cTaskAwaitBuffer.WaitAll();
        }


        public void UpdateSkill(List<int> skillIDs)
        {
            for (int i = 0; i < skillIDs.Count; i++)
            {
                SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(skillIDs[i]);
                // SkillConfig skillConfig = skillIDs[i];
                SkillBasic skillBasic = GetSkillBasic(skillConfig.IDGroup);
                if (skillBasic == null)
                {
                    AddSkill(skillConfig);
                }
                else
                {
                    skillBasic.InitSkillConfig(skillConfig);
                    skillBasic.InitSkill(_combatHeroEntity);
                }
            }
        }


        public void AddCommandSkill(SkillBasic skill)
        {
            SkillCommands.Add(skill);
        }

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

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

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

            if (skill.SelfSkillConfig.SkillType == 1)
            {
                SetNormalAttCd();
            }
        }

        /// <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++)
            {
                skillBasic = SkillCommands[i];
                break;
            }

            return skillBasic;
        }

        public void StartPolling()
        {
            for (int i = 0; i < _skillQueue.size; i++)
            {
                SkillBasic skillBasic = allSkill[i];
                skillBasic.PollingInitBefore(_skillQueue);
            }

            for (int i = 0; i < _skillQueue.size; i++)
            {
                SkillBasic skillBasic = allSkill[i];
                skillBasic.PollingInit(_skillQueue);
            }

            _currUseQueueIndex = 0;
        }

        protected override void ProUpdate(float t)
        {
            if (currUseSkill == null && SkillCommands.Count <= 0)
            {
                while (_currUseQueueIndex < _skillQueue.Count && SkillCommands.Count <= 0)
                {
                    SkillBasic skillBasic = _skillQueue[_currUseQueueIndex];
                    if (skillBasic.SelfSkillConfig.SkillType == 1)
                    {
                        if (skillBasic.IsCanUse())
                        {
                            AddCommandSkill(skillBasic);
                        }
                    }

                    _currUseQueueIndex++;
                }
            }

            if (_currUseQueueIndex >= _skillQueue.Count)
            {
                StartPolling();
            }
        }


        public void SetNormalAttCd()
        {
            // if (NormalAttack == null)
            // {
            //     return;
            // }
            //
            // string timeLineName = "attack";
            // float maxTime = _combatHeroEntity.combatHeroTimeLineControl.TimeLineData.GetTimeLineEventLogicGroupForTime(
            //     timeLineName, null);
            // float attackSpeed = _combatHeroEntity.CurrCombatHeroInfo.attSpeed.Value;
            // float cd = 1.0f / attackSpeed;
            // float attSpeed = (float)1;
            // if (cd < maxTime)
            // {
            //     attSpeed = maxTime / cd;
            // }
            //
            // NormalAttSpeedScale = attSpeed;
            // // Debug.Log(NormalAttSpeedScale);
            // NormalAttCd = cd;
        }

        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();
        }
    }
}