修改bug

Assets/Scripts/GameLogic/Combat/CombatEvent/CombatEventType.cs

@@ -73,5 +73,9 @@
         /// 移除buff
         /// </summary>
         RemoveBuff,
+        /// <summary>
+        /// 技能槽位改变
+        /// </summary>
+        SkillSlotsAlter,
     }
 }

Assets/Scripts/GameLogic/Combat/CombatEvent/SkillSlotsAlterEventData.cs

@@ -0,0 +1,14 @@
+using Core.Utility.Event;
+using GameLogic.Combat.Hero.Turntable;
+
+namespace Common.Utility.CombatEvent
+{
+    public class SkillSlotsAlterEventData: EventDataBasic<SkillSlotsAlterEventData>
+    {
+        public SkillSlots SkillSlots;
+        protected override void ProDispose()
+        {
+            SkillSlots = null;
+        }
+    }
+}

Assets/Scripts/GameLogic/Combat/CombatEvent/SkillSlotsAlterEventData.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 95b27224104a458c86e06ca91dfc5a0a
+timeCreated: 1744351362

Assets/Scripts/GameLogic/Combat/CombatTool/CombatCalculateTool.cs

@@ -23,9 +23,9 @@ namespace GameLogic.Combat.CombatTool
         {
             WuXingType.Water, // 金生水
             WuXingType.Fire, // 木生火
-            WuXingType.Gold, // 水生金
+            WuXingType.Wood, // 水生木
             WuXingType.Earth, // 火生土
-            WuXingType.Wood, // 土生木
+            WuXingType.Gold, // 土生金
             WuXingType.Null
         };
 

Assets/Scripts/GameLogic/Combat/Hero/CombatHeroEntity.cs

@@ -292,50 +292,50 @@ public class CombatHeroEntity : ShowBaiscEntity, ITimeLineAnimtion, ITimeLineGet
             return;
         }
 
