基于Unity3D（UGUI）的背包系统<四>完结篇

最新推荐文章于 2026-03-26 09:41:09 发布
原创 最新推荐文章于 2026-03-26 09:41:09 发布 · 1w 阅读 · 47 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#unity3d
本文详细介绍了如何使用Unity3D的UGUI构建背包系统，包括物品槽基类Slot实现交互功能，角色面板的EquipmentSlot，商店购买的VendorSlot，物品UI管理类ItemUI，提示框类ToolTip以及模拟主角行为的Player类。提供了一个完整的背包系统实现流程。 
这一篇介绍各个面板（UI）与数据的交互，以及对更细节方面的处理（如每一个面板的物品槽的管理）。PS：具体逻辑参照UML类图即可。


**①存货总管理类：重点是实现对物品Json文件的解析。**

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

/// <summary>
/// 存货总管理类
/// </summary>
public class InventroyManager : MonoBehaviour {
    //单例模式
    private static InventroyManager _instance;
    public static InventroyManager Instance 
    {
        get {
            if (_instance == null)
            {
                _instance = GameObject.Find("InventroyManager").GetComponent<InventroyManager>();
            }
           return _instance;
        }
    }
    private List<Item> itemList;//存储json解析出来的物品列表

    private ToolTip toolTip;//获取ToolTip脚本，方便对其管理
    private bool isToolTipShow = false;//提示框是否在显示状态
    private Canvas canvas;//Canva物体
    private Vector2 toolTipOffset =new Vector2(15, -10);//设置提示框跟随时与鼠标的偏移

    private ItemUI pickedItem;//鼠标选中的物品的脚本组件，用于制作拖动功能 
    public ItemUI PickedItem { get { return pickedItem; } }
    private bool isPickedItem = false;//鼠标是否选中该物品
    public bool IsPickedItem { get { return isPickedItem; } }

    void Awake() 
    {
        ParseItemJson();
    }

    void Start() 
    {
        toolTip = GameObject.FindObjectOfType<ToolTip>();//根据类型获取
        canvas = GameObject.Find("Canvas").GetComponent<Canvas>();
        pickedItem = GameObject.Find("PickedItem").GetComponent<ItemUI>();
        pickedItem.Hide();//开始为隐藏状态
    }

    void Update() 
    {
        if (isToolTipShow == true && isPickedItem == false) //控制提示框跟随鼠标移动
        {
            Vector2 postionToolTip;
            RectTransformUtility.ScreenPointToLocalPointInRectangle(canvas.transform as RectTransform, Input.mousePosition, null, out postionToolTip);
            toolTip.SetLocalPosition(postionToolTip+toolTipOffset);//设置提示框的位置，二维坐标会自动转化为三维坐标但Z坐标为0
        }
        else if (isPickedItem == true) //控制盛放物品的容器UI跟随鼠标移动
        {
            Vector2 postionPickeItem;
            RectTransformUtility.ScreenPointToLocalPointInRectangle(canvas.transform as RectTransform, Input.mousePosition, null, out postionPickeItem);
            pickedItem.SetLocalPosition(postionPickeItem);//设置容器的位置，二维坐标会自动转化为三维坐标但Z坐标为0
        }
        //物品丢弃功能：
        if (isPickedItem == true && Input.GetMouseButtonDown(0) && UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject(-1) == false )//UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject(-1) == false 表示判断鼠标是否正在在UI上
        {
            isPickedItem = false;
            pickedItem.Hide();
        }
    }

    /// <summary>
    /// 解析Json文件
    /// </summary>
    public void ParseItemJson() 
    {
        itemList = new List<Item>();
        //文本在unity里面是TextAsset类型
        TextAsset itemText = Resources.Load<TextAsset>("Item");//加载json文本
        string itemJson = itemText.text;//得到json文本里面的内容
        //bug.Log(itemJson);
        JSONObject j = new JSONObject(itemJson);
        foreach (var temp in j.list)
        {
            //物品类型字符串转化为枚举类型
            Item.ItemType type = (Item.ItemType)System.Enum.Parse(typeof(Item.ItemType), temp["type"].str);
            //print(type);
            //下面解析的是物品的共有属性：id，name，quality。。。注：temp["id"].n 的 .n，.str等是json插件的写法，用于解析
            int id = (int)(temp["id"].n);
            string name = temp["name"].str;
            Item.ItemQuality quality = (Item.ItemQuality)System.Enum.Parse(typeof(Item.ItemQuality), temp["quality"].str);
            string description = temp["description"].str;
            int capacity = (int)(temp["capacity"].n);
            int buyPrice = (int)(temp["buyPrice"].n);
            int sellPrice = (int)(temp["sellPrice"].n);
            string sprite = temp["sprite"].str;
            Item item = null;
            switch (type)
            {
                case Item.ItemType.Consumable:
                    int hp = (int)(temp["hp"].n);
                    int mp = (int)(temp["mp"].n);
                    item = new Consumable(id, name, type, quality, description, capacity, buyPrice, sellPrice, sprite, hp, mp);
                    break;
                case Item.ItemType.Equipment:
                    int strength = (int)(temp["strength"].n);
                    int intellect = (int)(temp["intellect"].n);
                    int agility = (int)(temp["agility"].n);
                    int stamina = (int)(temp["stamina"].n);
                    Equipment.EquipmentType equiType = (Equipment.EquipmentType)System.Enum.Parse(typeof(Equipment.EquipmentType), temp["equipType"].str);
                    item = new Equipment(id, name, type, quality, description, capacity, buyPrice, sellPrice, sprite,strength,intellect,agility,stamina,equiType);
                    break;
                case Item.ItemType.Weapon:
                    int damage = (int)(temp["damage"].n);
                    Weapon.WeaponType weaponType = (Weapon.WeaponType)System.Enum.Parse(typeof(Weapon.WeaponType), temp["weaponType"].str);
                    item = new Weapon(id, name, type, quality, description, capacity, buyPrice, sellPrice, sprite, damage, weaponType);
                    break;
                case Item.ItemType.Material:
                    item = new Material(id, name, type, quality, description, capacity, buyPrice, sellPrice, sprite);
                    break;
            }
            itemList.Add(item);//把解析到的物品信息加入物品列表里面
            //Debug.Log(item);
        }
    }

