0
0

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

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

学习目标：

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

学习内容：

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

public enum ItemType
{
    Seed,
    Commodity,
    Watering_tool,
    Hoeing_tool,
    Chopping_tool,
    Breaking_tool,
    Reping_tool,
    Collecting_tool,
    Reapable_scenery,
    Furinture,
    None,
    Count,

}

只有枚举没有类名，

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

using UnityEngine;

[System.Serializable]
public class ItemDetails
{
    public int itemCode;
    public ItemType itemType;
    public string itemDescription;
    public Sprite itemSprite;
    public string itemLongDescription;
    public short itemUseGridRadius;
    public float itemUseRadius;
    public bool isStartingItem;
    public bool canBePickUp;
    public bool canBeDropped;
    public bool canBeEaten;
    public bool canBeCarried;
}

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

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Item : MonoBehaviour
{
    [ItemCodeDescription][SerializeField] private int _itemCode;
    private SpriteRenderer spriteRenderer;

    public int ItemCode
    {
        get
        {
            return _itemCode;
        }
        set
        {
            _itemCode = value;
        }
    }

    private void Awake()
    {
        spriteRenderer = GetComponentInChildren<SpriteRenderer>();
    }

    private void Start()
    {
        if(ItemCode != 0)
        {
            Init(ItemCode);
        }
    }

    public void Init(int itemCodeParams)
    {
        
    }
}

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

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

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName  = "so_Itemlist", menuName = "Scriptable Objects/Item list")]
public class SO_ItemList : ScriptableObject
{
    public List<ItemDetails> itemDetails;
}

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

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

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

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

using UnityEngine;

public class ItemCodeDescriptionAttribute : PropertyAttribute
{
    
}

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


using System.Collections.Generic;
using UnityEngine;
using UnityEditor;

[CustomPropertyDrawer(typeof(ItemCodeDescriptionAttribute))] //告诉系统自定义特性名叫ItemCodeDescriptionAttribute
public class ItemCodeDescriptionDrawer : PropertyDrawer
{
    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
    {
        return EditorGUI.GetPropertyHeight(property) * 2;
    }

    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        EditorGUI.BeginProperty(position, label, property);

        if(property.propertyType == SerializedPropertyType.Integer)
        {
            EditorGUI.BeginChangeCheck();

            var newValue = EditorGUI.IntField(new Rect(position.x, position.y, position.width, position.height / 2),label,property.intValue);

            EditorGUI.LabelField(new Rect(position.x, position.y + position.height /2 , position.width, position.height / 2), "Item Description",
                GetItemDescription(property.intValue));

            //如果Item的ItemCode的值发生改变，则面板上的值也要发生变化

            if (EditorGUI.EndChangeCheck())
            {
                property.intValue = newValue;
            }
        }

        EditorGUI.EndProperty();
    }

    private string GetItemDescription(int itemCode)
    {
        SO_ItemList so_itemList;

        so_itemList = AssetDatabase.LoadAssetAtPath("Assets/Scriptable Object Assets/Items/so_Itemlist.asset", typeof(SO_ItemList)) as SO_ItemList;

        List<ItemDetails> itemDetailLists = so_itemList.itemDetails;

        ItemDetails itemDetail = itemDetailLists.Find(x => x.itemCode == itemCode);

        if(itemDetail!= null)
        {
            return itemDetail.itemDescription;
        }
        else
        {
            return "";
        }
    }
}

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

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

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

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

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

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

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