-        if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Gold))
-        {
-            int odds = Random.Range(0, 100);
-            if (odds < 50)
-            {
-                CurrCombatHeroInfo.Wood_Injury += Random.Range(1, 5);
-            }
-        }
-
-        if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Wood))
-        {
-            int odds = Random.Range(0, 100);
-            if (odds < 50)
-            {
-                CurrCombatHeroInfo.Earth_Injury += Random.Range(1, 5);
-            }
-        }
-
-        if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Water))
-        {
-            int odds = Random.Range(0, 100);
-            if (odds < 50)
-            {
-                CurrCombatHeroInfo.Fire_Injury += Random.Range(1, 5);
-            }
-        }
-
-        if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Fire))
-        {
-            int odds = Random.Range(0, 100);
-            if (odds < 50)
-            {
-                CurrCombatHeroInfo.Metal_Injury += Random.Range(1, 5);
-            }
-        }
-
-        if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Earth))
-        {
-            int odds = Random.Range(0, 100);
-            if (odds < 50)
-            {
-                CurrCombatHeroInfo.Water_Injury += Random.Range(1, 5);
-            }
-        }
+        // if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Gold))
+        // {
+        //     int odds = Random.Range(0, 100);
+        //     if (odds < 50)
+        //     {
+        //         CurrCombatHeroInfo.Wood_Injury += Random.Range(1, 5);
+        //     }
+        // }
+        //
+        // if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Wood))
+        // {
+        //     int odds = Random.Range(0, 100);
+        //     if (odds < 50)
+        //     {
+        //         CurrCombatHeroInfo.Earth_Injury += Random.Range(1, 5);
+        //     }
+        // }
+        //
+        // if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Water))
+        // {
+        //     int odds = Random.Range(0, 100);
+        //     if (odds < 50)
+        //     {
+        //         CurrCombatHeroInfo.Fire_Injury += Random.Range(1, 5);
+        //     }
+        // }
+        //
+        // if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Fire))
+        // {
+        //     int odds = Random.Range(0, 100);
+        //     if (odds < 50)
+        //     {
+        //         CurrCombatHeroInfo.Metal_Injury += Random.Range(1, 5);
+        //     }
+        // }
+        //
+        // if (harmReturnInfo.WuXingType.HasFlag(WuXingType.Earth))
+        // {
+        //     int odds = Random.Range(0, 100);
+        //     if (odds < 50)
+        //     {
+        //         CurrCombatHeroInfo.Water_Injury += Random.Range(1, 5);
+        //     }
+        // }
 
         if (harmReturnInfo.triggerData.IBarrier != null && ShieldsBarrier != null)
         {

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

@@ -5,6 +5,7 @@ using Fort23.Core;
 using Fort23.Mono;
 using Fort23.UTool;
 using GameLogic.Combat.CombatTool;
+using GameLogic.Combat.Hero.Turntable;
 using GameLogic.Combat.Skill;
 using GameLogic.Hero;
 using GameLogic.Player;
@@ -34,11 +35,18 @@ namespace GameLogic.Combat.Hero
         // public float NormalAttSpeedScale;
 
 
-        public BetterList<SkillBasic> _skillQueue = new BetterList<SkillBasic>();
+        // 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());
@@ -47,121 +55,18 @@ namespace GameLogic.Combat.Hero
             {
                 await SetNewSkill(PlayerManager.Instance.GongFaControl.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(SkillInfo[]  allSkill)
+        public override async CTask SetNewSkill(SkillInfo[] allSkill)
         {
-            CTaskAwaitBuffer cTaskAwaitBuffer = new CTaskAwaitBuffer();
-            _skillQueue.Clear();
-            // SkillInfo[] skillId = allSkill;
-            int indexCount = 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 = AddSkill(skillInfo);
-                    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);
+            await SkillTurntable.SetNewSkill(allSkill);
         }
 
         public SkillBasic GetSkillQueueForIndex(int index)
         {
-            if (index < 0 || index >= _skillQueue.Count)
-            {
-                return null;
-            }
-
-            return _skillQueue[index];
+            return SkillTurntable.GetSkillQueueForIndex(index);
         }
 
-       
-
 
         public void AddCommandSkill(SkillBasic skill)
         {
@@ -178,6 +83,16 @@ namespace GameLogic.Combat.Hero
             SkillCommands.Clear();
         }
 
+        public void UseSkillFinish(SkillBasic skill)
+        {
+            if (skill == null)
+            {
+                return;
+            }
+
+            SkillTurntable.UseSkillFinish(skill);
+        }
+
         public void UseSkill(SkillBasic skill)
         {
             CombatUseSkillEventData combatUseSkillEventData = CombatUseSkillEventData.Create();
@@ -185,11 +100,6 @@ namespace GameLogic.Combat.Hero
             CombatEventManager.Instance.Dispatch(CombatEventType.UseSkill, combatUseSkillEventData);
             currUseSkill = skill;
             skill.UseSkill();
-
-            if (skill.SelfSkillConfig.SkillType == 1)
-            {
-                SetNormalAttCd();
-            }
         }
 
         /// <summary>
@@ -223,172 +133,11 @@ namespace GameLogic.Combat.Hero
             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("旋转一圈");
-                        // }
-                    }
-                }
+                SkillTurntable.Update(t, 1 * speed);
             }
-
-            // 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;

Assets/Scripts/GameLogic/Combat/Hero/State/CombatHeroAttState.cs

@@ -29,6 +29,7 @@ namespace GameLogic.Combat.Hero.State
             {
                 if (sb == skillBasic)
                 {
+                    combatHeroEntity.CombatHeroSkillControl.This<CombatHeroSkillControl>().UseSkillFinish(skillBasic);
                     skillBasic = null;
                     combatHeroEntity.CombatAIBasic.ChangeState(CombatHeroStateType.idle);
                 }
@@ -46,9 +47,10 @@ namespace GameLogic.Combat.Hero.State
             if (skillBasic != null)
             {
                 skillBasic.BreakSkill();
+                combatHeroEntity.CombatHeroSkillControl.This<CombatHeroSkillControl>().UseSkillFinish(skillBasic);
             }
 
-          
+
             combatHeroEntity.CombatHeroSkillControl.This<CombatHeroSkillControl>().currUseSkill = null;
             skillBasic = null;
         }

Assets/Scripts/GameLogic/Combat/Hero/Turntable.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0323a2edfdeb47bea460e9bc46f9285d
+timeCreated: 1744278506

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