    //得到根据 id 得到Item
    public Item GetItemById(int id) 
    {
        foreach (Item item in itemList)
        {
            if (item.ID == id)
            {
                return item;
            }
        }
        return null;
    }

    //显示提示框方法
    public void ShowToolTip(string content) 
    {
        if (this.isPickedItem == true) return;//如果物品槽中的物品被捡起了，那就不需要再显示提示框了
        toolTip.Show(content);
        isToolTipShow = true;
    }
    //隐藏提示框方法
    public void HideToolTip() {
        toolTip.Hide();
        isToolTipShow = false;
    }

    //获取（拾取）物品槽里的指定数量的（amount）物品UI
    public void PickUpItem(Item item,int amount)
    {
        PickedItem.SetItem(item, amount);
        this.isPickedItem = true;
        PickedItem.Show();//获取到物品之后把跟随鼠标的容器（用来盛放捡起的物品的容器）显示出来
        this.toolTip.Hide();//同时隐藏物品信息提示框

        //控制盛放物品的容器UI跟随鼠标移动
            Vector2 postionPickeItem;
            RectTransformUtility.ScreenPointToLocalPointInRectangle(canvas.transform as RectTransform, Input.mousePosition, null, out postionPickeItem);
            pickedItem.SetLocalPosition(postionPickeItem);//设置容器的位置，二维坐标会自动转化为三维坐标但Z坐标为0

    }

    //从鼠标上减少（移除）指定数量的物品
    public void ReduceAmountItem(int amount = 1) 
    {
        this.pickedItem.RemoveItemAmount(amount);
        if (pickedItem.Amount <= 0)
        {
            isPickedItem = false;
            PickedItem.Hide();//如果鼠标上没有物品了那就隐藏了
        }
    }

    //点击保存按钮，保存当前物品信息
    public void SaveInventory() 
    {
        Knapscak.Instance.SaveInventory();
        Chest.Instance.SaveInventory();
        CharacterPanel.Instance.SaveInventory();
        Forge.Instance.SaveInventory();
        PlayerPrefs.SetInt("CoinAmount", GameObject.FindGameObjectWithTag("Player").GetComponent<Player>().CoinAmount);//保存玩家金币
    }

    //点击加载按钮，加载当前物品
    public void LoadInventory() 
    {
        Knapscak.Instance.LoadInventory();
        Chest.Instance.LoadInventory();
        CharacterPanel.Instance.LoadInventory();
        Forge.Instance.LoadInventory();
        //加载玩家金币
        if (PlayerPrefs.HasKey("CoinAmount") == true)
        {
            GameObject.FindGameObjectWithTag("Player").GetComponent<Player>().CoinAmount = PlayerPrefs.GetInt("CoinAmount");
        }
    }
}

②物品槽基类（Slot）：重点实现了物品槽里物品的各个交互功能

using UnityEngine;
using System.Collections;
using UnityEngine.EventSystems;

/// <summary>
/// 物品槽类
/// </summary>
public class Slot : MonoBehaviour,IPointerEnterHandler,IPointerExitHandler,IPointerDownHandler{

    public GameObject itemPrefab;//需要存储的物品预设

    /// <summary>
    ///(重点) 向物品槽中添加（存储）物品，如果自身下面已经有Item了，那就Item.amount++;
    /// 如果没有，那就根据ItemPrefab去实例化一个Item，放在其下面
    /// </summary>
    public void StoreItem(Item item) 
    {
        if (this.transform.childCount == 0)//如果这个物品槽下没有物品，那就实例化一个物品
        {
            GameObject itemGO = Instantiate<GameObject>(itemPrefab) as GameObject;
            itemGO.transform.SetParent(this.transform);//设置物品为物品槽的子物体
            itemGO.transform.localScale = Vector3.one;//正确保存物品的缩放比例
            itemGO.transform.localPosition = Vector3.zero;//设置物品的局部坐标，为了与其父亲物品槽相对应
            itemGO.GetComponent<ItemUI>().SetItem(item);//更新ItemUI
        }
        else
        {
            transform.GetChild(0).GetComponent<ItemUI>().AddItemAmount();//默认添加一个
        }
    }

    //根据索引器得到当前物品槽中的物品类型
    public Item.ItemType GetItemType() 
    {
        return transform.GetChild(0).GetComponent<ItemUI>().Item.Type;
    }

    //根据索引器得到当前物品槽中的物品ID
    public int GetItemID()
    {
        return transform.GetChild(0).GetComponent<ItemUI>().Item.ID;
    }

