(client) feat:实现掉落物，UI显示，维度

2025-08-27 13:56:22 +08:00
parent f04c89046b
commit 0c99e2beee
46 changed files with 6150 additions and 1809 deletions
--- a/Client/Assets/Scripts/UI/DevMenuUI.cs
+++ b/Client/Assets/Scripts/UI/DevMenuUI.cs
@ -1,10 +1,7 @@
-using System.Collections.Generic;
-using System.Linq;
 using Base;
-using Data;
+using Data; // 确保 Data 命名空间包含 DefBase, CharacterDef, MonsterDef, BuildingDef, ItemDef, EventDef
 using UnityEngine;
 using UnityEngine.SceneManagement;
-using UnityEngine.UI;

 namespace UI
 {
@ -29,6 +26,7 @@ namespace UI
            InitCharacter();
            InitMonster();
            InitBuilding();
+            InitItem();
        }

        private void InitReloadGameButton()
@ -38,89 +36,101 @@ namespace UI
            button.AddListener(HotReload);
        }

-        private void InitEvent()
+        /// <summary>
+        /// 通用的初始化定义按钮的方法。
+        /// </summary>
+        /// <typeparam name="TDef">定义的类型，必须继承自 Data.DefBase。</typeparam>
+        /// <param name="titleLabel">菜单部分的标题。</param>
+        /// <param name="noDefMessage">当没有定义时显示的提示信息。</param>
+        /// <param name="buttonTextSelector">用于从 TDef 获取按钮显示文本的函数。</param>
+        /// <param name="buttonAction">点击按钮时执行的动作，传入对应的 TDef 对象。</param>
+        private void InitDefineButtons<TDef>(string titleLabel, string noDefMessage, System.Func<TDef, string> buttonTextSelector, System.Action<TDef> buttonAction) where TDef : Define
        {
            var title = InstantiatePrefab(textTemplate, menuContent.transform);
-            title.Label = "事件菜单";
-            
-            title = InstantiatePrefab(textTemplate, menuContent.transform);
-            title.Label = "未定义任何事件";
-            title.text.color = Color.red;
-            // for (int i = 0; i < 30; i++)
-            // {
-            //     var button= InstantiatePrefab(buttonTemplate, menuContent.transform);
-            //     button.text.text = i.ToString();
-            // }
+            title.Label = titleLabel;

+            var defList = Managers.DefineManager.Instance.QueryNamedDefinesByType<TDef>();
+            if (defList == null || defList.Length == 0)
+            {
+                var noDefTitle = InstantiatePrefab(textTemplate, menuContent.transform);
+                noDefTitle.Label = noDefMessage;
+                noDefTitle.text.color = Color.red;
+            }
+            else
+            {
+                foreach (var def in defList)
+                {
+                    var button = InstantiatePrefab(buttonTemplate, menuContent.transform);
+                    button.Label = buttonTextSelector(def);
+                    // 确保 lambda 捕获的是循环当前迭代的 def 变量，而不是循环变量本身
+                    var currentDef = def; 
+                    button.AddListener(() => buttonAction(currentDef));
+                }
+            }
+        }
+
+        private void InitEvent()
+        {
+            // 假设存在 Data.EventDef 类型，且它继承自 Data.DefBase，并包含一个可作为标签的字段。
+            // 如果事件触发逻辑不同于生成实体，需要在此处定义相应的回调。
+            InitDefineButtons<EventDef>(
+                "事件菜单",
+                "未定义任何事件",
+                // 假设 EventDef 也有 label 字段作为按钮文本
+                def => def.label, 
+                eventDef => 
+                {
+                    // TODO: 在这里实现事件触发逻辑
+                    Debug.Log($"触发事件: {eventDef.label}");
+                    // 示例: Managers.EventManager.Instance.TriggerEvent(eventDef.id);
+                });
        }

        private void InitCharacter()
        {
-            var title = InstantiatePrefab(textTemplate, menuContent.transform);
-            title.Label = "生成人物";
-
-            var defList = Managers.DefineManager.Instance.QueryNamedDefinesByType<Data.CharacterDef>();
-            if (defList == null || defList.Length == 0)
-            {
-                title = InstantiatePrefab(textTemplate, menuContent.transform);
-                title.Label = "未定义任何角色";
-                title.text.color = Color.red;
-            }
-            else
-                foreach (var def in defList)
-                {
-                    var button = InstantiatePrefab(buttonTemplate, menuContent.transform);
-                    button.Label = def.label;
-                    var pawnDef = def;
-                    button.AddListener(() => GenerateEntityCallback(pawnDef));
-                }
-
+            InitDefineButtons<CharacterDef>(
+                "生成人物",
+                "未定义任何角色",
+                def => def.label,
+                GenerateEntityCallback);
        }

        private void InitMonster()
        {
-            var title = InstantiatePrefab(textTemplate, menuContent.transform);
-            title.Label = "生成怪物";
-
-            var defList = Managers.DefineManager.Instance.QueryNamedDefinesByType<Data.MonsterDef>();
-            if (defList == null || defList.Length == 0)
-            {
-                title = InstantiatePrefab(textTemplate, menuContent.transform);
-                title.Label = "未定义任何怪物";
-                title.text.color = Color.red;
-            }
-            else
-            foreach (var def in defList)
-            {
-                var button = InstantiatePrefab(buttonTemplate, menuContent.transform);
-                button.Label = def.label;
-                var pawnDef = def;
-                button.AddListener(() => GenerateEntityCallback(pawnDef));
-            }
+            InitDefineButtons<MonsterDef>(
+                "生成怪物",
+                "未定义任何怪物",
+                def => def.label,
+                GenerateEntityCallback);
        }

        private void InitBuilding()
        {
-            var title = InstantiatePrefab(textTemplate, menuContent.transform);
-            title.Label = "生成建筑";
-
-            var defList = Managers.DefineManager.Instance.QueryNamedDefinesByType<Data.BuildingDef>();
-            if (defList == null || defList.Length == 0)
-            {
-                title = InstantiatePrefab(textTemplate, menuContent.transform);
-                title.Label = "未定义任何建筑";
-                title.text.color = Color.red;
-            }
-            else
-                foreach (var def in defList)
-                {
-                    var button = InstantiatePrefab(buttonTemplate, menuContent.transform);
-                    button.Label = def.label;
-                    var pawnDef = def;
-                    button.AddListener(() => GenerateBuildingCallback(pawnDef));
-                }
+            InitDefineButtons<BuildingDef>(
+                "生成建筑",
+                "未定义任何建筑",
+                def => def.label,
+                GenerateBuildingCallback);
        }

