迁移剩下的 UI 到 Serialization 方式

2026-09-14 17:19:31 +08:00
parent 091a29db63
commit b628a8537c
107 changed files with 4147 additions and 3680 deletions
@@ -0,0 +1,234 @@
+using System.Collections;
+using SepCore.Event;
+using GameFramework.Event;
+using SepCore.EnemyManager;
+using UnityEngine;
+using Unity.Profiling;
+
+namespace SepCore.UI
+{
+    public partial class HudForm : UGuiForm
+    {
+        [SerializeField] private float _sliderFadeDuration = 0.5f;
+
+        private float _currentHpPercent = 0;
+        private Coroutine _hpSliderFadeCoroutine;
+
+        private float _currentExpPercent = 0;
+        private Coroutine _expSliderFadeCoroutine;
+
+        private int _playerCurrentLevel = 1;
+
+        private int _currentCoin = 0;
+
+        private int _currentTimeLeft = 0;
+
+        private EnemyManagerComponent _enemy;
+
+        [SerializeField] private float _performanceStatsRefreshInterval = 0.2f;
+
+        private ProfilerRecorder _cpuTimeRecorder;
+        private float _performanceStatsRefreshTimer;
+        private Coroutine _performanceStatsCoroutine;
+
+        public void RefreshUI(HudContext hudContext)
+        {
+            RefreshMovePrompt(hudContext.MovePrompt);
+        }
+
+        public void RefreshMovePrompt(string prompt)
+        {
+            bool visible = !string.IsNullOrEmpty(prompt);
+            View.inputPromptObject.gameObject.SetActive(visible);
+            View.inputPromptText.text = prompt;
+        }
+
+        #region FSM
+
+        protected override void OnInit(object userData)
+        {
+            base.OnInit(userData);
+
+            GameEntry.Event.Subscribe(PlayerHealthChangeEventArgs.EventId, PlayerHpChange);
+            GameEntry.Event.Subscribe(PlayerExpChangeEventArgs.EventId, PlayerExpChange);
+            GameEntry.Event.Subscribe(PlayerCoinChangeEventArgs.EventId, PlayerCoinChange);
+            GameEntry.Event.Subscribe(PlayerLevelUpEventArgs.EventId, PlayerLevelUp);
+            GameEntry.Event.Subscribe(LevelProcessEventArgs.EventId, LevelProcess);
+
+            _enemy = GameEntry.EnemyManager;
+        }
+
+        protected override void OnOpen(object userData)
+        {
+            base.OnOpen(userData);
+
+            StartPerformanceStatsCollection();
+        }
+
+        protected override void OnPause()
+        {
+            StopPerformanceStatsCoroutine();
+            base.OnPause();
+        }
+
+        protected override void OnResume()
+        {
+            base.OnResume();
+
+            StartPerformanceStatsCoroutine();
+        }
+
+        private void StartPerformanceStatsCollection()
+        {
+            DisposePerformanceStatsRecorders();
+            _cpuTimeRecorder = ProfilerRecorder.StartNew(ProfilerCategory.Internal, "Main Thread", 15);
+
+            StartPerformanceStatsCoroutine();
+        }
+
+        private void StartPerformanceStatsCoroutine()
+        {
+            StopPerformanceStatsCoroutine();
+            _performanceStatsRefreshTimer = 0f;
+            _performanceStatsCoroutine = StartCoroutine(RefreshPerformanceStatsAtEndOfFrame());
+        }
+
+        protected override void OnClose(bool isShutdown, object userData)
+        {
+            GameEntry.Event.Unsubscribe(PlayerLevelUpEventArgs.EventId, PlayerLevelUp);
+            GameEntry.Event.Unsubscribe(PlayerHealthChangeEventArgs.EventId, PlayerHpChange);
+            GameEntry.Event.Unsubscribe(PlayerExpChangeEventArgs.EventId, PlayerExpChange);
+            GameEntry.Event.Unsubscribe(PlayerCoinChangeEventArgs.EventId, PlayerCoinChange);
+            GameEntry.Event.Unsubscribe(PlayerLevelUpEventArgs.EventId, PlayerLevelUp);
+
+            StopPerformanceStatsCoroutine();
+            DisposePerformanceStatsRecorders();
+
+            base.OnClose(isShutdown, userData);
+        }
+
+        private void StopPerformanceStatsCoroutine()
+        {
+            if (_performanceStatsCoroutine != null)
+            {
+                StopCoroutine(_performanceStatsCoroutine);
+                _performanceStatsCoroutine = null;
+            }
+        }
+
+        private void DisposePerformanceStatsRecorders()
+        {
+            if (_cpuTimeRecorder.Valid)
+            {
+                _cpuTimeRecorder.Dispose();
+            }
+        }
+
+        protected override void OnUpdate(float elapseSeconds, float realElapseSeconds)
+        {
+            base.OnUpdate(elapseSeconds, realElapseSeconds);
+            View.enemyCountFormatText.Set(_enemy.CurrentEnemyCount);
+        }
+
+        #endregion
+
+        private IEnumerator RefreshPerformanceStatsAtEndOfFrame()
+        {
+            WaitForEndOfFrame waitForEndOfFrame = new WaitForEndOfFrame();
+            while (true)
+            {
+                yield return waitForEndOfFrame;
+
+                _performanceStatsRefreshTimer -= Time.unscaledDeltaTime;
+                if (_performanceStatsRefreshTimer > 0f) continue;
+
+                _performanceStatsRefreshTimer = Mathf.Max(0.05f, _performanceStatsRefreshInterval);
+                RefreshPerformanceStats();
+            }
+        }
+
+        private void RefreshPerformanceStats()
+        {
+            bool hasCpuFrame = TryGetLastValue(_cpuTimeRecorder, out long cpuFrameNanoseconds);
+
+            if (!hasCpuFrame)
+            {
+                View.cpuTimeCostFormatText.Set(-1);
+                return;
+            }
+
+            float cpuFrameMilliseconds = cpuFrameNanoseconds / 1_000_000f;
+
+            View.cpuTimeCostFormatText.Set(cpuFrameMilliseconds);
+        }
+
+        private static bool TryGetLastValue(ProfilerRecorder recorder, out long value)
+        {
+            if (recorder.Valid && recorder.Count > 0)
+            {
+                value = recorder.LastValue;
+                return true;
+            }
+
+            value = 0;
+            return false;
+        }
+
+        #region Event Handlers
+
+        private void PlayerHpChange(object sender, GameEventArgs e)
+        {
+            if (!(e is PlayerHealthChangeEventArgs args)) return;
+
+            View.hpFormatText.Set(args.CurrentHealth, args.MaxHealth);
+
+            float percent = (float)args.CurrentHealth / args.MaxHealth;
+            if (Mathf.Approximately(_currentHpPercent, percent)) return;
+
+            _currentHpPercent = percent;
+
+            if (_hpSliderFadeCoroutine != null) StopCoroutine(_hpSliderFadeCoroutine);
+            _hpSliderFadeCoroutine = StartCoroutine(View.hpSlider.SmoothValue(percent, _sliderFadeDuration));
+        }
+
+        private void PlayerExpChange(object sender, GameEventArgs e)
+        {
+            if (!(e is PlayerExpChangeEventArgs args)) return;
+            float percent = (float)args.CurrentExp / args.MaxExp;
+            if (Mathf.Approximately(_currentExpPercent, percent)) return;
+
+            _currentExpPercent = percent;
+
+            if (_expSliderFadeCoroutine != null) StopCoroutine(_expSliderFadeCoroutine);
+            _expSliderFadeCoroutine = StartCoroutine(View.expSlider.SmoothValue(percent, _sliderFadeDuration));
+        }
+
+        private void PlayerLevelUp(object sender, GameEventArgs e)
+        {
+            if (!(e is PlayerLevelUpEventArgs)) return;
+
+            _playerCurrentLevel++;
+            View.expFormatText.Set(_playerCurrentLevel);
+        }
+
+        private void PlayerCoinChange(object sender, GameEventArgs e)
+        {
+            if (!(e is PlayerCoinChangeEventArgs args)) return;
+            if (_currentCoin == args.CoinCount) return;
+
+            View.coinFormatText.Set(args.CoinCount);
+            _currentCoin = args.CoinCount;
+        }
+
+        private void LevelProcess(object sender, GameEventArgs e)
+        {
+            if (!(e is LevelProcessEventArgs args)) return;
+            if (_currentTimeLeft == args.LevelTimeLeft) return;
+
+            _currentTimeLeft = args.LevelTimeLeft;
+            View.countdownText.text = _currentTimeLeft.ToString();
+        }
+
+        #endregion
+    }
+}