    //判断物品个数是否超过物品槽的容量Capacity
    public bool isFiled() 
    {
        ItemUI itemUI = transform.GetChild(0).GetComponent<ItemUI>();
        return itemUI.Amount >= itemUI.Item.Capacity; //true表示当前数量大于等于容量，false表示当前数量小于容量
    }

    //接口实现的方法，鼠标覆盖时触发
    public void OnPointerEnter(PointerEventData eventData)
    {
        if (this.transform.childCount > 0)
        {
            string toolTipText = this.transform.GetChild(0).GetComponent<ItemUI>().Item.GetToolTipText();
            InventroyManager.Instance.ShowToolTip(toolTipText);//显示提示框
        }
    }
    //接口实现的方法，鼠标离开时触发
    public void OnPointerExit(PointerEventData eventData)
    {
        if (this.transform.childCount > 0)
        {
            InventroyManager.Instance.HideToolTip();//隐藏提示框
        }
    }

    public virtual void OnPointerDown(PointerEventData eventData)//为虚函数，方便子类EquipmentSlot重写
    {
        if (eventData.button == PointerEventData.InputButton.Right)//鼠标右键点击直接实现穿戴，不经过拖拽
        {
            if (transform.childCount > 0 && InventroyManager.Instance.IsPickedItem == false)//需要穿戴的物品得有，并且鼠标上要没有物品，否则就发生：当鼠标上有物品，在其他物品上点击鼠标右键也能穿上这种情况。
            {
                ItemUI currentItemUI = transform.GetChild(0).GetComponent<ItemUI>();
                if (currentItemUI.Item is Equipment || currentItemUI.Item is Weapon)//只有装备和物品才可以穿戴
                {
                    Item currentItem = currentItemUI.Item;//临时存储物品信息，防止物品UI销毁导致物品空指针
                    currentItemUI.RemoveItemAmount(1);//当前物品槽中的物品减少1个
                    if (currentItemUI.Amount <= 0)//物品槽中的物品没有了
                    {
                        DestroyImmediate(currentItemUI.gameObject);//立即销毁物品槽中的物品
                        InventroyManager.Instance.HideToolTip();//隐藏该物品的提示框
                    }
                    CharacterPanel.Instance.PutOn(currentItem);//直接穿戴
                }
            }
        }
        if (eventData.button != PointerEventData.InputButton.Left) return;  //只有鼠标左键能够点击物品拖拽
        //情况分析如下：
        //一：自身是空
                ///1.pickedItem != null(即IsPickedItem == true)，pickedItem放在这个位置
                        ////①按下Ctrl键，放置当前鼠标上的物品的一个
                        ////②没有按下Ctrl键，放置当前鼠标上物品的所有
                ///2.pickedItem==null(即IsPickedItem == false)，不做任何处理
        //二：自身不是空
                ///1.pickedItem != null(即 IsPickedItem == true)
                        ////①自身的id == pickedItem.id
                                //////A.按下Ctrl键，放置当前鼠标上的物品的一个
                                //////B.没有按下Ctrl键，放置当前鼠标上物品的所有
                                       ///////a.可以完全放下
                                       ///////b.只能放下其中一部分
                        ////②自身的id != pickedItem.id，pickedItem跟当前物品交换
               ///2.pickedItem == null(即IsPickedItem == false)
                        ////①按下Ctrl键，取得当前物品槽中物品的一半
                        ////②没有按下Ctrl键，把当前物品槽里面的物品放到鼠标上

        if (transform.childCount > 0) //二：自身不是空
        {
            ItemUI currentItem = transform.GetChild(0).GetComponent<ItemUI>();//取得当前的物品
            if (InventroyManager.Instance.IsPickedItem == false)///2.pickedItem == null。如果当前没有选中任何物品，即当前鼠标上没有物品
            {
                if (Input.GetKey(KeyCode.LeftControl))////①按下Ctrl键，取得当前物品槽中物品的一半
                {
                    int amountPicked = (currentItem.Amount + 1) / 2;//如果物品为偶数就拾取刚好一般，如果为奇数就拾取一半多一个
                    InventroyManager.Instance.PickUpItem(currentItem.Item, amountPicked);
                    int amountRemained = currentItem.Amount - amountPicked;//拾取后剩余的物品个数
                    if (amountRemained<=0)//如果物品槽中没有剩余的物品了，就销毁ItemUI
                    {
                        Destroy(currentItem.gameObject);
                    }
                    else//如果物品槽中还有剩余的物品，就让它的数量减去被拾取的数量
                    {
                        currentItem.SetAmount(amountRemained);
                    }
                }
                else      ////②没有按下Ctrl键，把当前物品槽里面的物品放到鼠标上
                {
                    //InventroyManager.Instance.PickedItem.SetItemUI(currentItem);//把当前物品槽里的物品复制给PickedItem（跟随鼠标移动）
                    //InventroyManager.Instance.IsPickedItem = true;//注释的这两句合并为下面的一句
                    InventroyManager.Instance.PickUpItem(currentItem.Item, currentItem.Amount);
                    Destroy(currentItem.gameObject);//复制完之后销毁当前物品槽中的物品
                }
            }
            else
            {
                ///1.pickedItem != null(即 IsPickedItem == true)
                    ////①自身的id == pickedItem.id
                        //////A.按下Ctrl键，放置当前鼠标上的物品的一个
                        //////B.没有按下Ctrl键，放置当前鼠标上物品的所有
                                 ///////a.可以完全放下
                                 ///////b.只能放下其中一部分
                ////②自身的id != pickedItem.id，pickedItem跟当前物品交换
                if (currentItem.Item.ID == InventroyManager.Instance.PickedItem.Item.ID)
                {
                    if (Input.GetKey(KeyCode.LeftControl))
                    {
                        if (currentItem.Item.Capacity > currentItem.Amount)//如果物品槽里的物品容量大于当前物品数量，那就说明物品槽里还能再放
                        {
                            currentItem.AddItemAmount();//增加物品槽中物品数量
                            InventroyManager.Instance.ReduceAmountItem();//让鼠标上的物品减掉一个(默认移除一个)
                        }
                        else//如果物品槽里的物品容量小于当前物品数量，那就说明物品槽里不能再放了
                        {
                            return;
                        }
                    }
                    else 
                    {
                        if (currentItem.Item.Capacity > currentItem.Amount)//如果物品槽里的物品容量大于当前物品数量，那就说明物品槽里还能再放
                        {
                            int itemRemain = currentItem.Item.Capacity - currentItem.Amount;//物品槽还可以再放的数量
                            if (itemRemain >= InventroyManager.Instance.PickedItem.Amount)//如果物品槽还可以再放的数量大于等于鼠标上的数量，                                那就可以完全放下
                            {
                                currentItem.AddItemAmount(InventroyManager.Instance.PickedItem.Amount);
                                InventroyManager.Instance.ReduceAmountItem(itemRemain);
                            }
                            else//只能放下其中一部分
                            {
                                currentItem.AddItemAmount(itemRemain);
                                InventroyManager.Instance.PickedItem.RemoveItemAmount(itemRemain);
                            }
                        }
                        else//如果物品槽里的物品容量小于当前物品数量，那就说明物品槽里不能再放了
                        {
                            return;
                        }
                    }
                }
                else//②自身的id != pickedItem.id，pickedItem跟当前物品交换
                {
                    //保存当前鼠标捡起物品，用于和物品槽中的物品交换
                    Item pickedItemTemp = InventroyManager.Instance.PickedItem.Item;
                    int pickedItemAmountTemp = InventroyManager.Instance.PickedItem.Amount;

                    //保存当前物品槽中的物品，用于和鼠标上的物品交换
                    Item currentItemTemp = currentItem.Item;
                    int currentItemAmountTemp = currentItem.Amount;
                    //两者交换
                    currentItem.SetItem(pickedItemTemp, pickedItemAmountTemp);//把当前鼠标上的物品放入物品槽
                    InventroyManager.Instance.PickedItem.SetItem(currentItemTemp, currentItemAmountTemp);//把当前物品槽中的物品放在鼠标上
                }
            }
        }
        else//一：自身是空
        { 
            ///1.pickedItem != null(即IsPickedItem == true)，pickedItem放在这个位置
                ////①按下Ctrl键，放置当前鼠标上的物品的一个
                ////②没有按下Ctrl键，放置当前鼠标上物品的所有
            ///2.pickedItem==null(即IsPickedItem == false)，不做任何处理
            if (InventroyManager.Instance.IsPickedItem == true)
            {
                if (Input.GetKey(KeyCode.LeftControl))
                {
                    this.StoreItem(InventroyManager.Instance.PickedItem.Item);
                    InventroyManager.Instance.ReduceAmountItem();
                }
                else//②没有按下Ctrl键，放置当前鼠标上物品的所有
                {
                    for(int i = 0 ; i<InventroyManager.Instance.PickedItem.Amount ; i++)
                    {
                        this.StoreItem(InventroyManager.Instance.PickedItem.Item);
                    }
                    InventroyManager.Instance.ReduceAmountItem(InventroyManager.Instance.PickedItem.Amount);
                }
            }
            else
            {
                return;
            }
        }
    }
}