@@ -0,0 +1,154 @@
+using Common.Utility.CombatEvent;
+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 float useAngle;
+        // public float lasetAngle = 360;
+        public int useCount;
+
+        public int useTriggerType;
+        private int triggerType = -1;
+        // public int useCount;
+        /// <summary>
+        /// 金金木水火土
+        /// </summary>
+        private int[] triggerAngle = new[] { 0, 72, 144, 216, 288 };
+
+        private SkillTurntable skillTurntable;
+
+        public void Init(int index, SkillTurntable skillTurntable)
+        {
+            this.index = index;
+            angle = index * 36;
+            this.skillTurntable = skillTurntable;
+        }
+
+        public void SetSkill(SkillBasic SkillBasic)
+        {
+            this.SkillBasic = SkillBasic;
+            if (SkillBasic != null)
+            {
+                SkillBasic.index= index;
+            }
+
+            SkillSlotsAlterEventData skillSlotsAlterEventData = SkillSlotsAlterEventData.Create();
+            skillSlotsAlterEventData.SkillSlots = this;
+            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);
+        }
+
+        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)
+        {
+            if (SkillBasic != null)
+            {
+                switch (SkillBasic.wuXingType)
+                {
+                    case WuXingType.Gold:
+                        if (triggerType != 0)
+                        {
+                            return;
+                        }
+
+                        break;
+                    case WuXingType.Wood:
+                        if (triggerType != 1)
+                        {
+                            return;
+                        }
+
+                        break;
+                    case WuXingType.Water:
+                        if (triggerType != 2)
+                        {
+                            return;
+                        }
+
+                        break;
+                    case WuXingType.Fire:
+                        if (triggerType != 3)
+                        {
+                            return;
+                        }
+
+                        break;
+                    case WuXingType.Earth:
+                        if (triggerType != 4)
+                        {
+                            return;
+                        }
+
+                        break;
+                }
+            }
+
+            useTriggerType = triggerType;
+            skillTurntable.TriggerSlots(this, triggerType);
+        }
+
+        public void Replace()
+        {
+            if (SkillBasic != null)
+            {
+                SkillBasic.Replace();
+            }
+
+            SkillBasic = null;
+        }
+
+        public void ActiveSkill()
+        {
+            if (SkillBasic != null)
+            {
+                SkillBasic.ActiveSkill();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f6039bfee7fa4435b4872c2dfa19de0f
+timeCreated: 1744278554

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

@@ -0,0 +1,287 @@
+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);
+        }
+
+        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];
+                    switch (dengDaiSkill.wuXingType)
+                    {
+                        case WuXingType.Gold:
+                            if (triggerType == 0)
+                            {
+                                skillSlots.SetSkill(dengDaiSkill);
+                                currUseFinishSkill.RemoveAt(i);
+                                return;
+                            }
+
+                            break;
+                        case WuXingType.Wood:
+                            if (triggerType == 1)
+                            {
+                                skillSlots.SetSkill(dengDaiSkill);
+                                currUseFinishSkill.RemoveAt(i);
+                                return;
+                            }
+
+                            break;
+                        case WuXingType.Water:
+                            if (triggerType == 2)
+                            {
+                                skillSlots.SetSkill(dengDaiSkill);
+                                currUseFinishSkill.RemoveAt(i);
+                                return;
+                            }
+
+                            break;
+                        case WuXingType.Fire:
+                            if (triggerType == 3)
+                            {
+                                skillSlots.SetSkill(dengDaiSkill);
+                                currUseFinishSkill.RemoveAt(i);
+                                return;
+                            }
+
+                            break;
+                        case WuXingType.Earth:
+                            if (triggerType == 4)
+                            {
+                                skillSlots.SetSkill(dengDaiSkill);
+                                currUseFinishSkill.RemoveAt(i);
+                                return;
+                            }
+
+                            break;
+                    }
+                }
+
+                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;
+            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);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b7974f1238ef4d06affe2db917280e34
+timeCreated: 1744278517

Assets/Scripts/GameLogic/Combat/Skill/S1201.cs

@@ -28,7 +28,7 @@ namespace GameLogic.Combat.Skill
 
         protected void FaShe()
         {
-            if (currCount > 3)
+            if (currCount > 3||CombatHeroEntity==null||CombatHeroEntity.CombatAIBasic==null)
             {
                 return;
             }

Assets/Scripts/GameLogic/Combat/Skill/S501001.cs

@@ -13,7 +13,7 @@ namespace GameLogic.Combat.Skill
             CombatEventManager.Instance.AddEventListener(CombatEventType.HeroInjured, HeroInjuredEventData);
         }
 