+        private void InitItem()
+        {
+            InitDefineButtons<ItemDef>(
+                "生成掉落物",
+                "未定义任何物品",
+                def => def.label,
+                GeneratePickupCallback);
+        }
+        private void InitWeapon()
+        {
+            InitDefineButtons<WeaponDef>(
+                "生成武器",
+                "未定义任何武器",
+                def => def.label,
+                GeneratePickupCallback);
+        }
+
+
        /// <summary>
        /// 通用的实例化函数，返回实例化的预制件脚本组件。
        /// </summary>
@ -154,24 +164,33 @@ namespace UI
        {
            entityPlacementUI.currentAction = () =>
            {
-                Managers.EntityManage.Instance.GenerateEntity(Program.Instance.focuseDimensionId,entityDef, Utils.MousePosition.GetWorldPosition());
+                Managers.EntityManage.Instance.GenerateEntity(Program.Instance.FocusedDimensionId,entityDef, Utils.MousePosition.GetWorldPosition());
            };
            entityPlacementUI.Prompt = $"当前生成器：\n名称：{entityDef.label}\n描述：{entityDef.description}";
            entityPlacementUI.snapEnabled = false;
-            Base.UIInputControl.Instance.Show(entityPlacementUI);
+            UIInputControl.Instance.Show(entityPlacementUI);
        }

        private void GenerateBuildingCallback(BuildingDef def)
        {
            entityPlacementUI.currentAction = () =>
            {
-                Managers.EntityManage.Instance.GenerateBuildingEntity(Program.Instance.focuseDimensionId,def, Utils.MousePosition.GetSnappedWorldPosition());
+                Managers.EntityManage.Instance.GenerateBuildingEntity(Program.Instance.FocusedDimensionId,def, Utils.MousePosition.GetSnappedWorldPosition());
            };
            entityPlacementUI.Prompt = $"当前生成器：\n名称：{def.label}\n描述：{def.description}";
            entityPlacementUI.snapEnabled = true;
-            Base.UIInputControl.Instance.Show(entityPlacementUI);
+            UIInputControl.Instance.Show(entityPlacementUI);
+        }
+        private void GeneratePickupCallback(ItemDef itemDef)
+        {
+            entityPlacementUI.currentAction = () =>
+            {
+                Managers.EntityManage.Instance.GeneratePickupEntity(Program.Instance.FocusedDimensionId,itemDef, Utils.MousePosition.GetWorldPosition());
+            };
+            entityPlacementUI.Prompt = $"当前生成器：\n名称：{itemDef.label}\n描述：{itemDef.description}";
+            entityPlacementUI.snapEnabled = false;
+            UIInputControl.Instance.Show(entityPlacementUI);
        }
