This commit is contained in:
2026-04-30 19:33:16 +08:00
commit fb2252f688
556 changed files with 69721 additions and 0 deletions
@@ -0,0 +1,152 @@
using System.Collections.Generic;
using GameFramework.Event;
using GeometryTD.CustomEvent;
using GeometryTD.Definition;
using UnityEngine;
using UnityGameFramework.Runtime;
namespace GeometryTD.UI
{
public partial class CombatFinishFormController : UIFormControllerCommonBase<CombatFinishFormContext, CombatFinishForm>
{
private CombatFinishFormUseCase _useCase;
private readonly Dictionary<long, ItemDescSeed> _itemDescSeedMap = new Dictionary<long, ItemDescSeed>();
private sealed class ItemDescSeed
{
public string Title;
public string TypeText;
public string Description;
public TagType[] Tags;
public TagRuntimeData[] TagRuntimes;
}
protected override UIFormType UIFormTypeId => UIFormType.CombatFinishForm;
protected override void RefreshUI(CombatFinishForm form, CombatFinishFormContext context)
{
form.RefreshUI(context);
}
protected override void SubscribeCustomEvents()
{
GameEntry.Event.Subscribe(CombatFinishReturnEventArgs.EventId, OnCombatFinishReturnButtonClicked);
GameEntry.Event.Subscribe(RepoItemClickedEventArgs.EventId, OnRepoItemClicked);
}
protected override void UnsubscribeCustomEvents()
{
GameEntry.Event.Unsubscribe(CombatFinishReturnEventArgs.EventId, OnCombatFinishReturnButtonClicked);
GameEntry.Event.Unsubscribe(RepoItemClickedEventArgs.EventId, OnRepoItemClicked);
}
public override int? OpenUI(object userData = null)
{
if (userData is CombatFinishFormContext context)
{
return OpenUIInternal(context);
}
if (userData is CombatFinishFormRawData rawDataFromUserData)
{
return OpenUI(rawDataFromUserData);
}
if (userData != null)
{
Log.Warning("CombatFinishFormController.OpenUI() userData type is invalid.");
return null;
}
if (_useCase == null)
{
Log.Error("CombatFinishFormController.OpenUI() useCase is null.");
return null;
}
CombatFinishFormRawData rawData = _useCase.CreateInitialModel();
return OpenUI(rawData);
}
public int? OpenUI(CombatFinishFormRawData rawData)
{
CombatFinishFormContext context = BuildContext(rawData);
return OpenUIInternal(context);
}
public override void BindUseCase(IUIUseCase useCase)
{
if (!(useCase is CombatFinishFormUseCase combatFinishFormUseCase))
{
Log.Error("CombatFinishFormController.BindUseCase() useCase is invalid.");
return;
}
_useCase = combatFinishFormUseCase;
}
#region Event Handlers
private void OnCombatFinishReturnButtonClicked(object sender, GameEventArgs e)
{
if (!IsEventFromCurrentForm(sender) || !(e is CombatFinishReturnEventArgs))
{
return;
}
_useCase?.TryReturnToMenu();
}
private void OnRepoItemClicked(object sender, GameEventArgs e)
{
if (!IsEventFromCurrentForm(sender))
{
return;
}
if (!(e is RepoItemClickedEventArgs args))
{
return;
}
if (!_itemDescSeedMap.TryGetValue(args.ItemId, out ItemDescSeed seed))
{
return;
}
GameEntry.UIRouter.OpenUI(UIFormType.ItemDescForm, new ItemDescFormRawData
{
Title = seed.Title,
TypeText = seed.TypeText,
Description = seed.Description ?? string.Empty,
Price = 0,
ScreenPosition = args.ScreenPosition,
Tags = seed.Tags,
TagRuntimes = seed.TagRuntimes
});
}
#endregion
private bool IsEventFromCurrentForm(object sender)
{
if (Form == null)
{
return false;
}
if (ReferenceEquals(sender, Form))
{
return true;
}
if (sender is Component component)
{
CombatFinishForm ownerForm = component.GetComponentInParent<CombatFinishForm>();
return ownerForm == Form;
}
return false;
}
}
}
@@ -0,0 +1,181 @@
using GeometryTD.CustomEvent;
using GeometryTD.Definition;
using GameFramework.Event;
using UnityGameFramework.Runtime;
namespace GeometryTD.UI
{
public partial class CombatInfoFormController : UIFormControllerCommonBase<CombatInfoFormContext, CombatInfoForm>
{
private CombatInfoFormUseCase _useCase;
protected override UIFormType UIFormTypeId => UIFormType.CombatInfoForm;
protected override void RefreshUI(CombatInfoForm form, CombatInfoFormContext context)
{
form.RefreshUI(context);
}
protected override void SubscribeCustomEvents()
{
GameEntry.Event.Subscribe(CombatPauseEventArgs.EventId, OnCombatPauseButtonClicked);
GameEntry.Event.Subscribe(CombatEndEventArgs.EventId, OnCombatEndButtonClicked);
GameEntry.Event.Subscribe(CombatDebugFailEventArgs.EventId, OnCombatDebugFailButtonClicked);
GameEntry.Event.Subscribe(CombatProcessEventArgs.EventId, OnCombatProcessChanged);
GameEntry.Event.Subscribe(CombatCoinChangedEventArgs.EventId, OnCombatCoinChanged);
GameEntry.Event.Subscribe(CombatBaseHpChangedEventArgs.EventId, OnCombatBaseHpChanged);
GameEntry.Event.Subscribe(CombatEnemyHpRateChangedEventArgs.EventId, OnCombatEnemyHpRateChanged);
}
protected override void UnsubscribeCustomEvents()
{
GameEntry.Event.Unsubscribe(CombatPauseEventArgs.EventId, OnCombatPauseButtonClicked);
GameEntry.Event.Unsubscribe(CombatEndEventArgs.EventId, OnCombatEndButtonClicked);
GameEntry.Event.Unsubscribe(CombatDebugFailEventArgs.EventId, OnCombatDebugFailButtonClicked);
GameEntry.Event.Unsubscribe(CombatProcessEventArgs.EventId, OnCombatProcessChanged);
GameEntry.Event.Unsubscribe(CombatCoinChangedEventArgs.EventId, OnCombatCoinChanged);
GameEntry.Event.Unsubscribe(CombatBaseHpChangedEventArgs.EventId, OnCombatBaseHpChanged);
GameEntry.Event.Unsubscribe(CombatEnemyHpRateChangedEventArgs.EventId, OnCombatEnemyHpRateChanged);
}
public int? OpenUI(CombatInfoFormRawData rawData)
{
CombatInfoFormContext context = BuildContext(rawData);
return OpenUIInternal(context);
}
public override int? OpenUI(object userData = null)
{
if (userData is CombatInfoFormContext context)
{
return OpenUIInternal(context);
}
if (userData is CombatInfoFormRawData rawDataFromUserData)
{
return OpenUI(rawDataFromUserData);
}
if (userData != null)
{
Log.Warning("CombatInfoFormController.OpenUI() userData type is invalid.");
return null;
}
if (_useCase == null)
{
Log.Error("CombatInfoFormController.OpenUI() useCase is null.");
return null;
}
CombatInfoFormRawData rawData = _useCase.CreateInitialModel();
return OpenUI(rawData);
}
public override void BindUseCase(IUIUseCase useCase)
{
if (!(useCase is CombatInfoFormUseCase combatInfoFormUseCase))
{
Log.Error("CombatInfoFormController.BindUseCase() useCase is invalid.");
return;
}
_useCase = combatInfoFormUseCase;
}
private void OnCombatPauseButtonClicked(object sender, GameEventArgs e)
{
if (!(sender is CombatInfoForm) || !(e is CombatPauseEventArgs))
{
return;
}
GameEntry.UIRouter.OpenUI(UIFormType.DialogForm, new DialogFormRawData
{
Mode = 1,
Title = "Pause",
Message = "Game paused.",
PauseGame = true,
ConfirmText = "Continue"
});
}
private void OnCombatEndButtonClicked(object sender, GameEventArgs e)
{
if (!(sender is CombatInfoForm) || !(e is CombatEndEventArgs))
{
return;
}
_useCase?.TryEndCombat();
}
private void OnCombatDebugFailButtonClicked(object sender, GameEventArgs e)
{
if (!(sender is CombatInfoForm) || !(e is CombatDebugFailEventArgs))
{
return;
}
_useCase?.TryDebugFail();
}
private void OnCombatProcessChanged(object sender, GameEventArgs e)
{
if (!(e is CombatProcessEventArgs))
{
return;
}
RefreshFromUseCase();
}
private void OnCombatCoinChanged(object sender, GameEventArgs e)
{
if (!(e is CombatCoinChangedEventArgs))
{
return;
}
RefreshFromUseCase();
}
private void OnCombatBaseHpChanged(object sender, GameEventArgs e)
{
if (!(e is CombatBaseHpChangedEventArgs))
{
return;
}
RefreshFromUseCase();
}
private void OnCombatEnemyHpRateChanged(object sender, GameEventArgs e)
{
if (!(e is CombatEnemyHpRateChangedEventArgs))
{
return;
}
RefreshFromUseCase();
}
private void RefreshFromUseCase()
{
if (_useCase == null)
{
return;
}
CombatInfoFormRawData rawData = _useCase.TryRefresh();
CombatInfoFormContext context = BuildContext(rawData);
if (context == null)
{
return;
}
SetContext(context);
RefreshCurrentUI();
}
}
}
@@ -0,0 +1,223 @@
using GameFramework.Event;
using GeometryTD.CustomEvent;
using GeometryTD.Definition;
using UnityEngine;
using UnityGameFramework.Runtime;
namespace GeometryTD.UI
{
public partial class CombatSelectFormController : UIFormControllerCommonBase<CombatSelectFormContext, CombatSelectForm>
{
private CombatSelectFormUseCase _useCase;
protected override UIFormType UIFormTypeId => UIFormType.CombatSelectForm;
protected override void RefreshUI(CombatSelectForm form, CombatSelectFormContext context)
{
form.RefreshUI(context);
}
protected override void SubscribeCustomEvents()
{
GameEntry.Event.Subscribe(CombatSelectItemClickEventArgs.EventId, OnSelectItemClicked);
GameEntry.Event.Subscribe(CombatCoinChangedEventArgs.EventId, OnCombatCoinChanged);
}
protected override void UnsubscribeCustomEvents()
{
GameEntry.Event.Unsubscribe(CombatSelectItemClickEventArgs.EventId, OnSelectItemClicked);
GameEntry.Event.Unsubscribe(CombatCoinChangedEventArgs.EventId, OnCombatCoinChanged);
}
public int? OpenUI(CombatSelectFormRawData rawData)
{
CombatSelectFormContext context = BuildContext(rawData);
if (context == null || !context.IsVisible)
{
CloseUI();
return null;
}
return OpenUIInternal(context);
}
public override int? OpenUI(object userData = null)
{
if (userData is CombatSelectFormUserData clickUserData)
{
return OpenUI(clickUserData);
}
if (userData is CombatSelectFormContext context)
{
if (context == null || !context.IsVisible)
{
CloseUI();
return null;
}
return OpenUIInternal(context);
}
if (userData is CombatSelectFormRawData rawDataFromUserData)
{
return OpenUI(rawDataFromUserData);
}
if (userData != null)
{
Log.Warning("CombatSelectFormController.OpenUI() userData type is invalid.");
return null;
}
if (_useCase == null)
{
Log.Error("CombatSelectFormController.OpenUI() useCase is null.");
return null;
}
CombatSelectFormRawData rawData = _useCase.CreateInitialModel();
return OpenUI(rawData);
}
public int? OpenUI(CombatSelectFormUserData userData)
{
if (_useCase == null)
{
Log.Error("CombatSelectFormController.OpenUI() useCase is null.");
return null;
}
if (userData == null)
{
_useCase.Hide();
CloseUI();
return null;
}
switch (userData.ClickObjectType)
{
case CombatSelectClickObjectType.Foundation:
_useCase.SetUpgradeVisible(true);
_useCase.ShowForFoundation(userData.ScreenPosition);
break;
case CombatSelectClickObjectType.Tower:
_useCase.SetUpgradePrice(userData.UpgradeCost);
_useCase.SetUpgradeVisible(!userData.IsTowerAtMaxLevel);
_useCase.SetDestroyGain(userData.DestroyGain);
_useCase.ShowForTower(userData.ScreenPosition);
break;
default:
_useCase.Hide();
CloseUI();
return null;
}
return OpenUI(_useCase.TryRefresh());
}
public override void BindUseCase(IUIUseCase useCase)
{
if (!(useCase is CombatSelectFormUseCase combatSelectFormUseCase))
{
Log.Error("CombatSelectFormController.BindUseCase() useCase is invalid.");
return;
}
_useCase = combatSelectFormUseCase;
}
public int? ShowForFoundation(Vector2 screenPosition)
{
if (_useCase == null)
{
Log.Error("CombatSelectFormController.ShowForFoundation() useCase is null.");
return null;
}
_useCase.SetUpgradeVisible(true);
_useCase.ShowForFoundation(screenPosition);
return OpenUI(_useCase.TryRefresh());
}
public int? ShowForTower(Vector2 screenPosition, int upgradeCost, int destroyGain)
{
if (_useCase == null)
{
Log.Error("CombatSelectFormController.ShowForTower() useCase is null.");
return null;
}
_useCase.SetUpgradePrice(upgradeCost);
_useCase.SetUpgradeVisible(true);
_useCase.SetDestroyGain(destroyGain);
_useCase.ShowForTower(screenPosition);
return OpenUI(_useCase.TryRefresh());
}
public void HideSelection()
{
_useCase?.Hide();
CloseUI();
}
public void RefreshFromUseCase()
{
if (_useCase == null)
{
return;
}
CombatSelectFormRawData rawData = _useCase.TryRefresh();
CombatSelectFormContext context = BuildContext(rawData);
if (context == null || !context.IsVisible)
{
CloseUI();
return;
}
SetContext(context);
RefreshCurrentUI();
}
private void OnSelectItemClicked(object sender, GameEventArgs e)
{
if (!(e is CombatSelectItemClickEventArgs args))
{
return;
}
if (_useCase == null)
{
return;
}
if (Form != null && sender is Component component)
{
CombatSelectForm ownerForm = component.GetComponentInParent<CombatSelectForm>();
if (ownerForm != Form)
{
return;
}
}
_useCase.TryExecuteAction(args.ActionType, args.ActionIndex);
RefreshFromUseCase();
}
private void OnCombatCoinChanged(object sender, GameEventArgs e)
{
if (!(e is CombatCoinChangedEventArgs))
{
return;
}
if (Form == null)
{
return;
}
RefreshFromUseCase();
}
}
}