XiuXianGame/Assets/Scripts/GameLogic/Combat/Hero/Turntable/SkillTurntable.cs

using Common.Utility.CombatEvent;
using Excel2Json;
using Fort23.Core;
using GameLogic.Combat.Skill;
using GameLogic.Hero;
using GameLogic.Player;
using UnityEngine;

namespace GameLogic.Combat.Hero.Turntable
{
    public class SkillTurntable
    {
        public BetterList<SkillSlots> allSkillSlots = new BetterList<SkillSlots>();

        protected CombatHeroSkillControl combatHeroSkillControl;
        protected CombatHeroEntity _combatHeroEntity;

        public BetterList<SkillBasic> _removeSkillBasic = new BetterList<SkillBasic>();
        private float _removeTime;

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

        public void Init(int count, CombatHeroSkillControl combatHeroSkillControl, CombatHeroEntity combatHeroEntity)
        {
            this.combatHeroSkillControl = combatHeroSkillControl;
            _combatHeroEntity = combatHeroEntity;
            for (int i = 0; i < count; i++)
            {
                SkillSlots skillSlots = new SkillSlots();
                skillSlots.Init(i, this);
                allSkillSlots.Add(skillSlots);
            }
        }

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

            return allSkillSlots[index].SkillBasic;
        }

        public void UseSkillFinish(SkillBasic skillBasic)
        {
            if (currUseFinishSkill.Contains(skillBasic))
            {
                return;
            }


            currUseFinishSkill.Add(skillBasic);
            UseSkillFinishEventData useSkillFinishEventData = UseSkillFinishEventData.Create();
            useSkillFinishEventData.SkillBasic = skillBasic;
            CombatEventManager.Instance.Dispatch(CombatEventType.UseSkillFinish, useSkillFinishEventData);
        }

        public async CTask SetNewSkill(SkillInfo[] allSkill)
        {
            currUseFinishSkill.Clear();
            CTaskAwaitBuffer cTaskAwaitBuffer = new CTaskAwaitBuffer();
            for (int i = 0; i < allSkillSlots.Count; i++)
            {
                SkillBasic skillBasic = allSkillSlots[i].SkillBasic;
                allSkillSlots[i].Replace();
                if (skillBasic != null)
                {
                    _removeSkillBasic.Add(skillBasic);
                }
            }


            _removeTime = 0;

            if (allSkill != null)
            {
                for (int i = 0; i < allSkill.Length; i++)
                {
                    SkillInfo skillInfo = allSkill[i];
                    if (skillInfo == null)
                    {
                        continue;
                    }

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


                    SetSkill(i, 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 < allSkillSlots.Count; i++)
            {
                SkillSlots skillBasic = allSkillSlots[i];
                skillBasic.ActiveSkill();
            }

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

        public void SetSkill(int index, SkillBasic skillBasic)
        {
            allSkillSlots[index].SetSkill(skillBasic);
        }

        public void TriggerSlots(SkillSlots skillSlots, int triggerType)
        {
            SkillBasic skillBasic = skillSlots.SkillBasic;
            if (skillBasic == null)
            {
                for (int i = 0; i < currUseFinishSkill.Count; i++)
                {
                    SkillBasic dengDaiSkill = currUseFinishSkill[i];
                    bool isOk = false;
                    switch (dengDaiSkill.wuXingType)
                    {
                        case WuXingType.Gold:
                            if (triggerType == 0)
                            {
                                isOk = true;
                            }

                            break;
                        case WuXingType.Water:
                            if (triggerType == 1)
                            {
                                isOk = true;
                            }

                            break;
                        case WuXingType.Wood:
                            if (triggerType == 2)
                            {
                                isOk = true;
                            }

                            break;
                        case WuXingType.Fire:
                            if (triggerType == 3)
                            {
                                isOk = true;
                            }

                            break;
                        case WuXingType.Earth:
                            if (triggerType == 4)
                            {
                                isOk = true;
                            }

                            break;
                    }

                    if (isOk)
                    {
                        skillSlots.SetSkill(dengDaiSkill);
                        currUseFinishSkill.RemoveAt(i);
                        FillInSkillSlotsEventData fillInSkillSlotsEventData = FillInSkillSlotsEventData.Create();
                        fillInSkillSlotsEventData.SkillBasic = dengDaiSkill;
                        fillInSkillSlotsEventData.SkillSlots = skillSlots;
                        CombatEventManager.Instance.Dispatch(CombatEventType.FillInSkillSlots,fillInSkillSlotsEventData);
                        return;
                    }
                }

                return;
            }

            if (skillBasic.SelfSkillConfig.SkillType != 1)
            {
                return;
            }

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

            skillSlots.SetSkill(null);
            skillSlots.useCount++;
            combatHeroSkillControl.AddCommandSkill(skillBasic);
            AddUseGongFaEventData addUseGongFaEventData = AddUseGongFaEventData.Create();
            addUseGongFaEventData.SkillBasic = skillBasic;
            addUseGongFaEventData.SkillSlots = skillSlots;
            CombatEventManager.Instance.Dispatch(CombatEventType.AddUseGongFa, addUseGongFaEventData);
        }


        public void Update(float t, float angle)
        {
            if (_removeSkillBasic.Count > 0)
            {
                _removeTime += t;
                if (_removeTime > 10)
                {
                    for (int i = 0; i < _removeSkillBasic.Count; i++)
                    {
                        _removeSkillBasic[i].Dispose();
                    }

                    _removeSkillBasic.Clear();
                }
            }

            for (int i = 0; i < allSkillSlots.Count; i++)
            {
                SkillSlots skillSlots = allSkillSlots[i];
                skillSlots.AddAngle(angle);
            }
        }
    }
}