-
        private void HotReload()
        {
            UIInputControl.Instance.HideAll();
@ -179,5 +198,4 @@ namespace UI
            SceneManager.LoadScene(0);
        }
    }
-
 }
--- a/Client/Assets/Scripts/UI/EquipmentUI.cs
+++ b/Client/Assets/Scripts/UI/EquipmentUI.cs
@ -1,10 +1,171 @@
+using System;
+using System.Collections.Generic;
+using Base;
+using Entity;
 using UnityEngine;

 namespace UI
 {
-    public class EquipmentUI:MonoBehaviour
+    /// <summary>
+    /// 负责管理和显示角色的装备用户界面。
+    /// 该组件会监听当前关注实体的变化，并根据所关注角色的库存数据动态更新装备槽位的显示，
+    /// 同时采用对象池技术高效管理 ItemUI 实例的创建和复用。
+    /// </summary>
+    public class EquipmentUI : MonoBehaviour,ITick
    {
-        [SerializeField] private GameObject uiParent;
-        
+        [SerializeField] 
+        [Tooltip("所有 ItemUI 实例的父级 GameObject，用于布局。")] 
+        private GameObject uiParent;
+
+        [SerializeField] 
+        [Tooltip("用于实例化装备槽位的 ItemUI 预制件。")] 
+        private ItemUI itemUIPrefab;
+
+        /// <summary>
+        /// 当前界面所关联和关注的角色实体。
+        /// </summary>
+        private Character focusedEntity = null;
+
+        /// <summary>
+        /// ItemUI 实例的对象池，用于高效管理和复用 ItemUI。
+        /// </summary>
+        private List<ItemUI> itemUIPool = new List<ItemUI>();
+
+        /// <summary>
+        /// MonoBehaviour 的 Start 生命周期方法。
+        /// 在此方法中，注册当游戏主要程序中关注的实体发生变化时，调用 <see cref="UpdateFocusedEntity"/> 方法进行更新。
+        /// </summary>
+        private void Start()
+        {
+            Program.Instance.OnFocusedEntityChanged += UpdateFocusedEntity;
+        }
+
+        /// <summary>
+        /// MonoBehaviour 的 OnDestroy 生命周期方法。
+        /// 在此方法中，取消注册所有已订阅的事件监听器，并清理对象池中创建的所有 ItemUI 实例，
+        /// 以防止内存泄漏和不必要的引用。
+        /// </summary>
+        private void OnDestroy()
+        {
+            Program.Instance.OnFocusedEntityChanged -= UpdateFocusedEntity;
+            
+            // 如果当前有关注的角色，取消注册其库存改变事件。
+            // 注意：此处需要确保 focusedEntity 不为 null，否则可能抛出 NullReferenceException。
+            if (focusedEntity != null) 
+            {
+                focusedEntity.Inventory.OnInventoryChanged -= UpdateUI;
+            }
+
+            // 销毁对象池中所有 ItemUI 的 GameObject。
+            foreach (var itemUI in itemUIPool)
+            {
+                if (itemUI != null && itemUI.gameObject != null) 
+                {
+                    Destroy(itemUI.gameObject);
+                }
+            }
+            itemUIPool.Clear();
+        }
+
+        /// <summary>
+        /// 当游戏程序中关注的实体发生变化时调用此方法。
+        /// 该方法会更新当前 EquipmentUI 所关联的角色，并相应地注册或取消注册库存改变事件。
+        /// </summary>
+        /// <param name="entity">新的关注实体，可能为 null 或非 Character 类型。</param>
+        private void UpdateFocusedEntity(Entity.Entity entity)
+        {
+            // 如果之前有关注的角色，先取消注册其库存改变事件。
+            // 注意：此处需要确保 focusedEntity 不为 null。
+            if (focusedEntity != null) 
+            {
+                focusedEntity.Inventory.OnInventoryChanged -= UpdateUI;
+            }
+
+            // 尝试将新的实体转换为角色类型。
+            Character newCharacter = entity as Character;
+            if (newCharacter != null)
+            {
+                focusedEntity = newCharacter;
+            }
+            // 如果传入的 entity 不是 Character 类型，focusedEntity 将保持其当前值。
+            // 如果希望在非 Character 实体被关注时清除 focusedEntity，则需要在此处添加 `else { focusedEntity = null; }`。
+
+            // 如果现在有关注的角色，注册其库存改变事件。
+            if (focusedEntity != null) 
+            {
+                focusedEntity.Inventory.OnInventoryChanged += UpdateUI;
+            }
+            
+            // 立即更新UI以反映新的关注实体（或没有关注实体）的状态。
+            UpdateUI(); 
+        }
+
+        /// <summary>
+        /// 根据当前关注角色的库存数据更新装备UI的显示。
+        /// 该方法通过对象池机制高效地管理 ItemUI 实例的创建、复用和禁用。
+        /// </summary>
+        private void UpdateUI()
+        {
+            // 如果没有关注的角色或其库存，则禁用所有 ItemUI。
+            // 注意：此处需要先检查 focusedEntity 是否为 null，以避免 NullReferenceException。
+            if (focusedEntity == null || focusedEntity.Inventory == null) 
+            {
+                foreach (var itemUI in itemUIPool)
+                {
+                    if (itemUI != null && itemUI.gameObject != null)
+                    {
+                        itemUI.gameObject.SetActive(false);
+                    }
+                }
+                return;
+            }
+
+            // 检查用于创建物品UI的预制件是否已在 Inspector 中赋值。
+            if (itemUIPrefab == null)
+            {
+                Debug.LogError("ItemUIPrefab 未在 EquipmentUI 中指定。无法创建物品用户界面。", this);
+                foreach (var itemUI in itemUIPool) itemUI.gameObject.SetActive(false);
+                return;
+            }
+
+            // 获取当前关注角色库存中的所有物品槽位。
+            var slots = focusedEntity.Inventory.GetSlots();
+            int requiredUIs = slots.Count; // 需要显示和激活的 ItemUI 数量。
+            int currentUIPoolSize = itemUIPool.Count; // 当前对象池中 ItemUI 实例的总数。
+
+            // 遍历所有必要的物品槽位，复用对象池中的 ItemUI，或在不足时创建新的 ItemUI。
+            for (int i = 0; i < requiredUIs; i++)
+            {
+                ItemUI itemUI;
+                if (i < currentUIPoolSize)
+                {
+                    itemUI = itemUIPool[i];
+                }
+                else
+                {
+                    itemUI = Instantiate(itemUIPrefab, uiParent.transform);
+                    itemUIPool.Add(itemUI);
+                    currentUIPoolSize++; // 更新池的大小计数。
+                }
+                
+                // 确保 ItemUI GameObject 处于激活状态，并使用当前物品槽位的数据进行初始化。
+                itemUI.gameObject.SetActive(true);
+                itemUI.Init(slots[i], i);
+            }
+
+            // 如果库存槽位数量减少，禁用对象池中多余的 ItemUI 实例。
+            for (int i = requiredUIs; i < currentUIPoolSize; i++)
+            {
+                if (itemUIPool[i] != null && itemUIPool[i].gameObject != null)
+                {
+                    itemUIPool[i].gameObject.SetActive(false);
+                }
+            }
+        }
+
+        public void Tick()
+        {
+            
+        }
    }
-}
+}
--- a/Client/Assets/Scripts/UI/ItemUI.cs
+++ b/Client/Assets/Scripts/UI/ItemUI.cs
@ -1,9 +1,91 @@
+using System;
+using Base;
+using TMPro;
 using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;

 namespace UI
 {
-    public class ItemUI:MonoBehaviour
+    public class ItemUI:MonoBehaviour,IPointerEnterHandler,IPointerExitHandler,IPointerClickHandler,ITick
    {
+        [SerializeField] private Image textureUI;
+        [SerializeField] private TMP_Text countUI;
+        [SerializeField] private TMP_Text nameUI;
+        [SerializeField] private GameObject selectedOutline;
        
+        private Entity.InventorySlot _item;
+        private float timer = 0;
+        private float switchTime = 0;
+        private int texturePtr = 0;
+        
+        public event Action OnPlayerSelect;
+        
+        public bool Select
+        {
+            get => selectedOutline.activeSelf;
+            set => selectedOutline.SetActive(value);
+        }
+
+        public int SlotIndex { get; private set; } = -1;
+
+        public void Init(Entity.InventorySlot item,int index)
+        {
+            if (item == null)
+            {
+                switchTime = -1;
+                textureUI.gameObject.SetActive(false);
+                countUI.text = "";
+                nameUI.text = "";
+                return;
+            }
+
+            textureUI.gameObject.SetActive(true);
+            _item = item;
+            textureUI.sprite = item.Item.Icon[0];
+            countUI.text = item.Quantity.ToString();
+            nameUI.text = item.Item.Name;
+            nameUI.gameObject.SetActive(false);
+            Select = false;
+            SlotIndex = index;
+            if (item.Item.FPS > 0)
+            {
+                switchTime = 1f / item.Item.FPS;
+            }
+            else
+            {
+                switchTime = 0;
+            }
+        }
+
+        public void OnPointerEnter(PointerEventData eventData)
+        {
+            nameUI.gameObject.SetActive(true);
+        }
+
+        public void OnPointerExit(PointerEventData eventData)
+        {
+            nameUI.gameObject.SetActive(false);
+        }
+        public void OnPointerClick(PointerEventData eventData)
+        {
+            OnPlayerSelect?.Invoke();
+        }
+        public void Tick()
+        {
+            if (switchTime > 0)
+            {
+                timer+=Time.deltaTime;
+                if (timer >= switchTime)
+                {
+                    timer-=switchTime;
+                    texturePtr++;
+                    texturePtr%=_item.Item.Icon.Count;
+                    textureUI.sprite=_item.Item.Icon[texturePtr];
+                }
+            }
+        }
+
+   
    }
 }
