init

2026-04-30 19:33:16 +08:00
commit fb2252f688
556 changed files with 69721 additions and 0 deletions
@@ -0,0 +1,78 @@
+using GeometryTD.Definition;
+using UnityGameFramework.Runtime;
+
+namespace GeometryTD.UI
+{
+    public class DialogFormController : UIFormControllerCommonBase<DialogFormContext, DialogForm>
+    {
+        protected override UIFormType UIFormTypeId => UIFormType.DialogForm;
+
+        protected override void RefreshUI(DialogForm form, DialogFormContext context)
+        {
+            form.RefreshUI(context);
+        }
+
+        protected override void CloseLoadedFormDirect(DialogForm form)
+        {
+            GameEntry.UI.CloseUIForm(form);
+        }
+
+        private static DialogFormContext BuildContext(DialogFormRawData rawData)
+        {
+            if (rawData == null)
+            {
+                return null;
+            }
+
+            return new DialogFormContext
+            {
+                Mode = rawData.Mode,
+                Title = rawData.Title,
+                Message = rawData.Message,
+                PauseGame = rawData.PauseGame,
+                ConfirmText = rawData.ConfirmText,
+                OnClickConfirm = rawData.OnClickConfirm,
+                CancelText = rawData.CancelText,
+                OnClickCancel = rawData.OnClickCancel,
+                OtherText = rawData.OtherText,
+                OnClickOther = rawData.OnClickOther,
+                UserData = rawData.UserData
+            };
+        }
+
+        public int? OpenUI(DialogFormRawData rawData)
+        {
+            DialogFormContext context = BuildContext(rawData);
+            return OpenUIInternal(context);
+        }
+
+        public override int? OpenUI(object userData = null)
+        {
+            if (userData is DialogFormContext context)
+            {
+                return OpenUIInternal(context);
+            }
+
+            if (userData is DialogFormRawData rawData)
+            {
+                return OpenUI(rawData);
+            }
+
+            if (userData != null)
+            {
+                Log.Warning("DialogFormController.OpenUI() userData type is invalid.");
+                return null;
+            }
+
+            return OpenUIInternal(Context);
+        }
+
+        public override void BindUseCase(IUIUseCase useCase)
+        {
+            if (useCase != null)
+            {
+                Log.Warning("DialogFormController does not use a use case.");
+            }
+        }
+    }
+}
@@ -0,0 +1,121 @@
+using GameFramework.Event;
+using GeometryTD.CustomUtility;
+using GeometryTD.Definition;
+using UnityGameFramework.Runtime;
+
+namespace GeometryTD.UI
+{
+    public class ItemDescFormController : UIFormControllerCommonBase<
+        ItemDescFormContext, ItemDescForm>
+    {
+        protected override UIFormType UIFormTypeId => UIFormType.ItemDescForm;
+
+
+        protected override void RefreshUI(ItemDescForm form, ItemDescFormContext context)
+        {
+            form.RefreshUI(context);
+        }
+
+        protected override void CloseLoadedFormDirect(ItemDescForm form)
+        {
+            GameEntry.UI.CloseUIForm(form);
+        }
+
+        private static ItemDescFormContext BuildContext(ItemDescFormRawData rawData)
+        {
+            if (rawData == null)
+            {
+                return null;
+            }
+
+            return new ItemDescFormContext
+            {
+                Title = rawData.Title,
+                TypeText = rawData.TypeText,
+                Description = BuildDescription(rawData),
+                Price = rawData.Price,
+                ScreenPosition = rawData.ScreenPosition,
+                Tags = BuildTags(rawData)
+            };
+        }
+
+        private static string BuildDescription(ItemDescFormRawData rawData)
+        {
+            string baseDescription = rawData?.Description ?? string.Empty;
+            string tagDescription = rawData?.TagRuntimes != null && rawData.TagRuntimes.Length > 0
+                ? TagDisplayUtility.BuildTagDescriptionText(rawData.TagRuntimes)
+                : TagDisplayUtility.BuildTagDescriptionText(rawData?.Tags);
+            if (string.IsNullOrWhiteSpace(tagDescription))
+            {
+                return baseDescription;
+            }
+
+            if (string.IsNullOrWhiteSpace(baseDescription))
+            {
+                return tagDescription;
+            }
+
+            return $"{baseDescription}\n{tagDescription}";
+        }
+
+        private static TagItemContext[] BuildTags(ItemDescFormRawData rawData)
+        {
+            string[] tagTexts = rawData?.TagRuntimes != null && rawData.TagRuntimes.Length > 0
+                ? TagDisplayUtility.BuildTagTexts(rawData.TagRuntimes)
+                : rawData?.Tags != null
+                    ? TagDisplayUtility.BuildTagTexts(rawData.Tags)
+                    : null;
+
+            if (tagTexts == null || tagTexts.Length <= 0)
+            {
+                return System.Array.Empty<TagItemContext>();
+            }
+
+            TagItemContext[] contexts = new TagItemContext[tagTexts.Length];
+            for (int i = 0; i < tagTexts.Length; i++)
+            {
+                contexts[i] = new TagItemContext
+                {
+                    TagName = tagTexts[i] ?? string.Empty
+                };
+            }
+
+            return contexts;
+        }
+
+        public int? OpenUI(ItemDescFormRawData rawData)
+        {
+            ItemDescFormContext context = BuildContext(rawData);
+            return OpenUIInternal(context);
+        }
+
+        public override int? OpenUI(object userData = null)
+        {
+            if (userData is ItemDescFormContext context)
+            {
+                return OpenUIInternal(context);
+            }
+
+            if (userData is ItemDescFormRawData rawData)
+            {
+                return OpenUI(rawData);
+            }
+
+            if (userData != null)
+            {
+                Log.Warning("ItemDescFormController.OpenUI() userData type is invalid.");
+                return null;
+            }
+
+            return OpenUIInternal(Context);
+        }
+
+        public override void BindUseCase(IUIUseCase useCase)
+        {
+            if (!(useCase is ItemDescFormUseCase))
+            {
+                Log.Error("ItemDescForm.BindUseCase() useCase is invalid.");
+            }
+        }
+    }
+}
@@ -0,0 +1,162 @@
+using GeometryTD.CustomEvent;
+using GeometryTD.Definition;
+using GameFramework.Event;
+using UnityEngine;
+using UnityGameFramework.Runtime;
+
+namespace GeometryTD.UI
+{
+    public partial class RewardSelectFormController : UIFormControllerCommonBase<RewardSelectFormContext, RewardSelectForm>
+    {
+        private RewardSelectFormUseCase _useCase;
+
+        protected override UIFormType UIFormTypeId => UIFormType.RewardSelectForm;
+
+        protected override void RefreshUI(RewardSelectForm form, RewardSelectFormContext context)
+        {
+            form.RefreshUI(context);
+        }
+
+        protected override void SubscribeCustomEvents()
+        {
+            GameEntry.Event.Subscribe(RewardSelectItemSelectedEventArgs.EventId, OnRewardSelected);
+            GameEntry.Event.Subscribe(RewardSelectRefreshEventArgs.EventId, OnRefreshClicked);
+            GameEntry.Event.Subscribe(RewardSelectGiveUpEventArgs.EventId, OnGiveUpClicked);
+        }
+
+        protected override void UnsubscribeCustomEvents()
+        {
+            GameEntry.Event.Unsubscribe(RewardSelectItemSelectedEventArgs.EventId, OnRewardSelected);
+            GameEntry.Event.Unsubscribe(RewardSelectRefreshEventArgs.EventId, OnRefreshClicked);
+            GameEntry.Event.Unsubscribe(RewardSelectGiveUpEventArgs.EventId, OnGiveUpClicked);
+        }
+
+        public override int? OpenUI(object userData = null)
+        {
+            if (userData is RewardSelectFormContext context)
+            {
+                return OpenUIInternal(context);
+            }
+
+            if (userData is RewardSelectFormRawData rawDataFromUserData)
+            {
+                return OpenUI(rawDataFromUserData);
+            }
+
+            if (userData != null)
+            {
+                Log.Warning("RewardSelectFormController.OpenUI() userData type is invalid.");
+                return null;
+            }
+
+            if (_useCase == null)
+            {
+                Log.Error("RewardSelectFormController.OpenUI() useCase is null.");
+                return null;
+            }
+
+            RewardSelectFormRawData rawData = _useCase.CreateInitialModel();
+            return OpenUI(rawData);
+        }
+
+        public int? OpenUI(RewardSelectFormRawData rawData)
+        {
+            RewardSelectFormContext context = BuildContext(rawData);
+            return OpenUIInternal(context);
+        }
+
+        public override void BindUseCase(IUIUseCase useCase)
+        {
+            if (!(useCase is RewardSelectFormUseCase rewardSelectUseCase))
+            {
+                Log.Error("RewardSelectFormController.BindUseCase() useCase is invalid.");
+                return;
+            }
+
+            _useCase = rewardSelectUseCase;
+        }
+
+        private void OnRewardSelected(object sender, GameEventArgs e)
+        {
+            if (!IsEventFromCurrentForm(sender) || !(e is RewardSelectItemSelectedEventArgs args))
+            {
+                return;
+            }
+
+            if (_useCase == null)
+            {
+                return;
+            }
+
+            RewardSelectFormRawData nextRawData = _useCase.SelectReward(args.SelectedIndex);
+            if (nextRawData == null)
+            {
+                CloseUI();
+                return;
+            }
+
+            OpenUI(nextRawData);
+        }
+
+        private void OnRefreshClicked(object sender, GameEventArgs e)
+        {
+            if (!IsEventFromCurrentForm(sender) || !(e is RewardSelectRefreshEventArgs))
+            {
+                return;
+            }
+
+            if (_useCase == null)
+            {
+                return;
+            }
+
+            RewardSelectFormRawData nextRawData = _useCase.TryRotateSelection();
+            if (nextRawData == null)
+            {
+                CloseUI();
+                return;
+            }
+
+            OpenUI(nextRawData);
+        }
+
+        private void OnGiveUpClicked(object sender, GameEventArgs e)
+        {
+            if (!IsEventFromCurrentForm(sender) || !(e is RewardSelectGiveUpEventArgs))
+            {
+                return;
+            }
+
+            if (_useCase == null)
+            {
+                return;
+            }
+
+            if (_useCase.TryGiveUp())
+            {
+                CloseUI();
+            }
+        }
+
+        private bool IsEventFromCurrentForm(object sender)
+        {
+            if (Form == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(sender, Form))
+            {
+                return true;
+            }
+
+            if (sender is Component component)
+            {
+                RewardSelectForm ownerForm = component.GetComponentInParent<RewardSelectForm>();
+                return ownerForm == Form;
+            }
+
+            return false;
+        }
+    }
+}