写个新脚本用协程来实现

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ItemNudge : MonoBehaviour
{
    [SerializeField] private float pauseTime = 0.04f;
    private WaitForSeconds pause;
    private bool isAnimating = false;

    private void Awake()
    {
        pause = new WaitForSeconds(pauseTime);
    }

    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (!isAnimating)
        {
            if(gameObject.transform.position.x < collision.transform.position.x) //如果在左边
            {
                StartCoroutine(nameof(RotateAndClock));
            }
            else
            {
                StartCoroutine(nameof(RotateClock));
            }
        }
    }

    private IEnumerator RotateAndClock()
    {
        isAnimating = true;

        for (int i = 0; i < 4; i++)
        {
            gameObject.transform.GetChild(0).Rotate(0f, 0f, 2f);
            yield return pause;
        }

        for (int i = 0; i < 5; i++)
        {
            gameObject.transform.GetChild(0).Rotate(0f, 0f, -2f);
            yield return pause;
        }

        gameObject.transform.GetChild(0).Rotate(0f, 0f, 2f);

        yield return pause;

        isAnimating = false;
    }

    private IEnumerator RotateClock()
    {
        isAnimating = true;

        for (int i = 0; i < 4; i++)
        {
            gameObject.transform.GetChild(0).Rotate(0f, 0f, -2f);
            yield return pause;
        }

        for (int i = 0; i < 5; i++)
        {
            gameObject.transform.GetChild(0).Rotate(0f, 0f, 2f);
            yield return pause;
        }

        gameObject.transform.GetChild(0).Rotate(0f, 0f, -2f);

        yield return pause;

        isAnimating = false;
    }
}

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

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Item : MonoBehaviour
{
    [ItemCodeDescription][SerializeField] private int _itemCode;
    private SpriteRenderer spriteRenderer;

    public int ItemCode
    {
        get
        {
            return _itemCode;
        }
        set
        {
            _itemCode = value;
        }
    }

    private void Awake()
    {
        spriteRenderer = GetComponentInChildren<SpriteRenderer>();
    }

    private void Start()
    {
        if(ItemCode != 0)
        {
            Init(ItemCode);
        }
    }

    public void Init(int itemCodeParams)
    {
        if(itemCodeParams != 0)
        {
            ItemCode = itemCodeParams;

            ItemDetails itemDetails = InventoryManager.Instance.GetItemDetails(ItemCode);

            spriteRenderer.sprite = itemDetails.itemSprite;

            if(itemDetails.itemType == ItemType.Reapable_scenery) //如果该物品是风景类型的话
            {
                gameObject.AddComponent<ItemNudge>();
            }
        }
    }
}

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

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

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ItemPickUp : MonoBehaviour
{
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.TryGetComponent<Item>(out Item item))
        {
            ItemDetails itemDetails = InventoryManager.Instance.GetItemDetails(item.ItemCode);

            if (itemDetails.canBePickUp)
            {
               
            }
        }
    }
}

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

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


public enum InventoryLocation
{
    player,
    chest,
    count,
}

public enum ItemType
{
    Seed,
    Commodity,
    Watering_tool,
    Hoeing_tool,
    Chopping_tool,
    Breaking_tool,
    Reping_tool,
    Collecting_tool,
    Reapable_scenery,
    Furinture,
    None,
    Count,

}

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

[System.Serializable]
public struct InventoryItem 
{
    public int itemCode;
    public int itemQuantity;
}