③处理角色面板的物品槽类（EquipmentSlot），继承自Slot类：

using UnityEngine;
using System.Collections;
using UnityEngine.EventSystems;

/// <summary>
/// 处理角色面板上的装备物品槽类（有特殊限制的Slot：只能存放装备），不同格子只能存放这个格子应该有的装备。
/// </summary>
public class EquipmentSlot :Slot
{
    public Equipment.EquipmentType equipmentSoltType;//角色装备里每个物品槽的物品类型。因为每个物品槽能装备的物品类型不同，所以才分类型，比如说，头部只能放头部，腿部只能放腿部之类的。主手只能放武器。
    public Weapon.WeaponType wpType;//武器类型，只有副手和主手能有武器，其他为Null



    public override void OnPointerDown(UnityEngine.EventSystems.PointerEventData eventData)//重写父类Slot的方法
    {
        if (eventData.button == PointerEventData.InputButton.Right)//鼠标右键点击直接实现脱掉，不经过拖拽
        {
            if (transform.childCount > 0 && InventroyManager.Instance.IsPickedItem == false)//需要脱掉的物品得有，并且鼠标上要没有物品，否则就发生：当鼠标上有物品，在其他物品上点击鼠标右键也能脱掉这种情况。
            {
                ItemUI currentItemUI = transform.GetChild(0).GetComponent<ItemUI>();
                Item item = currentItemUI.Item;//临时保存物品信息，防止下面一销毁就没了
                DestroyImmediate(currentItemUI.gameObject);//立即销毁物品槽中的物品
                transform.parent.SendMessage("PutOff", item);//脱掉物品放入背包里（发送消息方式）
                InventroyManager.Instance.HideToolTip();//隐藏该物品的提示框
            }
        }
        if (eventData.button != PointerEventData.InputButton.Left) return;  //只有鼠标左键能够点击物品拖动
        //情况分析：
                //一：鼠标上有物品
                        //1.当前装备槽有装备
                        //2.当前装备槽无装备
               //二：鼠标上没有物品
                        //1.当前装备槽有装备
                       //2.当前装备槽无装备（不做任何处理）
        bool isUpdataProperty = false;//是否需要更新角色属性
        if (InventroyManager.Instance.IsPickedItem == true)//一：鼠标上有物品
        {
            ItemUI pickedItemUI = InventroyManager.Instance.PickedItem;//鼠标上的物品
            if (transform.childCount > 0)//1.当前装备槽有装备
            {
                ItemUI currentItemUI = transform.GetChild(0).GetComponent<ItemUI>();//当前物品槽中的物品
                if (IsRightItem(pickedItemUI.Item) && pickedItemUI.Amount == 1)//如果鼠标上的物品是否适合放在该位置并且鼠标上的物品只有一个时，那就交换，否则不做处理
                {
                    pickedItemUI.Exchange(currentItemUI);
                    isUpdataProperty = true;//需要更新角色属性
                }
            }
            else//2.当前装备槽无装备
            {
                if (IsRightItem(pickedItemUI.Item))//如果鼠标上的物品是否适合放在该位置，那就把该物品放入角色面板，并且鼠标上的物品减少一个，否则不做处理
                {
                    this.StoreItem(pickedItemUI.Item);
                    InventroyManager.Instance.ReduceAmountItem(1);
                    isUpdataProperty = true;//需要更新角色属性
                }
            }
        }
        else//二：鼠标上没有物品
        {
            if (transform.childCount>0) //1.当前装备槽有装备，把装备去到鼠标上，销毁物品槽中的物品
            {
                ItemUI currentItemUI = transform.GetChild(0).GetComponent<ItemUI>();
                InventroyManager.Instance.PickUpItem(currentItemUI.Item, currentItemUI.Amount);
                Destroy(currentItemUI.gameObject);
                isUpdataProperty = true;//需要更新角色属性
            } //2.当前装备槽无装备（不做任何处理）
        }
        if (isUpdataProperty == true)
        {
            transform.parent.SendMessage("UpdatePropertyText");
        }
    }