--- a/Client/Assets/Scripts/UI/PlayerStateUI.cs
+++ b/Client/Assets/Scripts/UI/PlayerStateUI.cs
@ -1,3 +1,4 @@
+using System;
 using TMPro;
 using UnityEngine;

@ -7,15 +8,17 @@ namespace UI
    {
        [SerializeField] private BarUI focusedEntityHP;
        [SerializeField] private BarUI lastEntityHP;
-
+        

        public void Tick()
        {
-            var focusedEntity = Program.Instance.focusedEntity;
-            if (focusedEntity)
+            var focusedEntity = Program.Instance.FocusedEntity;
+            if (focusedEntity && focusedEntity.entityDef != null)
            {
-                focusedEntityHP.Progress = (float)focusedEntity.attributes.health/focusedEntity.entityDef.attributes.health;
+                focusedEntityHP.Progress =
+                    (float)focusedEntity.attributes.health / focusedEntity.entityDef.attributes.health;
            }
        }
+        
    }
 }
--- a/Client/Assets/Scripts/UI/SettingUI.cs
+++ b/Client/Assets/Scripts/UI/SettingUI.cs
@ -11,6 +11,7 @@ namespace UI
        [SerializeField] private Scrollbar globalVolume;
        [SerializeField] private Toggle developerMode;
        [SerializeField] private Toggle friendlyFire;