还需要一个单例模式

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Singleton<T> : MonoBehaviour where T : Component
{
    private static T instance;

    public static T Instance
    {
        get
        {
            return instance;
        }
    }

    protected virtual void Awake()
    {
        if(instance == null)
        {
            instance = this as T;
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

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

using System;
using System.Collections;
using System.Collections.Generic;

public static class EventHandler
{
    public static event Action<InventoryLocation,List<InventoryItem>> InventoryUpdateEvent;

    public static void CallInventoryUpdateEvent(InventoryLocation inventoryLocation,List<InventoryItem> inventoryLists)
    {
        if(InventoryUpdateEvent != null)
        {
            InventoryUpdateEvent(inventoryLocation, inventoryLists);
        }
    }

    
}

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

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

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class InventoryManager : Singleton<InventoryManager>
{
    private Dictionary<int, ItemDetails> itemDetailsDictionary; //通过itemDetails上的itemCode(int类型)的值寻找对应的itemDetails
    public List<InventoryItem>[] inventoryLists; //一个存放所有InventoryItem的链表的数组
    [HideInInspector] public int[] inventoryListInCapcityInArray; //背包容量大小默认是12

    [SerializeField] private SO_ItemList itemLists; //SO_ItemList登记过所有Item

    protected override void Awake()
    {
        base.Awake();

        CreateInventoryLists();

        CreateItemDetailsDictionary();
    }

    private void CreateInventoryLists()
    {
        inventoryLists = new List<InventoryItem>[(int)InventoryLocation.count];//我们有0号背包系统的链表和1号背包系统的链表

        for (int i = 0; i < (int)InventoryLocation.count; i++)
        {
            inventoryLists[i] = new List<InventoryItem>();
        }

        //出事背包容量列表
        inventoryListInCapcityInArray = new int[(int)InventoryLocation.count];

        //初始化玩家背包（0号背包）容量
        inventoryListInCapcityInArray[(int)InventoryLocation.player] = Settings.playerIntialInventoryCapcity;
    }
    public void AddItem(InventoryLocation inventoryLocation, Item item,GameObject gameObjectToDelete) 
    {
        AddItem(inventoryLocation, item);

        Destroy(gameObjectToDelete);
    }
    /// <summary>
    /// 添加物品
    /// </summary>
    /// <param name="inventoryLocation"></param>
    /// <param name="item"></param>
    public void AddItem(InventoryLocation inventoryLocation,Item item)
    {
        int itemCode = item.ItemCode;
        List<InventoryItem> inventoryList = inventoryLists[(int)inventoryLocation];

        int itemPositon = FindItemInventory(inventoryLocation, itemCode);

        if(itemPositon != -1)
        {
            AddItemAtPosition(inventoryList, itemCode, itemPositon);//如果找到物品就数量++
        }
        else
        {
            AddItemAtPosition(inventoryList, itemCode); //找不到就在空白处新添加物品
        }

        EventHandler.CallInventoryUpdateEvent(inventoryLocation, inventoryLists[(int)inventoryLocation]);
    }
    /// <summary>
    /// 交换物品顺序
    /// </summary>
    /// <param name="inventoryLocation"></param>
    /// <param name="fromSlotNumber"></param>
    /// <param name="toSlotNumber"></param>
    public void SwapInventoryItems(InventoryLocation inventoryLocation, int fromSlotNumber, int toSlotNumber)
    {
        if(fromSlotNumber < inventoryLists[(int)inventoryLocation].Count && toSlotNumber < inventoryLists[(int)inventoryLocation].Count &&
            fromSlotNumber != toSlotNumber  && toSlotNumber >= 0)
        {
            InventoryItem fromSlotItem = inventoryLists[(int)inventoryLocation][fromSlotNumber];
            InventoryItem toSlotItem = inventoryLists[(int)inventoryLocation][toSlotNumber];

            inventoryLists[(int)inventoryLocation][toSlotNumber] = fromSlotItem;
            inventoryLists[(int)inventoryLocation][fromSlotNumber] = toSlotItem;

            EventHandler.CallInventoryUpdateEvent(inventoryLocation, inventoryLists[(int)inventoryLocation]);

        }
    }

    /// <summary>
    /// 将物品添加到背包的位置
    /// </summary>
    /// <param name="inventoryList"></param>
    /// <param name="itemCode"></param>

    private void AddItemAtPosition(List<InventoryItem> inventoryList, int itemCode)
    {
        InventoryItem inventoryItem = new InventoryItem();

        inventoryItem.itemCode = itemCode;
        inventoryItem.itemQuantity = 1;

        inventoryList.Add(inventoryItem);
    }

    /// <summary>
    /// 对于背包中已经有的物品就加数量
    /// </summary>
    /// <param name="inventoryList"></param>
    /// <param name="itemCode"></param>
    /// <param name="itemPositon"></param>

    private void AddItemAtPosition(List<InventoryItem> inventoryList, int itemCode, int positon)
    {
        InventoryItem inventoryItem = new InventoryItem();

        int quantity = inventoryList[positon].itemQuantity + 1;
        inventoryItem.itemCode = itemCode;
        inventoryItem.itemQuantity = quantity;
        inventoryList[positon] = inventoryItem;

        Debug.ClearDeveloperConsole();
    }

    internal void RemoveItem(InventoryLocation inventoryLocation, int itemCode)
    {
        List<InventoryItem> inventoryList = inventoryLists[(int)inventoryLocation];
        int itemPosition = FindItemInventory(inventoryLocation, itemCode);

        if (itemPosition != -1)
        {
            RemoveItemAtPosition(inventoryList,itemCode,itemPosition);
        }
        EventHandler.CallInventoryUpdateEvent(inventoryLocation, inventoryLists[(int)inventoryLocation]);
    }

    private void RemoveItemAtPosition(List<InventoryItem> inventoryList, int itemCode, int position)
    {
        InventoryItem inventoryItem = new InventoryItem();

        int quantity = inventoryList[position].itemQuantity - 1;

        if(quantity > 0)
        {
            inventoryItem.itemQuantity = quantity;
            inventoryItem.itemCode = itemCode;
            inventoryList[position] = inventoryItem;
        }
        else
        {
            inventoryList.RemoveAt(position);
        }
    }

    /// <summary>
    /// 判断物品是否在背包里面，找不到就return -1，找到的话就返回发现物品的位置
    /// </summary>
    /// <param name="inventoryLocation"></param>
    /// <param name="itemCode"></param>
    /// <returns></returns>
    private int FindItemInventory(InventoryLocation inventoryLocation,int itemCode)
    {
        List<InventoryItem> inventoryList = inventoryLists[(int)inventoryLocation];

        for (int i = 0; i < inventoryList.Count; i++)
        {
            if(inventoryList[i].itemCode == itemCode)
            {
                return i;
            }
        }

        return -1;
    }

    /// <summary>
    /// 初始化创建的字典
    /// </summary>

    private void CreateItemDetailsDictionary()
    {
        itemDetailsDictionary = new Dictionary<int, ItemDetails>();

        foreach (var itemDetails in itemLists.itemDetails)
        {
            itemDetailsDictionary.Add(itemDetails.itemCode,itemDetails);
        }
    }

    /// <summary>
    /// 在背包中找ItemDetails
    /// </summary>
    /// <param name="itemCode"></param>
    /// <returns></returns>
    public ItemDetails GetItemDetails(int itemCode)
    {
        ItemDetails itemDetails;

        if(itemDetailsDictionary.TryGetValue(itemCode,out itemDetails))
        {
            return itemDetails;
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 吃到物品用的调试
    /// </summary>
    /// <param name="inventoryLists"></param>
    private void DebugPrintInventoryList(List<InventoryItem> inventoryLists)
    {
        foreach (var inventoyItem in inventoryLists)
        {
            Debug.Log("Item Description:" + InventoryManager.Instance.GetItemDetails(inventoyItem.itemCode).itemDescription +
                "       Item Quantity:" + inventoyItem.itemQuantity);
        }
    }
}

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

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ItemPickUp : MonoBehaviour
{
    private void OnTriggerEnter2D(Collider2D collision)
    {
        if(collision.TryGetComponent<Item>(out Item item))
        {
            ItemDetails itemDetails = InventoryManager.Instance.GetItemDetails(item.ItemCode);

            if (itemDetails.canBePickUp)
            {
                InventoryManager.Instance.AddItem(InventoryLocation.player, item, collision.gameObject);
            }
        }
    }
}

UI：

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

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

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class UIInventoryBar : MonoBehaviour
{
    [SerializeField] private PlayerController2D playerController2D;
    [SerializeField] private Sprite blank16Sprite = null;
    [SerializeField] private UIInventorySlot[] inventorySlots = null;
    public GameObject inventoryBarDragItem;

    private RectTransform rectTransform;

    private bool isInventoryBarPositionBottom = true;  //判断背包条是否在视角下方

    public bool IsInventoryBarPositionBottom
    {
        get
        {
            return isInventoryBarPositionBottom;
        }
        set
        {
            isInventoryBarPositionBottom = value;
        }
    }

    private void Awake()
    {
        rectTransform = GetComponent<RectTransform>();
    }

    private void Update()
    {
        SwitchInventoryBarPosition();
    }

    private void OnEnable()
    {
        EventHandler.InventoryUpdateEvent += InventoryUpdate;
    }

    private void OnDisable()
    {
        EventHandler.InventoryUpdateEvent -= InventoryUpdate;
    }

    private void InventoryUpdate(InventoryLocation inventoryLocation, List<InventoryItem> inventoryList)
    {
        if(inventoryLocation == InventoryLocation.player)
        {
            CLearInventorySlots(); //先清空InventroyBar里面所有的InvnetorSlot
            if(inventoryList.Count >0 && inventorySlots.Length > 0) //再遍历一遍inventoryList和inventorySlots重新添加回bar里
            {
                for (int i = 0; i < inventorySlots.Length; i++)
                {
                    if (i < inventoryList.Count)
                    {
                        int itemCode = inventoryList[i].itemCode;

                        ItemDetails itemDetails = InventoryManager.Instance.GetItemDetails(itemCode);

                        if (itemDetails != null)
                        {
                            inventorySlots[i].inventorySlotImage.sprite = itemDetails.itemSprite;
                            inventorySlots[i].textMeshProUGUI.text = inventoryList[i].itemQuantity.ToString();
                            inventorySlots[i].itemDetails = itemDetails;
                            inventorySlots[i].itemQuantity = inventoryList[i].itemQuantity;                            
                        }
                    }
                    else
                    {
                        break;
                    }

                }
            }
        }
    }

    private void CLearInventorySlots()
    {
        if(inventorySlots.Length > 0)
        {
            for (int i = 0; i < inventorySlots.Length; i++)
            {
                inventorySlots[i].inventorySlotImage.sprite = blank16Sprite;
                inventorySlots[i].textMeshProUGUI.text = "";
                inventorySlots[i].itemDetails = null;
                inventorySlots[i].itemQuantity = 0;
            }
        }
    }

    /// <summary>
    /// 切换InventoryBar
    /// </summary>
    private void SwitchInventoryBarPosition()
    {
        Vector3 playerViewportPosition = playerController2D.GetPlayerVierportPosition();

        if (playerViewportPosition.y > 0.3f && !IsInventoryBarPositionBottom)
        {
            rectTransform.pivot = new Vector2(0.5f, 0f);
            rectTransform.anchorMin = new Vector2(0.5f, 0f);
            rectTransform.anchorMax = new Vector2(0.5f, 0f);
            rectTransform.anchoredPosition = new Vector2(0f, 2.5f);

            isInventoryBarPositionBottom = true;
        }

        else if(playerViewportPosition.y <= 0.3f && IsInventoryBarPositionBottom)
        {

            rectTransform.pivot = new Vector2(0.5f, 1f);
            rectTransform.anchorMin = new Vector2(0.5f, 1f);
            rectTransform.anchorMax = new Vector2(0.5f, 1f);
            rectTransform.anchoredPosition = new Vector2(0f, -2.5f);

            isInventoryBarPositionBottom = false;            
        }
    }
}

InventorySlot的脚本如下

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using TMPro;
using UnityEngine.UI;
using System;

public class UIInventorySlot : MonoBehaviour,IBeginDragHandler,IDragHandler,IEndDragHandler
{
    private Camera mainCamera;
    private GameObject draggedItem;
    private Transform itemParent;

    public Image inventorySlotHighlight;
    public Image inventorySlotImage;
    public TextMeshProUGUI textMeshProUGUI;

    [SerializeField] private UIInventoryBar inventoryBar = null;
    [HideInInspector] public ItemDetails itemDetails;
    [SerializeField] private GameObject itemPrefab = null;
    [HideInInspector] public int itemQuantity;
    [SerializeField] private int slotNumber = 0;

    private void Start()
    {
        mainCamera = Camera.main;
        itemParent = GameObject.FindGameObjectWithTag(Tags.ItemsParentTransform).transform;
    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        if(itemDetails != null)
        {
            //PlayerController.Instance.DisablePlayerInputAndResetMovement();

            draggedItem = Instantiate(inventoryBar.inventoryBarDragItem, inventoryBar.transform);

            Image draggedItemImage = draggedItem.GetComponentInChildren<Image>();
            draggedItemImage.sprite = inventorySlotImage.sprite;
            Debug.Log("draggedItemImage.sprite" + draggedItemImage.sprite);
        }
    }

    public void OnDrag(PointerEventData eventData)
    {
        if(draggedItem != null)
        {
            draggedItem.transform.position = Input.mousePosition;
        }
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        if(draggedItem != null)
        {
            Destroy(draggedItem);

            if(eventData.pointerCurrentRaycast.gameObject != null && eventData.pointerCurrentRaycast.gameObject.GetComponent<UIInventorySlot>() != null)
            {
                int toSlotNumber = eventData.pointerCurrentRaycast.gameObject.GetComponent<UIInventorySlot>().slotNumber;

                InventoryManager.Instance.SwapInventoryItems(InventoryLocation.player,slotNumber,toSlotNumber);
            }
            else
            {
                if (itemDetails.canBeDropped)
                {
                    DropSelectedItemMousePosition();
                }
            }

            //PlayerController.Instance.EnablePlayerInput();
        }
    }

    private void DropSelectedItemMousePosition()
    {
        if(itemDetails != null)
        {
            Vector3 worldPosition = mainCamera.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, -mainCamera.transform.position.z));

            GameObject itemGameobject = Instantiate(itemPrefab, worldPosition, Quaternion.identity, itemParent);
            Item item = itemGameobject.GetComponent<Item>();
            item.ItemCode = itemDetails.itemCode;

            InventoryManager.Instance.RemoveItem(InventoryLocation.player, item.ItemCode);
        }
    }
}

依次添加

对应的SlotNumer

.....

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

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

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

    /// <summary>
    /// 交换物品顺序
    /// </summary>
    /// <param name="inventoryLocation"></param>
    /// <param name="fromSlotNumber"></param>
    /// <param name="toSlotNumber"></param>
    public void SwapInventoryItems(InventoryLocation inventoryLocation, int fromSlotNumber, int toSlotNumber)
    {
        if(fromSlotNumber < inventoryLists[(int)inventoryLocation].Count && toSlotNumber < inventoryLists[(int)inventoryLocation].Count &&
            fromSlotNumber != toSlotNumber  && toSlotNumber >= 0)
        {
            InventoryItem fromSlotItem = inventoryLists[(int)inventoryLocation][fromSlotNumber];
            InventoryItem toSlotItem = inventoryLists[(int)inventoryLocation][toSlotNumber];

            inventoryLists[(int)inventoryLocation][toSlotNumber] = fromSlotItem;
            inventoryLists[(int)inventoryLocation][fromSlotNumber] = toSlotItem;

            EventHandler.CallInventoryUpdateEvent(inventoryLocation, inventoryLists[(int)inventoryLocation]);

        }
    }

回到OnEndDrag的函数

public void OnEndDrag(PointerEventData eventData)
    {
        if(draggedItem != null)
        {
            Destroy(draggedItem);

            if(eventData.pointerCurrentRaycast.gameObject != null && eventData.pointerCurrentRaycast.gameObject.GetComponent<UIInventorySlot>() != null)
            {
                int toSlotNumber = eventData.pointerCurrentRaycast.gameObject.GetComponent<UIInventorySlot>().slotNumber;

                InventoryManager.Instance.SwapInventoryItems(InventoryLocation.player,slotNumber,toSlotNumber);
            }
            else
            {
                if (itemDetails.canBeDropped)
                {
                    DropSelectedItemMousePosition();
                }
            }

            //PlayerController.Instance.EnablePlayerInput();
        }
    }

学习产出：

1

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

标签： unity 游戏引擎 c#
本文转载自: https://blog.csdn.net/dangoxiba/article/details/126802595
版权归原作者 dangoxiba 所有， 如有侵权，请联系我们删除。
登录后发布评论

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

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

初识风控安全，你永远绕不开的话题

[Ubuntu] 文件/目录权限更改

CCF ChinaOSC |「开源科学计算与系统建模openSCS专题分论坛」11月9日与您相约深圳

常见 HTTP 状态码分类和解释及服务端向前端返回响应时的最完整格式

怎么用phpstudy制作网站

新版IDEA使用Spring Initializr创建工程(两种方法，官方工具和IDEA)

万字博文教你爬虫代理工具mitmproxy【详解篇】

文章导航