    //判断鼠标上的物品是否适合放在该位置
    public bool IsRightItem(Item item) 
    {
        if ((item is Equipment && ((Equipment)(item)).EquipType == this.equipmentSoltType) || (item is Weapon && ((Weapon)(item)).WpType == this.wpType))//如果此物品是装备并且此物品的装备类型和当前物品槽中的装备类型相同   或者   此物品是武器并且此武器的类型和当前物品槽中的武器类型相同，那就可以合适放在该位置，否则不合适。
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

④处理商店购买物品面板的物品槽类（VendorSlot），同样继承自Slot类：

using UnityEngine;
using System.Collections;

public class VendorSlot : Slot {

    //重写父类Slot的鼠标点击方法，但是什么都不用做，因为不需要交互，商贩只管卖物品
    public override void OnPointerDown(UnityEngine.EventSystems.PointerEventData eventData)
    {
        if (eventData.button == UnityEngine.EventSystems.PointerEventData.InputButton.Right)//在商贩那里点击右键直接购买物品
        {
            if (transform.childCount > 0 && InventroyManager.Instance.IsPickedItem == false)//首先商贩得有物品,其次鼠标上没有物品
            {
                Item currentItem = transform.GetChild(0).GetComponent<ItemUI>().Item;//取得当前点击的要买的物品
                transform.parent.parent.SendMessage("BuyItem",currentItem);
            }
        }
        else if (eventData.button == UnityEngine.EventSystems.PointerEventData.InputButton.Left && InventroyManager.Instance.IsPickedItem == true)//在背包鼠标左键拖动售卖物品
        {
            transform.parent.parent.SendMessage("SellItem");
        }
    }
}

⑤物品UI处理类（ItemUI）：

using UnityEngine;
using System.Collections;
using UnityEngine.UI;
public class ItemUI : MonoBehaviour
{

    public Item Item { get; private set; } //UI上的物品
    public int Amount { get; private  set; }//物品数量

    private Image itemImage;//获取item的Image组件
    private Text amountText;//获取item下子物体用于显示数量的组件

    private float targetScale = 1f;//目标缩放大小
    private Vector3 animationScale = new Vector3(1.4f, 1.4f, 1.4f);
    private float smothing = 4f;//动画平滑过渡时间

    void Awake() //可用 属性get方式替代
    {
        itemImage = this.GetComponent<Image>();
        amountText = this.GetComponentInChildren<Text>();
    }

    void Update()
    {
        if (this.transform.localScale.x != targetScale)//设置物品动画
        {
            float scaleTemp = Mathf.Lerp(this.transform.localScale.x, targetScale, smothing*Time.deltaTime);
            this.transform.localScale = new Vector3(scaleTemp, scaleTemp, scaleTemp);
            if (Mathf.Abs(transform.localScale.x-targetScale) < 0.02f)//插值运算达不到临界值，比较耗性能，加上临界值判断能更好的控制
            {
                this.transform.localScale = new Vector3(targetScale, targetScale, targetScale);
            }
        }
    }

    /// <summary>
    ///更新item的UI显示，默认数量为1个
    /// </summary>
    /// <param name="item"></param>
    public void SetItem(Item item, int amount = 1)
    {
        this.transform.localScale = this.animationScale;//物品更新时放大UI，用于动画
        this.Item = item;
        this.Amount = amount;
        this.itemImage.sprite = Resources.Load<Sprite>(item.Sprite);        //更新UI
        if (this.Amount > 1)
        {
            this.amountText.text = Amount.ToString();
        }
        else
        {
            this.amountText.text = "";
        }
    }
    /// <summary>
    /// 添加item数量
    /// </summary>
    /// <param name="num"></param>
    public void AddItemAmount(int num = 1)
    {
        this.transform.localScale = this.animationScale;//物品更新时放大UI，用于动画
        this.Amount += num;
        if (this.Amount> 1)//更新UI
        {
            this.amountText.text = Amount.ToString();
        }
        else
        {
            this.amountText.text = "";
        }
    }
    //设置item的个数
    public void SetAmount(int amount) {
        this.transform.localScale = this.animationScale;//物品更新时放大UI，用于动画
        this.Amount = amount;
        if (this.Amount > 1)//更新UI
        {
            this.amountText.text = Amount.ToString();
        }
        else
        {
            this.amountText.text = "";
        }
    }

    //减少物品数量
    public void RemoveItemAmount(int amount = 1) 
    {
        this.transform.localScale = this.animationScale;//物品更新时放大UI，用于动画
        this.Amount -= amount;
        if (this.Amount > 1)//更新UI
        {
            this.amountText.text = Amount.ToString();
        }
        else
        {
            this.amountText.text = "";
        }
    }

    //显示方法
    public void Show() {
        gameObject.SetActive(true);
    }

    //隐藏方法
    public void Hide() {
        gameObject.SetActive(false);
    }

    //设置位置方法
    public void SetLocalPosition(Vector3 position)
    {
        this.transform.localPosition = position;
    }

    //当前物品（UI）和 出入物品（UI）交换显示
    public void Exchange(ItemUI itemUI) 
    {
        Item itemTemp = itemUI.Item;
        int amountTemp = itemUI.Amount;
        itemUI.SetItem(this.Item, this.Amount);
        this.SetItem(itemTemp, amountTemp);
    }
}

⑥信息提示框类（ToolTip），处理提示框的各种功能：

using UnityEngine;
using System.Collections;
using UnityEngine.UI;
/// <summary>
/// 提示框类
/// </summary>
public class ToolTip : MonoBehaviour {

    private Text toolTipText;//提示框的父Text，主要用来控制提示框的大小
    private Text contentText;//提示框的子Text，主要用来显示提示
    private CanvasGroup toolTipCanvasGroup;//提示框的CanvasGroup组件，用来制作显示和隐藏功能
    private float targetAlpha = 0.0f ;//设置提示框的Alpha值，0代表隐藏，1代表显示
    public float smothing = 1.0f;//用于显示和隐藏的插值运输

    void Awake() 
    {
        toolTipText = this.GetComponent<Text>();
        contentText = this.transform.Find("Content").GetComponent<Text>();
        toolTipCanvasGroup = this.GetComponent<CanvasGroup>();
    }

    // Update is called once per frame
    void Update () {
        if (toolTipCanvasGroup.alpha != targetAlpha)
        {
            toolTipCanvasGroup.alpha = Mathf.Lerp(toolTipCanvasGroup.alpha, targetAlpha, smothing*Time.deltaTime);
            if (Mathf.Abs(targetAlpha - toolTipCanvasGroup.alpha) < 0.01f)//如果当前提示框的Alpha值与目标Alpha值相差很小，那就设置为目表值
            {
                toolTipCanvasGroup.alpha = targetAlpha;
            }
        }
    }

    //提示框的显示方法
    public void Show(string text) 
    {
        this.toolTipText.text = text;
        this.contentText.text = text;
        this.targetAlpha = 1;
    }
    //提示框的隐藏方法
    public void Hide() 
    {
        this.targetAlpha = 0;
    }

    //设置提示框自身的位置
    public void SetLocalPosition(Vector3 postion) 
    {
       this.transform.localPosition = postion;
    }
}

⑦模拟主角行为类（Player）：

using UnityEngine;
using System.Collections;
using UnityEngine.UI;
/// <summary>
/// 模拟主角类
/// </summary>
public class Player : MonoBehaviour {

    //角色基本属性：
    private int basicStrength = 10;
    public int BasicStrength { get { return basicStrength;} }//基本力量

    private int basicIntellect = 10;
    public int BasicIntellect { get { return basicIntellect; } }//基本智力

    private int basicAgility = 10;
    public int BasicAgility { get { return basicAgility; } }//基本敏捷

    private int basicStamina = 10;
    public int BasicStamina { get { return basicStamina; } }//基本体力

    private int basicDamage = 10;
    public int BasicDamage { get { return basicDamage; } }//基本伤害

    private Text coinText;//对金币Text组件的引用
    private int coinAmount = 100;//角色所持有的金币，用于从商贩那里购买物品
    public int CoinAmount {
        get { return coinAmount; }
        set { coinAmount = value; coinText.text = coinAmount.ToString(); }
    }


    // Use this for initialization
    void Start () {
        coinText = GameObject.Find("Coin").GetComponentInChildren<Text>();
        coinText.text = coinAmount.ToString();
    }

    // Update is called once per frame
    void Update () {
        //按G键随机得到一个物品
        if (Input.GetKeyDown(KeyCode.G))
        {
            int id = Random.Range(1, 23);
            Knapscak.Instance.StoreItem(id);
        }
        //按下B键控制背包的显示和隐藏
        if (Input.GetKeyDown(KeyCode.B))
        {
            Knapscak.Instance.DisplaySwitch();
        }
        //按下H键控制箱子的显示和隐藏
        if (Input.GetKeyDown(KeyCode.H))
        {
            Chest.Instance.DisplaySwitch();
        }
        //按下V键控制角色面板的显示和隐藏
        if (Input.GetKeyDown(KeyCode.V))
        {
            CharacterPanel.Instance.DisplaySwitch();
        }
        //按下N键商店小贩面板的显示和隐藏
        if (Input.GetKeyDown(KeyCode.N))
        {
            Vendor.Instance.DisplaySwitch();
        }
        //按下M键锻造面板的显示和隐藏
        if (Input.GetKeyDown(KeyCode.M))
        {
           Forge.Instance.DisplaySwitch();
        }
    }

    //消费金币
    public bool ConsumeCoin(int amount) 
    {
        if (coinAmount >= amount)
        {
            coinAmount -= amount;
            coinText.text = coinAmount.ToString();//更新金币数量
            return true;//消费成功
        }
        return false;//否则消费失败
    }

    //赚取金币
    public void EarnCoin(int amount) 
    {
        this.coinAmount += amount;
        coinText.text = coinAmount.ToString();//更新金币数量
    }
}

好了，一个较为完整的背包系统整理完毕。如果其中有错请与我及时联系改正，期待与你交流！若有需要源项目工程的，请留言！

unity中简单背包系统
m0_66744030的博客
06-04 2724
管理数据，显示UI的类。
Unity UI拖放交互实战：从零实现一个可拖拽的背包系统
最新发布
weixin_29001423的博客
03-26 218
本文详细介绍了在Unity中实现可拖拽背包系统的完整流程，从基础架构设计到核心拖拽功能实现，再到高级功能扩展和性能优化。通过使用Unity的EventSystem接口和UI组件，开发者可以轻松创建流畅的拖放交互体验，适用于各类游戏开发场景。文章还涵盖了移动端适配、物品提示框和持久化存储等实用技巧。
Unity3D RPG实现 2 —— 背包系统
热门推荐
weixin_43757333的博客
02-28 2万+
本文实现了背包系统，包含物品与数据库连接，物品的使用，拖拽交换、展示详情等功能。
[UGUI]Unity背包系统制作详细步骤
leoysq的博客
11-23 5156
创建空物体作为网格内容容器，相对父亲居中，700*450像素，为他再添加一个组件UI -image，铺满作为背包背景图。滑动框是由三部分组成：横向和纵向滑动块、被关联的滑动内容（这个内容可以是任何UI，文本、图片、视频，只认UI）在创建一个顶部image做LOGO（宽度和父亲一样，高是50像素），里面创建子文本写上内容。选中BG，找到他的锚点设置，按住Alt键，点击右下角的适配，让锚点和内容都匹配画布。然后把位置调整好，把刚才做好的背包关联到滑动面板的内容变量里面。然后开始添加子物体，可以看到自动排列了。
Unity--背包系统（含锻造和装备系统）
qq_62947569的博客
07-26 5209
3.解析完所有的装备信息后，就是需要设计物品槽和物品的搭建，实现面板和物品之间的交互比如移动物品，获得物品等，是将物品槽和物品都做成单独的预制件，在实现交互等功能（比如将物品储存在槽中，逻辑就是将Item设为槽的子物体，随后将局部坐标变为0就能实现），这里有需要创建多个面板的话（比如背包，商店等面板），就需要有个Inventory父类(是所有面板的父类)，子类不同的面板有不同的功能，就可以单独设置。//因为中心轴设置的位置的原因，因此要有个偏差才能达到合适的效果。
Unity游戏开发：背包系统的实现
float_freedom的博客
08-09 8041
背包是游戏中经常使用的一个组件，它负责管理玩家在游戏中所获得的道具。一个完整的背包系统应当具有将物品放置进背包、对背包内物品进行管理和使用背包内物品等功能。而往往一个背包系统的逻辑关系较为复杂，如果把所有功能都放在一个脚本中实现会使代码显得十分冗杂且缺乏逻辑。所以在背包系统的设计过程中，我们常将其分解为数据、逻辑和UI三部分分别来进行完成。......
基于Unity3D（UGUI）的背包系统<二>
Say__Yes的博客
05-15 1万+
这篇文章接着上一章的背包系统，上文主要介绍了这个背包系统的效果和总的大概。接下来的就是具体的实现了！！（实现嘛，当然少不了代码咯）在这里我继续利用上一篇文章中的UML图，从UML图的左边部分讲述，也就是装备物品数据的获取和存储方面。好，先放上上文中的UNML图，也方便大家查阅（具体介绍看上一篇文章哈）。 一：存储物品的Json文件（轻量级）。我把每一个物品的信息都存储在一个Json文件中，然后再从
Unity3D的简单商店、背包与装备系统（UGUI）
YarAx的博客
07-23 1万+
Store And Equipment System In Unity3D Introduction 物品元素可以说是所有RPG的必备系统，毕竟，如果没有物品系统就没有消耗，没有消耗哪能骗玩家充钱呢？最简单的物品系统应该是所谓的商店、背包加装备的结构，而这个Demo则主要基于UGUI实现一个简单的上述系统 UI 制作系统的第一步便是UI的绘制了。无论美术资源来自何方，画风如何，应该...
Unity3D自学笔记——UGUI背包系统（七）物品的装备与卸下
alistair_chow的博客
11-09 1万+
物品的装备与卸下效果图装备 卸下 实现功能 点击背包里的物品，属性弹出框将显示装备按钮 点击角色身上的物品，属性弹出框显示卸下按钮 点击装备后，所选物体将从背包中移除，角色相应装备栏将显示该装备，然后属性动态修改 点击卸下，所选物体将从角色装备栏移除，并将装备添加至背包 对象关系 背包 物理关系 UIScene_Inventory 最外层 PnlGrid 背包格子的容器 Gri
Unity3D自学笔记——UGUI背包系统（八）物品的分类与整理
alistair_chow的博客
11-10 1万+
物品的分类与整理效果图全部 装备 药水 其他 实现功能1.全部显示背包的所有格子及所有物品 2.分类显示该类物品及该类物品个数的格子 3.不管是哪个面板的装备进行了更新，其余面板都应更新 4.数量显示当前格子数量和总数量例如 从装备Tab装备一个装备至角色身上 装备分页该装备要消失 并且在全部分页中也应该对应消失 实现逻辑1.有两个背包容器，一个为全部的物品
Unity2D背包系统的搭建
如果可以一直带着少年时的酷
11-19 2307
这篇文章参考了麦扣老师@M_Studio的教程我做了许多修改和调整。希望可以帮到你😉。
Unity背包系统一：实现物品获取效果
qq_74418765的博客
03-19 3148
实现物品拾取效果
Unity背包系统（源码）
qq_29172391的博客
05-08 1072
3、GoodsOnWorld与InventoryManage。2、GoodsItem与Inventory。3、背包中物体的显示、移动、交换。以下是这个背包系统的所以源码。1、背包的打开、关闭与拖拽。2、背包中物品数据的存储。4、背包数据库的实时更新。
【Unity开发字典】初学小白三分钟就能懂的简单背包系统
初学者的博客
04-24 1651
【Unity开发字典】初学小白三分钟就能懂的简单背包系统!!!!!!!!本文分享通过极简代码和可视化工具，实现一个基础但功能完整的背包系统。无需复杂编程基础，结合UGUI和C#脚本快速上手。
关于在unity中实现背包系统
2301_77778262的博客
04-28 1838
接下来是我个人对于背包系统的理解，一种是刻板印象里的背包，如《像素地牢》里面的人物背包主要强调用于保存玩家获得的物品，而另一种并不像刻板印象的背包，但它又如背包那样可以保存，获取，调用，但相比于刻板印象中的背包强调 “保存” 而它是强调 “调用”（类似于《元气骑士》里的武器吧） 与其叫她为背包或许叫它装备更为合适，可能这种的 “背包”真的被称为装备吧，学的不多欢迎指教，总之，不同的 “背包” 侧重点不同，因此背包系统不应像保存数据的系统和对象池一样，有着固定通用的设计思路，应该根据项目的需要定制。
Unity背包系统笔记
Jesui的博客
10-28 2321
无
Unity 高级背包系统
海月的博客
05-08 6025
之前实现了一个初级的背包系统，它没有对物品进行分类。 这一次新增了物品的分类存储与显示。 Asset的结构 为了对物品进行分类管理，在ScriptableObject中使用列表存储三个类型的物品，分别是武器、食物以及材料。这个列表中的元素是一个特别的类，它包含了这类物品的名字，以及存储这类物品的列表。在物品配置表中，存储的是Item类对象，在背包物品数据表中，存储的是InventoryItem对象，它们的差异是，InventoryItem类的对象多了一个数量的属性。 代码 ......
Unity 农场 1 —— 环境搭建、背包系统、时间系统
weixin_43757333的博客
07-24 6432
本文实现了背包、种植、时间系统，以及使用A*算法实现了NPC的自动寻路和跨场景寻路。
unity：背包系统讲解
weixin_50642897的博客
11-18 5130
图片描述 特别说明：UI框架的作用只是为了方便管理，和使得整个结构清晰明了。窗体封装了打开与关闭的公有方法，并无涉及到窗体具体的特有功能，所以这里不讲框架并不会造成做不出背包的问题。 UI_PacksackForm.cs（脚本说明） using System.Collections; using System.Collections.Generic; using UnityEngine; using MyUI; using System; using UnityEngine.EventSystems
Unity背包系统
m0_61490399的博客
07-26 1359
流程创建网格自生脚本Slot，图片、文字、点击等等👉👉通过装备的触发条件执行InvensoryManager管理脚本的函数👉👉然后给Slot赋值等。流程先给背包系统Inventory设置好位子👉👉然后判断位置下的Item是否为空，空就隐藏，否者就显示然后赋值等。3、Panel嵌套管理网格的的Img、舔加GridLayoutGroup组件，使用组件调整网格布局。10、.网格自身脚本、创建生成网格Grid脚本、显示装备、舔加装备详细信息等等。4、嵌套的网格Img再嵌套Img再嵌套Text。...........
评论 27
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值