补充参战防御塔进入战斗逻辑

- 将 Inventory 中参战的防御塔数据传递到 CombatSelectForm 中 - 为防御塔的图标展示添加 TowerRepoItem 与 TowerIconArea 适配防御塔的三层 Image
2026-03-05 13:44:49 +08:00
parent 9db9aeabcd
commit 8a478982f8
56 changed files with 2507 additions and 467 deletions
@@ -2,6 +2,7 @@ namespace GeometryTD.UI
 {
    public class CompAreaContext
    {
-        public RepoItemContext[] Items;
+        public RepoItemContext[] ComponentItems;
+        public TowerRepoItemContext[] TowerItems;
    }
 }
@@ -2,7 +2,7 @@ namespace GeometryTD.UI
 {
    public class ParticipantAreaContext : UIContext
    {
-        public RepoItemContext[] Items;
+        public TowerRepoItemContext[] TowerItems;
        public int MaxCount;
    }
 }
@@ -0,0 +1,9 @@
+using System;
+
+namespace GeometryTD.UI
+{
+    [Serializable]
+    public class TowerRepoItemContext : RepoItemContext
+    {
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 813496ec671788a4b975fa980ce16555
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -10,8 +10,9 @@ namespace GeometryTD.UI
    {
        private RepoFormContext BuildContext(RepoFormRawData rawData)
        {
-            _itemContextMap.Clear();
+            _itemClickActionMap.Clear();
            _itemDescSeedMap.Clear();
+            _compAreaTowerIds.Clear();
            if (rawData?.Inventory == null)
            {
                _participantTowerIds.Clear();
@@ -22,7 +23,8 @@ namespace GeometryTD.UI
            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>();
+            List<RepoItemContext> componentItems = new List<RepoItemContext>();
+            List<TowerRepoItemContext> towerItems = new List<TowerRepoItemContext>();

            if (rawData.Inventory.Towers != null)
            {
@@ -33,15 +35,9 @@ namespace GeometryTD.UI
                        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)
-                    });
+                    TowerRepoItemContext towerContext = BuildTowerRepoItemContext(tower, muzzleMap, bearingMap, baseMap,
+                        RepoItemClickActionType.OpenDetail, true);
+                    AddTowerItemContext(towerItems, towerContext);
                    AddItemDescSeed(
                        tower.InstanceId,
                        tower.Name,
@@ -60,7 +56,7 @@ namespace GeometryTD.UI
                        continue;
                    }

-                    AddItemContext(items, new RepoItemContext
+                    RepoItemContext componentContext = new RepoItemContext
                    {
                        InstanceId = item.InstanceId,
                        CanDrag = true,
@@ -68,7 +64,8 @@ namespace GeometryTD.UI
                        ClickActionType = RepoItemClickActionType.OpenDetail,
                        ComponentSlotType = TowerCompSlotType.Muzzle,
                        IconAreaContext = BuildIconAreaContext(item)
-                    });
+                    };
+                    AddComponentItemContext(componentItems, componentContext);
                    AddItemDescSeed(
                        item.InstanceId,
                        item.Name,
@@ -87,7 +84,7 @@ namespace GeometryTD.UI
                        continue;
                    }

-                    AddItemContext(items, new RepoItemContext
+                    RepoItemContext componentContext = new RepoItemContext
                    {
                        InstanceId = item.InstanceId,
                        CanDrag = true,
@@ -95,7 +92,8 @@ namespace GeometryTD.UI
                        ClickActionType = RepoItemClickActionType.OpenDetail,
                        ComponentSlotType = TowerCompSlotType.Bearing,
                        IconAreaContext = BuildIconAreaContext(item)
-                    });
+                    };
+                    AddComponentItemContext(componentItems, componentContext);
                    AddItemDescSeed(
                        item.InstanceId,
                        item.Name,
@@ -114,7 +112,7 @@ namespace GeometryTD.UI
                        continue;
                    }

-                    AddItemContext(items, new RepoItemContext
+                    RepoItemContext componentContext = new RepoItemContext
                    {
                        InstanceId = item.InstanceId,
                        CanDrag = true,
@@ -122,7 +120,8 @@ namespace GeometryTD.UI
                        ClickActionType = RepoItemClickActionType.OpenDetail,
                        ComponentSlotType = TowerCompSlotType.Base,
                        IconAreaContext = BuildIconAreaContext(item)
-                    });
+                    };
+                    AddComponentItemContext(componentItems, componentContext);
                    AddItemDescSeed(
                        item.InstanceId,
                        item.Name,
@@ -140,13 +139,14 @@ namespace GeometryTD.UI
                CombineAreaContext = new CombineAreaContext(),
                CompAreaContext = new CompAreaContext
                {
-                    Items = items.ToArray()
+                    ComponentItems = componentItems.ToArray(),
+                    TowerItems = towerItems.ToArray()
                },
                ParticipantAreaContext = participantAreaContext
            };
        }

