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

Client/Assets/Scripts/Base/Launcher.cs

@@ -148,6 +148,9 @@ namespace Base
                 EventManager.Instance,
                 AudioManager.Instance,
                 SkillTreeManager.Instance,
+                
+                KeyValueArchiveManager.Instance,
+                SaveManager.Instance, // 存档管理器应在其他依赖管理器之后加载
             };
 
             // 缓存UI的初始颜色，以便后续操作（如渐隐）或重置

Client/Assets/Scripts/Base/MainMenuSet.cs

@@ -0,0 +1,13 @@
+using System;
+using UnityEngine;
+
+namespace Base
+{
+    public class MainMenuSet:MonoBehaviour
+    {
+        private void Start()
+        {
+            Program.Instance.EndPlayGame();
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cec06564c6ae43daa1dc257835c919ac
+timeCreated: 1759404751

Client/Assets/Scripts/Base/PlayGameSceneControl.cs

@@ -0,0 +1,126 @@
+using System;
+using Data;
+using Entity;
+using Managers;
+using Map;
+using UI;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Base
+{
+    public class PlayGameSceneControl:MonoBehaviour,ITick
+    {
+        public Dimension dimensionPrefab;
+        
+        public WaitStartUI waitStartUI;
+
+        public bool AllDimensionsLoaded => OutsideDimensionsLoaded && InsideDimensionsLoaded;
+        public bool OutsideDimensionsLoaded { get; private set; }
+        public bool InsideDimensionsLoaded { get; private set; }
+
+        public DimensionDef OutsideDef{get; private set;}
+        public DimensionDef InsideDef{get; private set;}
+        
+        public Dimension OutsideDimension{get; private set;}
+        public Dimension InsideDimension{get; private set;}
+        
+        public bool TaskCompleted{get; private set;}
+        private void Start()
+        {
+            OutsideDef = Program.Instance.OutsidePlayDimension;
+            InsideDef = Program.Instance.CurrentCharacter.insideDimensionDef ??
+                        DefineManager.Instance.FindDefine<DimensionDef>(
+                            Configs.ConfigManager.Instance.GetValue<string>("InsideDimension"));
+            if (OutsideDef == null || InsideDef == null)
+            {
+                MessageManager.Instance.DisplayMessage("初始化失败！检查XML文件完整性",PromptDisplayCategory.ScreenCenterLargeText,Color.brown);
+                Invoke(nameof(ReturnMainMenu), 3);
+            }
+            OutsideDimension=Instantiate(dimensionPrefab);
+            InsideDimension = Instantiate(dimensionPrefab);
+            
+            OutsideDimension.transform.localPosition = new Vector3(0, 0, 1);
+            InsideDimension.transform.localPosition = new Vector3(0, 1000, 1);
+            
+            _ = OutsideDimension.ApplyDimensionDef(OutsideDef);
+            _ = InsideDimension.ApplyDimensionDef(InsideDef);
+
+            OutsideDimension.OnDimensionLoaded += OutsideDimensionLoaded;
+            OutsideDimension.OnDimensionLoaded += InsideDimensionLoaded;
+            
+            
+            
+            Program.Instance.SetFocusedDimension(OutsideDimension.DimensionId);
+            
+            Clock.AddTick(this);
+        }
+
+        private void OnDestroy()
+        {
+            Clock.RemoveTick(this);
+        }
+
+
+        private void StartGame()
+        {
+            if (!AllDimensionsLoaded)
+            {
+                return;
+            }
+            waitStartUI.Hide();
+            Program.Instance.PutPlayer();
+            if (OutsideDef.story != null)
+            {
+                EventManager.Instance.PlayStory(OutsideDef.story.defName, OutsideDimension.DimensionId);
+            }
+
+            if (InsideDef.story != null)
+            {
+                EventManager.Instance.PlayStory(InsideDef.story.defName, InsideDimension.DimensionId);
+            }
+        }
+        
+        
+        private void ReturnMainMenu()
+        {
+            EscUI.ReturnMainMenu();
+        }
+
+        private void OutsideDimensionLoaded(Dimension dimension)
+        {
+            OutsideDimensionsLoaded = true;
+            StartGame();
+        }
+
+        private void InsideDimensionLoaded(Dimension dimension)
+        {
+            InsideDimensionsLoaded = true;
+            StartGame();
+        }
+
+        public void Tick()
+        {
+            if(!AllDimensionsLoaded)
+                return;
+            if (EventManager.Instance.HasStoryDisplay || TaskCompleted)
+                return;
+            MessageManager.Instance.DisplayMessage("清理完毕！", PromptDisplayCategory.ScreenCenterLargeText,
+                Color.softYellow);
+            TaskCompleted = true;
+            Invoke(nameof(ReturnBase), 5);
+
+            var player = Program.Instance.FocusedEntity as Character;
+            if(!player)
+                return;
+            Program.Instance.CoinCount += player.Coin.Quantity;
+
+        }
+
+        public void ReturnBase()
+        {
+            Program.Instance.EndPlayGame();
+            SceneManager.LoadScene("Base");
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c8957653de16448fad7c6dc5b273ffe3
+timeCreated: 1759370474

Client/Assets/Scripts/Base/UIInputControl.cs

@@ -40,6 +40,8 @@ namespace Base
         /// </summary>
         public int VisibleWindowCount => _visibleWindows.Count;
 
+        public bool HasWindowOpen => _visibleWindows.Any();
+
         /// <summary>
         /// 查询指定名称的UI窗口是否当前可见。
         /// </summary>
@@ -245,15 +247,20 @@ namespace Base
         private void UpdateVisibleWindowsCache()
         {
             _visibleWindows.Clear();
-            foreach (var window in _allWindows)
+
+            var exclusiveWindow = _allWindows.FirstOrDefault(window => window && window.IsVisible && window.exclusive);
+
+            if (exclusiveWindow)
             {
-                if (window && window.IsVisible)
-                {
-                    _visibleWindows.Add(window);
-                }
+                _visibleWindows.Add(exclusiveWindow);
+            }
+            else
+            {
+                _visibleWindows.AddRange(_allWindows.Where(window => window && window.IsVisible));
             }
         }
 
+
         /// <summary>
         /// 当脚本实例被销毁时调用。
         /// 用于在销毁时取消订阅场景加载事件，防止内存泄漏。
@@ -283,6 +290,7 @@ namespace Base
         private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
         {
             RegisterAllWindows();
+            Clock.AddTickUI(this);
         }
     }
 }