(client) feat:添加基地界面到游玩界面的过程，添加存档管理，技能树变得可用 (#58)

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/58

Client/Assets/Scripts/Base/Clock.cs

@@ -35,7 +35,9 @@ namespace Base
     /// </summary>
     public class Clock : MonoSingleton<Clock>
     {
+        // 游戏是否暂停
         private bool _pause;
+
         /// <summary>
         /// 获取或设置游戏的暂停状态。当设置为true时，Time.timeScale将变为0；当设置为false时，Time.timeScale将恢复为1。
         /// 该操作会检查当前状态，避免重复设置Time.timeScale。
@@ -54,65 +56,96 @@ namespace Base
             }
         }
 
-        /// <summary>
-        /// 存储所有需要在常规Update中执行Tick逻辑的对象。使用HashSet确保唯一性并提高查找效率。
-        /// </summary>
+        // 存储所有需要在常规Update中执行Tick逻辑的对象
         private readonly HashSet<ITick> _ticks = new();
-        /// <summary>
-        /// 存储所有需要在FixedUpdate中执行物理Tick逻辑的对象。使用HashSet确保唯一性并提高查找效率。
-        /// </summary>
+        // 存储所有需要在FixedUpdate中执行物理Tick逻辑的对象
         private readonly HashSet<ITickPhysics> _tickPhysics = new();
-        /// <summary>
-        /// 存储所有需要在常规Update中执行UI Tick逻辑的对象。使用HashSet确保唯一性并提高查找效率。
-        /// </summary>
+        // 存储所有需要在常规Update中执行UI Tick逻辑的对象
         private readonly HashSet<ITickUI> _tickUIs = new();
 
-        /// <summary>
-        /// 待添加的ITick对象缓冲区。在LateUpdate中统一处理，以避免在迭代主列表时修改列表。
-        /// </summary>
+        // 待添加的ITick对象缓冲区
         private readonly HashSet<ITick> _ticksToAdd = new();
-        /// <summary>
-        /// 待添加的ITickPhysics对象缓冲区。在LateUpdate中统一处理。
-        /// </summary>
+        // 待添加的ITickPhysics对象缓冲区
         private readonly HashSet<ITickPhysics> _tickPhysicsToAdd = new();
-        /// <summary>
-        /// 待添加的ITickUI对象缓冲区。在LateUpdate中统一处理。
-        /// </summary>
+        // 待添加的ITickUI对象缓冲区
         private readonly HashSet<ITickUI> _tickUIsToAdd = new();
 
-        /// <summary>
-        /// 待移除的ITick对象缓冲区。在LateUpdate中统一处理，以避免在迭代主列表时修改列表。
-        /// </summary>
+        // 待移除的ITick对象缓冲区
         private readonly HashSet<ITick> _ticksToRemove = new();
-        /// <summary>
-        /// 待移除的ITickPhysics对象缓冲区。在LateUpdate中统一处理。
-        /// </summary>
+        // 待移除的ITickPhysics对象缓冲区
         private readonly HashSet<ITickPhysics> _tickPhysicsToRemove = new();
-        /// <summary>
-        /// 待移除的ITickUI对象缓冲区。在LateUpdate中统一处理。
-        /// </summary>
+        // 待移除的ITickUI对象缓冲区
         private readonly HashSet<ITickUI> _tickUIsToRemove = new();
+        
+        /// <summary>
+        /// 在单例首次创建时调用。
+        /// </summary>
+        protected override void OnStart()
+        {
+            SceneManager.sceneLoaded += OnSceneLoadedCallback;
+        }
+        
+        /// <summary>
+        /// 在Clock组件被销毁时调用。
+        /// 取消订阅场景加载事件并清理所有内部Tick列表。
+        /// </summary>
+        protected void OnDestroy()
+        {
+            SceneManager.sceneLoaded -= OnSceneLoadedCallback;
+            ClearAllTicksInternal(false);
+        }
 