-        private void AddItemContext(List<RepoItemContext> items, RepoItemContext itemContext)
+        private void AddComponentItemContext(List<RepoItemContext> items, RepoItemContext itemContext)
        {
            if (itemContext == null)
            {
@@ -154,7 +154,19 @@ namespace GeometryTD.UI
            }

            items.Add(itemContext);
-            _itemContextMap[itemContext.InstanceId] = 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)
@@ -243,7 +255,7 @@ namespace GeometryTD.UI
            IReadOnlyDictionary<long, BaseCompItemData> baseMap)
        {
            _participantTowerIds.Clear();
-            List<RepoItemContext> participantItems = new List<RepoItemContext>();
+            List<TowerRepoItemContext> participantItems = new List<TowerRepoItemContext>();
            if (inventory?.ParticipantTowerInstanceIds != null && towerMap != null)
            {
                for (int i = 0; i < inventory.ParticipantTowerInstanceIds.Count; i++)
@@ -264,41 +276,33 @@ namespace GeometryTD.UI
                        continue;
                    }

-                    participantItems.Add(new RepoItemContext
+                    TowerRepoItemContext towerContext = BuildTowerRepoItemContext(tower, muzzleMap, bearingMap, baseMap,
+                        RepoItemClickActionType.RemoveParticipant, false);
+                    if (towerContext != null)
                    {
-                        InstanceId = tower.InstanceId,
-                        CanDrag = false,
-                        EnduranceRate01 = ItemDescUtility.ResolveTowerEnduranceRate(tower, muzzleMap, bearingMap, baseMap),
-                        ClickActionType = RepoItemClickActionType.RemoveParticipant,
-                        ComponentSlotType = TowerCompSlotType.None,
-                        IconAreaContext = BuildIconAreaContext(tower)
-                    });
+                        participantItems.Add(towerContext);
+                        _itemClickActionMap[towerContext.InstanceId] = towerContext.ClickActionType;
+                    }
                }
            }

            return new ParticipantAreaContext
            {
-                Items = participantItems.ToArray(),
+                TowerItems = participantItems.ToArray(),
                MaxCount = MaxParticipantCount
            };
        }

        private void ApplyParticipantSelection()
        {
-            if (Form == null || _itemContextMap.Count <= 0)
+            if (Form == null || _compAreaTowerIds.Count <= 0)
            {
                return;
            }

-            foreach (KeyValuePair<long, RepoItemContext> pair in _itemContextMap)
+            foreach (long towerId in _compAreaTowerIds)
            {
-                RepoItemContext itemContext = pair.Value;
-                if (itemContext == null || itemContext.ComponentSlotType != TowerCompSlotType.None)
-                {
-                    continue;
-                }
-
-                Form.SetRepoItemSelected(pair.Key, _participantTowerIds.Contains(pair.Key));
+                Form.SetRepoItemSelected(towerId, _participantTowerIds.Contains(towerId));
            }
        }

@@ -319,25 +323,33 @@ namespace GeometryTD.UI
            ApplyParticipantSelection();
        }

-        private static IconAreaContext BuildIconAreaContext(TowerItemData tower)
+        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 new IconAreaContext
-                {
-                    ComponentSlotType = TowerCompSlotType.None,
-                    Rarity = RarityType.None,
-                    Color = Color.white,
-                    Icon = null
-                };
+                return null;
            }

-            return new IconAreaContext
+            return new TowerRepoItemContext
            {
+                InstanceId = tower.InstanceId,
+                CanDrag = canDrag,
+                EnduranceRate01 = ItemDescUtility.ResolveTowerEnduranceRate(tower, muzzleMap, bearingMap, baseMap),
+                ClickActionType = clickActionType,
                ComponentSlotType = TowerCompSlotType.None,
-                Rarity = tower.Rarity,
-                Color = IconColorGenerator.GenerateForTower(tower),
-                Icon = null
+                IconAreaContext = new TowerIconAreaContext
+                {
+                    Rarity = tower.Rarity,
+                    MuzzleColor = ResolveComponentColor(tower.MuzzleComponentInstanceId, muzzleMap),
+                    BearingColor = ResolveComponentColor(tower.BearingComponentInstanceId, bearingMap),
+                    BaseColor = ResolveComponentColor(tower.BaseComponentInstanceId, baseMap)
+                }
            };
        }

