651 lines
22 KiB
C#
651 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using GeometryTD.CustomEvent;
|
|
using GeometryTD.Definition;
|
|
using GameFramework.Event;
|
|
using GeometryTD.CustomUtility;
|
|
using UnityEngine;
|
|
using UnityGameFramework.Runtime;
|
|
|
|
namespace GeometryTD.UI
|
|
{
|
|
public class RepoFormController : UIFormControllerCommonBase<RepoFormContext, RepoForm>
|
|
{
|
|
private const int MaxParticipantCount = 4;
|
|
private RepoFormUseCase _useCase;
|
|
private readonly Dictionary<long, RepoItemContext> _itemContextMap = new Dictionary<long, RepoItemContext>();
|
|
private readonly Dictionary<long, ItemDescSeed> _itemDescSeedMap = new Dictionary<long, ItemDescSeed>();
|
|
private readonly HashSet<long> _participantTowerIds = new HashSet<long>();
|
|
|
|
private sealed class ItemDescSeed
|
|
{
|
|
public string Title;
|
|
public string TypeText;
|
|
public string Description;
|
|
public TagType[] Tags;
|
|
}
|
|
|
|
protected override UIFormType UIFormTypeId => UIFormType.RepoForm;
|
|
|
|
protected override void RefreshUI(RepoForm form, RepoFormContext context)
|
|
{
|
|
form.RefreshUI(context);
|
|
ApplyParticipantSelection();
|
|
}
|
|
|
|
protected override void SubscribeCustomEvents()
|
|
{
|
|
GameEntry.Event.Subscribe(RepoItemDetailRequestedEventArgs.EventId, OnRepoItemDetailRequested);
|
|
GameEntry.Event.Subscribe(RepoItemDragEndedEventArgs.EventId, OnRepoItemDragEnded);
|
|
GameEntry.Event.Subscribe(CombineSlotClickedEventArgs.EventId, OnCombineSlotClicked);
|
|
GameEntry.Event.Subscribe(RepoCombineRequestedEventArgs.EventId, OnRepoCombineRequested);
|
|
GameEntry.Event.Subscribe(RepoParticipantAssignRequestedEventArgs.EventId, OnRepoParticipantAssignRequested);
|
|
GameEntry.Event.Subscribe(RepoParticipantRemoveRequestedEventArgs.EventId, OnRepoParticipantRemoveRequested);
|
|
GameEntry.Event.Subscribe(RepoFormReturnEventArgs.EventId, OnRepoFormReturn);
|
|
}
|
|
|
|
protected override void UnsubscribeCustomEvents()
|
|
{
|
|
GameEntry.Event.Unsubscribe(RepoItemDetailRequestedEventArgs.EventId, OnRepoItemDetailRequested);
|
|
GameEntry.Event.Unsubscribe(RepoItemDragEndedEventArgs.EventId, OnRepoItemDragEnded);
|
|
GameEntry.Event.Unsubscribe(CombineSlotClickedEventArgs.EventId, OnCombineSlotClicked);
|
|
GameEntry.Event.Unsubscribe(RepoCombineRequestedEventArgs.EventId, OnRepoCombineRequested);
|
|
GameEntry.Event.Unsubscribe(RepoParticipantAssignRequestedEventArgs.EventId, OnRepoParticipantAssignRequested);
|
|
GameEntry.Event.Unsubscribe(RepoParticipantRemoveRequestedEventArgs.EventId, OnRepoParticipantRemoveRequested);
|
|
GameEntry.Event.Unsubscribe(RepoFormReturnEventArgs.EventId, OnRepoFormReturn);
|
|
}
|
|
|
|
public override int? OpenUI(object userData = null)
|
|
{
|
|
if (userData is RepoFormContext repoFormContext)
|
|
{
|
|
return OpenUIInternal(repoFormContext);
|
|
}
|
|
|
|
if (userData is RepoFormRawData rawDataFromUserData)
|
|
{
|
|
return OpenUI(rawDataFromUserData);
|
|
}
|
|
|
|
if (userData != null)
|
|
{
|
|
Log.Warning("RepoFormController.OpenUI() userData type is invalid.");
|
|
return null;
|
|
}
|
|
|
|
if (_useCase == null)
|
|
{
|
|
Log.Error("RepoFormController.OpenUI() useCase is null.");
|
|
return null;
|
|
}
|
|
|
|
RepoFormRawData rawData = _useCase.CreateInitialModel();
|
|
return OpenUI(rawData);
|
|
}
|
|
|
|
public int? OpenUI(RepoFormRawData rawData)
|
|
{
|
|
RepoFormContext context = BuildContext(rawData);
|
|
return OpenUIInternal(context);
|
|
}
|
|
|
|
public override void BindUseCase(IUIUseCase useCase)
|
|
{
|
|
if (!(useCase is RepoFormUseCase repoFormUseCase))
|
|
{
|
|
Log.Error("RepoFormController.BindUseCase() useCase is invalid.");
|
|
return;
|
|
}
|
|
|
|
_useCase = repoFormUseCase;
|
|
}
|
|
|
|
private RepoFormContext BuildContext(RepoFormRawData rawData)
|
|
{
|
|
_itemContextMap.Clear();
|
|
_itemDescSeedMap.Clear();
|
|
if (rawData?.Inventory == null)
|
|
{
|
|
_participantTowerIds.Clear();
|
|
return null;
|
|
}
|
|
|
|
Dictionary<long, MuzzleCompItemData> muzzleMap = BuildComponentMap(rawData.Inventory.MuzzleComponents);
|
|
Dictionary<long, BearingCompItemData> bearingMap = BuildComponentMap(rawData.Inventory.BearingComponents);
|
|
Dictionary<long, BaseCompItemData> baseMap = BuildComponentMap(rawData.Inventory.BaseComponents);
|
|
Dictionary<long, TowerItemData> towerMap = BuildTowerMap(rawData.Inventory.Towers);
|
|
List<RepoItemContext> items = new List<RepoItemContext>();
|
|
|
|
if (rawData.Inventory.Towers != null)
|
|
{
|
|
foreach (TowerItemData tower in rawData.Inventory.Towers)
|
|
{
|
|
if (tower == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AddItemContext(items, new RepoItemContext
|
|
{
|
|
InstanceId = tower.InstanceId,
|
|
CanDrag = true,
|
|
EnduranceRate01 = ItemDescUtility.ResolveTowerEnduranceRate(tower, muzzleMap, bearingMap, baseMap),
|
|
ClickActionType = RepoItemClickActionType.OpenDetail,
|
|
ComponentSlotType = TowerCompSlotType.None,
|
|
IconAreaContext = BuildIconAreaContext(tower)
|
|
});
|
|
AddItemDescSeed(
|
|
tower.InstanceId,
|
|
tower.Name,
|
|
"Tower",
|
|
ItemDescUtility.BuildTowerDesc(tower, muzzleMap, bearingMap, baseMap) ?? string.Empty,
|
|
tower.Stats != null ? tower.Stats.Tags : null);
|
|
}
|
|
}
|
|
|
|
if (rawData.Inventory.MuzzleComponents != null)
|
|
{
|
|
foreach (MuzzleCompItemData item in rawData.Inventory.MuzzleComponents)
|
|
{
|
|
if (item == null || item.IsAssembledIntoTower)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AddItemContext(items, new RepoItemContext
|
|
{
|
|
InstanceId = item.InstanceId,
|
|
CanDrag = true,
|
|
EnduranceRate01 = ItemDescUtility.ResolveComponentEnduranceRate(item),
|
|
ClickActionType = RepoItemClickActionType.OpenDetail,
|
|
ComponentSlotType = TowerCompSlotType.Muzzle,
|
|
IconAreaContext = BuildIconAreaContext(item)
|
|
});
|
|
AddItemDescSeed(
|
|
item.InstanceId,
|
|
item.Name,
|
|
BuildComponentTypeText(item.SlotType),
|
|
ItemDescUtility.BuildMuzzleDesc(item) ?? string.Empty,
|
|
item.Tags);
|
|
}
|
|
}
|
|
|
|
if (rawData.Inventory.BearingComponents != null)
|
|
{
|
|
foreach (BearingCompItemData item in rawData.Inventory.BearingComponents)
|
|
{
|
|
if (item == null || item.IsAssembledIntoTower)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AddItemContext(items, new RepoItemContext
|
|
{
|
|
InstanceId = item.InstanceId,
|
|
CanDrag = true,
|
|
EnduranceRate01 = ItemDescUtility.ResolveComponentEnduranceRate(item),
|
|
ClickActionType = RepoItemClickActionType.OpenDetail,
|
|
ComponentSlotType = TowerCompSlotType.Bearing,
|
|
IconAreaContext = BuildIconAreaContext(item)
|
|
});
|
|
AddItemDescSeed(
|
|
item.InstanceId,
|
|
item.Name,
|
|
BuildComponentTypeText(item.SlotType),
|
|
ItemDescUtility.BuildBearingDesc(item) ?? string.Empty,
|
|
item.Tags);
|
|
}
|
|
}
|
|
|
|
if (rawData.Inventory.BaseComponents != null)
|
|
{
|
|
foreach (BaseCompItemData item in rawData.Inventory.BaseComponents)
|
|
{
|
|
if (item == null || item.IsAssembledIntoTower)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AddItemContext(items, new RepoItemContext
|
|
{
|
|
InstanceId = item.InstanceId,
|
|
CanDrag = true,
|
|
EnduranceRate01 = ItemDescUtility.ResolveComponentEnduranceRate(item),
|
|
ClickActionType = RepoItemClickActionType.OpenDetail,
|
|
ComponentSlotType = TowerCompSlotType.Base,
|
|
IconAreaContext = BuildIconAreaContext(item)
|
|
});
|
|
AddItemDescSeed(
|
|
item.InstanceId,
|
|
item.Name,
|
|
BuildComponentTypeText(item.SlotType),
|
|
ItemDescUtility.BuildBaseDesc(item) ?? string.Empty,
|
|
item.Tags);
|
|
}
|
|
}
|
|
|
|
ParticipantAreaContext participantAreaContext =
|
|
BuildParticipantAreaContext(rawData.Inventory, towerMap, muzzleMap, bearingMap, baseMap);
|
|
|
|
return new RepoFormContext
|
|
{
|
|
CombineAreaContext = new CombineAreaContext(),
|
|
CompAreaContext = new CompAreaContext
|
|
{
|
|
Items = items.ToArray()
|
|
},
|
|
ParticipantAreaContext = participantAreaContext
|
|
};
|
|
}
|
|
|
|
private void AddItemContext(List<RepoItemContext> items, RepoItemContext itemContext)
|
|
{
|
|
if (itemContext == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
items.Add(itemContext);
|
|
_itemContextMap[itemContext.InstanceId] = itemContext;
|
|
}
|
|
|
|
private void AddItemDescSeed(long itemId, string title, string typeText, string description, TagType[] tags)
|
|
{
|
|
if (itemId <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_itemDescSeedMap[itemId] = new ItemDescSeed
|
|
{
|
|
Title = string.IsNullOrWhiteSpace(title) ? $"Item {itemId}" : title,
|
|
TypeText = typeText ?? string.Empty,
|
|
Description = description ?? string.Empty,
|
|
Tags = CloneTags(tags)
|
|
};
|
|
}
|
|
|
|
private static TagType[] CloneTags(TagType[] tags)
|
|
{
|
|
return tags != null ? (TagType[])tags.Clone() : Array.Empty<TagType>();
|
|
}
|
|
|
|
private static string BuildComponentTypeText(TowerCompSlotType slotType)
|
|
{
|
|
return slotType switch
|
|
{
|
|
TowerCompSlotType.Muzzle => "Muzzle Component",
|
|
TowerCompSlotType.Bearing => "Bearing Component",
|
|
TowerCompSlotType.Base => "Base Component",
|
|
TowerCompSlotType.Accessory => "Accessory",
|
|
_ => "Component"
|
|
};
|
|
}
|
|
|
|
private static Dictionary<long, TComp> BuildComponentMap<TComp>(IReadOnlyList<TComp> items)
|
|
where TComp : TowerCompItemData
|
|
{
|
|
Dictionary<long, TComp> map = new Dictionary<long, TComp>();
|
|
if (items == null)
|
|
{
|
|
return map;
|
|
}
|
|
|
|
for (int i = 0; i < items.Count; i++)
|
|
{
|
|
TComp item = items[i];
|
|
if (item == null || item.InstanceId <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
map[item.InstanceId] = item;
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
private static Dictionary<long, TowerItemData> BuildTowerMap(IReadOnlyList<TowerItemData> towers)
|
|
{
|
|
Dictionary<long, TowerItemData> map = new Dictionary<long, TowerItemData>();
|
|
if (towers == null)
|
|
{
|
|
return map;
|
|
}
|
|
|
|
for (int i = 0; i < towers.Count; i++)
|
|
{
|
|
TowerItemData tower = towers[i];
|
|
if (tower == null || tower.InstanceId <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
map[tower.InstanceId] = tower;
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
private ParticipantAreaContext BuildParticipantAreaContext(
|
|
BackpackInventoryData inventory,
|
|
IReadOnlyDictionary<long, TowerItemData> towerMap,
|
|
IReadOnlyDictionary<long, MuzzleCompItemData> muzzleMap,
|
|
IReadOnlyDictionary<long, BearingCompItemData> bearingMap,
|
|
IReadOnlyDictionary<long, BaseCompItemData> baseMap)
|
|
{
|
|
_participantTowerIds.Clear();
|
|
List<RepoItemContext> participantItems = new List<RepoItemContext>();
|
|
if (inventory?.ParticipantTowerInstanceIds != null && towerMap != null)
|
|
{
|
|
for (int i = 0; i < inventory.ParticipantTowerInstanceIds.Count; i++)
|
|
{
|
|
long towerId = inventory.ParticipantTowerInstanceIds[i];
|
|
if (towerId <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!towerMap.TryGetValue(towerId, out TowerItemData tower) || tower == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!_participantTowerIds.Add(towerId))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
participantItems.Add(new RepoItemContext
|
|
{
|
|
InstanceId = tower.InstanceId,
|
|
CanDrag = false,
|
|
EnduranceRate01 = ItemDescUtility.ResolveTowerEnduranceRate(tower, muzzleMap, bearingMap, baseMap),
|
|
ClickActionType = RepoItemClickActionType.RemoveParticipant,
|
|
ComponentSlotType = TowerCompSlotType.None,
|
|
IconAreaContext = BuildIconAreaContext(tower)
|
|
});
|
|
}
|
|
}
|
|
|
|
return new ParticipantAreaContext
|
|
{
|
|
Items = participantItems.ToArray(),
|
|
MaxCount = MaxParticipantCount
|
|
};
|
|
}
|
|
|
|
private void ApplyParticipantSelection()
|
|
{
|
|
if (Form == null || _itemContextMap.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach (KeyValuePair<long, RepoItemContext> pair in _itemContextMap)
|
|
{
|
|
RepoItemContext itemContext = pair.Value;
|
|
if (itemContext == null || itemContext.ComponentSlotType != TowerCompSlotType.None)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Form.SetRepoItemSelected(pair.Key, _participantTowerIds.Contains(pair.Key));
|
|
}
|
|
}
|
|
|
|
private void RefreshParticipantAreaOnly()
|
|
{
|
|
if (_useCase == null || Form == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
RepoFormContext latestContext = BuildContext(_useCase.CreateInitialModel());
|
|
if (latestContext?.ParticipantAreaContext == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Form.RefreshParticipantArea(latestContext.ParticipantAreaContext);
|
|
ApplyParticipantSelection();
|
|
}
|
|
|
|
private static IconAreaContext BuildIconAreaContext(TowerItemData tower)
|
|
{
|
|
if (tower == null)
|
|
{
|
|
return new IconAreaContext
|
|
{
|
|
ComponentSlotType = TowerCompSlotType.None,
|
|
Rarity = RarityType.None,
|
|
Color = Color.white,
|
|
Icon = null
|
|
};
|
|
}
|
|
|
|
return new IconAreaContext
|
|
{
|
|
ComponentSlotType = TowerCompSlotType.None,
|
|
Rarity = tower.Rarity,
|
|
Color = IconColorGenerator.GenerateForTower(tower),
|
|
Icon = null
|
|
};
|
|
}
|
|
|
|
private static IconAreaContext BuildIconAreaContext(TowerCompItemData item)
|
|
{
|
|
if (item == null)
|
|
{
|
|
return new IconAreaContext
|
|
{
|
|
ComponentSlotType = TowerCompSlotType.None,
|
|
Rarity = RarityType.None,
|
|
Color = Color.white,
|
|
Icon = null
|
|
};
|
|
}
|
|
|
|
return new IconAreaContext
|
|
{
|
|
ComponentSlotType = item.SlotType,
|
|
Rarity = item.Rarity,
|
|
Color = IconColorGenerator.GenerateForComponent(item),
|
|
Icon = null
|
|
};
|
|
}
|
|
|
|
#region Event Handlers
|
|
|
|
private void OnRepoItemDetailRequested(object sender, GameEventArgs e)
|
|
{
|
|
if (!IsEventFromCurrentForm(sender))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!(e is RepoItemDetailRequestedEventArgs 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,
|
|
TargetPos = args.TargetPos,
|
|
Tags = CloneTags(seed.Tags)
|
|
});
|
|
}
|
|
|
|
private void OnRepoItemDragEnded(object sender, GameEventArgs e)
|
|
{
|
|
if (!IsEventFromCurrentForm(sender))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!(e is RepoItemDragEndedEventArgs args))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (Form == null || !_itemContextMap.ContainsKey(args.ItemId))
|
|
{
|
|
return;
|
|
}
|
|
|
|
Form.SetRepoItemSelected(args.ItemId, args.Assigned);
|
|
}
|
|
|
|
private void OnCombineSlotClicked(object sender, GameEventArgs e)
|
|
{
|
|
if (!IsEventFromCurrentForm(sender))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!(e is CombineSlotClickedEventArgs args))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (Form == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (Form.TryClearCombineSlot(args.SlotIndex, out long removedItemId) && removedItemId > 0)
|
|
{
|
|
Form.SetRepoItemSelected(removedItemId, false);
|
|
}
|
|
}
|
|
|
|
private void OnRepoFormReturn(object sender, GameEventArgs e)
|
|
{
|
|
if (!IsEventFromCurrentForm(sender) || !(e is RepoFormReturnEventArgs))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (Form == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
this.CloseUI();
|
|
}
|
|
|
|
private void OnRepoCombineRequested(object sender, GameEventArgs e)
|
|
{
|
|
if (!IsEventFromCurrentForm(sender))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!(e is RepoCombineRequestedEventArgs args))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_useCase == null || Form == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!_useCase.TryAssembleTower(args.MuzzleItemId, args.BearingItemId, args.BaseItemId))
|
|
{
|
|
return;
|
|
}
|
|
|
|
RepoFormRawData latestRawData = _useCase.CreateInitialModel();
|
|
RepoFormContext latestContext = BuildContext(latestRawData);
|
|
if (latestContext != null)
|
|
{
|
|
Form.RefreshUI(latestContext);
|
|
ApplyParticipantSelection();
|
|
}
|
|
}
|
|
|
|
private void OnRepoParticipantAssignRequested(object sender, GameEventArgs e)
|
|
{
|
|
if (!IsEventFromCurrentForm(sender))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!(e is RepoParticipantAssignRequestedEventArgs args))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_useCase == null || Form == null || args.TowerItemId <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!_useCase.TryAddParticipantTower(args.TowerItemId))
|
|
{
|
|
return;
|
|
}
|
|
|
|
RefreshParticipantAreaOnly();
|
|
}
|
|
|
|
private void OnRepoParticipantRemoveRequested(object sender, GameEventArgs e)
|
|
{
|
|
if (!IsEventFromCurrentForm(sender))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!(e is RepoParticipantRemoveRequestedEventArgs args))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_useCase == null || Form == null || args.TowerItemId <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!_useCase.TryRemoveParticipantTower(args.TowerItemId))
|
|
{
|
|
return;
|
|
}
|
|
|
|
RefreshParticipantAreaOnly();
|
|
}
|
|
|
|
private bool IsEventFromCurrentForm(object sender)
|
|
{
|
|
if (Form == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (ReferenceEquals(sender, Form))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (sender is Component component)
|
|
{
|
|
RepoForm ownerForm = component.GetComponentInParent<RepoForm>();
|
|
return ownerForm == Form;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|