(client) feat:实现技能树界面，实现地图生成器，实现维度指定，实现规则瓦片定义，实现逃跑逻辑，实现消息定义，实现武器动画，实现受击动画 fix: 修复单攻击子弹击中多个目标，修复人物属性计算错误 (#56)

Co-authored-by: m0_75251201 <m0_75251201@noreply.gitcode.com>
Reviewed-on: http://47.107.252.169:3000/Roguelite-Game-Developing-Team/Gen_Hack-and-Slash-Roguelite/pulls/56

Client/Assets/Scripts/Base/Clock.cs

@@ -5,30 +5,48 @@ using Utils; // 假设此命名空间包含MonoSingleton
 
 namespace Base
 {
+    /// <summary>
+    /// 定义一个Tick更新接口，用于在常规Update中执行逻辑。
+    /// </summary>
     public interface ITick
     {
         public void Tick();
     }
 
+    /// <summary>
+    /// 定义一个TickPhysics更新接口，用于在FixedUpdate中执行物理逻辑。
+    /// </summary>
     public interface ITickPhysics
     {
         public void TickPhysics();
     }
 
+    /// <summary>
+    /// 定义一个TickUI更新接口，用于在常规Update中执行UI逻辑。
+    /// </summary>
     public interface ITickUI
     {
         public void TickUI();
     }
 
+    /// <summary>
+    /// 全局计时器和更新管理器，负责在Unity的Update、FixedUpdate和LateUpdate生命周期中调度注册的Ticks。
+    /// 支持游戏暂停、场景加载时自动重置以及缓冲区的添加/移除操作以避免迭代器错误。
+    /// </summary>
     public class Clock : MonoSingleton<Clock>
     {
-        private bool _pause = false;
+        private bool _pause;
+        /// <summary>
+        /// 获取或设置游戏的暂停状态。当设置为true时，Time.timeScale将变为0；当设置为false时，Time.timeScale将恢复为1。
+        /// 该操作会检查当前状态，避免重复设置Time.timeScale。
+        /// </summary>
         public bool Pause
         {
             get => _pause;
             set
             {
-                if (value != _pause) // 逻辑修改说明：避免重复设置Time.timeScale
+                // 如果新值与当前暂停状态不同，则更新Time.timeScale。
+                if (value != _pause)
                 {
                     Time.timeScale = value ? 0 : 1;
                     _pause = value;
@@ -36,36 +54,59 @@ namespace Base
             }
         }
 
-        // 修改点 1.1：主列表用于迭代
-        private readonly List<ITick> _ticks = new();
-        private readonly List<ITickPhysics> _tickPhysics = new();
-        private readonly List<ITickUI> _tickUIs = new();
+        /// <summary>
+        /// 存储所有需要在常规Update中执行Tick逻辑的对象。使用HashSet确保唯一性并提高查找效率。
+        /// </summary>
+        private readonly HashSet<ITick> _ticks = new();
+        /// <summary>
+        /// 存储所有需要在FixedUpdate中执行物理Tick逻辑的对象。使用HashSet确保唯一性并提高查找效率。
+        /// </summary>
+        private readonly HashSet<ITickPhysics> _tickPhysics = new();
+        /// <summary>
+        /// 存储所有需要在常规Update中执行UI Tick逻辑的对象。使用HashSet确保唯一性并提高查找效率。
+        /// </summary>
+        private readonly HashSet<ITickUI> _tickUIs = new();
 
-        // 修改点 1.1：缓冲列表用于添加
-        private readonly HashSet<ITick> _ticksToAdd = new(); // 逻辑修改说明：使用HashSet避免重复添加，提高查找效率
+        /// <summary>
+        /// 待添加的ITick对象缓冲区。在LateUpdate中统一处理，以避免在迭代主列表时修改列表。
+        /// </summary>
+        private readonly HashSet<ITick> _ticksToAdd = new();
+        /// <summary>
+        /// 待添加的ITickPhysics对象缓冲区。在LateUpdate中统一处理。
+        /// </summary>
         private readonly HashSet<ITickPhysics> _tickPhysicsToAdd = new();
+        /// <summary>
+        /// 待添加的ITickUI对象缓冲区。在LateUpdate中统一处理。
+        /// </summary>
         private readonly HashSet<ITickUI> _tickUIsToAdd = new();
 
-        // 修改点 1.1：缓冲列表用于移除
-        private readonly HashSet<ITick> _ticksToRemove = new(); // 逻辑修改说明：使用HashSet避免重复移除，提高查找效率
+        /// <summary>
+        /// 待移除的ITick对象缓冲区。在LateUpdate中统一处理，以避免在迭代主列表时修改列表。
+        /// </summary>
+        private readonly HashSet<ITick> _ticksToRemove = new();
+        /// <summary>
+        /// 待移除的ITickPhysics对象缓冲区。在LateUpdate中统一处理。
+        /// </summary>
         private readonly HashSet<ITickPhysics> _tickPhysicsToRemove = new();
+        /// <summary>
+        /// 待移除的ITickUI对象缓冲区。在LateUpdate中统一处理。
+        /// </summary>
         private readonly HashSet<ITickUI> _tickUIsToRemove = new();
 
         private void Update()
         {
-            // 逻辑修改说明：UI部分的Tick不应受_pause影响
+            // 如果游戏未暂停，则执行常规的Tick更新。
             if (!_pause)
             {
-                // 逻辑修改说明：迭代时使用只读副本或确保不会被修改
-                // 这里是直接迭代_ticks，确保_ticks在Update生命周期内不会被Add/Remove直接修改
-                // 添加和移除操作通过缓冲区在LateUpdate处理
+                // 迭代主列表，确保_ticks在Update生命周期内不会被Add/Remove直接修改。
+                // 添加和移除操作通过缓冲区在LateUpdate处理。
                 foreach (var tick in _ticks)
                 {
                     tick.Tick();
                 }
             }
-            // UI更新通常不受游戏暂停影响（例如菜单动画、UI计时器等），除非UI本身也需要暂停逻辑。
-            // 根据需求决定是否受_pause影响。此处假设UI不暂停。
+            // UI更新通常不受游戏暂停影响（例如菜单动画、UI计时器等）。
+            // 这是当前的默认设计，如果需要UI也暂停，则需修改此处逻辑或引入单独的UI暂停状态。
             foreach (var uiTick in _tickUIs)
             {
                 uiTick.TickUI();
@@ -74,6 +115,7 @@ namespace Base
 
         private void FixedUpdate()
         {
+            // 如果游戏未暂停，则执行物理Tick更新。
             if (!_pause)
             {
                 foreach (var physicsTick in _tickPhysics)
@@ -83,41 +125,51 @@ namespace Base
             }
         }
 
-        // 修改点 1.4：在LateUpdate应用缓冲区的更改
+        /// <summary>
+        /// 在所有Update操作完成后，应用Tick注册和注销的缓冲区更改，确保列表在迭代期间不被修改。
+        /// </summary>
         private void LateUpdate()
         {
             ApplyBufferedChanges();
         }
 
-        // 修改点 3.1：OnDestroy保持不变，确保事件移除
         private void OnDestroy()
         {
+            // 在对象销毁时，取消订阅场景加载事件，避免潜在的内存泄漏。
             SceneManager.sceneLoaded -= OnSceneLoaded;
         }
 
-        // 修改点 3.1：OnStart保持不变，负责事件注册和初始化
-        protected override void OnStart() // MonoSingleton的Awake后调用
+        /// <summary>
+        /// 单例的初始化方法，在Clock实例的生命周期开始时调用（Unity的Awake后）。
+        /// 订阅场景加载事件，并执行初始设置。
+        /// </summary>
+        protected override void OnStart()
         {
             SceneManager.sceneLoaded += OnSceneLoaded;
-            // 逻辑修改说明：Initial清理所有列表，而不是填充
-            Init(); 
-        }
-
-        private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
-        {
-            Init();
+            Init(); // 初始化时清空所有列表并重新填充
         }
 
         /// <summary>
-        ///     初始化/重置方法。清空所有注册列表和缓冲列表。
+        /// 场景加载完成时回调，用于重置所有Tick列表，以适应新场景中的对象。
+        /// </summary>
+        /// <param name="scene">已加载的场景。</param>
+        /// <param name="mode">场景加载模式。</param>
+        private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
+        {
+            Init(); // 场景加载时重置
+        }
+
+        /// <summary>
+        /// 初始化或重置计时器系统。清空所有注册列表和缓冲列表，并重新扫描场景中的所有MonoBehaviour以注册相应的Tick接口。
         /// </summary>
-        // 修改点 2.1：Init() 方法不再负责FindObjectsByType
         public void Init()
         {
+            // 清空所有主列表
             _ticks.Clear();
             _tickPhysics.Clear();
             _tickUIs.Clear();
 
+            // 清空所有缓冲区列表
             _ticksToAdd.Clear();
             _tickPhysicsToAdd.Clear();
             _tickUIsToAdd.Clear();
@@ -126,8 +178,8 @@ namespace Base
             _tickPhysicsToRemove.Clear();
             _tickUIsToRemove.Clear();
 
-            // 逻辑修改说明：移除 FindObjectsByType 逻辑
-            // 对象应通过其各自的 OnEnable/OnDisable 生命周期来注册/反注册
+            // 扫描场景中所有MonoBehaviour并注册它们实现的Tick接口。
+            // 使用HashSet会自动处理重复添加，确保列表唯一性。
             foreach (var obj in FindObjectsByType<MonoBehaviour>(FindObjectsSortMode.None))
             {
                 if (obj is ITick tickObj) _ticks.Add(tickObj);
@@ -136,27 +188,44 @@ namespace Base
             }
         }
 
-        // 修改点 1.2 & 1.3：将更改放入缓冲，并在LateUpdate统一处理
+        /// <summary>
+        /// 将一个ITick对象添加到待添加缓冲区。它将在下一个LateUpdate中被添加到主Tick列表。
+        /// 如果对象已经在待移除列表中，则会先从待移除列表中移除，以处理添加/移除冲突。
+        /// </summary>
+        /// <param name="tick">要添加的ITick对象。</param>
         public static void AddTick(ITick tick)
         {
-            if (Instance != null && tick != null) // 逻辑修改说明：添加null检查
+            // 确保Clock实例存在且对象不为空。
+            if (Instance != null && tick != null)
             {
                 Instance._ticksToAdd.Add(tick);
-                Instance._ticksToRemove.Remove(tick); // 逻辑修改说明：如果在待移除列表，则先移除
+                Instance._ticksToRemove.Remove(tick); // 如果在待移除列表，则先从待移除中删除
             }
         }
 
+        /// <summary>
+        /// 将一个ITick对象添加到待移除缓冲区。它将在下一个LateUpdate中从主Tick列表移除。
+        /// 如果对象已经在待添加列表中，则会先从待添加列表中移除，以处理添加/移除冲突。
+        /// </summary>
+        /// <param name="tick">要移除的ITick对象。</param>
         public static void RemoveTick(ITick tick)
         {
-            if (Instance != null && tick != null) // 逻辑修改说明：添加null检查
+            // 确保Clock实例存在且对象不为空。
+            if (Instance != null && tick != null)
             {
                 Instance._ticksToRemove.Add(tick);
-                Instance._ticksToAdd.Remove(tick); // 逻辑修改说明：如果在待添加列表，则先移除
+                Instance._ticksToAdd.Remove(tick); // 如果在待添加列表，则先从待添加中删除
             }
         }
 
+        /// <summary>
+        /// 将一个ITickPhysics对象添加到待添加缓冲区。它将在下一个LateUpdate中被添加到主物理Tick列表。
+        /// 如果对象已经在待移除列表中，则会先从待移除列表中移除，以处理添加/移除冲突。
+        /// </summary>
+        /// <param name="physics">要添加的ITickPhysics对象。</param>
         public static void AddTickPhysics(ITickPhysics physics)
         {
+            // 确保Clock实例存在且对象不为空。
             if (Instance != null && physics != null)
             {
                 Instance._tickPhysicsToAdd.Add(physics);
@@ -164,8 +233,14 @@ namespace Base
             }
         }
 
+        /// <summary>
+        /// 将一个ITickPhysics对象添加到待移除缓冲区。它将在下一个LateUpdate中从主物理Tick列表移除。
+        /// 如果对象已经在待添加列表中，则会先从待添加列表中移除，以处理添加/移除冲突。
+        /// </summary>
+        /// <param name="physics">要移除的ITickPhysics对象。</param>
         public static void RemoveTickPhysics(ITickPhysics physics)
         {
+            // 确保Clock实例存在且对象不为空。
             if (Instance != null && physics != null)
             {
                 Instance._tickPhysicsToRemove.Add(physics);
@@ -173,8 +248,14 @@ namespace Base
             }
         }
 
+        /// <summary>
+        /// 将一个ITickUI对象添加到待添加缓冲区。它将在下一个LateUpdate中被添加到主UI Tick列表。
+        /// 如果对象已经在待移除列表中，则会先从待移除列表中移除，以处理添加/移除冲突。
+        /// </summary>
+        /// <param name="ui">要添加的ITickUI对象。</param>
         public static void AddTickUI(ITickUI ui)
         {
+            // 确保Clock实例存在且对象不为空。
             if (Instance != null && ui != null)
             {
                 Instance._tickUIsToAdd.Add(ui);
@@ -182,8 +263,14 @@ namespace Base
             }
         }
 
+        /// <summary>
+        /// 将一个ITickUI对象添加到待移除缓冲区。它将在下一个LateUpdate中从主UI Tick列表移除。
+        /// 如果对象已经在待添加列表中，则会先从待添加列表中移除，以处理添加/移除冲突。
+        /// </summary>
+        /// <param name="ui">要移除的ITickUI对象。</param>
         public static void RemoveTickUI(ITickUI ui)
         {
+            // 确保Clock实例存在且对象不为空。
             if (Instance != null && ui != null)
             {
                 Instance._tickUIsToRemove.Add(ui);
@@ -191,17 +278,20 @@ namespace Base
             }
         }
 
-        // 修改点 1.3：应用缓冲区的更改
+        /// <summary>
+        /// 私有方法，用于将缓冲区中的添加和移除操作应用到主Tick列表中。
+        /// 此方法应在LateUpdate中调用，以确保在所有Tick执行完毕后进行列表修改，从而避免迭代器错误。
+        /// </summary>
         private void ApplyBufferedChanges()
         {
-            // 先处理移除
+            // --- 先处理移除操作 ---
             if (_ticksToRemove.Count > 0)
             {
                 foreach (var tick in _ticksToRemove)
                 {
-                    _ticks.Remove(tick);
+                    _ticks.Remove(tick); // 从主列表移除，HashSet的移除操作平均为O(1)
                 }
-                _ticksToRemove.Clear();
+                _ticksToRemove.Clear(); // 清空移除缓冲区
             }
 
             if (_tickPhysicsToRemove.Count > 0)
@@ -222,27 +312,22 @@ namespace Base
                 _tickUIsToRemove.Clear();
             }
 
-            // 后处理添加
+            // --- 后处理添加操作 ---
             if (_ticksToAdd.Count > 0)
             {
                 foreach (var tick in _ticksToAdd)
                 {
-                    if (!_ticks.Contains(tick)) // 逻辑修改说明：避免重复添加到主列表
-                    {
-                        _ticks.Add(tick);
-                    }
+                    // 添加到主列表。HashSet.Add平均为O(1)，并自动处理重复添加（会忽略重复项）。
+                    _ticks.Add(tick);
                 }
-                _ticksToAdd.Clear();
+                _ticksToAdd.Clear(); // 清空添加缓冲区
             }
 
             if (_tickPhysicsToAdd.Count > 0)
             {
                 foreach (var physicsTick in _tickPhysicsToAdd)
                 {
-                    if (!_tickPhysics.Contains(physicsTick))
-                    {
-                        _tickPhysics.Add(physicsTick);
-                    }
+                    _tickPhysics.Add(physicsTick); // HashSet.Add 会自动处理重复
                 }
                 _tickPhysicsToAdd.Clear();
             }
@@ -251,10 +336,7 @@ namespace Base
             {
                 foreach (var uiTick in _tickUIsToAdd)
                 {
-                    if (!_tickUIs.Contains(uiTick))
-                    {
-                        _tickUIs.Add(uiTick);
-                    }
+                    _tickUIs.Add(uiTick); // HashSet.Add 会自动处理重复
                 }
                 _tickUIsToAdd.Clear();
             }

Client/Assets/Scripts/Base/GradientColor.cs

@@ -1,151 +0,0 @@
-using System;
-using System.Collections.Generic;
-using UnityEngine;
-using UnityEngine.UI;
-
-namespace Base
-{
-    // 定义渐变方向枚举
-    [AddComponentMenu("UI/Effects/Gradient")]
-    public enum Dir
-    {
-        Horizontal, // 水平方向
-        Vertical,   // 垂直方向
-    }
-
-    // 自定义梯度效果类，继承自BaseMeshEffect
-    public class Gradient : BaseMeshEffect
-    {
-        [SerializeField] // 序列化字段，可在Inspector中编辑
-        private Dir dir = Dir.Vertical; // 渐变方向，默认垂直
-
-        [SerializeField]
-        public Color32 color1 = Color.white; // 渐变起始颜色，默认白色
-
-        [SerializeField]
-        public Color32 color2 = Color.white; // 渐变结束颜色，默认白色
-
-        [SerializeField]
-        private float range = 0f; // 渐变范围，控制颜色的过渡区域，默认无范围（完全渐变）
-
-        [SerializeField]
-        private bool isFlip = false; // 是否翻转渐变方向，默认不翻转
-
-
-        public void Refresh()
-        {
-            graphic.SetVerticesDirty();
-        }
-
-        // 重写ModifyMesh方法，用于修改UI元素的网格
-        public override void ModifyMesh(VertexHelper vh)
-        {
-            if (!IsActive()) // 如果组件未激活，则不执行后续操作
-            {
-                return;
-            }
-            var count = vh.currentVertCount; // 获取当前顶点数量
-            if (count > 0) // 如果有顶点，则进行处理
-            {
-                var vertices = new List<UIVertex>(); // 创建顶点列表
-
-                // 遍历所有顶点并添加到列表中
-                for (var i = 0; i < count; i++)
-                {
-                    var uIVertex = new UIVertex();
-                    vh.PopulateUIVertex(ref uIVertex, i); // 填充顶点信息
-                    vertices.Add(uIVertex);
-                }
-
-                // 根据渐变方向调用相应的绘制方法
-                switch (dir)
-                {
-                    case Dir.Horizontal:
-                        DrawHorizontal(vh, vertices, count);
-                        break;
-                    case Dir.Vertical:
-                        DrawVertical(vh, vertices, count);
-                        break;
-                    default:
-                        throw new ArgumentOutOfRangeException();
-                }
-            }
-        }
-
-        // 绘制垂直方向的渐变
-        private void DrawVertical(VertexHelper vh, List<UIVertex> vertices, int count)
-        {
-            // 初始化顶部和底部Y坐标
-            var topY = vertices[0].position.y;
-            var bottomY = vertices[0].position.y;
-
-            // 遍历所有顶点，找到最高和最低的Y坐标
-            for (var i = 0; i < count; i++)
-            {
-                var y = vertices[i].position.y;
-                if (y > topY) topY = y;
-                else if (y < bottomY) bottomY = y;
-            }
-
-            var height = topY - bottomY; // 计算高度差
-
-            // 遍历所有顶点，设置颜色渐变
-            for (var i = 0; i < count; i++)
-            {
-                var vertex = vertices[i];
-                Color32 color = Color.white;
-
-                // 根据是否翻转，计算当前顶点的颜色
-                if (isFlip)
-                {
-                    color = Color32.Lerp(color2, color1, 1 - (vertex.position.y - bottomY) / height * (1f - range));
-                }
-                else
-                {
-                    color = Color32.Lerp(color2, color1, (vertex.position.y - bottomY) / height * (1f - range));
-                }
-
-                vertex.color = color; // 设置顶点颜色
-                vh.SetUIVertex(vertex, i); // 更新网格中的顶点
-            }
-        }
-
-        // 绘制水平方向的渐变
-        private void DrawHorizontal(VertexHelper vh, List<UIVertex> vertices, int count)
-        {
-            // 注意：这里应该是找到最左和最右的X坐标，注释中存在笔误
-            var leftX = vertices[0].position.x;
-            var rightX = vertices[0].position.x;
-
-            // 遍历所有顶点，找到最左和最右的X坐标
-            for (var i = 0; i < count; i++)
-            {
-                var x = vertices[i].position.x;
-                if (x > rightX) rightX = x;
-                else if (x < leftX) leftX = x;
-            }
-
-            var width = rightX - leftX; // 计算宽度差
-
-            // 遍历所有顶点，设置颜色渐变
-            for (var i = 0; i < count; i++)
-            {
-                var vertex = vertices[i];
-                Color32 color = Color.white;
-
-                // 根据是否翻转，计算当前顶点的颜色
-                if (isFlip)
-                {
-                    color = Color32.Lerp(color2, color1, 1 - (vertex.position.x - leftX) / width * (1f - range));
-                }
-                else
-                {
-                    color = Color32.Lerp(color2, color1, (vertex.position.x - leftX) / width * (1f - range));
-                }
-
-                vertex.color = color; // 设置顶点颜色
-                vh.SetUIVertex(vertex, i); // 更新网格中的顶点
-            }
-        }
-    }
-}

Client/Assets/Scripts/Base/GradientColor.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 8df3d16a358d74644b86e92ca5177fa1

Client/Assets/Scripts/Base/Launcher.cs

@@ -1,8 +1,10 @@
 using System.Collections;
-using System.Collections.Generic; // 提供List等通用集合类型
+using System.Collections.Generic;
+using Configs; // 提供List等通用集合类型
 using Logging; // 提供日志记录功能
 using Managers; // 提供管理器接口和实现
-using TMPro; // TextMeshPro文本组件命名空间
+using TMPro;
+using UI; // TextMeshPro文本组件命名空间
 using UnityEngine; // Unity引擎核心命名空间
 using UnityEngine.SceneManagement; // 场景管理命名空间
 
@@ -29,7 +31,7 @@ namespace Base
         /// 用于显示加载进度的自定义进度条组件。
         /// <para>请参阅类注释以了解其声明类型与预期API的差异。</para>
         /// </summary>
-        public Gradient progressBar;
+        public ColorBar progressBar;
 
         /// <summary>
         /// 用于显示当前加载步骤描述的文本组件。
@@ -137,6 +139,7 @@ namespace Base
             _managersToLoad = new List<ILaunchManager>
             {
                 new LoggerManagerWrapper(), // Unity日志的包装器
+                ConfigManager.Instance,
                 DefineManager.Instance,
                 PackagesImageManager.Instance,
                 TileManager.Instance,
@@ -144,6 +147,7 @@ namespace Base
                 ItemResourceManager.Instance,
                 EventManager.Instance,
                 AudioManager.Instance,
+                SkillTreeManager.Instance,
             };
 
             // 缓存UI的初始颜色，以便后续操作（如渐隐）或重置

Client/Assets/Scripts/Base/Setting.cs

@@ -21,6 +21,10 @@ namespace Base
             public Vector2Int windowResolution = new(1920, 1080);
 
             public string[] loadOrder;
+
+            public bool showHealthBarByHit = true;
+            public bool alwaysShowHealthBar = false;
+            public bool showHitNumber = true;
         }
 
         // 当前游戏设置

Client/Assets/Scripts/Base/UIInputControl.cs

@@ -81,7 +81,6 @@ namespace Base
             var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
             if (!activeScene.isLoaded)
             {
-                Debug.LogWarning("[UIInputControl] 当前场景未加载，无法注册窗口！");
                 return;
             }
 
@@ -309,8 +308,6 @@ namespace Base
         {
             // 订阅场景加载事件，以便在新场景加载后重新注册UI窗口
             SceneManager.sceneLoaded += OnSceneLoaded;
-            // 首次启动时也注册一次窗口（例如在进入第一个场景时）。
-            RegisterAllWindows();
         }
 
         /// <summary>