@@ -362,5 +374,21 @@ namespace GeometryTD.UI
                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;
+        }
    }
 }
+
@@ -11,9 +11,11 @@ namespace GeometryTD.UI
    {
        private const int MaxParticipantCount = 4;
        private RepoFormUseCase _useCase;
-        private readonly Dictionary<long, RepoItemContext> _itemContextMap = new Dictionary<long, RepoItemContext>();
+        private readonly Dictionary<long, RepoItemClickActionType> _itemClickActionMap =
+            new Dictionary<long, RepoItemClickActionType>();
        private readonly Dictionary<long, ItemDescSeed> _itemDescSeedMap = new Dictionary<long, ItemDescSeed>();
        private readonly HashSet<long> _participantTowerIds = new HashSet<long>();
+        private readonly HashSet<long> _compAreaTowerIds = new HashSet<long>();

        private sealed class ItemDescSeed
        {
@@ -111,14 +113,9 @@ namespace GeometryTD.UI
            }

            RepoItemClickActionType clickActionType = RepoItemClickActionType.OpenDetail;
-            if (sender is RepoItem clickedItem && clickedItem.Context != null)
+            if (_itemClickActionMap.TryGetValue(args.ItemId, out RepoItemClickActionType mappedAction))
            {
-                clickActionType = clickedItem.Context.ClickActionType;
-            }
-            else if (_itemContextMap.TryGetValue(args.ItemId, out RepoItemContext itemContextFromMap) &&
-                     itemContextFromMap != null)
-            {
-                clickActionType = itemContextFromMap.ClickActionType;
+                clickActionType = mappedAction;
            }

            if (args.ItemId <= 0)
@@ -170,7 +167,7 @@ namespace GeometryTD.UI
                return;
            }

-            if (Form == null || !_itemContextMap.ContainsKey(args.ItemId))
+            if (Form == null || !_itemClickActionMap.ContainsKey(args.ItemId))
            {
                return;
            }
@@ -212,8 +209,8 @@ namespace GeometryTD.UI
            {
                return;
            }
-            
-            this.CloseUI();
+
+            CloseUI();
        }

        private void OnRepoCombineRequested(object sender, GameEventArgs e)
@@ -258,12 +255,12 @@ namespace GeometryTD.UI
            {
                return;
            }
-            
+
            if (_useCase == null || Form == null || args.TowerItemId <= 0)
            {
                return;
            }
-            
+
            if (!_useCase.TryAddParticipantTower(args.TowerItemId))
            {
                return;
@@ -67,11 +67,6 @@ namespace GeometryTD.UI
            InventoryParticipantUtility.NormalizeParticipantState(_fallbackInventory, MaxParticipantCount);
            return _fallbackInventory;
        }
-
-        public static BackpackInventoryData SampleInventory()
-        {
-            return InventorySeedUtility.CreateSampleInventory();
-        }
    }
 }

@@ -1,5 +1,5 @@
-using GeometryTD.Definition;
 using GeometryTD.CustomEvent;
+using GeometryTD.Definition;
 using UnityEngine;
 using UnityEngine.EventSystems;

@@ -102,19 +102,15 @@ namespace GeometryTD.UI
                return;
            }

-            RepoItem repoItem = pointerDrag.GetComponent<RepoItem>();
-            if (repoItem == null)
-            {
-                repoItem = pointerDrag.GetComponentInParent<RepoItem>();
-            }
-
-            if (repoItem == null)
+            IRepoDragItemView dragItem = pointerDrag.GetComponent<IRepoDragItemView>() ??
+                                         pointerDrag.GetComponentInParent<IRepoDragItemView>();
+            if (dragItem == null)
            {
                return;
            }

-            bool assigned = TryAssignItem(repoItem.Context);
-            repoItem.SetDropResult(assigned);
+            bool assigned = TryAssignItem(dragItem.ComponentContext);
+            dragItem.SetDropResult(assigned);
        }

        private CombineSlotItem FindSlot(TowerCompSlotType slotType)
