geometry-tower-defense/Assets/GameMain/Scripts/UI/Combat/ContextBuilder/CombatFinishFormController.ContextBuilder.cs

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
            };
        }
    }
}