+        /// <summary>
+        /// 场景加载完成时的回调方法。
+        /// 用于在加载新场景后清理所有Tick列表并重置游戏暂停状态。
+        /// </summary>
+        /// <param name="scene">被加载的场景。</param>
+        /// <param name="mode">场景加载模式。</param>
+        private void OnSceneLoadedCallback(Scene scene, LoadSceneMode mode)
+        {
+            ClearAllTicksInternal(true);
+        }
+
+        /// <summary>
+        /// 每帧更新方法。
+        /// 如果游戏未暂停，则执行所有注册的ITick对象的Tick方法；
+        /// 执行所有注册的ITickUI对象的TickUI方法（UI通常不受暂停影响）。
+        /// </summary>
         private void Update()
         {
             // 如果游戏未暂停，则执行常规的Tick更新。
             if (!_pause)
             {
-                // 迭代主列表，确保_ticks在Update生命周期内不会被Add/Remove直接修改。
-                // 添加和移除操作通过缓冲区在LateUpdate处理。
                 foreach (var tick in _ticks)
                 {
-                    tick.Tick();
+                    try
+                    {
+                        tick.Tick();
+                    }
+                    catch (System.Exception e)
+                    {
+                        Debug.LogError($"[Clock] ITick对象 '{tick.GetType().Name}' 在Tick()执行期间抛出异常: {e}");
+                    }
                 }
             }
             // UI更新通常不受游戏暂停影响（例如菜单动画、UI计时器等）。
-            // 这是当前的默认设计，如果需要UI也暂停，则需修改此处逻辑或引入单独的UI暂停状态。
             foreach (var uiTick in _tickUIs)
             {
-                uiTick.TickUI();
+                try
+                {
+                    uiTick.TickUI();
+                }
+                catch (System.Exception e)
+                {
+                    Debug.LogError($"[Clock] ITickUI对象 '{uiTick.GetType().Name}' 在TickUI()执行期间抛出异常: {e}");
+                }
             }
         }
 
+        /// <summary>
+        /// 每固定帧更新方法。
+        /// 如果游戏未暂停，则执行所有注册的ITickPhysics对象的TickPhysics方法。
+        /// </summary>
         private void FixedUpdate()
         {
             // 如果游戏未暂停，则执行物理Tick更新。
@@ -120,7 +153,14 @@ namespace Base
             {
                 foreach (var physicsTick in _tickPhysics)
                 {
-                    physicsTick.TickPhysics();
+                    try
+                    {
+                        physicsTick.TickPhysics();
+                    }
+                    catch (System.Exception e)
+                    {
+                        Debug.LogError($"[Clock] ITickPhysics对象 '{physicsTick.GetType().Name}' 在TickPhysics()执行期间抛出异常: {e}");
+                    }
                 }
             }
         }
@@ -132,22 +172,6 @@ namespace Base
         {
             ApplyBufferedChanges();
         }
-        
-
-        /// <summary>
-        /// 单例的初始化方法，在Clock实例的生命周期开始时调用（Unity的Awake后）。
-        /// 订阅场景加载事件，并执行初始设置。
-        /// </summary>
-        protected override void OnStart()
-        {
-
-
-        }
-
-
-        
-
-
 
         /// <summary>
         /// 将一个ITick对象添加到待添加缓冲区。它将在下一个LateUpdate中被添加到主Tick列表。
@@ -156,11 +180,10 @@ namespace Base
         /// <param name="tick">要添加的ITick对象。</param>
         public static void AddTick(ITick tick)
         {
-            // 确保Clock实例存在且对象不为空。
-            if (Instance != null && tick != null)
+            if (tick != null)
             {
                 Instance._ticksToAdd.Add(tick);
-                Instance._ticksToRemove.Remove(tick); // 如果在待移除列表，则先从待移除中删除
+                Instance._ticksToRemove.Remove(tick);
             }
         }
 
@@ -171,11 +194,10 @@ namespace Base
         /// <param name="tick">要移除的ITick对象。</param>
         public static void RemoveTick(ITick tick)
         {
-            // 确保Clock实例存在且对象不为空。
-            if (Instance != null && tick != null)
+            if (tick != null)
             {
                 Instance._ticksToRemove.Add(tick);
-                Instance._ticksToAdd.Remove(tick); // 如果在待添加列表，则先从待添加中删除
+                Instance._ticksToAdd.Remove(tick);
             }
         }
 
