init

2026-04-30 19:33:16 +08:00
commit fb2252f688
556 changed files with 69721 additions and 0 deletions
@@ -0,0 +1,269 @@
+using System.Collections.Generic;
+using GeometryTD.CustomUtility;
+using GeometryTD.Definition;
+using UnityEngine;
+
+namespace GeometryTD.UI
+{
+    public partial class CombatFinishFormController
+    {
+        private CombatFinishFormContext BuildContext(CombatFinishFormRawData rawData)
+        {
+            _itemDescSeedMap.Clear();
+            if (rawData == null)
+            {
+                return null;
+            }
+
+            return new CombatFinishFormContext
+            {
+                EnemyKilledText = rawData.DefeatedEnemyCount.ToString(),
+                GoldGainedText = rawData.GainedGold.ToString(),
+                RewardItems = BuildRewardItems(rawData.RewardInventory),
+                CanReturn = rawData.CanReturn
+            };
+        }
+
+        private RepoItemContext[] BuildRewardItems(BackpackInventoryData inventory)
+        {
+            if (inventory == null)
+            {
+                return System.Array.Empty<RepoItemContext>();
+            }
+
+            Dictionary<long, MuzzleCompItemData> muzzleMap = BuildComponentMap(inventory.MuzzleComponents);
+            Dictionary<long, BearingCompItemData> bearingMap = BuildComponentMap(inventory.BearingComponents);
+            Dictionary<long, BaseCompItemData> baseMap = BuildComponentMap(inventory.BaseComponents);
+            List<RepoItemContext> itemContexts = new List<RepoItemContext>();
+
+            if (inventory.Towers != null)
+            {
+                foreach (TowerItemData tower in inventory.Towers)
+                {
+                    if (tower == null)
+                    {
+                        continue;
+                    }
+
+                    itemContexts.Add(new RepoItemContext
+                    {
+                        InstanceId = tower.InstanceId,
+                        CanDrag = false,
+                        EnduranceRate01 = ItemDescUtility.ResolveTowerEnduranceRate(tower, muzzleMap, bearingMap, baseMap),
+                        ClickActionType = RepoItemClickActionType.OpenDetail,
+                        ComponentSlotType = TowerCompSlotType.None,
+                        IconAreaContext = BuildTowerIconContext(tower, muzzleMap, bearingMap, baseMap)
+                    });
+
+                    AddItemDescSeed(
+                        tower.InstanceId,
+                        tower.Name,
+                        "Tower",
+                        ItemDescUtility.BuildTowerDesc(tower, muzzleMap, bearingMap, baseMap) ?? string.Empty,
+                        tower.Stats?.Tags,
+                        tower.Stats?.TagRuntimes);
+                }
+            }
+
+            if (inventory.MuzzleComponents != null)
+            {
+                foreach (MuzzleCompItemData item in inventory.MuzzleComponents)
+                {
+                    if (item == null)
+                    {
+                        continue;
+                    }
+
+                    itemContexts.Add(new RepoItemContext
+                    {
+                        InstanceId = item.InstanceId,
+                        CanDrag = false,
+                        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,
+                        null);
+                }
+            }
+
+            if (inventory.BearingComponents != null)
+            {
+                foreach (BearingCompItemData item in inventory.BearingComponents)
+                {
+                    if (item == null)
+                    {
+                        continue;
+                    }
+
+                    itemContexts.Add(new RepoItemContext
+                    {
+                        InstanceId = item.InstanceId,
+                        CanDrag = false,
+                        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,
+                        null);
+                }
+            }
+
+            if (inventory.BaseComponents != null)
+            {
+                foreach (BaseCompItemData item in inventory.BaseComponents)
+                {
+                    if (item == null)
+                    {
+                        continue;
+                    }
+
+                    itemContexts.Add(new RepoItemContext
+                    {
+                        InstanceId = item.InstanceId,
+                        CanDrag = false,
+                        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,
+                        null);
+                }
+            }
+
+            return itemContexts.ToArray();
+        }
+
+        private static TowerIconAreaContext BuildTowerIconContext(
+            TowerItemData tower,
+            IReadOnlyDictionary<long, MuzzleCompItemData> muzzleMap,
+            IReadOnlyDictionary<long, BearingCompItemData> bearingMap,
+            IReadOnlyDictionary<long, BaseCompItemData> baseMap)
+        {
+            if (tower == null)
+            {
+                return null;
+            }
+
+            return new TowerIconAreaContext
+            {
+                Rarity = tower.Rarity,
+                MuzzleColor = ResolveComponentColor(tower.MuzzleComponentInstanceId, muzzleMap),
+                BearingColor = ResolveComponentColor(tower.BearingComponentInstanceId, bearingMap),
+                BaseColor = ResolveComponentColor(tower.BaseComponentInstanceId, baseMap)
+            };
+        }
+
+        private static Color ResolveComponentColor<TComp>(long instanceId, IReadOnlyDictionary<long, TComp> componentMap)
+            where TComp : TowerCompItemData
+        {
+            if (instanceId > 0 && componentMap != null && componentMap.TryGetValue(instanceId, out TComp comp) &&
+                comp != null)
+            {
+                return IconColorGenerator.GenerateForComponent(comp);
+            }
+
+            return Color.white;
+        }
+
+        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 (TComp item in items)
+            {
+                if (item == null || item.InstanceId <= 0)
+                {
+                    continue;
+                }
+
+                map[item.InstanceId] = item;
+            }
+
+            return map;
+        }
+
+        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
+            };
+        }
+    }
+}
@@ -0,0 +1,76 @@
+using GeometryTD.Definition;
+using UnityEngine;
+
+namespace GeometryTD.UI
+{
+    public partial class CombatInfoFormController
+    {
+        private static CombatInfoFormContext BuildContext(CombatInfoFormRawData rawData)
+        {
+            if (rawData == null)
+            {
+                return null;
+            }
+
+            return new CombatInfoFormContext
+            {
+                LevelMetaText = BuildLevelMetaText(rawData.LevelThemeType, rawData.LevelId),
+                LevelPhaseText = BuildPhaseText(rawData.CurrentPhaseIndex, rawData.TotalPhaseCount),
+                CoinText = BuildCoinText(rawData.Coin),
+                BaseHpText = BuildBaseHpText(rawData.BaseHp, rawData.BaseHpMax),
+                EnemyHpRateText = BuildEnemyHpRateText(rawData.EnemyHpRateMultiplier),
+                CanPause = rawData.CanPause,
+                CanEnd = rawData.CanEnd
+            };
+        }
+
+        private static string BuildLevelMetaText(LevelThemeType themeType, int levelId)
+        {
+            if (levelId <= 0)
+            {
+                return "Map -";
+            }
+
+            return $"{themeType} Map.{levelId}";
+        }
+
+        private static string BuildPhaseText(int currentPhaseIndex, int totalPhaseCount)
+        {
+            int phaseIndex = currentPhaseIndex < 0 ? 0 : currentPhaseIndex;
+            if (totalPhaseCount <= 0)
+            {
+                return $"{phaseIndex}/?";
+            }
+
+            return $"Wave: {phaseIndex}/{totalPhaseCount}";
+        }
+
+        private static string BuildCoinText(int coin)
+        {
+            if (coin < 0)
+            {
+                return "Coin: -";
+            }
+
+            return $"Coin: {coin}";
+        }
+
+        private static string BuildBaseHpText(int baseHp, int baseHpMax)
+        {
+            if (baseHpMax <= 0)
+            {
+                return "\u57FA\u5730\uFF1A-";
+            }
+
+            int clampedHp = Mathf.Clamp(baseHp, 0, baseHpMax);
+            int percent = Mathf.RoundToInt((float)clampedHp / baseHpMax * 100f);
+            return $"\u57FA\u5730\uFF1A{percent}%";
+        }
+
+        private static string BuildEnemyHpRateText(int enemyHpRateMultiplier)
+        {
+            int resolvedMultiplier = enemyHpRateMultiplier > 0 ? enemyHpRateMultiplier : 1;
+            return $"\u96BE\u5EA6\uFF1A{resolvedMultiplier}x";
+        }
+    }
+}
@@ -0,0 +1,77 @@
+using UnityEngine;
+
+namespace GeometryTD.UI
+{
+    public partial class CombatSelectFormController
+    {
+        private static CombatSelectFormContext BuildContext(CombatSelectFormRawData rawData)
+        {
+            if (rawData == null)
+            {
+                return null;
+            }
+
+            return new CombatSelectFormContext
+            {
+                IsVisible = rawData.IsVisible,
+                ScreenPosition = rawData.ScreenPosition,
+                ShowBuildArea = rawData.IsVisible && rawData.DisplayMode == CombatSelectDisplayMode.Build,
+                ShowFuncArea = rawData.IsVisible && rawData.DisplayMode == CombatSelectDisplayMode.Func,
+                BuildItems = BuildItemContexts(rawData.BuildItems),
+                UpgradeItem = BuildItemContext(rawData.UpgradeItem),
+                DestroyItem = BuildItemContext(rawData.DestroyItem)
+            };
+        }
+
+        private static TowerSelectItemContext[] BuildItemContexts(TowerSelectItemRawData[] itemRawData)
+        {
+            if (itemRawData == null || itemRawData.Length <= 0)
+            {
+                return System.Array.Empty<TowerSelectItemContext>();
+            }
+
+            TowerSelectItemContext[] contexts = new TowerSelectItemContext[itemRawData.Length];
+            for (int i = 0; i < itemRawData.Length; i++)
+            {
+                contexts[i] = BuildItemContext(itemRawData[i]);
+            }
+
+            return contexts;
+        }
+
+        private static TowerSelectItemContext BuildItemContext(TowerSelectItemRawData rawData)
+        {
+            if (rawData == null)
+            {
+                return null;
+            }
+
+            return new TowerSelectItemContext
+            {
+                Icon = rawData.Icon,
+                PriceText = BuildPriceText(rawData.Price, rawData.IsGain),
+                IsVisible = rawData.IsVisible,
+                IsInteractable = rawData.IsInteractable,
+                ActionType = rawData.ActionType,
+                ActionIndex = rawData.ActionIndex,
+                TowerIconAreaContext = new TowerIconAreaContext
+                {
+                    BaseColor = rawData.BaseColor,
+                    BearingColor = rawData.BearingColor,
+                    MuzzleColor = rawData.MuzzleColor
+                }
+            };
+        }
+
+        private static string BuildPriceText(int price, bool isGain)
+        {
+            int positivePrice = Mathf.Max(0, price);
+            if (isGain)
+            {
+                return $"+{positivePrice}";
+            }
+
+            return positivePrice.ToString();
+        }
+    }
+}