397 lines
14 KiB
C#
397 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using GeometryTD.CustomUtility;
|
|
using GeometryTD.Definition;
|
|
using UnityEngine;
|
|
|
|
namespace GeometryTD.UI
|
|
{
|
|
public partial class RepoFormController
|
|
{
|
|
private RepoFormContext BuildContext(RepoFormRawData rawData)
|
|
{
|
|
_itemClickActionMap.Clear();
|
|
_itemDescSeedMap.Clear();
|
|
_compAreaTowerIds.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> componentItems = new List<RepoItemContext>();
|
|
List<TowerRepoItemContext> towerItems = new List<TowerRepoItemContext>();
|
|
|
|
if (rawData.Inventory.Towers != null)
|
|
{
|
|
foreach (var tower in rawData.Inventory.Towers)
|
|
{
|
|
if (tower == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TowerRepoItemContext towerContext = BuildTowerRepoItemContext(tower, muzzleMap, bearingMap, baseMap,
|
|
RepoItemClickActionType.OpenDetail, true);
|
|
AddTowerItemContext(towerItems, towerContext);
|
|
AddItemDescSeed(
|
|
tower.InstanceId,
|
|
tower.Name,
|
|
"Tower",
|
|
ItemDescUtility.BuildTowerDesc(tower, muzzleMap, bearingMap, baseMap) ?? string.Empty,
|
|
tower.Stats?.Tags,
|
|
tower.Stats?.TagRuntimes);
|
|
}
|
|
}
|
|
|
|
if (rawData.Inventory.MuzzleComponents != null)
|
|
{
|
|
foreach (var item in rawData.Inventory.MuzzleComponents)
|
|
{
|
|
if (item == null || item.IsAssembledIntoTower)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
RepoItemContext componentContext = new RepoItemContext
|
|
{
|
|
InstanceId = item.InstanceId,
|
|
CanDrag = true,
|
|
EnduranceRate01 = ItemDescUtility.ResolveComponentEnduranceRate(item),
|
|
ClickActionType = RepoItemClickActionType.OpenDetail,
|
|
ComponentSlotType = TowerCompSlotType.Muzzle,
|
|
IconAreaContext = BuildIconAreaContext(item)
|
|
};
|
|
AddComponentItemContext(componentItems, componentContext);
|
|
AddItemDescSeed(
|
|
item.InstanceId,
|
|
item.Name,
|
|
BuildComponentTypeText(item.SlotType),
|
|
ItemDescUtility.BuildMuzzleDesc(item) ?? string.Empty,
|
|
item.Tags,
|
|
null);
|
|
}
|
|
}
|
|
|
|
if (rawData.Inventory.BearingComponents != null)
|
|
{
|
|
foreach (BearingCompItemData item in rawData.Inventory.BearingComponents)
|
|
{
|
|
if (item == null || item.IsAssembledIntoTower)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
RepoItemContext componentContext = new RepoItemContext
|
|
{
|
|
InstanceId = item.InstanceId,
|
|
CanDrag = true,
|
|
EnduranceRate01 = ItemDescUtility.ResolveComponentEnduranceRate(item),
|
|
ClickActionType = RepoItemClickActionType.OpenDetail,
|
|
ComponentSlotType = TowerCompSlotType.Bearing,
|
|
IconAreaContext = BuildIconAreaContext(item)
|
|
};
|
|
AddComponentItemContext(componentItems, componentContext);
|
|
AddItemDescSeed(
|
|
item.InstanceId,
|
|
item.Name,
|
|
BuildComponentTypeText(item.SlotType),
|
|
ItemDescUtility.BuildBearingDesc(item) ?? string.Empty,
|
|
item.Tags,
|
|
null);
|
|
}
|
|
}
|
|
|
|
if (rawData.Inventory.BaseComponents != null)
|
|
{
|
|
foreach (BaseCompItemData item in rawData.Inventory.BaseComponents)
|
|
{
|
|
if (item == null || item.IsAssembledIntoTower)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
RepoItemContext componentContext = new RepoItemContext
|
|
{
|
|
InstanceId = item.InstanceId,
|
|
CanDrag = true,
|
|
EnduranceRate01 = ItemDescUtility.ResolveComponentEnduranceRate(item),
|
|
ClickActionType = RepoItemClickActionType.OpenDetail,
|
|
ComponentSlotType = TowerCompSlotType.Base,
|
|
IconAreaContext = BuildIconAreaContext(item)
|
|
};
|
|
AddComponentItemContext(componentItems, componentContext);
|
|
AddItemDescSeed(
|
|
item.InstanceId,
|
|
item.Name,
|
|
BuildComponentTypeText(item.SlotType),
|
|
ItemDescUtility.BuildBaseDesc(item) ?? string.Empty,
|
|
item.Tags,
|
|
null);
|
|
}
|
|
}
|
|
|
|
ParticipantAreaContext participantAreaContext =
|
|
BuildParticipantAreaContext(rawData.Inventory, towerMap, muzzleMap, bearingMap, baseMap);
|
|
|
|
return new RepoFormContext
|
|
{
|
|
CombineAreaContext = new CombineAreaContext(),
|
|
CompAreaContext = new CompAreaContext
|
|
{
|
|
ComponentItems = componentItems.ToArray(),
|
|
TowerItems = towerItems.ToArray()
|
|
},
|
|
ParticipantAreaContext = participantAreaContext
|
|
};
|
|
}
|
|
|
|
private void AddComponentItemContext(List<RepoItemContext> items, RepoItemContext itemContext)
|
|
{
|
|
if (itemContext == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
items.Add(itemContext);
|
|
_itemClickActionMap[itemContext.InstanceId] = itemContext.ClickActionType;
|
|
}
|
|
|
|
private void AddTowerItemContext(List<TowerRepoItemContext> items, TowerRepoItemContext itemContext)
|
|
{
|
|
if (itemContext == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
items.Add(itemContext);
|
|
_itemClickActionMap[itemContext.InstanceId] = itemContext.ClickActionType;
|
|
_compAreaTowerIds.Add(itemContext.InstanceId);
|
|
}
|
|
|
|
private void AddItemDescSeed(
|
|
long itemId,
|
|
string title,
|
|
string typeText,
|
|
string description,
|
|
TagType[] tags,
|
|
TagRuntimeData[] tagRuntimes)
|
|
{
|
|
if (itemId <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_itemDescSeedMap[itemId] = new ItemDescSeed
|
|
{
|
|
Title = string.IsNullOrWhiteSpace(title) ? $"Item {itemId}" : title,
|
|
TypeText = typeText ?? string.Empty,
|
|
Description = description ?? string.Empty,
|
|
Tags = tags,
|
|
TagRuntimes = tagRuntimes
|
|
};
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
foreach (var item in items)
|
|
{
|
|
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;
|
|
}
|
|
|
|
foreach (var tower in towers)
|
|
{
|
|
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<TowerRepoItemContext> participantItems = new List<TowerRepoItemContext>();
|
|
if (inventory?.ParticipantTowerInstanceIds != null && towerMap != null)
|
|
{
|
|
foreach (var towerId in inventory.ParticipantTowerInstanceIds)
|
|
{
|
|
if (towerId <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!towerMap.TryGetValue(towerId, out TowerItemData tower) || tower == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!_participantTowerIds.Add(towerId))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TowerRepoItemContext towerContext = BuildTowerRepoItemContext(tower, muzzleMap, bearingMap, baseMap,
|
|
RepoItemClickActionType.RemoveParticipant, false);
|
|
if (towerContext != null)
|
|
{
|
|
participantItems.Add(towerContext);
|
|
_itemClickActionMap[towerContext.InstanceId] = towerContext.ClickActionType;
|
|
}
|
|
}
|
|
}
|
|
|
|
return new ParticipantAreaContext
|
|
{
|
|
TowerItems = participantItems.ToArray(),
|
|
MaxCount = MaxParticipantCount
|
|
};
|
|
}
|
|
|
|
private void ApplyParticipantSelection()
|
|
{
|
|
if (Form == null || _compAreaTowerIds.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach (long towerId in _compAreaTowerIds)
|
|
{
|
|
Form.SetRepoItemSelected(towerId, _participantTowerIds.Contains(towerId));
|
|
}
|
|
}
|
|
|
|
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 TowerRepoItemContext BuildTowerRepoItemContext(
|
|
TowerItemData tower,
|
|
IReadOnlyDictionary<long, MuzzleCompItemData> muzzleMap,
|
|
IReadOnlyDictionary<long, BearingCompItemData> bearingMap,
|
|
IReadOnlyDictionary<long, BaseCompItemData> baseMap,
|
|
RepoItemClickActionType clickActionType,
|
|
bool canDrag)
|
|
{
|
|
if (tower == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new TowerRepoItemContext
|
|
{
|
|
InstanceId = tower.InstanceId,
|
|
CanDrag = canDrag,
|
|
EnduranceRate01 = ItemDescUtility.ResolveTowerEnduranceRate(tower, muzzleMap, bearingMap, baseMap),
|
|
ClickActionType = clickActionType,
|
|
ComponentSlotType = TowerCompSlotType.None,
|
|
IconAreaContext = new TowerIconAreaContext
|
|
{
|
|
Rarity = tower.Rarity,
|
|
MuzzleColor = ResolveComponentColor(tower.MuzzleComponentInstanceId, muzzleMap),
|
|
BearingColor = ResolveComponentColor(tower.BearingComponentInstanceId, bearingMap),
|
|
BaseColor = ResolveComponentColor(tower.BaseComponentInstanceId, baseMap)
|
|
}
|
|
};
|
|
}
|
|
|
|
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
|
|
};
|
|
}
|
|
|
|
private static Color ResolveComponentColor<TComp>(long instanceId,
|
|
IReadOnlyDictionary<long, TComp> componentMap)
|
|
where TComp : TowerCompItemData
|
|
{
|
|
if (instanceId > 0 &&
|
|
componentMap != null &&
|
|
componentMap.TryGetValue(instanceId, out TComp component) &&
|
|
component != null)
|
|
{
|
|
return IconColorGenerator.GenerateForComponent(component);
|
|
}
|
|
|
|
return Color.white;
|
|
}
|
|
}
|
|
}
|