@@ -186,8 +208,7 @@ namespace Base
         /// <param name="physics">要添加的ITickPhysics对象。</param>
         public static void AddTickPhysics(ITickPhysics physics)
         {
-            // 确保Clock实例存在且对象不为空。
-            if (Instance != null && physics != null)
+            if (physics != null)
             {
                 Instance._tickPhysicsToAdd.Add(physics);
                 Instance._tickPhysicsToRemove.Remove(physics);
@@ -201,8 +222,7 @@ namespace Base
         /// <param name="physics">要移除的ITickPhysics对象。</param>
         public static void RemoveTickPhysics(ITickPhysics physics)
         {
-            // 确保Clock实例存在且对象不为空。
-            if (Instance != null && physics != null)
+            if (physics != null)
             {
                 Instance._tickPhysicsToRemove.Add(physics);
                 Instance._tickPhysicsToAdd.Remove(physics);
@@ -216,8 +236,7 @@ namespace Base
         /// <param name="ui">要添加的ITickUI对象。</param>
         public static void AddTickUI(ITickUI ui)
         {
-            // 确保Clock实例存在且对象不为空。
-            if (Instance != null && ui != null)
+            if (ui != null)
             {
                 Instance._tickUIsToAdd.Add(ui);
                 Instance._tickUIsToRemove.Remove(ui);
@@ -231,8 +250,7 @@ namespace Base
         /// <param name="ui">要移除的ITickUI对象。</param>
         public static void RemoveTickUI(ITickUI ui)
         {
-            // 确保Clock实例存在且对象不为空。
-            if (Instance != null && ui != null)
+            if (ui != null)
             {
                 Instance._tickUIsToRemove.Add(ui);
                 Instance._tickUIsToAdd.Remove(ui);
@@ -240,19 +258,18 @@ namespace Base
         }
 
         /// <summary>
-        /// 私有方法，用于将缓冲区中的添加和移除操作应用到主Tick列表中。
+        /// 将缓冲区中的添加和移除操作应用到主Tick列表中。
         /// 此方法应在LateUpdate中调用，以确保在所有Tick执行完毕后进行列表修改，从而避免迭代器错误。
         /// </summary>
         private void ApplyBufferedChanges()
         {
-            // --- 先处理移除操作 ---
             if (_ticksToRemove.Count > 0)
             {
                 foreach (var tick in _ticksToRemove)
                 {
-                    _ticks.Remove(tick); // 从主列表移除，HashSet的移除操作平均为O(1)
+                    _ticks.Remove(tick);
                 }
-                _ticksToRemove.Clear(); // 清空移除缓冲区
+                _ticksToRemove.Clear();
             }
 
             if (_tickPhysicsToRemove.Count > 0)
@@ -273,22 +290,32 @@ namespace Base
                 _tickUIsToRemove.Clear();
             }
 
-            // --- 后处理添加操作 ---
             if (_ticksToAdd.Count > 0)
             {
                 foreach (var tick in _ticksToAdd)
                 {
-                    // 添加到主列表。HashSet.Add平均为O(1)，并自动处理重复添加（会忽略重复项）。
+                    // 逻辑修改：
+                    // 防止将已销毁的Unity对象添加到主Tick列表中。
+                    // Unity的UnityEngine.Object重载了"=="运算符，因此对于已销毁的对象，
+                    // (unityObject == null) 会返回 true。
+                    if (tick is Object unityObject && unityObject == null)
+                    {
+                        continue; // 跳过已销毁的Unity对象
+                    }
                     _ticks.Add(tick);
                 }
-                _ticksToAdd.Clear(); // 清空添加缓冲区
+                _ticksToAdd.Clear();
             }
 
             if (_tickPhysicsToAdd.Count > 0)
             {
                 foreach (var physicsTick in _tickPhysicsToAdd)
                 {
-                    _tickPhysics.Add(physicsTick); // HashSet.Add 会自动处理重复
+                    if (physicsTick is Object unityObject && unityObject == null)
+                    {
+                        continue;
+                    }
+                    _tickPhysics.Add(physicsTick);
                 }
                 _tickPhysicsToAdd.Clear();
             }
@@ -297,10 +324,45 @@ namespace Base
             {
                 foreach (var uiTick in _tickUIsToAdd)
                 {
-                    _tickUIs.Add(uiTick); // HashSet.Add 会自动处理重复
+                    if (uiTick is Object unityObject && unityObject == null)
+                    {
+                        continue;
+                    }
+                    _tickUIs.Add(uiTick);
                 }
                 _tickUIsToAdd.Clear();
             }
         }
+
+        /// <summary>
+        /// 集中处理所有Tick列表和缓冲区的清理。
+        /// 此方法会在场景加载、Clock被禁用或销毁时调用。
+        /// </summary>
+        /// <param name="clearPauseState">指示是否同时重置Pause状态和Time.timeScale。</param>
+        private void ClearAllTicksInternal(bool clearPauseState)
+        {
+            _ticks.Clear();
+            _tickPhysics.Clear();
+            _tickUIs.Clear();
+
+            // 逻辑修改：
+            // 在场景加载时，不应清除_ToAdd缓冲区。
+            // 这些缓冲区用于收集当前帧内（包括场景加载期间）的有效注册请求。
+            // 清除它们会导致在场景加载过程中新注册的Ticks被立即抹除。
+            // 对于前一场景中已销毁的Tick引用，将在ApplyBufferedChanges中进行过滤处理。
+            // _ticksToAdd.Clear(); 
+            // _tickPhysicsToAdd.Clear();
+            // _tickUIsToAdd.Clear(); 
+
+            _ticksToRemove.Clear();
+            _tickPhysicsToRemove.Clear();
+            _tickUIsToRemove.Clear();
+
+            if (clearPauseState)
+            {
+                Pause = false;
+            }
+        }
+
     }
 }