• [Unity独立/合作开发]实现背包系统中物品的拾取拖拽掉落还有换位置

    米娜桑扩你急哇，大家好久不见，由于最近一直在忙活比赛的项目，什么画画啊写代码啊一直都没时间跟大伙更新一期视频，今天就来点大家想看的东西，我们来实现背包系统中物品的拾取拖拽掉落还有换位置。

    学习目标：

      首先学习之前所需要的必备知识有：ScriptableObject,数据结构链表的使用，以及一些涉及到UnityEditor相关便于我们开发的，射线相关的UI以及EventSystems的命名空间，那么现在就开始吧。

    学习内容：

      首先我们需要整体的对物品进行一个描述，如它是什么类型的，是可以浇花的，还是可以种地的，还是可以攻击的，我们将在一个只用来写枚举的C#脚本中创建它，

    1. public enum ItemType
    2. {
    3.     Seed,
    4.     Commodity,
    5.     Watering_tool,
    6.     Hoeing_tool,
    7.     Chopping_tool,
    8.     Breaking_tool,
    9.     Reping_tool,
    10.     Collecting_tool,
    11.     Reapable_scenery,
    12.     Furinture,
    13.     None,
    14.     Count,
    15.  
    16. }

    只有枚举没有类名，

    首先我们先写展现Item细节类的脚本ItemDetails，我们使用
    [System.Serializable]让它即使不能被挂载到游戏对象上，也能被其它类识别然后调用，

    1. using UnityEngine;
    2.  
    3. [System.Serializable]
    4. public class ItemDetails
    5. {
    6.     public int itemCode;
    7.     public ItemType itemType;
    8.     public string itemDescription;
    9.     public Sprite itemSprite;
    10.     public string itemLongDescription;
    11.     public short itemUseGridRadius;
    12.     public float itemUseRadius;
    13.     public bool isStartingItem;
    14.     public bool canBePickUp;
    15.     public bool canBeDropped;
    16.     public bool canBeEaten;
    17.     public bool canBeCarried;
    18. }

    然后我们就可以开始写Item类了，（这里[ItemCodeDescription]需要自定义的，一会讲）ItemCode属性是非常重要的东西，每一个独一无二的Item都将拥有属于自己ItemCode，然后我们就可以在ItemCode中调用它

    1. using System;
    2. using System.Collections;
    3. using System.Collections.Generic;
    4. using UnityEngine;
    5.  
    6. public class Item : MonoBehaviour
    7. {
    8.     [ItemCodeDescription][SerializeField] private int _itemCode;
    9.     private SpriteRenderer spriteRenderer;
    10.  
    11.     public int ItemCode
    12.     {
    13.         get
    14.         {
    15.             return _itemCode;
    16.         }
    17.         set
    18.         {
    19.             _itemCode = value;
    20.         }
    21.     }
    22.  
    23.     private void Awake()
    24.     {
    25.         spriteRenderer = GetComponentInChildren();
    26.     }
    27.  
    28.     private void Start()
    29.     {
    30.         if(ItemCode != 0)
    31.         {
    32.             Init(ItemCode);
    33.         }
    34.     }
    35.  
    36.     public void Init(int itemCodeParams)
    37.     {
    38.         
    39.     }
    40. }

    （这里[ItemCodeDescription]需要自定义的，一会讲）

    弄完后我们需要一个链表数组来存储所有的Item

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. [CreateAssetMenu(fileName  = "so_Itemlist", menuName = "Scriptable Objects/Item list")]
    6. public class SO_ItemList : ScriptableObject
    7. {
    8.     public List itemDetails;
    9. }

    回到Unity，我们为每一个Item创建独一无二的数据，这里就根据你的需求来填写这些数据了。

     

     

    那么这个 iItemCodeDescription是从哪里来的呢，这里就设计到我们的UnityEditor知识了。

    在你的脚本文件夹中创建两个如下名字的脚本

    先 打开Attribute，我们只需要让它继承PropertyAttribute即可

    1. using UnityEngine;
    2.  
    3. public class ItemCodeDescriptionAttribute : PropertyAttribute
    4. {
    5.     
    6. }

    剩下的脚本则需要引用UnityEditor命名空间，我们将在GUI上更改信息

    1.  
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4. using UnityEditor;
    5.  
    6. [CustomPropertyDrawer(typeof(ItemCodeDescriptionAttribute))] //告诉系统自定义特性名叫ItemCodeDescriptionAttribute
    7. public class ItemCodeDescriptionDrawer : PropertyDrawer
    8. {
    9.     public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
    10.     {
    11.         return EditorGUI.GetPropertyHeight(property) * 2;
    12.     }
    13.  
    14.     public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    15.     {
    16.         EditorGUI.BeginProperty(position, label, property);
    17.  
    18.         if(property.propertyType == SerializedPropertyType.Integer)
    19.         {
    20.             EditorGUI.BeginChangeCheck();
    21.  
    22.             var newValue = EditorGUI.IntField(new Rect(position.x, position.y, position.width, position.height / 2),label,property.intValue);
    23.  
    24.             EditorGUI.LabelField(new Rect(position.x, position.y + position.height /2 , position.width, position.height / 2), "Item Description",
    25.                 GetItemDescription(property.intValue));
    26.  
    27.  
    28.             //如果Item的ItemCode的值发生改变，则面板上的值也要发生变化
    29.  
    30.             if (EditorGUI.EndChangeCheck())
    31.             {
    32.                 property.intValue = newValue;
    33.             }
    34.         }
    35.  
    36.  
    37.         EditorGUI.EndProperty();
    38.     }
    39.  
    40.     private string GetItemDescription(int itemCode)
    41.     {
    42.         SO_ItemList so_itemList;
    43.  
    44.         so_itemList = AssetDatabase.LoadAssetAtPath("Assets/Scriptable Object Assets/Items/so_Itemlist.asset", typeof(SO_ItemList)) as SO_ItemList;
    45.  
    46.         List itemDetailLists = so_itemList.itemDetails;
    47.  
    48.         ItemDetails itemDetail = itemDetailLists.Find(x => x.itemCode == itemCode);
    49.  
    50.         if(itemDetail!= null)
    51.         {
    52.             return itemDetail.itemDescription;
    53.         }
    54.         else
    55.         {
    56.             return "";
    57.         }
    58.     }
    59. }

     我们会用到链表系统SO_ItmeList，并且用 AssetDatabase.LoadAssetAtPath获取本地路径，找到SO_ItmeList里面所有的链表，然后用Find函数寻找相同itemCode的ItemDetails，如果找到了就返回它的描述字符串，否则返回空双引号"";

    接下来就可以用你自定义的特性了

     接下来我们创建一个父预制体，如下所示添加Item类，

      

     把Item做成预制体后创建它的子对象操作如下

     

    比如我做了一个南瓜Item，可以看到，我们给南瓜对应的编号，底下的Decsription就会跟着改变，我是10001，描述的内容就是南瓜 

     我们可以添加一些效果给场景中的Item类，例如有些Item的属性中是不能被拾取，例如这些草仅仅是风景用途

     我们可以让在经过草的时候摆动一下。

    写个新脚本用协程来实现

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. public class ItemNudge : MonoBehaviour
    6. {
    7.     [SerializeField] private float pauseTime = 0.04f;
    8.     private WaitForSeconds pause;
    9.     private bool isAnimating = false;
    10.  
    11.     private void Awake()
    12.     {
    13.         pause = new WaitForSeconds(pauseTime);
    14.     }
    15.  
    16.     private void OnTriggerEnter2D(Collider2D collision)
    17.     {
    18.         if (!isAnimating)
    19.         {
    20.             if(gameObject.transform.position.x < collision.transform.position.x) //如果在左边
    21.             {
    22.                 StartCoroutine(nameof(RotateAndClock));
    23.             }
    24.             else
    25.             {
    26.                 StartCoroutine(nameof(RotateClock));
    27.             }
    28.         }
    29.     }
    30.  
    31.     private IEnumerator RotateAndClock()
    32.     {
    33.         isAnimating = true;
    34.  
    35.         for (int i = 0; i < 4; i++)
    36.         {
    37.             gameObject.transform.GetChild(0).Rotate(0f, 0f, 2f);
    38.             yield return pause;
    39.         }
    40.  
    41.         for (int i = 0; i < 5; i++)
    42.         {
    43.             gameObject.transform.GetChild(0).Rotate(0f, 0f, -2f);
    44.             yield return pause;
    45.         }
    46.  
    47.         gameObject.transform.GetChild(0).Rotate(0f, 0f, 2f);
    48.  
    49.         yield return pause;
    50.  
    51.         isAnimating = false;
    52.     }
    53.  
    54.     private IEnumerator RotateClock()
    55.     {
    56.         isAnimating = true;
    57.  
    58.         for (int i = 0; i < 4; i++)
    59.         {
    60.             gameObject.transform.GetChild(0).Rotate(0f, 0f, -2f);
    61.             yield return pause;
    62.         }
    63.  
    64.         for (int i = 0; i < 5; i++)
    65.         {
    66.             gameObject.transform.GetChild(0).Rotate(0f, 0f, 2f);
    67.             yield return pause;
    68.         }
    69.  
    70.         gameObject.transform.GetChild(0).Rotate(0f, 0f, -2f);
    71.  
    72.         yield return pause;
    73.  
    74.         isAnimating = false;
    75.     }
    76. }

     再回到Item类在初始化方法中判断是不是ItemType.Reapable_scenery，是的话就给它添加我们刚刚新建的脚本

    1. using System;
    2. using System.Collections;
    3. using System.Collections.Generic;
    4. using UnityEngine;
    5.  
    6. public class Item : MonoBehaviour
    7. {
    8.     [ItemCodeDescription][SerializeField] private int _itemCode;
    9.     private SpriteRenderer spriteRenderer;
    10.  
    11.     public int ItemCode
    12.     {
    13.         get
    14.         {
    15.             return _itemCode;
    16.         }
    17.         set
    18.         {
    19.             _itemCode = value;
    20.         }
    21.     }
    22.  
    23.     private void Awake()
    24.     {
    25.         spriteRenderer = GetComponentInChildren();
    26.     }
    27.  
    28.     private void Start()
    29.     {
    30.         if(ItemCode != 0)
    31.         {
    32.             Init(ItemCode);
    33.         }
    34.     }
    35.  
    36.     public void Init(int itemCodeParams)
    37.     {
    38.         if(itemCodeParams != 0)
    39.         {
    40.             ItemCode = itemCodeParams;
    41.  
    42.             ItemDetails itemDetails = InventoryManager.Instance.GetItemDetails(ItemCode);
    43.  
    44.             spriteRenderer.sprite = itemDetails.itemSprite;
    45.  
    46.             if(itemDetails.itemType == ItemType.Reapable_scenery) //如果该物品是风景类型的话
    47.             {
    48.                 gameObject.AddComponent();
    49.             }
    50.         }
    51.     }
    52. }

    接下来来实现如何做到拾取物品

      我们给玩家添加一个新脚本就叫ItemPickUp，因为每一个Item身上都有一个触发器

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. public class ItemPickUp : MonoBehaviour
    6. {
    7.     private void OnTriggerEnter2D(Collider2D collision)
    8.     {
    9.         if(collision.TryGetComponent(out Item item))
    10.         {
    11.             ItemDetails itemDetails = InventoryManager.Instance.GetItemDetails(item.ItemCode);
    12.  
    13.             if (itemDetails.canBePickUp)
    14.             {
    15.                
    16.             }
    17.         }
    18.     }
    19. }

     我们还需要一个背包系统InventoryManager，它和SO_ItemList的区别在于，它是一个存储你所能收集到的Item，而SO_ItemList则更像是一个登记所有物品信息的。

    我们要写一个新枚举，我们将使用二维数组来控制使用的是哪一个背包。

    1.  
    2. public enum InventoryLocation
    3. {
    4.     player,
    5.     chest,
    6.     count,
    7. }
    8.  
    9. public enum ItemType
    10. {
    11.     Seed,
    12.     Commodity,
    13.     Watering_tool,
    14.     Hoeing_tool,
    15.     Chopping_tool,
    16.     Breaking_tool,
    17.     Reping_tool,
    18.     Collecting_tool,
    19.     Reapable_scenery,
    20.     Furinture,
    21.     None,
    22.     Count,
    23.  
    24. }

     接着创建一个结构来管理背包中的Item

    1. [System.Serializable]
    2. public struct InventoryItem 
    3. {
    4.     public int itemCode;
    5.     public int itemQuantity;
    6. }

    还需要一个单例模式

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. public class Singleton<T> : MonoBehaviour where T : Component
    6. {
    7.     private static T instance;
    8.  
    9.     public static T Instance
    10.     {
    11.         get
    12.         {
    13.             return instance;
    14.         }
    15.     }
    16.  
    17.     protected virtual void Awake()
    18.     {
    19.         if(instance == null)
    20.         {
    21.             instance = this as T;
    22.         }
    23.         else
    24.         {
    25.             Destroy(gameObject);
    26.         }
    27.     }
    28. }

    w我们需要一个事件处理程序来完成它

    1. using System;
    2. using System.Collections;
    3. using System.Collections.Generic;
    4.  
    5. public static class EventHandler
    6. {
    7.     public static event Action> InventoryUpdateEvent;
    8.  
    9.     public static void CallInventoryUpdateEvent(InventoryLocation inventoryLocation,List inventoryLists)
    10.     {
    11.         if(InventoryUpdateEvent != null)
    12.         {
    13.             InventoryUpdateEvent(inventoryLocation, inventoryLists);
    14.         }
    15.     }
    16.  
    17.     
    18. }

    准备工作就绪，我们就可以继续写InventoryManager了

    首先要考虑它的添加和移除物品，以及初始化的时候要创建的数组

    1. using System;
    2. using System.Collections;
    3. using System.Collections.Generic;
    4. using UnityEngine;
    5.  
    6. public class InventoryManager : Singleton<InventoryManager>
    7. {
    8.     private Dictionary<int, ItemDetails> itemDetailsDictionary; //通过itemDetails上的itemCode(int类型)的值寻找对应的itemDetails
    9.     public List[] inventoryLists; //一个存放所有InventoryItem的链表的数组
    10.     [HideInInspector] public int[] inventoryListInCapcityInArray; //背包容量大小默认是12
    11.  
    12.     [SerializeField] private SO_ItemList itemLists; //SO_ItemList登记过所有Item
    13.  
    14.     protected override void Awake()
    15.     {
    16.         base.Awake();
    17.  
    18.         CreateInventoryLists();
    19.  
    20.         CreateItemDetailsDictionary();
    21.     }
    22.  
    23.     private void CreateInventoryLists()
    24.     {
    25.         inventoryLists = new List[(int)InventoryLocation.count];//我们有0号背包系统的链表和1号背包系统的链表
    26.  
    27.         for (int i = 0; i < (int)InventoryLocation.count; i++)
    28.         {
    29.             inventoryLists[i] = new List();
    30.         }
    31.  
    32.         //出事背包容量列表
    33.         inventoryListInCapcityInArray = new int[(int)InventoryLocation.count];
    34.  
    35.         //初始化玩家背包（0号背包）容量
    36.         inventoryListInCapcityInArray[(int)InventoryLocation.player] = Settings.playerIntialInventoryCapcity;
    37.     }
    38.     public void AddItem(InventoryLocation inventoryLocation, Item item,GameObject gameObjectToDelete) 
    39.     {
    40.         AddItem(inventoryLocation, item);
    41.  
    42.         Destroy(gameObjectToDelete);
    43.     }
    44.     /// 
    45.     /// 添加物品
    46.     /// 
    47.     /// 
    48.     /// 
    49.     public void AddItem(InventoryLocation inventoryLocation,Item item)
    50.     {
    51.         int itemCode = item.ItemCode;
    52.         List inventoryList = inventoryLists[(int)inventoryLocation];
    53.  
    54.         int itemPositon = FindItemInventory(inventoryLocation, itemCode);
    55.  
    56.         if(itemPositon != -1)
    57.         {
    58.             AddItemAtPosition(inventoryList, itemCode, itemPositon);//如果找到物品就数量++
    59.         }
    60.         else
    61.         {
    62.             AddItemAtPosition(inventoryList, itemCode); //找不到就在空白处新添加物品
    63.         }
    64.  
    65.         EventHandler.CallInventoryUpdateEvent(inventoryLocation, inventoryLists[(int)inventoryLocation]);
    66.     }
    67.     /// 
    68.     /// 交换物品顺序
    69.     /// 
    70.     /// 
    71.     /// 
    72.     /// 
    73.     public void SwapInventoryItems(InventoryLocation inventoryLocation, int fromSlotNumber, int toSlotNumber)
    74.     {
    75.         if(fromSlotNumber < inventoryLists[(int)inventoryLocation].Count && toSlotNumber < inventoryLists[(int)inventoryLocation].Count &&
    76.             fromSlotNumber != toSlotNumber  && toSlotNumber >= 0)
    77.         {
    78.             InventoryItem fromSlotItem = inventoryLists[(int)inventoryLocation][fromSlotNumber];
    79.             InventoryItem toSlotItem = inventoryLists[(int)inventoryLocation][toSlotNumber];
    80.  
    81.             inventoryLists[(int)inventoryLocation][toSlotNumber] = fromSlotItem;
    82.             inventoryLists[(int)inventoryLocation][fromSlotNumber] = toSlotItem;
    83.  
    84.             EventHandler.CallInventoryUpdateEvent(inventoryLocation, inventoryLists[(int)inventoryLocation]);
    85.  
    86.         }
    87.     }
    88.  
    89.     /// 
    90.     /// 将物品添加到背包的位置
    91.     /// 
    92.     /// 
    93.     /// 
    94.  
    95.     private void AddItemAtPosition(List inventoryList, int itemCode)
    96.     {
    97.         InventoryItem inventoryItem = new InventoryItem();
    98.  
    99.         inventoryItem.itemCode = itemCode;
    100.         inventoryItem.itemQuantity = 1;
    101.  
    102.         inventoryList.Add(inventoryItem);
    103.     }
    104.  
    105.     /// 
    106.     /// 对于背包中已经有的物品就加数量
    107.     /// 
    108.     /// 
    109.     /// 
    110.     /// 
    111.  
    112.     private void AddItemAtPosition(List inventoryList, int itemCode, int positon)
    113.     {
    114.         InventoryItem inventoryItem = new InventoryItem();
    115.  
    116.         int quantity = inventoryList[positon].itemQuantity + 1;
    117.         inventoryItem.itemCode = itemCode;
    118.         inventoryItem.itemQuantity = quantity;
    119.         inventoryList[positon] = inventoryItem;
    120.  
    121.         Debug.ClearDeveloperConsole();
    122.     }
    123.  
    124.     internal void RemoveItem(InventoryLocation inventoryLocation, int itemCode)
    125.     {
    126.         List inventoryList = inventoryLists[(int)inventoryLocation];
    127.         int itemPosition = FindItemInventory(inventoryLocation, itemCode);
    128.  
    129.         if (itemPosition != -1)
    130.         {
    131.             RemoveItemAtPosition(inventoryList,itemCode,itemPosition);
    132.         }
    133.         EventHandler.CallInventoryUpdateEvent(inventoryLocation, inventoryLists[(int)inventoryLocation]);
    134.     }
    135.  
    136.     private void RemoveItemAtPosition(List inventoryList, int itemCode, int position)
    137.     {
    138.         InventoryItem inventoryItem = new InventoryItem();
    139.  
    140.         int quantity = inventoryList[position].itemQuantity - 1;
    141.  
    142.         if(quantity > 0)
    143.         {
    144.             inventoryItem.itemQuantity = quantity;
    145.             inventoryItem.itemCode = itemCode;
    146.             inventoryList[position] = inventoryItem;
    147.         }
    148.         else
    149.         {
    150.             inventoryList.RemoveAt(position);
    151.         }
    152.     }
    153.  
    154.     /// 
    155.     /// 判断物品是否在背包里面，找不到就return -1，找到的话就返回发现物品的位置
    156.     /// 
    157.     /// 
    158.     /// 
    159.     /// 
    160.     private int FindItemInventory(InventoryLocation inventoryLocation,int itemCode)
    161.     {
    162.         List inventoryList = inventoryLists[(int)inventoryLocation];
    163.  
    164.         for (int i = 0; i < inventoryList.Count; i++)
    165.         {
    166.             if(inventoryList[i].itemCode == itemCode)
    167.             {
    168.                 return i;
    169.             }
    170.         }
    171.  
    172.         return -1;
    173.     }
    174.  
    175.     /// 
    176.     /// 初始化创建的字典
    177.     /// 
    178.  
    179.     private void CreateItemDetailsDictionary()
    180.     {
    181.         itemDetailsDictionary = new Dictionary<int, ItemDetails>();
    182.  
    183.         foreach (var itemDetails in itemLists.itemDetails)
    184.         {
    185.             itemDetailsDictionary.Add(itemDetails.itemCode,itemDetails);
    186.         }
    187.     }
    188.  
    189.     /// 
    190.     /// 在背包中找ItemDetails
    191.     /// 
    192.     /// 
    193.     /// 
    194.     public ItemDetails GetItemDetails(int itemCode)
    195.     {
    196.         ItemDetails itemDetails;
    197.  
    198.         if(itemDetailsDictionary.TryGetValue(itemCode,out itemDetails))
    199.         {
    200.             return itemDetails;
    201.         }
    202.         else
    203.         {
    204.             return null;
    205.         }
    206.     }
    207.  
    208.     /// 
    209.     /// 吃到物品用的调试
    210.     /// 
    211.     /// 
    212.     private void DebugPrintInventoryList(List inventoryLists)
    213.     {
    214.         foreach (var inventoyItem in inventoryLists)
    215.         {
    216.             Debug.Log("Item Description:" + InventoryManager.Instance.GetItemDetails(inventoyItem.itemCode).itemDescription +
    217.                 "       Item Quantity:" + inventoyItem.itemQuantity);
    218.         }
    219.     }
    220. }

    回到PickUp脚本，我们就可以直接添加了

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4.  
    5. public class ItemPickUp : MonoBehaviour
    6. {
    7.     private void OnTriggerEnter2D(Collider2D collision)
    8.     {
    9.         if(collision.TryGetComponent(out Item item))
    10.         {
    11.             ItemDetails itemDetails = InventoryManager.Instance.GetItemDetails(item.ItemCode);
    12.  
    13.             if (itemDetails.canBePickUp)
    14.             {
    15.                 InventoryManager.Instance.AddItem(InventoryLocation.player, item, collision.gameObject);
    16.             }
    17.         }
    18.     }
    19. }

     

    UI：

      搞完后就可以制作UI了，直接我们采用熟悉的设计UI模式

     

     

     

    一定要注意这个Slot的两个子对象的Raycast Target要取消勾选，不然会导致后面拖拽的时候出现问题。 

     

     

     

    1. using System;
    2. using System.Collections;
    3. using System.Collections.Generic;
    4. using UnityEngine;
    5.  
    6. public class UIInventoryBar : MonoBehaviour
    7. {
    8.     [SerializeField] private PlayerController2D playerController2D;
    9.     [SerializeField] private Sprite blank16Sprite = null;
    10.     [SerializeField] private UIInventorySlot[] inventorySlots = null;
    11.     public GameObject inventoryBarDragItem;
    12.  
    13.     private RectTransform rectTransform;
    14.  
    15.     private bool isInventoryBarPositionBottom = true;  //判断背包条是否在视角下方
    16.  
    17.     public bool IsInventoryBarPositionBottom
    18.     {
    19.         get
    20.         {
    21.             return isInventoryBarPositionBottom;
    22.         }
    23.         set
    24.         {
    25.             isInventoryBarPositionBottom = value;
    26.         }
    27.     }
    28.  
    29.     private void Awake()
    30.     {
    31.         rectTransform = GetComponent();
    32.     }
    33.  
    34.     private void Update()
    35.     {
    36.         SwitchInventoryBarPosition();
    37.     }
    38.  
    39.     private void OnEnable()
    40.     {
    41.         EventHandler.InventoryUpdateEvent += InventoryUpdate;
    42.     }
    43.  
    44.     private void OnDisable()
    45.     {
    46.         EventHandler.InventoryUpdateEvent -= InventoryUpdate;
    47.     }
    48.  
    49.     private void InventoryUpdate(InventoryLocation inventoryLocation, List inventoryList)
    50.     {
    51.         if(inventoryLocation == InventoryLocation.player)
    52.         {
    53.             CLearInventorySlots(); //先清空InventroyBar里面所有的InvnetorSlot
    54.             if(inventoryList.Count >0 && inventorySlots.Length > 0) //再遍历一遍inventoryList和inventorySlots重新添加回bar里
    55.             {
    56.                 for (int i = 0; i < inventorySlots.Length; i++)
    57.                 {
    58.                     if (i < inventoryList.Count)
    59.                     {
    60.                         int itemCode = inventoryList[i].itemCode;
    61.  
    62.                         ItemDetails itemDetails = InventoryManager.Instance.GetItemDetails(itemCode);
    63.  
    64.                         if (itemDetails != null)
    65.                         {
    66.                             inventorySlots[i].inventorySlotImage.sprite = itemDetails.itemSprite;
    67.                             inventorySlots[i].textMeshProUGUI.text = inventoryList[i].itemQuantity.ToString();
    68.                             inventorySlots[i].itemDetails = itemDetails;
    69.                             inventorySlots[i].itemQuantity = inventoryList[i].itemQuantity;                            
    70.                         }
    71.                     }
    72.                     else
    73.                     {
    74.                         break;
    75.                     }
    76.  
    77.                 }
    78.             }
    79.         }
    80.     }
    81.  
    82.     private void CLearInventorySlots()
    83.     {
    84.         if(inventorySlots.Length > 0)
    85.         {
    86.             for (int i = 0; i < inventorySlots.Length; i++)
    87.             {
    88.                 inventorySlots[i].inventorySlotImage.sprite = blank16Sprite;
    89.                 inventorySlots[i].textMeshProUGUI.text = "";
    90.                 inventorySlots[i].itemDetails = null;
    91.                 inventorySlots[i].itemQuantity = 0;
    92.             }
    93.         }
    94.     }
    95.  
    96.     /// 
    97.     /// 切换InventoryBar
    98.     /// 
    99.     private void SwitchInventoryBarPosition()
    100.     {
    101.         Vector3 playerViewportPosition = playerController2D.GetPlayerVierportPosition();
    102.  
    103.         if (playerViewportPosition.y > 0.3f && !IsInventoryBarPositionBottom)
    104.         {
    105.             rectTransform.pivot = new Vector2(0.5f, 0f);
    106.             rectTransform.anchorMin = new Vector2(0.5f, 0f);
    107.             rectTransform.anchorMax = new Vector2(0.5f, 0f);
    108.             rectTransform.anchoredPosition = new Vector2(0f, 2.5f);
    109.  
    110.             isInventoryBarPositionBottom = true;
    111.         }
    112.  
    113.         else if(playerViewportPosition.y <= 0.3f && IsInventoryBarPositionBottom)
    114.         {
    115.  
    116.             rectTransform.pivot = new Vector2(0.5f, 1f);
    117.             rectTransform.anchorMin = new Vector2(0.5f, 1f);
    118.             rectTransform.anchorMax = new Vector2(0.5f, 1f);
    119.             rectTransform.anchoredPosition = new Vector2(0f, -2.5f);
    120.  
    121.             isInventoryBarPositionBottom = false;            
    122.         }
    123.     }
    124. }

    InventorySlot的脚本如下

    1. using System.Collections;
    2. using System.Collections.Generic;
    3. using UnityEngine;
    4. using UnityEngine.EventSystems;
    5. using TMPro;
    6. using UnityEngine.UI;
    7. using System;
    8.  
    9. public class UIInventorySlot : MonoBehaviour,IBeginDragHandler,IDragHandler,IEndDragHandler
    10. {
    11.     private Camera mainCamera;
    12.     private GameObject draggedItem;
    13.     private Transform itemParent;
    14.  
    15.     public Image inventorySlotHighlight;
    16.     public Image inventorySlotImage;
    17.     public TextMeshProUGUI textMeshProUGUI;
    18.  
    19.     [SerializeField] private UIInventoryBar inventoryBar = null;
    20.     [HideInInspector] public ItemDetails itemDetails;
    21.     [SerializeField] private GameObject itemPrefab = null;
    22.     [HideInInspector] public int itemQuantity;
    23.     [SerializeField] private int slotNumber = 0;
    24.  
    25.     private void Start()
    26.     {
    27.         mainCamera = Camera.main;
    28.         itemParent = GameObject.FindGameObjectWithTag(Tags.ItemsParentTransform).transform;
    29.     }
    30.  
    31.     public void OnBeginDrag(PointerEventData eventData)
    32.     {
    33.         if(itemDetails != null)
    34.         {
    35.             //PlayerController.Instance.DisablePlayerInputAndResetMovement();
    36.  
    37.             draggedItem = Instantiate(inventoryBar.inventoryBarDragItem, inventoryBar.transform);
    38.  
    39.             Image draggedItemImage = draggedItem.GetComponentInChildren();
    40.             draggedItemImage.sprite = inventorySlotImage.sprite;
    41.             Debug.Log("draggedItemImage.sprite" + draggedItemImage.sprite);
    42.         }
    43.     }
    44.  
    45.     public void OnDrag(PointerEventData eventData)
    46.     {
    47.         if(draggedItem != null)
    48.         {
    49.             draggedItem.transform.position = Input.mousePosition;
    50.         }
    51.     }
    52.  
    53.     public void OnEndDrag(PointerEventData eventData)
    54.     {
    55.         if(draggedItem != null)
    56.         {
    57.             Destroy(draggedItem);
    58.  
    59.             if(eventData.pointerCurrentRaycast.gameObject != null && eventData.pointerCurrentRaycast.gameObject.GetComponent() != null)
    60.             {
    61.                 int toSlotNumber = eventData.pointerCurrentRaycast.gameObject.GetComponent().slotNumber;
    62.  
    63.                 InventoryManager.Instance.SwapInventoryItems(InventoryLocation.player,slotNumber,toSlotNumber);
    64.             }
    65.             else
    66.             {
    67.                 if (itemDetails.canBeDropped)
    68.                 {
    69.                     DropSelectedItemMousePosition();
    70.                 }
    71.             }
    72.  
    73.             //PlayerController.Instance.EnablePlayerInput();
    74.         }
    75.     }
    76.  
    77.     private void DropSelectedItemMousePosition()
    78.     {
    79.         if(itemDetails != null)
    80.         {
    81.             Vector3 worldPosition = mainCamera.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, -mainCamera.transform.position.z));
    82.  
    83.             GameObject itemGameobject = Instantiate(itemPrefab, worldPosition, Quaternion.identity, itemParent);
    84.             Item item = itemGameobject.GetComponent();
    85.             item.ItemCode = itemDetails.itemCode;
    86.  
    87.             InventoryManager.Instance.RemoveItem(InventoryLocation.player, item.ItemCode);
    88.         }
    89.     }
    90. }

    依次添加 

    对应的SlotNumer 

     

    .....

     

     

    我们需要创建一个名字叫UIInventoryDraggedItem的预制体，用来处理拖拽出来的图像显示

     

     

     完成以后我们可以把物品放到场景中试玩一下，可以

    我们来做最后的交换位置，在我们之前写的InventoryManager加上这个函数即可

    1.     /// 
    2.     /// 交换物品顺序
    3.     /// 
    4.     /// 
    5.     /// 
    6.     /// 
    7.     public void SwapInventoryItems(InventoryLocation inventoryLocation, int fromSlotNumber, int toSlotNumber)
    8.     {
    9.         if(fromSlotNumber < inventoryLists[(int)inventoryLocation].Count && toSlotNumber < inventoryLists[(int)inventoryLocation].Count &&
    10.             fromSlotNumber != toSlotNumber  && toSlotNumber >= 0)
    11.         {
    12.             InventoryItem fromSlotItem = inventoryLists[(int)inventoryLocation][fromSlotNumber];
    13.             InventoryItem toSlotItem = inventoryLists[(int)inventoryLocation][toSlotNumber];
    14.  
    15.             inventoryLists[(int)inventoryLocation][toSlotNumber] = fromSlotItem;
    16.             inventoryLists[(int)inventoryLocation][fromSlotNumber] = toSlotItem;
    17.  
    18.             EventHandler.CallInventoryUpdateEvent(inventoryLocation, inventoryLists[(int)inventoryLocation]);
    19.  
    20.         }
    21.     }

    回到OnEndDrag的函数

    1. public void OnEndDrag(PointerEventData eventData)
    2.     {
    3.         if(draggedItem != null)
    4.         {
    5.             Destroy(draggedItem);
    6.  
    7.             if(eventData.pointerCurrentRaycast.gameObject != null && eventData.pointerCurrentRaycast.gameObject.GetComponent() != null)
    8.             {
    9.                 int toSlotNumber = eventData.pointerCurrentRaycast.gameObject.GetComponent().slotNumber;
    10.  
    11.                 InventoryManager.Instance.SwapInventoryItems(InventoryLocation.player,slotNumber,toSlotNumber);
    12.             }
    13.             else
    14.             {
    15.                 if (itemDetails.canBeDropped)
    16.                 {
    17.                     DropSelectedItemMousePosition();
    18.                 }
    19.             }
    20.  
    21.             //PlayerController.Instance.EnablePlayerInput();
    22.         }
    23.     }

     

    学习产出：

    1

    由于时间有限（要去恰午饭了）展示就不展示了，总之我们先做到通过这些来实现玩家有关物体UI的效果，下次更新可能是比赛完以后，我先走啦，拜拜。

  • 相关阅读:
    软件需求说明书(GB856T-88)
    【零基础入门Mybatis系列】第十篇——查询专题
    内网穿透的应用-通过内网穿透技术实现PLSQL远程访问Oracle数据库
    MySQL索引原理之索引与约束
    作为产品经理，在工作中常逛哪些网站？
    【Codeforces】 CF79D Password
    [含lw+源码等]微信小程序家政预约系统+后台管理系统[包运行成功]
    腾讯云2023年双11云服务器优惠价格表
    71、Spring Data JPA 的 样本查询--参数作为样本去查询数据库的数据，也可以定义查询的匹配规则
    Flask 实战笔记02 - SQLAlchemy实现mysql的应用
  • 原文地址：https://blog.csdn.net/dangoxiba/article/details/126802595