-        protected override void ProDispose()
+        protected override void ProReplace()
         {
             CombatEventManager.Instance.RemoveEventListener(CombatEventType.HeroInjured, HeroInjuredEventData);
         }

Assets/Scripts/GameLogic/Combat/Skill/S501201.cs

@@ -19,7 +19,7 @@ namespace GameLogic.Combat.Skill
         {
         }
 
-        protected override void ProDispose()
+        protected override void ProReplace()
         {
             _currAddCount = 0;
             CombatEventManager.Instance.RemoveEventListener(CombatEventType.StartInjured, StartInjured);
@@ -27,14 +27,14 @@ namespace GameLogic.Combat.Skill
 
         protected override void ProActiveSkill()
         {
-            if (angle > hd)
-            {
-                lastJingGuo += 360;
-            }
-            else
-            {
-                lastJingGuo = hd;
-            }
+            // if (angle > hd)
+            // {
+            //     lastJingGuo += 360;
+            // }
+            // else
+            // {
+            //     lastJingGuo = hd;
+            // }
 
             CombatEventManager.Instance.AddEventListener(CombatEventType.StartInjured, StartInjured);
         }
@@ -42,14 +42,14 @@ namespace GameLogic.Combat.Skill
         protected override void ProCombatUpdate(float time)
         {
             // float jd = angle % 360;
-            if (angle >= lastJingGuo)
-            {
-                lastJingGuo += 360;
-                if (_currAddCount < SelfSkillConfig.effectValue[1])
-                {
-                    _currAddCount++;
-                }
-            }
+            // if (angle >= lastJingGuo)
+            // {
+            //     lastJingGuo += 360;
+            //     if (_currAddCount < SelfSkillConfig.effectValue[1])
+            //     {
+            //         _currAddCount++;
+            //     }
+            // }
         }
 
         private void StartInjured(IEventData iEventData)

Assets/Scripts/GameLogic/Combat/Skill/S501301.cs

@@ -12,7 +12,7 @@ namespace GameLogic.Combat.Skill
         {
         }
 
-        protected override void ProDispose()
+        protected override void ProReplace()
         {
             CombatEventManager.Instance.RemoveEventListener(CombatEventType.TimelineFxLogicInit, TimelineFxLogicInit);
         }
@@ -26,7 +26,7 @@ namespace GameLogic.Combat.Skill
         {
             TimelineFxLogicInitEventData timelineFxLogicInitEventData = iEventData as TimelineFxLogicInitEventData;
             if (timelineFxLogicInitEventData.SkillBasic.CombatHeroEntity == CombatHeroEntity &&
-                timelineFxLogicInitEventData.SkillBasic.index - 1 == index)
+                timelineFxLogicInitEventData.SkillBasic.index + 1 == index)
             {
                 timelineFxLogicInitEventData.timelineFxLogic.size *= 2;
                 // timelineFxLogicInitEventData.timelineFxLogic.SkillFeaturesData.

Assets/Scripts/GameLogic/Combat/Skill/S501401.cs

@@ -17,7 +17,7 @@ namespace GameLogic.Combat.Skill
         {
         }
 
-        protected override void ProDispose()
+        protected override void ProReplace()
         {
             CombatEventManager.Instance.RemoveEventListener(CombatEventType.AddUseGongFa, AddUseGongFa);
             Finish();

Assets/Scripts/GameLogic/Combat/Skill/S501501.cs

@@ -14,7 +14,7 @@ namespace GameLogic.Combat.Skill
         {
         }
 
-        protected override void ProDispose()
+        protected override void ProReplace()
         {
             CombatEventManager.Instance.RemoveEventListener(CombatEventType.HeroInjured, HeroInjured);
         }

Assets/Scripts/GameLogic/Combat/Skill/SkillBasic.cs

@@ -54,9 +54,9 @@ namespace GameLogic.Combat.Skill
 
         private bool _isDis;
 
-        public float angle = 180;
-        public float useAngle;
-        public float lasetAngle = 360;
+        // public float angle = 180;
+        // public float useAngle;
+        // public float lasetAngle = 360;
         public int useCount;
 
         /// <summary>
@@ -139,6 +139,7 @@ namespace GameLogic.Combat.Skill
         }
 
 
+        // public void 
         public void IntensifyingEffect(float bl)
         {
             if (SelfSkillConfig.intensifierIndex == null)
@@ -188,6 +189,15 @@ namespace GameLogic.Combat.Skill
         {
         }
 
+        public void Replace()
+        {
+            ProReplace();
+        }
+
+        protected virtual void ProReplace()
+        {
+            
+        }
 
         /// <summary>
         /// 轮询的初始化
@@ -267,24 +277,7 @@ namespace GameLogic.Combat.Skill
             //     SkillIntensifierData = new SkillIntensifierData();
             // }
 
-            switch (SelfSkillConfig.attribute)
-            {
-                case 1:
-                    useAngle = 0;
-                    break;
-                case 2:
-                    useAngle = 72;
-                    break;
-                case 4:
-                    useAngle = 144;
-                    break;
-                case 8:
-                    useAngle = 216;
-                    break;
-                case 16:
-                    useAngle = 288;
-                    break;
-            }
+         
 
             ProInitSkillConfig();
 

Assets/Scripts/GameUI/UI/CombatPanel/SkillSelectPanel.cs

@@ -58,7 +58,7 @@ namespace Fort23.Mono
             for (int i = 0; i < 10; i++)
             {
                 int index = i;
-                double hd = (36 * i) * Math.PI / 180f;
+                double hd = (-36 * i) * Math.PI / 180f;
                 double a = Math.Cos(hd);
                 double b = -Math.Sin(hd);
                 double c = Math.Sin(hd);

Assets/Scripts/GameUI/UI/CombatPanel/ZhuanPanPanel.cs

@@ -4,6 +4,7 @@ using Common.Utility.CombatEvent;
 using Fort23.Core;
 using GameLogic.Combat.CombatTool;
 using GameLogic.Combat.Hero;
+using GameLogic.Combat.Hero.Turntable;
 using GameLogic.Combat.Skill;
 using UnityEngine;
 
@@ -76,9 +77,14 @@ namespace Fort23.Mono
             CombatHeroSkillControl combatHeroSkillControl = CombatController.currActiveCombat.CombatHeroController
                 .playerHeroEntity.CombatHeroSkillControl
                 .This<CombatHeroSkillControl>();
-            for (int i = 0; i < combatHeroSkillControl._skillQueue.Count; i++)
+            for (int i = 0; i < combatHeroSkillControl.SkillTurntable.allSkillSlots.Count; i++)
             {
-                SkillBasic skillBasic = combatHeroSkillControl._skillQueue[i];
+                SkillSlots skillBasic = combatHeroSkillControl.SkillTurntable.allSkillSlots[i];
+                if (skillBasic == null)
+                {
+                    continue;
+                }
+
                 gf_widget gfWidget = await UIManager.Instance.CreateGComponentForObject<gf_widget>(this.gf_widget, null,
                     Gf_root, isInstance: true);
                 gfWidget.SkillBasic = skillBasic;
@@ -118,21 +124,21 @@ namespace Fort23.Mono
                 if (gfWidget.useCount != gfWidget.SkillBasic.useCount)
                 {
                     gfWidget.useCount = gfWidget.SkillBasic.useCount;
-                    switch (gfWidget.SkillBasic.SelfSkillConfig.attribute)
+                    switch (gfWidget.SkillBasic.useTriggerType)
                     {
-                        case 1:
+                        case 0:
                             jin.Play("show", false);
                             break;
-                        case 2:
+                        case 1:
                             mu.Play("show", false);
                             break;
-                        case 4:
+                        case 2:
                             shui.Play("show", false);
                             break;
-                        case 8:
+                        case 3:
                             huo.Play("show", false);
                             break;
-                        case 16:
+                        case 4:
                             tu.Play("show", false);
                             break;
                     }

Assets/Scripts/GameUI/UI/CombatPanel/gf_widget.cs

@@ -1,3 +1,6 @@
+using Common.Utility.CombatEvent;
+using Fort23.Core;
+using GameLogic.Combat.Hero.Turntable;
 using GameLogic.Combat.Skill;
 using UnityEngine;
 
@@ -6,8 +9,11 @@ namespace Fort23.Mono
     [UIBinding(prefab = "gf_widget")]
     public partial class gf_widget : UIComponent
     {
-        public SkillBasic SkillBasic;
+        public SkillSlots SkillBasic;
+
+      
         public float jd;
+
         public int useCount;
         private void Init()
         {
@@ -15,38 +21,66 @@ namespace Fort23.Mono
 
         public override void AddEvent()
         {
+            CombatEventManager.Instance.AddEventListener(CombatEventType.SkillSlotsAlter, SkillSlotsAlter);
         }
 
         public override void DelEvent()
         {
+            CombatEventManager.Instance.RemoveEventListener(CombatEventType.SkillSlotsAlter, SkillSlotsAlter);
+        }
+
+        public void SkillSlotsAlter(IEventData eventData)
+        {
+            SkillSlotsAlterEventData skillSlotsAlterEventData = (SkillSlotsAlterEventData)eventData;
+            if (skillSlotsAlterEventData.SkillSlots == SkillBasic)
+            {
+                SetUIInfo();
+            }
         }
 
         public override void AddButtonEvent()
         {
         }
 
-        public void InitWidget( SkillBasic SkillBasic)
+        private void SetUIInfo()
         {
-            this.SkillBasic = SkillBasic;
-            useCount= SkillBasic.UseCount;
-            switch (SkillBasic.SelfSkillConfig.attribute)
+            if (SkillBasic.SkillBasic == null)
+            {
+                gf_icon.color = Color.white;
+                return;
+            }
+
+            if (SkillBasic.SkillBasic.SelfSkillConfig.SkillType==2)
+            {
+                gf_icon.color = new Color(0.81f, 0.21f, 1f);
+                return;
+            }
+
+            // useCount= SkillBasic.UseCount;
+            switch (SkillBasic.SkillBasic.SelfSkillConfig.attribute)
             {
-              case 1: 
-                  gf_icon.color=new Color(1f, 0.98f, 0.09f);
-                  break;
-              case 2: 
-                  gf_icon.color=new Color(0.17f, 1f, 0.35f);
-                  break;
-              case 4: 
-                  gf_icon.color=new Color(0.19f, 0.51f, 1f);
-                  break;
-              case 8: 
-                  gf_icon.color=new Color(1f, 0.19f, 0.04f);
-                  break;
-              case 16: 
-                  gf_icon.color=new Color(1f, 0.65f, 0.17f);
-                  break;
+                case 1:
+                    gf_icon.color = new Color(1f, 0.98f, 0.09f);
+                    break;
+                case 2:
+                    gf_icon.color = new Color(0.17f, 1f, 0.35f);
+                    break;
+                case 4:
+                    gf_icon.color = new Color(0.19f, 0.51f, 1f);
+                    break;
+                case 8:
+                    gf_icon.color = new Color(1f, 0.19f, 0.04f);
+                    break;
+                case 16:
+                    gf_icon.color = new Color(1f, 0.65f, 0.17f);
+                    break;
             }
         }
+
+        public void InitWidget(SkillSlots SkillBasic)
+        {
+            this.SkillBasic = SkillBasic;
+            SetUIInfo();
+        }
     }
 }

UserSettings/Layouts/default-2022.dwlt

@@ -14,12 +14,12 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   m_PixelRect:
     serializedVersion: 2
-    x: 2560
+    x: 0
     y: 43
     width: 2560
     height: 1349
   m_ShowMode: 4
-  m_Title: Hierarchy
+  m_Title: Inspector
   m_RootView: {fileID: 7}
   m_MinSize: {x: 875, y: 300}
   m_MaxSize: {x: 10000, y: 10000}
@@ -40,9 +40,9 @@ MonoBehaviour:
   m_Position:
     serializedVersion: 2
     x: 0
-    y: 651
+    y: 743
     width: 711
-    height: 325
+    height: 233
   m_MinSize: {x: 102, y: 121}
   m_MaxSize: {x: 4002, y: 4021}
   m_ActualView: {fileID: 13}
@@ -101,7 +101,7 @@ MonoBehaviour:
   m_MinSize: {x: 100, y: 150}
   m_MaxSize: {x: 8096, y: 24288}
   vertical: 1
-  controlID: 48
+  controlID: 42
   draggingID: 0
 --- !u!114 &5
 MonoBehaviour:
@@ -118,12 +118,12 @@ MonoBehaviour:
   m_Children: []
   m_Position:
     serializedVersion: 2
-    x: 1977
+    x: 1976
     y: 0
-    width: 583
+    width: 584
     height: 1299
-  m_MinSize: {x: 276, y: 71}
-  m_MaxSize: {x: 4001, y: 4021}
+  m_MinSize: {x: 275, y: 50}
+  m_MaxSize: {x: 4000, y: 4000}
   m_ActualView: {fileID: 16}
   m_Panes:
   - {fileID: 16}
@@ -232,7 +232,7 @@ MonoBehaviour:
   m_MinSize: {x: 400, y: 150}
   m_MaxSize: {x: 32384, y: 24288}
   vertical: 0
-  controlID: 47
+  controlID: 41
   draggingID: 0
 --- !u!114 &10
 MonoBehaviour:
@@ -272,7 +272,7 @@ MonoBehaviour:
     serializedVersion: 2
     x: 1427
     y: 0
-    width: 550
+    width: 549
     height: 1299
   m_MinSize: {x: 202, y: 221}
   m_MaxSize: {x: 4002, y: 4021}
@@ -299,7 +299,7 @@ MonoBehaviour:
     x: 0
     y: 0
     width: 711
-    height: 651
+    height: 743
   m_MinSize: {x: 202, y: 221}
   m_MaxSize: {x: 4002, y: 4021}
   m_ActualView: {fileID: 19}
@@ -327,10 +327,10 @@ MonoBehaviour:
     m_Tooltip: 
   m_Pos:
     serializedVersion: 2
-    x: 3276
-    y: 724
+    x: 716
+    y: 816
     width: 709
-    height: 304
+    height: 212
   m_SerializedDataModeController:
     m_DataMode: 0
     m_PreferredDataMode: 0
@@ -404,9 +404,9 @@ MonoBehaviour:
     m_Tooltip: 
   m_Pos:
     serializedVersion: 2
-    x: 3987
+    x: 1427
     y: 73
-    width: 548
+    width: 547
     height: 1278
   m_SerializedDataModeController:
     m_DataMode: 0
@@ -423,21 +423,21 @@ MonoBehaviour:
       scrollPos: {x: 0, y: 0}
       m_SelectedIDs: 
       m_LastClickedID: 0
-      m_ExpandedIDs: 78faffff
+      m_ExpandedIDs: 60d4fbff7cd4fbff80d4fbff8ad4fbff78faffff
       m_RenameOverlay:
         m_UserAcceptedRename: 0
-        m_Name: Directional Light (1)
-        m_OriginalName: Directional Light (1)
+        m_Name: 
+        m_OriginalName: 
         m_EditFieldRect:
           serializedVersion: 2
           x: 0
           y: 0
           width: 0
           height: 0
-        m_UserData: 43768
+        m_UserData: 0
         m_IsWaitingForDelay: 0
         m_IsRenaming: 0
-        m_OriginalEventType: 0
+        m_OriginalEventType: 11
         m_IsRenamingFilename: 0
         m_ClientGUIView: {fileID: 11}
       m_SearchString: 
@@ -467,9 +467,9 @@ MonoBehaviour:
     m_Tooltip: 
   m_Pos:
     serializedVersion: 2
-    x: 4537
+    x: 1976
     y: 73
-    width: 582
+    width: 583
     height: 1278
   m_SerializedDataModeController:
     m_DataMode: 0
@@ -514,7 +514,7 @@ MonoBehaviour:
     m_Tooltip: 
   m_Pos:
     serializedVersion: 2
-    x: 3276
+    x: 716
     y: 1049
     width: 709
     height: 302
@@ -529,7 +529,7 @@ MonoBehaviour:
     m_SaveData: []
     m_OverlaysVisible: 1
   m_SearchFilter:
-    m_NameFilter: Mit
+    m_NameFilter: 
     m_ClassNames: []
     m_AssetLabels: []
     m_AssetBundleNames: []
@@ -539,24 +539,24 @@ MonoBehaviour:
     m_SkipHidden: 1
     m_SearchArea: 1
     m_Folders:
-    - Assets/Scripts/GameLogic/Combat/CombatTool
+    - Assets/Scripts/GameLogic/Combat/Hero
     m_Globs: []
-    m_OriginalText: Mit
+    m_OriginalText: 
     m_ImportLogFlags: 0
     m_FilterByTypeIntersection: 0
   m_ViewMode: 1
   m_StartGridSize: 16
   m_LastFolders:
-  - Assets/Scripts/GameLogic/Combat/CombatTool
+  - Assets/Scripts/GameLogic/Combat/Hero
   m_LastFoldersGridSize: 16
   m_LastProjectPath: D:\unityProject\XiuXianGame
   m_LockTracker:
     m_IsLocked: 0
   m_FolderTreeState:
-    scrollPos: {x: 0, y: 464}
-    m_SelectedIDs: 42370100
-    m_LastClickedID: 79682
-    m_ExpandedIDs: 0000000074b8000076b8000078b800007ab800007cb800007eb8000080b8000082b8000084b8000086b8000088b800008ab800008cb800008eb8000090b8000092b8000042b9000060b9000000ca9a3bffffff7f
+    scrollPos: {x: 0, y: 486}
+    m_SelectedIDs: 74b90000
+    m_LastClickedID: 47476
+    m_ExpandedIDs: 000000007cb800007eb8000080b8000082b8000084b8000086b8000088b800008ab800008cb800008eb8000090b8000092b8000094b8000096b8000098b800009ab800004ab9000062b9000074b9000000ca9a3bffffff7f
     m_RenameOverlay:
       m_UserAcceptedRename: 0
       m_Name: 
@@ -584,7 +584,7 @@ MonoBehaviour:
     scrollPos: {x: 0, y: 0}
     m_SelectedIDs: 
     m_LastClickedID: 0
-    m_ExpandedIDs: 0000000074b8000076b8000078b800007ab800007cb800007eb8000080b8000082b8000084b8000086b8000088b800008ab800008cb800008eb8000090b8000092b80000
+    m_ExpandedIDs: 000000007cb800007eb8000080b8000082b8000084b8000086b8000088b800008ab800008cb800008eb8000090b8000092b8000094b8000096b8000098b800009ab80000
     m_RenameOverlay:
       m_UserAcceptedRename: 0
       m_Name: 
@@ -636,7 +636,7 @@ MonoBehaviour:
       m_Icon: {fileID: 0}
       m_ResourceFile: 
     m_NewAssetIndexInList: -1
-    m_ScrollPosition: {x: 0, y: 0}
+    m_ScrollPosition: {x: 0, y: 96.5}
     m_GridSize: 16
   m_SkipHiddenPackages: 1
   m_DirectoriesAreaWidth: 318
@@ -660,7 +660,7 @@ MonoBehaviour:
     m_Tooltip: 
   m_Pos:
     serializedVersion: 2
-    x: 2560
+    x: 0
     y: 73
     width: 715
     height: 1278
@@ -758,10 +758,10 @@ MonoBehaviour:
     m_Tooltip: 
   m_Pos:
     serializedVersion: 2
-    x: 3276
+    x: 716
     y: 73
     width: 709
-    height: 630
+    height: 722
   m_SerializedDataModeController:
     m_DataMode: 0
     m_PreferredDataMode: 0
@@ -1133,9 +1133,9 @@ MonoBehaviour:
   m_PlayAudio: 0
   m_AudioPlay: 0
   m_Position:
-    m_Target: {x: 6.11454, y: 7.7398353, z: 48.484695}
+    m_Target: {x: 0, y: -1.21, z: 0}
     speed: 2
-    m_Value: {x: 6.11454, y: 7.7398353, z: 48.484695}
+    m_Value: {x: 0, y: -1.21, z: 0}
   m_RenderMode: 0
   m_CameraMode:
     drawMode: 0
@@ -1185,9 +1185,9 @@ MonoBehaviour:
     speed: 2
     m_Value: {x: -0.038930397, y: -0.10533857, z: 0.005574437, w: -0.9936584}
   m_Size:
-    m_Target: 10.277417
+    m_Target: 1.0792253
     speed: 2
-    m_Value: 10.277417
+    m_Value: 1.0792253
   m_Ortho:
     m_Target: 0
     speed: 2