Gen_Hack-and-Slash-Roguelite/Client/Assets/Scripts/Base/UIInputControl.cs

using System;
using System.Collections.Generic;
using System.Linq;
using UI;
using UnityEngine;
using UnityEngine.SceneManagement;
using Object = UnityEngine.Object;

namespace Base
{
    /// <summary>
    /// UI窗口输入控制和管理类
    /// 负责根据输入显示/隐藏UI，并根据UI状态管理游戏暂停。
    /// </summary>
    public class UIInputControl : Utils.MonoSingleton<UIInputControl>, ITickUI
    {
        // 存储场景中所有UIBase的实例
        private List<UIBase> _allWindows = new List<UIBase>();
        // 缓存当前可见的窗口
        private readonly List<UIBase> _visibleWindows = new List<UIBase>();

        private bool needUpdate = false;
        /// <summary>
        /// 查找并注册场景中所有的UI窗口，包括非激活状态的
        /// </summary>
        private void RegisterAllWindows()
        {
            _allWindows.Clear();

            // 获取当前活动场景中的所有 GameObject
            var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
            if (!activeScene.isLoaded)
            {
                Debug.LogWarning("当前场景未加载，无法注册窗口！");
                return;
            }

            // 遍历场景中的所有根对象，并查找其子对象中的 UIBase
            foreach (var rootGameObject in activeScene.GetRootGameObjects())
            {
                var windows = rootGameObject.GetComponentsInChildren<UIBase>(true);
                _allWindows.AddRange(windows);
            }

            // 去重（如果有重复的窗口）
            _allWindows = _allWindows.Distinct().ToList();

            // 初始化所有窗口为隐藏状态
            foreach (var window in _allWindows)
            {
                if (window != null && window.gameObject != null)
                {
                    window.Hide();
                }
            }

            needUpdate = true;
            Debug.Log($"窗口数量{_allWindows.Count}");
        }

        /// <summary>
        /// UI逻辑更新循环，需要被外部的某个管理器在Update中调用
        /// </summary>
        public void TickUI()
        {
            //使用这个是为了让输入独占窗口关闭自己后不会立即激活其他窗口的按键，延迟一帧
            if (needUpdate)
            {
                // 更新可见窗口缓存和暂停状态
                UpdateVisibleWindowsCache();
                UpdatePauseState();
                needUpdate = false;
                return;
            }
            if(_visibleWindows.Any(window => window.isInputOccupied))
                return;
            foreach (var window in _allWindows)
            {
                // 检查窗口是否设置了有效的激活按键，并且该按键在本帧被按下
                if (window.actionButton == KeyCode.None || !Input.GetKeyDown(window.actionButton)) continue;
                if (window.IsVisible)
                {
                    // 如果窗口当前是可见的，且未占用输入，则通过按键隐藏它
                    if (!window.isInputOccupied)
                    {
                        Hide(window);
                    }
                }
                else
                {
                    // 如果窗口当前是隐藏的，则显示它
                    Show(window);
                }
            }
        }

        /// <summary>
        /// 公开的显示窗口方法
        /// </summary>
        /// <param name="windowToShow">要显示的窗口</param>
        public void Show(UIBase windowToShow)
        {
            if (!windowToShow || windowToShow.IsVisible) return;

            // 如果窗口是独占的，隐藏所有其他窗口
            if (windowToShow.exclusive)
            {
                List<UIBase> windowsToHide = new List<UIBase>(_visibleWindows);
                foreach (var visibleWindow in windowsToHide)
                {
                    Hide(visibleWindow);
                }
            }

            // 显示目标窗口并更新缓存与暂停状态
            windowToShow.Show();
            needUpdate = true;
        }

        /// <summary>
        /// 公开的隐藏窗口方法
        /// </summary>
        /// <param name="windowToHide">要隐藏的窗口</param>
        public void Hide(UIBase windowToHide)
        {
            if (!windowToHide || !windowToHide.IsVisible) return;

            // 隐藏目标窗口并更新缓存与暂停状态
            windowToHide.Hide();
            needUpdate = true;
        }

        /// <summary>
        /// 根据当前所有可见窗口的 needPause 属性来更新游戏时钟的暂停状态
        /// </summary>
        private void UpdatePauseState()
        {
            bool shouldPause = _visibleWindows.Any(w => w.needPause);
            if (Base.Clock.Instance.Pause != shouldPause)
            {
                Base.Clock.Instance.Pause = shouldPause;
            }
        }

        /// <summary>
        /// 更新当前可见窗口的缓存列表
        /// </summary>
        private void UpdateVisibleWindowsCache()
        {
            _visibleWindows.Clear();
            foreach (var window in _allWindows)
            {
                if (window.IsVisible)
                {
                    _visibleWindows.Add(window);
                }
            }
        }

        private void OnDestroy()
        {
            SceneManager.sceneLoaded -= OnSceneLoaded;
        }

        protected override void OnStart()
        {
            SceneManager.sceneLoaded += OnSceneLoaded;
            
            // RegisterAllWindows();
        }

        private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
        {
            RegisterAllWindows();
        }
    }
}