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.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 int useSkillCount
        {
            get { return SkillCommands.size; }
        }

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


        // public float NormalAttSpeedScale;


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


        protected override async CTask ProInit()
        {
            if (_combatHeroEntity.IsEnemy)
            {
                await SetNewSkill(_combatHeroEntity.CurrCombatHeroInfo.unLockSkills);
            }
            else
            {
                await SetNewSkill(PlayerManager.Instance.allUseSkill);
            }
            // 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;
            //         }
            //
            //         skillBasic.index = i;
            //         _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();
            // for (int i = 0; i < _skillQueue.Count; i++)
            // {
            //     SkillBasic skillBasic = _skillQueue[i];
            //     skillBasic.ActiveSkill();
            //     skillBasic.angle -= i * 36;
            // }
            //
            // CombatEventManager.Instance.Dispatch(CombatEventType.ExercisesAlter, null);
        }

        public override async CTask SetNewSkill(List<SkillInfo> allSkill)
        {
            CTaskAwaitBuffer cTaskAwaitBuffer = new CTaskAwaitBuffer();
            _skillQueue.Clear();
            // SkillInfo[] skillId = allSkill;
            int indexCount = 0;
            if (allSkill != null)
            {
                for (int i = 0; i < allSkill.Count; i++)
                {
                    SkillInfo skillInfo = allSkill[i];
                    if (skillInfo == null)
                    {
                        continue;
                    }

                    SkillConfig skillConfig = skillInfo.skillConfig;
                    SkillBasic skillBasic = AddSkill(skillConfig);
                    if (skillBasic == null)
                    {
                        continue;
                    }

                    skillBasic.index = indexCount;
                    indexCount++;
                    skillBasic.angle = i * 36;
                    _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();
            for (int i = 0; i < _skillQueue.Count; i++)
            {
                SkillBasic skillBasic = _skillQueue[i];
                skillBasic.ActiveSkill();
            }

            CombatEventManager.Instance.Dispatch(CombatEventType.ExercisesAlter, null);
        }

        public SkillBasic GetSkillQueueForIndex(int index)
        {
            if (index < 0 || index >= _skillQueue.Count)
            {
                return null;
            }

            return _skillQueue[index];
        }

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


        protected override void ProUpdate(float t)
        {
            if (CombatController.currActiveCombat.IsFightState)
            {
                float speed = _combatHeroEntity.CurrCombatHeroInfo.GetAttSpeed;
                for (int i = 0; i < _skillQueue.Count; i++)
                {
                    SkillBasic skillBasic = _skillQueue[i];
                    skillBasic.angle += 1 * speed;
                    if (skillBasic.SelfSkillConfig.SkillType == 2)
                    {
                        continue;
                    }

                    float jd = skillBasic.angle % 360;
                    if (jd > skillBasic.useAngle && skillBasic.angle > skillBasic.lasetAngle)
                    {
                        skillBasic.lasetAngle += 360;
                        // if (allMagic > 30)
                        // {
                        //     allMagic -= 30;
                        //     skillBasic.useCount++;
                        //     if (!isKuoLiQuanKai)
                        //     {
                        //         addChongNeng += 10;
                        //         if (addChongNeng >= 150)
                        //         {
                        //             isKuoLiQuanKai = true;
                        //         }
                        //     }


                        if (skillBasic.wuXingType.HasFlag(WuXingType.Gold))
                        {
                            int odds = Random.Range(0, 100);
                            if (odds < 50)
                            {
                                _combatHeroEntity.CurrCombatHeroInfo.Water_Injury -= Random.Range(2, 5);
                                if (_combatHeroEntity.CurrCombatHeroInfo.Water_Injury < 0)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Water_Injury = 0;
                                }
                            }
                        }

                        if (skillBasic.wuXingType.HasFlag(WuXingType.Wood))
                        {
                            int odds = Random.Range(0, 100);
                            if (odds < 50)
                            {
                                _combatHeroEntity.CurrCombatHeroInfo.Fire_Injury -= Random.Range(2, 5);
                                if (_combatHeroEntity.CurrCombatHeroInfo.Fire_Injury < 0)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Fire_Injury = 0;
                                }
                            }
                        }

                        if (skillBasic.wuXingType.HasFlag(WuXingType.Water))
                        {
                            int odds = Random.Range(0, 100);
                            if (odds < 50)
                            {
                                _combatHeroEntity.CurrCombatHeroInfo.Wood_Injury -= Random.Range(2, 5);
                                if (_combatHeroEntity.CurrCombatHeroInfo.Wood_Injury < 0)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Wood_Injury = 0;
                                }
                            }
                        }

                        if (skillBasic.wuXingType.HasFlag(WuXingType.Fire))
                        {
                            int odds = Random.Range(0, 100);
                            if (odds < 50)
                            {
                                _combatHeroEntity.CurrCombatHeroInfo.Earth_Injury -= Random.Range(2, 5);
                                if (_combatHeroEntity.CurrCombatHeroInfo.Earth_Injury < 0)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Earth_Injury = 0;
                                }
                            }
                        }

                        if (skillBasic.wuXingType.HasFlag(WuXingType.Earth))
                        {
                            int odds = Random.Range(0, 100);
                            if (odds < 50)
                            {
                                _combatHeroEntity.CurrCombatHeroInfo.Metal_Injury -= Random.Range(2, 5);
                                if (_combatHeroEntity.CurrCombatHeroInfo.Metal_Injury < 0)
                                {
                                    _combatHeroEntity.CurrCombatHeroInfo.Metal_Injury = 0;
                                }
                            }
                        }

                        AddCommandSkill(skillBasic);
                        AddUseGongFaEventData addUseGongFaEventData = AddUseGongFaEventData.Create();
                        addUseGongFaEventData.SkillBasic = skillBasic;
                        CombatEventManager.Instance.Dispatch(CombatEventType.AddUseGongFa, addUseGongFaEventData);
                        // Debug.Log("旋转一圈");
                        // }
                    }
                }
            }

            // if (isKuoLiQuanKai)
            // {
            //     qiankaiTime += t;
            //     if (qiankaiTime > 3)
            //     {
            //         isKuoLiQuanKai = false;
            //         qiankaiTime = 0;
            //         addChongNeng = 0;
            //     }
            // }

            // allMagic += t * addMaicSpeed;
            // if (allMagic > 500)
            // {
            //     allMagic = 500;
            // }

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