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

using Common.Utility.CombatEvent;
using GameLogic.Combat.Buff;
using GameLogic.Combat.Skill;
using GameLogic.Player;

namespace GameLogic.Combat.Hero.Turntable
{
    public class SkillSlots
    {
        public SkillBasic SkillBasic;
        public int index;
        public float angle;

        public int useCount;

        public int useTriggerType;

        private int triggerType = -1;

        /// <summary>
        /// 触发的次数
        /// </summary>
        public int triggerCount;

        // public int useCount;
        /// <summary>
        /// 金、水、木、火、土
        /// </summary>
        private int[] triggerAngle = new[] { 0, 72, 144, 216, 288 };

        private SkillTurntable skillTurntable;
        private int currTriggerTypeIndex;

        public void Init(int index, SkillTurntable skillTurntable)
        {
            this.index = index;
            angle = index * 36;
            this.skillTurntable = skillTurntable;
        }

        public void SetSkill(SkillBasic SkillBasic)
        {
            triggerCount = 0;
            this.SkillBasic = SkillBasic;
            if (SkillBasic != null)
            {
                SkillBasic.index = index;
                SkillBasic.AddToSkillSlots();
            }

            if (SkillBasic != null)
            {
                switch (SkillBasic.wuXingType)
                {
                    case WuXingType.Gold:
                        currTriggerTypeIndex = 0;

                        break;
                    case WuXingType.Water:
                        currTriggerTypeIndex = 1;

                        break;
                    case WuXingType.Wood:
                        currTriggerTypeIndex = 2;

                        break;
                    case WuXingType.Fire:
                        currTriggerTypeIndex = 3;

                        break;
                    case WuXingType.Earth:
                        currTriggerTypeIndex = 4;
                        break;
                }
            }


            SkillSlotsAlterEventData skillSlotsAlterEventData = SkillSlotsAlterEventData.Create();
            skillSlotsAlterEventData.SkillSlots = this;
            skillSlotsAlterEventData.SkillBasic = SkillBasic;
            CombatEventManager.Instance.Dispatch(CombatEventType.SkillSlotsAlter, skillSlotsAlterEventData);
        }

        public void AddAngle(float addAngle)
        {
            int c = (int)(addAngle / 2);
            float d = addAngle % 2;
            for (int i = 0; i < c; i++)
            {
                Angle(2);
            }

            Angle(d);
        }

        public float GetFinishBl()
        {
            if (!SkillBasic.isActive)
            {
                return 0;
            }

            float v = angle % 360;
            int targetAngle = triggerAngle[currTriggerTypeIndex];
            float jd = v;
            if (targetAngle == 0)
            {
                targetAngle = 360;
            }

            float finishAngle = 0;
            if (jd < targetAngle)
            {
                finishAngle = 360 - (targetAngle - jd);
            }
            else
            {
                finishAngle = (jd - targetAngle);
            }

            float allT = SkillBasic.SelfSkillConfig.cd * 360;
            return (finishAngle + triggerCount * 360) / allT;
        }

        public float GetFinishAngle()
        {
            if (SkillBasic == null || !SkillBasic.isActive)
            {
                return int.MaxValue;
            }

            float v = angle % 360;
            int targetAngle = triggerAngle[currTriggerTypeIndex];
            float jd = v;
            if (targetAngle == 0)
            {
                targetAngle = 360;
            }

            float finishAngle = 0;
            if (jd < targetAngle)
            {
                finishAngle = 360 - (targetAngle - jd);
            }
            else
            {
                finishAngle = (jd - targetAngle);
            }

            float allT = SkillBasic.SelfSkillConfig.cd * 360;
            return allT - (finishAngle + triggerCount * 360);
        }

        private void Angle(float addAngle)
        {
            angle += addAngle;
            float v = angle % 360;
            for (int i = 0; i < triggerAngle.Length; i++)
            {
                if (triggerType == i)
                {
                    continue;
                }

                float jd = v;
                int a = triggerAngle[i];
                int max = a + 2;
                int min = a - 2;
                if (min < 0)
                {
                    jd -= 360;
                }

                if (jd <= max && jd >= min)
                {
                    triggerType = i;
                    Trigger(triggerType);
                    break;
                }
            }
        }

        private void Trigger(int triggerType)
        {
            switch (triggerType)
            {
                case 0:
                    b_1019 b1019 = skillTurntable.CombatHeroEntity.BuffControl.GetBuffBasicForType<b_1019>();
                    if (b1019 != null)
                    {
                        return;
                    }

                    break;
                case 1:
                    b_1021 b_1021 = skillTurntable.CombatHeroEntity.BuffControl.GetBuffBasicForType<b_1021>();
                    if (b_1021 != null)
                    {
                        return;
                    }

                    break;
                case 2:
                    b_1020 b1020 = skillTurntable.CombatHeroEntity.BuffControl.GetBuffBasicForType<b_1020>();
                    if (b1020 != null)
                    {
                        return;
                    }

                    break;
                case 3:
                    b_1022 b_1022 = skillTurntable.CombatHeroEntity.BuffControl.GetBuffBasicForType<b_1022>();
                    if (b_1022 != null)
                    {
                        return;
                    }

                    break;
                case 4:
                    b_1023 b_1023 = skillTurntable.CombatHeroEntity.BuffControl.GetBuffBasicForType<b_1023>();
                    if (b_1023 != null)
                    {
                        return;
                    }

                    break;
            }

            if (SkillBasic != null)
            {
                if (!SkillBasic.IsCanTriggerSkillSlots())
                {
                    return;
                }


                switch (SkillBasic.wuXingType)
                {
                    case WuXingType.Gold:
                        if (triggerType != 0)
                        {
                            return;
                        }

                        break;
                    case WuXingType.Water:
                        if (triggerType != 1)
                        {
                            return;
                        }

                        break;
                    case WuXingType.Wood:
                        if (triggerType != 2)
                        {
                            return;
                        }

                        break;
                    case WuXingType.Fire:
                        if (triggerType != 3)
                        {
                            return;
                        }

                        break;
                    case WuXingType.Earth:
                        if (triggerType != 4)
                        {
                            return;
                        }

                        break;
                }

                triggerCount++;
                if (triggerCount < SkillBasic.SelfSkillConfig.cd)
                {
                    return;
                }

                triggerCount = 0;
                TriggerSkillSlotsEventData triggerSkillSlotsEventData = TriggerSkillSlotsEventData.Create();
                triggerSkillSlotsEventData.SkillBasic = SkillBasic;
                triggerSkillSlotsEventData.SkillSlots = this;
                triggerSkillSlotsEventData.triggerType = triggerType;
                CombatEventManager.Instance.Dispatch(CombatEventType.TriggerSkillSlots, triggerSkillSlotsEventData,
                    false);
                if (triggerSkillSlotsEventData.isNotUseSkill)
                {
                    triggerSkillSlotsEventData.Recycle();
                    return;
                }

                triggerSkillSlotsEventData.Recycle();
            }

            useTriggerType = triggerType;
            skillTurntable.TriggerSlots(this, triggerType);
        }

        public void Replace()
        {
            if (SkillBasic != null)
            {
                SkillBasic.Replace();
            }

            SkillBasic = null;
        }

        public void ActiveSkill()
        {
            if (SkillBasic != null)
            {
                SkillBasic.ActiveSkill();
            }
        }
    }
}