+        [SerializeField] private Toggle showMiniMap;
        [SerializeField] private TMP_Dropdown windowMode;
        [SerializeField] private TMP_Dropdown windowResolution;
        [SerializeField] private TMP_InputField progressStepDuration;
@ -25,6 +26,7 @@ namespace UI
            globalVolume.value = currentSettings.globalVolume;
            developerMode.isOn = currentSettings.developerMode;
            friendlyFire.isOn = currentSettings.friendlyFire;
+            showMiniMap.isOn = currentSettings.showMiniMap;

            progressStepDuration.text = currentSettings.progressStepDuration.ToString(CultureInfo.InvariantCulture);
            exitAnimationDuration.text = currentSettings.exitAnimationDuration.ToString(CultureInfo.InvariantCulture);
@ -59,6 +61,7 @@ namespace UI
            currentSettings.windowResolution = Base.Setting.CommonResolutions[windowResolution.value];
            currentSettings.progressStepDuration = float.Parse(progressStepDuration.text, CultureInfo.InvariantCulture);
            currentSettings.exitAnimationDuration = float.Parse(exitAnimationDuration.text, CultureInfo.InvariantCulture);
+            currentSettings.showMiniMap = showMiniMap.isOn;
            Base.Setting.Instance.CurrentSettings = currentSettings;
            Base.Setting.Instance.Apply();
        }