@@ -11,12 +11,17 @@ namespace GeometryTD.UI
    {
        [FormerlySerializedAs("m_Content")] [SerializeField] private Transform _content;
        [FormerlySerializedAs("m_ItemTemplate")] [SerializeField] private RepoItem _itemTemplate;
+        [SerializeField] private TowerRepoItem _towerItemTemplate;
        [FormerlySerializedAs("m_InstancePoolCapacity")] [SerializeField] private int _instancePoolCapacity = 64;

-        private readonly List<RepoItem> _activeItems = new List<RepoItem>();
-        private readonly Dictionary<long, RepoItem> _itemMap = new Dictionary<long, RepoItem>();
-        private IObjectPool<RepoItemObject> _itemPool;
-        private string _poolName;
+        private readonly List<RepoItem> _activeComponentItems = new List<RepoItem>();
+        private readonly List<TowerRepoItem> _activeTowerItems = new List<TowerRepoItem>();
+        private readonly Dictionary<long, RepoItem> _componentItemMap = new Dictionary<long, RepoItem>();
+        private readonly Dictionary<long, TowerRepoItem> _towerItemMap = new Dictionary<long, TowerRepoItem>();
+        private IObjectPool<RepoItemObject> _componentItemPool;
+        private IObjectPool<TowerRepoItemObject> _towerItemPool;
+        private string _componentPoolName;
+        private string _towerPoolName;

        public void OnInit(CompAreaContext context)
        {
@@ -29,31 +34,46 @@ namespace GeometryTD.UI
            EnsurePool();
            OnReset();

-            if (context.Items == null || context.Items.Length == 0)
+            if (context.ComponentItems != null)
            {
-                return;
+                foreach (RepoItemContext itemContext in context.ComponentItems)
+                {
+                    RepoItem item = CreateOrSpawnComponentItem();
+                    if (item == null)
+                    {
+                        continue;
+                    }
+
+                    item.gameObject.SetActive(true);
+                    item.OnInit(itemContext);
+                    _activeComponentItems.Add(item);
+                    _componentItemMap[itemContext.InstanceId] = item;
+                }
            }

-            foreach (var itemContext in context.Items)
+            if (context.TowerItems != null)
            {
-                RepoItem item = CreateOrSpawnItem();
-                if (item == null)
+                foreach (TowerRepoItemContext itemContext in context.TowerItems)
                {
-                    continue;
-                }
+                    TowerRepoItem item = CreateOrSpawnTowerItem();
+                    if (item == null)
+                    {
+                        continue;
+                    }

-                item.gameObject.SetActive(true);
-                item.OnInit(itemContext);
-                _activeItems.Add(item);
-                _itemMap[itemContext.InstanceId] = item;
+                    item.gameObject.SetActive(true);
+                    item.OnInit(itemContext);
+                    _activeTowerItems.Add(item);
+                    _towerItemMap[itemContext.InstanceId] = item;
+                }
            }
        }

        public void OnReset()
        {
-            for (int i = _activeItems.Count - 1; i >= 0; i--)
+            for (int i = _activeComponentItems.Count - 1; i >= 0; i--)
            {
-                RepoItem item = _activeItems[i];
+                RepoItem item = _activeComponentItems[i];
                if (item == null)
                {
                    continue;
@@ -61,49 +81,102 @@ namespace GeometryTD.UI

                item.OnReset();
                item.gameObject.SetActive(false);
-                _itemPool?.Unspawn(item);
+                _componentItemPool?.Unspawn(item);
            }

-            _activeItems.Clear();
-            _itemMap.Clear();
+            for (int i = _activeTowerItems.Count - 1; i >= 0; i--)
+            {
+                TowerRepoItem item = _activeTowerItems[i];
+                if (item == null)
+                {
+                    continue;
+                }
+
+                item.OnReset();
+                item.gameObject.SetActive(false);
+                _towerItemPool?.Unspawn(item);
+            }
+
+            _activeComponentItems.Clear();
+            _activeTowerItems.Clear();
+            _componentItemMap.Clear();
+            _towerItemMap.Clear();
        }

        private void OnDestroy()
        {
            OnReset();
-            _itemPool?.ReleaseAllUnused();
+            _componentItemPool?.ReleaseAllUnused();
+            _towerItemPool?.ReleaseAllUnused();
        }

        private void EnsurePool()
        {
-            if (_itemPool != null)
+            if (_componentItemPool == null)
            {
-                return;
+                _componentPoolName = $"RepoItemPool_{GetInstanceID()}";
+                _componentItemPool =
+                    GameEntry.ObjectPool.CreateSingleSpawnObjectPool<RepoItemObject>(_componentPoolName,
+                        _instancePoolCapacity);
            }

-            _poolName = $"RepoItemPool_{GetInstanceID()}";
-            _itemPool = GameEntry.ObjectPool.CreateSingleSpawnObjectPool<RepoItemObject>(_poolName, _instancePoolCapacity);
+            if (_towerItemPool == null)
+            {
+                _towerPoolName = $"TowerRepoItemPool_{GetInstanceID()}";
+                _towerItemPool =
+                    GameEntry.ObjectPool.CreateSingleSpawnObjectPool<TowerRepoItemObject>(_towerPoolName,
+                        _instancePoolCapacity);
+            }
        }

-        private RepoItem CreateOrSpawnItem()
+        private RepoItem CreateOrSpawnComponentItem()
        {
-            if (_itemPool == null)
+            if (_componentItemPool == null)
            {
                return null;
            }

-            RepoItemObject itemObject = _itemPool.Spawn();
+            RepoItemObject itemObject = _componentItemPool.Spawn();
            RepoItem item = itemObject != null ? (RepoItem)itemObject.Target : null;
            if (item == null)
            {
                if (_itemTemplate == null)
                {
-                    Log.Warning("CompArea requires an item template.");
+                    Log.Warning("CompArea requires a component item template.");
                    return null;
                }

                item = Instantiate(_itemTemplate);
-                _itemPool.Register(RepoItemObject.Create(item), true);
+                _componentItemPool.Register(RepoItemObject.Create(item), true);
+            }
+
+            if (_content != null)
+            {
+                item.transform.SetParent(_content, false);
+            }
+
+            return item;
+        }
+
+        private TowerRepoItem CreateOrSpawnTowerItem()
+        {
+            if (_towerItemPool == null)
+            {
+                return null;
+            }
+
+            TowerRepoItemObject itemObject = _towerItemPool.Spawn();
+            TowerRepoItem item = itemObject != null ? (TowerRepoItem)itemObject.Target : null;
+            if (item == null)
+            {
+                if (_towerItemTemplate == null)
+                {
+                    Log.Warning("CompArea requires a tower item template.");
+                    return null;
+                }
+
+                item = Instantiate(_towerItemTemplate);
+                _towerItemPool.Register(TowerRepoItemObject.Create(item), true);
            }

            if (_content != null)
@@ -116,12 +189,15 @@ namespace GeometryTD.UI

        public void SetItemSelected(long itemId, bool isSelected)
        {
-            if (!_itemMap.TryGetValue(itemId, out RepoItem item))
+            if (_componentItemMap.TryGetValue(itemId, out RepoItem componentItem))
            {
-                return;
+                componentItem.SetSelected(isSelected);
            }

-            item.SetSelected(isSelected);
+            if (_towerItemMap.TryGetValue(itemId, out TowerRepoItem towerItem))
+            {
+                towerItem.SetSelected(isSelected);
+            }
        }
    }
 }
@@ -0,0 +1,19 @@
+using GeometryTD.Definition;
+
+namespace GeometryTD.UI
+{
+    public interface IRepoDragItemView
+    {
+        long InstanceId { get; }
+
+        bool CanDrag { get; }
+
+        TowerCompSlotType ComponentSlotType { get; }
+
+        RepoItemClickActionType ClickActionType { get; }
+
+        RepoItemContext ComponentContext { get; }
+
+        void SetDropResult(bool assigned);
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5cb3c8e275a9ba646a58a2656af31faa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -12,12 +12,12 @@ namespace GeometryTD.UI
    public class ParticipantArea : MonoBehaviour, IDropHandler
    {
        [SerializeField] private Transform _content;
-        [SerializeField] private RepoItem _itemTemplate;
+        [SerializeField] private TowerRepoItem _towerItemTemplate;
        [SerializeField] private int _instancePoolCapacity = 8;

-        private readonly List<RepoItem> _activeItems = new List<RepoItem>();
+        private readonly List<TowerRepoItem> _activeItems = new List<TowerRepoItem>();
        private readonly HashSet<long> _boundItemIds = new HashSet<long>();
-        private IObjectPool<RepoItemObject> _itemPool;
+        private IObjectPool<TowerRepoItemObject> _itemPool;
        private string _poolName;
        private int _maxCount = 4;

@@ -27,20 +27,20 @@ namespace GeometryTD.UI
            EnsurePool();

            _maxCount = Mathf.Max(1, context != null ? context.MaxCount : 4);
-            if (context?.Items == null || context.Items.Length <= 0)
+            if (context?.TowerItems == null || context.TowerItems.Length <= 0)
            {
                return;
            }

-            for (int i = 0; i < context.Items.Length; i++)
+            for (int i = 0; i < context.TowerItems.Length; i++)
            {
-                RepoItemContext itemContext = context.Items[i];
+                TowerRepoItemContext itemContext = context.TowerItems[i];
                if (itemContext == null || itemContext.InstanceId <= 0)
                {
                    continue;
                }

-                RepoItem item = CreateOrSpawnItem();
+                TowerRepoItem item = CreateOrSpawnItem();
                if (item == null)
                {
                    continue;
@@ -57,7 +57,7 @@ namespace GeometryTD.UI
        {
            for (int i = _activeItems.Count - 1; i >= 0; i--)
            {
-                RepoItem item = _activeItems[i];
+                TowerRepoItem item = _activeItems[i];
                if (item == null)
                {
                    continue;
@@ -79,19 +79,19 @@ namespace GeometryTD.UI
            _itemPool?.ReleaseAllUnused();
        }

-        public bool CanAssign(RepoItemContext itemContext)
+        public bool CanAssign(IRepoDragItemView dragItem)
        {
-            if (itemContext == null || itemContext.InstanceId <= 0)
+            if (dragItem == null || dragItem.InstanceId <= 0)
            {
                return false;
            }

-            if (itemContext.ComponentSlotType != TowerCompSlotType.None)
+            if (dragItem.ComponentSlotType != TowerCompSlotType.None)
            {
                return false;
            }

-            if (_boundItemIds.Contains(itemContext.InstanceId))
+            if (_boundItemIds.Contains(dragItem.InstanceId))
            {
                return false;
            }
@@ -117,21 +117,21 @@ namespace GeometryTD.UI
                return;
            }

-            RepoItem repoItem = pointerDrag.GetComponent<RepoItem>() ?? pointerDrag.GetComponentInParent<RepoItem>();
-            if (repoItem == null)
+            IRepoDragItemView dragItem = pointerDrag.GetComponent<IRepoDragItemView>() ??
+                                         pointerDrag.GetComponentInParent<IRepoDragItemView>();
+            if (dragItem == null)
            {
                return;
            }

-            RepoItemContext itemContext = repoItem.Context;
-            bool assigned = CanAssign(itemContext);
-            repoItem.SetDropResult(assigned);
+            bool assigned = CanAssign(dragItem);
+            dragItem.SetDropResult(assigned);
            if (!assigned)
            {
                return;
            }

-            GameEntry.Event.Fire(this, RepoParticipantAssignRequestedEventArgs.Create(itemContext.InstanceId));
+            GameEntry.Event.Fire(this, RepoParticipantAssignRequestedEventArgs.Create(dragItem.InstanceId));
        }

        private void EnsurePool()
@@ -141,29 +141,30 @@ namespace GeometryTD.UI
                return;
            }

-            _poolName = $"ParticipantRepoItemPool_{GetInstanceID()}";
-            _itemPool = GameEntry.ObjectPool.CreateSingleSpawnObjectPool<RepoItemObject>(_poolName, _instancePoolCapacity);
+            _poolName = $"ParticipantTowerRepoItemPool_{GetInstanceID()}";
+            _itemPool =
+                GameEntry.ObjectPool.CreateSingleSpawnObjectPool<TowerRepoItemObject>(_poolName, _instancePoolCapacity);
        }

-        private RepoItem CreateOrSpawnItem()
+        private TowerRepoItem CreateOrSpawnItem()
        {
            if (_itemPool == null)
            {
                return null;
            }

-            RepoItemObject itemObject = _itemPool.Spawn();
-            RepoItem item = itemObject != null ? (RepoItem)itemObject.Target : null;
+            TowerRepoItemObject itemObject = _itemPool.Spawn();
+            TowerRepoItem item = itemObject != null ? (TowerRepoItem)itemObject.Target : null;
            if (item == null)
            {
-                if (_itemTemplate == null)
+                if (_towerItemTemplate == null)
                {
-                    Log.Warning("ParticipantArea requires an item template.");
+                    Log.Warning("ParticipantArea requires a tower item template.");
                    return null;
                }

-                item = Instantiate(_itemTemplate);
-                _itemPool.Register(RepoItemObject.Create(item), true);
+                item = Instantiate(_towerItemTemplate);
+                _itemPool.Register(TowerRepoItemObject.Create(item), true);
            }

            if (_content != null)
@@ -6,10 +6,10 @@ using UnityEngine.UI;

 namespace GeometryTD.UI
 {
-    public class RepoItem : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
+    public class RepoItem : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler, IRepoDragItemView
    {
        [SerializeField] private Image _bgImage;
-        
+
        [SerializeField] private IconArea _iconArea;

        private static readonly Color SelectedColor = new Color32(255, 216, 102, 255);
@@ -20,8 +20,8 @@ namespace GeometryTD.UI
        [SerializeField] private RepoItemContext _context;
        private CanvasGroup _canvasGroup;
        private RectTransform _dragRoot;
-        private GameObject _dragGhostObject;
-        private RectTransform _dragGhostRect;
+        protected GameObject _dragGhostObject;
+        protected RectTransform _dragGhostRect;
        private bool _isSelected;
        private bool _isDragging;
        private bool _dropHandled;
@@ -29,6 +29,24 @@ namespace GeometryTD.UI

        public RepoItemContext Context => _context;

+        public long InstanceId => _context != null ? _context.InstanceId : 0;
+
+        bool IRepoDragItemView.CanDrag => _context != null && _context.CanDrag;
+
+        public TowerCompSlotType ComponentSlotType =>
+            _context != null ? _context.ComponentSlotType : TowerCompSlotType.None;
+
+        public RepoItemClickActionType ClickActionType =>
+            _context != null ? _context.ClickActionType : RepoItemClickActionType.OpenDetail;
+
+        public RepoItemContext ComponentContext => _context;
+
+        protected IconArea IconArea => _iconArea;
+
+        protected Image BackgroundImage => _bgImage;
+
+        protected RectTransform DragRoot => _dragRoot;
+
        private void Awake()
        {
            _canvasGroup = GetComponent<CanvasGroup>();
@@ -43,7 +61,7 @@ namespace GeometryTD.UI
            ResetDragState();
        }

-        public void OnInit(RepoItemContext context)
+        public virtual void OnInit(RepoItemContext context)
        {
            if (context == null)
            {
@@ -52,14 +70,13 @@ namespace GeometryTD.UI
            }

            _context = context;
-
            _iconArea.OnInit(context.IconAreaContext);

            SetSelected(false);
            ResetDragState();
        }

-        public void OnReset()
+        public virtual void OnReset()
        {
            _context = null;
            _iconArea.OnReset();
@@ -165,6 +182,7 @@ namespace GeometryTD.UI
            {
                _canvasGroup.blocksRaycasts = true;
            }
+
            DestroyDragGhost();
            _dragRoot = null;

@@ -232,7 +250,7 @@ namespace GeometryTD.UI
            return canvas.rootCanvas.transform as RectTransform;
        }

-        private bool CreateDragGhost()
+        protected virtual bool CreateDragGhost()
        {
            DestroyDragGhost();

@@ -246,7 +264,6 @@ namespace GeometryTD.UI
            Material iconMaterial = _iconArea != null ? _iconArea.CurrentIconMaterial : null;
            Vector2 iconSize = _iconArea != null ? _iconArea.CurrentIconSize : Vector2.zero;

-            // Towers may not have an icon sprite; fall back to background sprite so drag still works.
            if (iconSprite == null && _bgImage != null)
            {
                iconSprite = _bgImage.sprite;
@@ -260,7 +277,8 @@ namespace GeometryTD.UI
                return false;
            }

-            _dragGhostObject = new GameObject("RepoItemDragGhost", typeof(RectTransform), typeof(CanvasGroup), typeof(Image));
+            _dragGhostObject = new GameObject("RepoItemDragGhost", typeof(RectTransform), typeof(CanvasGroup),
+                typeof(Image));
            _dragGhostObject.layer = gameObject.layer;

            _dragGhostRect = _dragGhostObject.GetComponent<RectTransform>();
@@ -273,6 +291,7 @@ namespace GeometryTD.UI
            {
                iconSize = DefaultDragGhostSize;
            }
+
            _dragGhostRect.sizeDelta = iconSize;

            Image ghostImage = _dragGhostObject.GetComponent<Image>();
@@ -290,7 +309,7 @@ namespace GeometryTD.UI
            return true;
        }

-        private void UpdateDragGhostPosition(PointerEventData eventData)
+        protected virtual void UpdateDragGhostPosition(PointerEventData eventData)
        {
            if (_dragGhostRect == null || _dragRoot == null || eventData == null)
            {
@@ -304,7 +323,7 @@ namespace GeometryTD.UI
            }
        }

-        private void DestroyDragGhost()
+        protected virtual void DestroyDragGhost()
        {
            if (_dragGhostObject != null)
            {
@@ -329,3 +348,4 @@ namespace GeometryTD.UI
        }
    }
 }
+
@@ -0,0 +1,109 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace GeometryTD.UI
+{
+    public class TowerRepoItem : RepoItem
+    {
+        private static readonly Vector2 DefaultTowerDragGhostSize = new Vector2(64f, 64f);
+
+        public new TowerRepoItemContext Context => base.Context as TowerRepoItemContext;
+
+        public void OnInit(TowerRepoItemContext context)
+        {
+            base.OnInit(context);
+        }
+
+        protected override bool CreateDragGhost()
+        {
+            DestroyDragGhost();
+
+            if (DragRoot == null)
+            {
+                return false;
+            }
+
+            TowerIconArea towerIconArea = IconArea as TowerIconArea;
+            if (towerIconArea == null)
+            {
+                return base.CreateDragGhost();
+            }
+
+            _dragGhostObject = new GameObject("TowerRepoItemDragGhost", typeof(RectTransform), typeof(CanvasGroup));
+            _dragGhostObject.layer = gameObject.layer;
+
+            _dragGhostRect = _dragGhostObject.GetComponent<RectTransform>();
+            _dragGhostRect.SetParent(DragRoot, false);
+            _dragGhostRect.anchorMin = new Vector2(0.5f, 0.5f);
+            _dragGhostRect.anchorMax = new Vector2(0.5f, 0.5f);
+            _dragGhostRect.pivot = new Vector2(0.5f, 0.5f);
+
+            Vector2 iconSize = IconArea != null ? IconArea.CurrentIconSize : Vector2.zero;
+            if (iconSize.x <= 0f || iconSize.y <= 0f)
+            {
+                iconSize = BackgroundImage != null ? BackgroundImage.rectTransform.rect.size : DefaultTowerDragGhostSize;
+            }
+
+            if (iconSize.x <= 0f || iconSize.y <= 0f)
+            {
+                iconSize = DefaultTowerDragGhostSize;
+            }
+
+            _dragGhostRect.sizeDelta = iconSize;
+
+            bool hasAnyLayer = false;
+            hasAnyLayer |= TryCreateLayer("Base", towerIconArea.BaseIconSprite, towerIconArea.BaseIconColor,
+                towerIconArea.BaseIconMaterial, _dragGhostRect, 0);
+            hasAnyLayer |= TryCreateLayer("Bearing", towerIconArea.BearingIconSprite, towerIconArea.BearingIconColor,
+                towerIconArea.BearingIconMaterial, _dragGhostRect, 1);
+            hasAnyLayer |= TryCreateLayer("Muzzle", towerIconArea.MuzzleIconSprite, towerIconArea.MuzzleIconColor,
+                towerIconArea.MuzzleIconMaterial, _dragGhostRect, 2);
+
+            if (!hasAnyLayer)
+            {
+                DestroyDragGhost();
+                return base.CreateDragGhost();
+            }
+
+            CanvasGroup ghostCanvasGroup = _dragGhostObject.GetComponent<CanvasGroup>();
+            ghostCanvasGroup.blocksRaycasts = false;
+            ghostCanvasGroup.interactable = false;
+
+            _dragGhostObject.transform.SetAsLastSibling();
+            return true;
+        }
+
+        private static bool TryCreateLayer(
+            string layerName,
+            Sprite sprite,
+            Color color,
+            Material material,
+            RectTransform parent,
+            int siblingIndex)
+        {
+            if (parent == null || sprite == null)
+            {
+                return false;
+            }
+
+            GameObject layerObject = new GameObject($"TowerGhost{layerName}", typeof(RectTransform), typeof(Image));
+            layerObject.layer = parent.gameObject.layer;
+
+            RectTransform layerRect = layerObject.GetComponent<RectTransform>();
+            layerRect.SetParent(parent, false);
+            layerRect.anchorMin = Vector2.zero;
+            layerRect.anchorMax = Vector2.one;
+            layerRect.offsetMin = Vector2.zero;
+            layerRect.offsetMax = Vector2.zero;
+            layerRect.SetSiblingIndex(siblingIndex);
+
+            Image layerImage = layerObject.GetComponent<Image>();
+            layerImage.raycastTarget = false;
+            layerImage.sprite = sprite;
+            layerImage.color = color;
+            layerImage.material = material;
+            layerImage.preserveAspect = true;
+            return true;
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: caf7b65cc179a5d46828128f574ed63e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: