unity中背包系统（Newtonsoft储存数据）

最新推荐文章于 2024-08-16 10:21:38 发布
最新推荐文章于 2024-08-16 10:21:38 发布
阅读量177 收藏
点赞数
文章标签： unity 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66744030/article/details/134517983
版权

先创建单列模式方便继承

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

public class Singleton<T> : MonoBehaviour where T : Component
{
    public static T instance {  get; private set; }
    protected virtual void Awake()
    {
        // as 强制转换类型
        instance=this as T;
    }

}

数据储存类 继承单列模式，使用Newtonsoft来储存数据

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Newtonsoft.Json;
using System.IO;

public class SaveLoadManager : Singleton<SaveLoadManager>
{
    string jsonFolder;//目录
    List<ISaveable> saveableList=new List<ISaveable>();

    Dictionary<string,GameData> saveDataDic=new Dictionary<string,GameData>();

    protected override void Awake()
    {
        base.Awake();
        jsonFolder = Application.persistentDataPath + "/Save/";//文件路径
    }
    public void Regiser(ISaveable saveable)
    {
          saveableList.Add(saveable);
    }
    void OnStartGame()
    {
        var resultPath = jsonFolder + "data.sav";
        if(File.Exists(resultPath))//如果文件存在
        {
            File.Delete(resultPath);
        }
    }
    
   public void SaveGameData()
    {
        saveDataDic.Clear();
        foreach (var saveable in saveableList)
        {
            saveDataDic.Add(saveable.GetType().Name, saveable.GeneraterGameData());
        }
        var resultPath = jsonFolder + "data.sav";
        //序列化字典 独立排序
        var jsonData= JsonConvert.SerializeObject(saveDataDic, Formatting.Indented);
        //没有文件夹
        if (!File.Exists(resultPath))
        {
            //创建文件
            Directory.CreateDirectory(jsonFolder);
        }
        File.WriteAllText(resultPath, jsonData);
    }
    public void LoadGameData()
    {
        var resultPath = jsonFolder + "data.sav";
        if (!File.Exists(resultPath)) return;
        //读取数据
        var stringData= File.ReadAllText(resultPath);
        //反序列化
        var jsonData=JsonConvert.DeserializeObject<Dictionary<string,GameData>>(stringData);

        foreach (var saveable in saveableList)
        {
            //类名注册
            saveable.RestoreGameData(jsonData[saveable.GetType().Name]);
        }
    }
}

其中的GameData，是自定义的数据类


using System.Collections.Generic;
using UnityEngine;

public class GameData 
{
    //储存物品栏名字，物体id
    public Dictionary<string, int> dataDict;
    //物体id,物体数量
    public Dictionary<int, int> itemDictionary;
}

ISaveable接口 要储存数据的类，继承这个接口


//接口
public interface ISaveable 
{
    void SaveableRegiser()
    {
        SaveLoadManager.instance.Regiser(this);
    }
   
    GameData GeneraterGameData();

    void RestoreGameData(GameData saveData);
}

创建物体类的信息 用scriptableobject来创建物体信息

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

[CreateAssetMenu(fileName = "New Item", menuName = "Inventory/New Item")]//可以在鼠标右单击 创建 找到  可以创建一New Item类的文件
public class Item : ScriptableObject//数据本地化
{
    public int id;//标识
    public Sprite itemImage;//物体图片
    public int itemNumber; //物体数量
    [TextArea]
    public string desprict;

}

创建物体数据管理类 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using Unity.VisualScripting;

public class ItemManager : Singleton<ItemManager>,ISaveable
{
    public List<Item> itemList;
    public Dictionary<int, int> itemDictionary=new Dictionary<int, int>();
    private void Start()
    {
        //注册数据
        ISaveable saveable = this;
        saveable.SaveableRegiser();

    }

    public void ItemDictionary()
    {
        itemDictionary.Clear();
        foreach (var item in itemList)
        {
            itemDictionary.Add(item.id, item.itemNumber);
        }
    }
    public void ItemList()
    {
        foreach (var item in itemList)
        {
            foreach(var dic in itemDictionary)
            {
                if(item.id==dic.Key)
                {
                    item.itemNumber=dic.Value;
                }
            }
        }
    }
    public void ItemDictionaryShow()
    {
        foreach(var dic in itemDictionary)
        {
            Debug.Log("物体 id key"+dic.Key+"物体数量 value"+dic.Value);
        }
    }

    //创建数据
    public GameData GeneraterGameData()
    {
        GameData data = new GameData();
        ItemDictionary();
        data.itemDictionary = this.itemDictionary;
        return data;
    }
    //加载数据
    public void RestoreGameData(GameData saveData)
    {
        this.itemDictionary = saveData.itemDictionary;
        ItemList();
    }
}

物体在ui上的类，用于选择，和交换位置

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

public class UIItemButton : MonoBehaviour,IPointerEnterHandler, IPointerExitHandler, IBeginDragHandler, IDragHandler, IEndDragHandler//检测UI
{
    public Item itemScriptableObject;
    public Image image;
    public Text text;

    Transform originalParent;
    Button button;
    Canvas canvas;


    bool isMouseOver = false;
    private void Awake()
    {
        button = GetComponent<Button>();
        canvas = GetComponent<Canvas>();
    }

    private void Start()
    {
        button.onClick.AddListener(ButtonOnClick);
        image.sprite = itemScriptableObject.itemImage;
    }
   public void ButtonOnClick()
    {
        Debug.Log("按下"+gameObject.name);
        ItemShowPanel.instance.ItemInformationShow(itemScriptableObject);
    }

    // 当鼠标进入UI元素时调用
    public void OnPointerEnter(PointerEventData eventData)
    {
        Color currentColor = image.color;
        currentColor.a = 0.5f;
        image.color = currentColor;
        isMouseOver = true;
    }
    // 当鼠标离开UI元素时调用
    public void OnPointerExit(PointerEventData eventData)
    {
        Color currentColor = image.color;
        currentColor.a = 1f;
        image.color = currentColor;
        isMouseOver = false;
    }

    //开始拖拽
    public void OnBeginDrag(PointerEventData eventData)
    {
        originalParent = transform.parent;
        transform.SetParent(transform.parent.parent);

        Vector3 screenPos = eventData.position;
        screenPos.z =5;
        Vector3 worldPos = Camera.main.ScreenToWorldPoint(screenPos);
        transform.position = worldPos;
    }
    //拖拽中
    public void OnDrag(PointerEventData eventData)
    {
        Vector3 screenPos = eventData.position;
        screenPos.z = 5;
        Vector3 worldPos = Camera.main.ScreenToWorldPoint(screenPos);
        transform.position = worldPos;

 
    }
    //拖拽结束
    public void OnEndDrag(PointerEventData eventData)
    {
        Vector3 screenPos = eventData.position;
        screenPos.z =5 ;
        Vector3 worldPos = Camera.main.ScreenToWorldPoint(screenPos);
        transform.position = worldPos;

        //射线检测是否含有UIGrid
        Vector2 mousePosition = Input.mousePosition;
        PointerEventData pointerEventData = new PointerEventData(EventSystem.current);
        pointerEventData.position = mousePosition;
        List<RaycastResult> raycastResults = new List<RaycastResult>();
        EventSystem.current.RaycastAll(pointerEventData, raycastResults);

        bool isHaveGrid = false;
        foreach (RaycastResult result in raycastResults)
        {
            GameObject hitObject = result.gameObject;
            // 检查 UI 元素是否挂载了UIGrid脚本
            UIGrid script = hitObject.GetComponent<UIGrid>();
            if (script != null)
            {
                isHaveGrid = true;
                //是否有子物体
                UIItemButton childrenItem = script.GetComponentInChildren<UIItemButton>();
                //有物体
                if (childrenItem != null)
                {
                    //交换位置
                    childrenItem.transform.SetParent(originalParent);
                    childrenItem.transform.position = originalParent.position;
                    //背包字典更改数据  用名字绑定物体id
                    InvontoryManager.instance.RemoveValue(itemScriptableObject.id);
                    InvontoryManager.instance.UpdateValueData(originalParent.gameObject.name, childrenItem.itemScriptableObject.id);
                 

                    transform.SetParent(script.transform);
                    transform.position = script.transform.position;
                    originalParent = transform.parent;
                    InvontoryManager.instance.AddData(hitObject.name, itemScriptableObject.id);
                }
                else
                {
                    transform.SetParent(script.transform);
                    transform.position = script.transform.position;
                    originalParent = transform.parent;
                    //背包字典更改数据  用名字绑定物体id
                    InvontoryManager.instance.UpdateValueData(hitObject.name, itemScriptableObject.id);
                }            
                break;
            }              
        }
        //放在没格子的地方
        if(!isHaveGrid)
        {
            Debug.Log(originalParent);
            //返回原位置
            transform.SetParent(originalParent);
            transform.position = originalParent.position;
        }
    }
   //增加到背包中
    public void AddInInvory()
    {
        InvontoryManager.instance.AddItem(gameObject);
    }
    //减少背包物体
    public void ReduceInInvory(int number)
    {
        InvontoryManager.instance.ReduceItem(gameObject,number);
    }

    void Update()
    {
        if (isMouseOver && Input.GetKeyDown(KeyCode.Delete))
        {
            InvontoryManager.instance.RemoveItem(gameObject);
        }
    }

}

背包管理类，能加载数据，加载物体

using JetBrains.Annotations;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;
using static UnityEngine.Rendering.DebugUI;

public class InvontoryManager : Singleton<InvontoryManager>,ISaveable
{
    public GameObject Gird;

    public GameObject[] itemS;

    //字典必须实例化
    //背包数据
    public Dictionary<string, int> dataDict=new Dictionary<string, int>();


    private void Start()
    {
        //注册数据
        ISaveable saveable = this;
        saveable.SaveableRegiser();

    }

    //加载数据到背包中
    public void LoadInvontoryData()
    {
        ClearAllChildren();
        // 遍历字典的键
        foreach (KeyValuePair<string, int> kvp in dataDict )
        {
            string key = kvp.Key;
            int value = kvp.Value;

            foreach (Transform childTransform in transform)
            {
                GameObject childObject = childTransform.gameObject;
                if (childObject.name == key)
                {
                  var loadItem=  Instantiate(itemS[value], childObject.transform);

                    UIItemButton newItem = loadItem.GetComponent<UIItemButton>();
                    newItem.text.text = newItem.itemScriptableObject.itemNumber.ToString();
                    Debug.Log(" 加载数据"+newItem.itemScriptableObject.itemNumber.ToString());
                }
            }
        }
    }
    //清除背包格子下面的子对象
    public void ClearAllChildren()
    {
        foreach (Transform childTransform in transform)
        {
            GameObject childObject = childTransform.gameObject;
            if (childObject.transform.childCount != 0)
            {
                ClearAllChildren(childObject);
            }
        }        
    }
    //清除子对象
    public void ClearAllChildren(GameObject parent)
    {
        int childCount = parent.transform.childCount;

        for (int i = childCount - 1; i >= 0; i--)
        {
            Transform child = parent.transform.GetChild(i);
            ClearAllChildren(child.gameObject);
            Destroy(child.gameObject);
        }
    }
    //放入背包网格中
    public void AddItemInBag(GameObject _itemToAdd)
    {
        bool isEnough=true;
        //遍历外层背包
        foreach (Transform childTransform in transform)
        {
            isEnough = false;
            GameObject childObject = childTransform.gameObject;
            //没有子物体
            if (childObject.transform.childCount==0)
            {
                isEnough = true;
                UIItemButton newItem = _itemToAdd.GetComponent<UIItemButton>();
                Instantiate(newItem, childObject.transform);
                newItem.itemScriptableObject.itemNumber = 1;
                newItem.text.text = newItem.itemScriptableObject.itemNumber.ToString();

                //背包字典增加数据  用名字绑定物体id
                AddData(childObject.name, newItem.itemScriptableObject.id);

                Debug.Log(childObject.name);           
                break;
            }
        }
        if (!isEnough)
        {
            GameObject newGrid= Instantiate(Gird, transform);
            UIItemButton newItem = _itemToAdd.GetComponent<UIItemButton>();
            Instantiate(newItem, newGrid.transform);
            newItem.itemScriptableObject.itemNumber = 1;
            newItem.text.text = newItem.itemScriptableObject.itemNumber.ToString();
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    //增加物体
    public void AddItem(GameObject _itemToAdd)
    {
        UIItemButton newItem = _itemToAdd.GetComponent<UIItemButton>();
        bool isHaveItem = false;
        // 获取子对象上的多个特定类型组件
        UIItemButton[] UIItemButtons = instance.transform.GetComponentsInChildren<UIItemButton>();
        foreach (UIItemButton button in UIItemButtons)
        {
            if (button.itemScriptableObject.id == newItem.itemScriptableObject.id)
            {
                button.itemScriptableObject.itemNumber++;
                button.text.text = button.itemScriptableObject.itemNumber.ToString();
                isHaveItem = true;
                break;
            }
        }
        if (!isHaveItem)
        {
            AddItemInBag(_itemToAdd);
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    public void AddItem(GameObject _itemToAdd,int number)
    {
        UIItemButton newItem = _itemToAdd.GetComponent<UIItemButton>();
        bool isHaveItem = false;
        // 获取子对象上的多个特定类型组件
        UIItemButton[] UIItemButtons = instance.transform.GetComponentsInChildren<UIItemButton>();
        foreach (UIItemButton button in UIItemButtons)
        {
            if (button.itemScriptableObject.id == newItem.itemScriptableObject.id)
            {
                button.itemScriptableObject.itemNumber+= number;
                button.text.text = button.itemScriptableObject.itemNumber.ToString();
                isHaveItem = true;
                break;
            }
        }
        if (!isHaveItem)
        {
            AddItemInBag(_itemToAdd);
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    public void ReduceItem(GameObject _itemToReduce)
    {
        UIItemButton newItem = _itemToReduce.GetComponent<UIItemButton>();

        // 获取子对象上的多个特定类型组件
        UIItemButton[] UIItemButtons = instance.transform.GetComponentsInChildren<UIItemButton>();
        foreach (UIItemButton button in UIItemButtons)
        {
            if (button.itemScriptableObject.id == newItem.itemScriptableObject.id)
            {
                button.itemScriptableObject.itemNumber --;
                button.text.text = button.itemScriptableObject.itemNumber.ToString();
                if (button.itemScriptableObject.itemNumber <= 0)
                {
                    RemoveItem(_itemToReduce);
                }
                break;
            }
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    public void ReduceItem(GameObject _itemToReduce,int number)
    {
        UIItemButton newItem = _itemToReduce.GetComponent<UIItemButton>();

        // 获取子对象上的多个特定类型组件
        UIItemButton[] UIItemButtons = instance.transform.GetComponentsInChildren<UIItemButton>();
        foreach (UIItemButton button in UIItemButtons)
        {
            if (button.itemScriptableObject.id == newItem.itemScriptableObject.id)
            {
                button.itemScriptableObject.itemNumber-= number;
                button.text.text = button.itemScriptableObject.itemNumber.ToString();
                if(button.itemScriptableObject.itemNumber <=0)
                {
                    RemoveItem(_itemToReduce);
                }

                break;
            }
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    public void ReduceItem(int itemID, int number)
    {
        // 获取子对象上的多个特定类型组件
        UIItemButton[] UIItemButtons = instance.transform.GetComponentsInChildren<UIItemButton>();
        foreach (UIItemButton button in UIItemButtons)
        {
            if (button.itemScriptableObject.id == itemID)
            {
                button.itemScriptableObject.itemNumber -= number;
                button.text.text = button.itemScriptableObject.itemNumber.ToString();
                if (button.itemScriptableObject.itemNumber <= 0)
                {
                    RemoveItem(itemID);
                }

                break;
            }
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    //删除物体 背包清除
    public void RemoveItem(GameObject _itemToRemove)
    {
        UIItemButton item = _itemToRemove.GetComponent<UIItemButton>();
        UIItemButton[] UIItemButtons = instance.transform.GetComponentsInChildren<UIItemButton>();
        foreach (UIItemButton button in UIItemButtons)
        {
            var objectID=button.itemScriptableObject.id;

            if (button.itemScriptableObject.id == item.itemScriptableObject.id)
            {
                button.itemScriptableObject.itemNumber = 1;

                字典背包列表移除
                RemoveValue(button.itemScriptableObject.id);
            
                Destroy(button.gameObject);
            }
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    public void RemoveItem(int itemID)
    {
        UIItemButton[] UIItemButtons = instance.transform.GetComponentsInChildren<UIItemButton>();
        foreach (UIItemButton button in UIItemButtons)
        {

            if (button.itemScriptableObject.id == itemID)
            {
                button.itemScriptableObject.itemNumber = 1;

                字典背包列表移除
                RemoveValue(button.itemScriptableObject.id);

                Destroy(button.gameObject);
            }
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }

    public int ReturnItemNumebr(int itemID)
    {
        UIItemButton[] UIItemButtons = instance.transform.GetComponentsInChildren<UIItemButton>();
        int number = 0;
        foreach (UIItemButton button in UIItemButtons)
        {
            if (button.itemScriptableObject.id == itemID)
            {
                number=button.itemScriptableObject.itemNumber;
            }
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
        return number;
    }

    #region 字典处理
    public void AddData(string key, int value)
    {
        if (!dataDict.ContainsKey(key))
        {
            dataDict.Add(key, value);
        }
        else
        {
            Debug.LogWarning("Key already exists in the dictionary!");
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    public int GetData(string key)
    {
        if (dataDict.ContainsKey(key))
        {
            //保存数据
            SaveLoadManager.instance.SaveGameData();
            ItemManager.instance.ItemDictionaryShow();
            return dataDict[key];
        }
        else
        {
            Debug.LogWarning("Key does not exist in the dictionary!");
            return 0;
        }

    }  
    public void UpdateData(string key, int newValue)
    {
        if (dataDict.ContainsKey(key))
        {
            dataDict[key] = newValue;
        }
        else
        {
            Debug.LogWarning("Key does not exist in the dictionary!");
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    public void UpdateValueData(string newName,int objectID)
    {
         List<string> keysToRemove = new List<string>();

            foreach (var kvp in dataDict)
            {
                var key = kvp.Key; // 键
                var value = kvp.Value; // 值

                if (value == objectID)
                {
                    keysToRemove.Add(kvp.Key);                  
                    break;
                }
            }
            foreach (var key in keysToRemove)
            {
                dataDict.Remove(key);
            }
            AddData(newName, objectID);
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    //根据值来删除 数据  必须用个列表来存储，不然会出问题
    public void RemoveValue(int objectID)
    {
        List<string> keysToRemove = new List<string>();

        foreach (var kvp in dataDict)
        {
            if (kvp.Value == objectID)
            {
                keysToRemove.Add(kvp.Key);
            }
        }

        foreach (var key in keysToRemove)
        {
            RemoveData(key);
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    //根据键删除数据
    public void RemoveData(string key)
    {
        if (dataDict.ContainsKey(key))
        {
            dataDict.Remove(key);
        }
        else
        {
            Debug.LogWarning("Key does not exist in the dictionary!");
        }
        //保存数据
        SaveLoadManager.instance.SaveGameData();
        ItemManager.instance.ItemDictionaryShow();
    }
    #endregion

    //private void Update()
    //{

    //    //if (Input.GetKeyDown(KeyCode.S))
    //    //{
    //    //    SaveLoadManager.instance.SaveGameData();
    //    //    ItemManager.instance.ItemDictionaryShow();
    //    //}
    //    //if (Input.GetKeyDown(KeyCode.P))
    //    //{
    //    //    SaveLoadManager.instance.LoadGameData();
    //    //    LoadInvontoryData();
    //    //}

    //}

    //创建数据
    public GameData GeneraterGameData()
    {
        GameData data = new GameData();

        data.dataDict = this.dataDict;
        return data;
    }
    //加载数据
    public void RestoreGameData(GameData saveData)
    {
        this.dataDict = saveData.dataDict;
    }
}

物体显示面板，用于物体的处理

using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;

public class ItemShowPanel : Singleton<ItemShowPanel>
{
    [SerializeField] Image image;
    [SerializeField] Text numberText;
    [SerializeField] Text descriptionText;
    [SerializeField] Sprite defaultSprite;
    [SerializeField] Slider slider;
    [SerializeField] Text  sliderText;

    [Header("Button")]
    [SerializeField] Button testUseItemButton;
    [SerializeField] Button testDelItemButton;

    private int itemID;

    private void Start()
    {
        slider.onValueChanged.AddListener(OnSliderValueChanged);
    }

    private void OnEnable()
    {
        ButtonPressBehavior.buttonFunctionTable.Add(testUseItemButton.gameObject.name, OnUseItemButtonClik);
        ButtonPressBehavior.buttonFunctionTable.Add(testDelItemButton.gameObject.name, OnDelItemButtonClik);
    }
    private void OnDisable()
    {
        ButtonPressBehavior.buttonFunctionTable.Clear();
    }
    public void ItemInformationShow(Item  item)
    {
        image.sprite = item.itemImage;
        numberText.text=item.itemNumber.ToString();
        descriptionText.text = item.desprict;
        itemID = item.id;
        slider.maxValue = item.itemNumber;
    }
    public void DefaultSituation()
    {
        image.sprite = defaultSprite;
        descriptionText.text = "";
        numberText.text = "";
        sliderText.text = "";
        slider.value = 0;
    }
    public void OnUseItemButtonClik()
    {
        int intValue = Mathf.RoundToInt(slider.value);
        for (int i = 0; i < intValue; i++)
        {
            EventManager.instance.TriggerEvent(itemID);
            Debug.Log("EventManager.instance.TriggerEvent(itemID);次数" + intValue);
        }
        OnDelItemButtonClik();
    }
    //删除按钮
    public void OnDelItemButtonClik()
    {
        int intValue = Mathf.RoundToInt(slider.value);
        if (InvontoryManager.instance.ReturnItemNumebr(itemID) == intValue)
        {
            InvontoryManager.instance.ReduceItem(itemID, intValue);
            DefaultSituation();

        }
        else
        {
            InvontoryManager.instance.ReduceItem(itemID, intValue);
            numberText.text = InvontoryManager.instance.ReturnItemNumebr(itemID).ToString();
        }

        slider.maxValue = InvontoryManager.instance.ReturnItemNumebr(itemID);

    }

    void OnSliderValueChanged(float value)
    {
        sliderText.text = Mathf.RoundToInt(value).ToString();
    }
}

事件管理类，用物品id来注册事件

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

public class EventManager : Singleton<EventManager>
{
    private Dictionary<int, Action> eventDictionary;

    public EventManager()
    {
        eventDictionary = new Dictionary<int, Action>();
    }
    //出现重复委托
    //public void AddEvent(int objectId, Action eventAction)
    //{
    //    if (eventDictionary.ContainsKey(objectId))
    //    {
    //        eventDictionary[objectId] += eventAction;
    //    }
    //    else
    //    {
    //        eventDictionary[objectId] = eventAction;
    //    }
    //}

    //确保只有一次委托
    public void AddEvent(int objectId, Action eventAction)
    {
        if (eventDictionary.ContainsKey(objectId))
        {
            RemoveEvent(objectId);
        }

        eventDictionary[objectId] = eventAction;
    }



    public void RemoveEvent(int objectId, Action eventAction)
    {
        if (eventDictionary.ContainsKey(objectId))
        {
            eventDictionary[objectId] -= eventAction;

            if (eventDictionary[objectId] == null)
            {
                eventDictionary.Remove(objectId);
            }
        }
    }
    public void RemoveEvent(int objectId)
    {
        if (eventDictionary.ContainsKey(objectId))
        {
            eventDictionary.Remove(objectId);
        }
    }

    public void TriggerEvent(int objectId)
    {
        if (eventDictionary.ContainsKey(objectId))
        {
            eventDictionary[objectId]?.Invoke();
        }
    }

}

在世界坐标上的物体

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
public class LootitemAddMissile : LootItem
{
    [SerializeField] GameObject UIitemPrefab;

    UIItemButton uiItem;

    protected override void Awake()
    {
        base.Awake();
        uiItem = UIitemPrefab.GetComponent<UIItemButton>();
        EventManager.instance.AddEvent(uiItem.itemScriptableObject.id, AddMissileNumber);
        Debug.Log("导弹注册事件");
    }
    protected override void PickUp()
    {
        base.PickUp();
        uiItem.AddInInvory();
    }
  public void AddMissileNumber()
    {
       //自己要触发的功能


        
    }
}

物体基础类 

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

public class LootItem : MonoBehaviour
{
    protected Player player;
    [SerializeField] float minSpeed;
    [SerializeField] float maxSpeed;
    [SerializeField] protected AudioData pickUpSFX;

    protected Text LootText;
    Animator animator;

    int pickUpStateID = Animator.StringToHash("PickUp");
    protected virtual void Awake()
    {
        animator = GetComponent<Animator>();
        player = FindObjectOfType<Player>();//找到挂有Player的物体的脚本
        LootText = GetComponentInChildren<Text>(true);//true 获得禁用时的组件
    }
    private void OnEnable()
    {
        StartCoroutine(nameof(MoveCorotine));
    }
    //跟随玩家移动
    IEnumerator MoveCorotine()
    {
        float speed = Random.Range(minSpeed, maxSpeed);
        Vector3 direction = Vector3.left;//向左   
        while (isActiveAndEnabled)
        {
            if (player.isActiveAndEnabled)
            {
                direction = (player.transform.position - transform.position).normalized;

            }
            transform.Translate(direction * speed * Time.deltaTime);
            yield return null;
        }

    }

    private void OnTriggerEnter2D(Collider2D collision)
    {
        PickUp();
    }
    protected virtual void PickUp()
    {
        StopAllCoroutines();
        animator.Play(pickUpStateID);
        AudioManager.instance.PlayRandomSFX(pickUpSFX);

    }

}

加载数据放在背包打开的时候就行

        //加载背包数据
        SaveLoadManager.instance.LoadGameData();
        InvontoryManager.instance. LoadInvontoryData();

创建物体信息

 编写物体信息，id为唯一值创建ui物体信息预制体

创建场景中物体，挂载ui物体信息 预制体

 背包ui界面

 背包面板用Scroll View，内容填充用Grid layout Group

显示界面

Upward silent
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Unity3d背包系统（三）—— 设计物品类的JSON文件
RT_Geek的博客
10-09 2205
这节谈谈物品的json文件，json文件主要的包括两种结构： 一种是 “名称/值”对的集合，在不同的语言中，被解析的方式也不用如：对象(object),记录(record),结构(struct),字典(dictionary),哈希表(hash table),有键列表(keyed list),关联数组 (associative array)等;一种是值的有序列表，在大多部分语言中也被叫
KnapcackSystemScripts_背包系统_unity3d_
10-01
在Unity3D中实现背包系统，首先需要设计数据结构来存储和管理物品。这通常涉及到定义一个物品类（Item Class），包含如物品ID、名称、描述、类型、数量、图片等属性。物品可能还需要附加一些特殊属性，比如稀有度、...
Unity使用JSON存储实现背包功能
ackow的博客
11-13 677
在Unity有五种常用的存储数据的方法，可以用来存储我们游戏的数据。
Newtonsoft.Json 可以序列化Vector向量的方法
Marccco的博客
01-10 1511
【代码】Newtonsoft.Json 可以序列化Vector向量的方法。
Unity—3D数学-Vector3
m0_63330263的博客
07-23 1717
Vector3 向量 向量的大小 向量的方向 向量运算 向量相减、相加 需求：t3沿着t1-t2的方向移动 向量与标量的乘除 角度度量方式： 角度Degree与弧度Radin 角度与弧度的换算 三角函数 反三角函数 练习：计算物体右前方30度，10米远坐标...
【Unity3D小技巧】Unity3D中复杂Json结构的生成与解析--List＜List＜int＞＞--Dic＜int,List＜List＜int＞＞＞
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
01-13 6401
推荐阅读 CSDN主页 GitHub开源地址 Unity3D插件分享 简书地址 我的个人博客 QQ群：1040082875 大家好，我是佛系工程师☆恬静的小魔龙☆，不定时更新Unity开发技巧，觉得有用记得一键三连哦。 一、前言 最近有小伙伴在群里询问复杂Json格式应该怎么解析和生成。 比如： List<List<int>> Dictionary<int, List<int>> Dictionary<int, Dictionary<st.
Unity 3D背包系统源码.zip
07-08
在游戏开发中，背包系统是游戏物品管理的重要组成部分，它允许玩家收集、存储和使用各种游戏内的道具。"Unity 3D背包系统源码.zip"包含了实现这一功能的源代码，为开发者提供了一套完整的解决方案。 该源码可能是用...
Unity版Newtonsoft.Json
01-19
Unity版的Newtonsoft.Json是Unity开发中常用的JSON序列化与反序列化库，它使得在Unity引擎中处理JSON数据变得更加方便。本教程将详细介绍如何在Unity项目中集成和使用Newtonsoft.Json，以及它的一些核心功能。 首先...
背包系统——基于Unity3DUGUI.zip
03-15
在Unity3D游戏开发中，背包系统是游戏交互的核心部分之一，它允许玩家收集、存储、查看和管理游戏内的物品。本项目“背包系统——基于Unity3D UGUI”着重于利用Unity3D的UI系统（UGUI）来构建一个功能完备的背包界面...
Unity背包系统
11-29
Unity背包系统
Unity | 用于可序列化的Vector3、Quaternion
小小小小羽的博客
01-08 4229
Vector3向量，可序列化封装 using UnityEngine; /// <summary> /// /// * Writer：June /// /// * Data：2022.1.6 /// /// * Function：可序列化的三维向量 /// /// * Remarks： /// /// </summary> [System.Serializable] public struct SerV3 { public float x; publ
Newtonsoft.Json 反序列化字典Key为Vector时解决方案
小鱼游戏开发的博客
04-29 1011
栗子： using Test = Dictionary<Vector2Int, Vector2>; public class NewBehaviourScript : MonoBehaviour { private void Awake() { Test list = new Test(); list.Add(Vector2Int.zero, Vector2Int.one); ...
Newtonsoft.Json之json解析
uokeyo的博客
03-13 616
1.定义需要对应的数据类public class UnUsefulMessageInfo { public string key; public int msgId; }public class MessageInfo { public string key; public int msgId; public int listSize; pub...
在unity中使用Newtonsoft.Json
热门推荐
mrzhengttl的博客
05-11 2万+
由于unity（目前是用unity5.5）目前最高支持.net framework 版本是3.5，所以无法直接通过NuGet导入Newtonsoft.Json来使用。 可以访问GitHub下载相应的支持Unity的Newtonsoft.Json资源包，导入即可使用。(https://github.com/SaladLab/Json.Net.Unity3D/releases)  导入后如下图所示
Unity中使用Newtonsoft反序列化Json的一些基本操作
qq_37421018的博客
10-16 4846
 声明： 本帖仅为个人学习笔记，且本人表达可能不准确，如有帮助最好不过，写得不好请见谅，另欢迎各位大佬补充和纠错，多谢支持 关于Newtonsoft： 官网地址：https://www.newtonsoft.com/json/help/html/SerializingJSON.htm（里面有一些例子，方便各位去学习） json在线编辑器地址：http://www.bejson.com/ol...
Unity使用Newtonsoft报错的解决方案
qq_53126706的博客
11-26 1万+
文章目录Unity 使用 Newtonsoft 报错的解决方案问题描述解决方法 Unity 使用 Newtonsoft 报错的解决方案 问题描述 由于最近在做人机交互课的实验，主要开发工具选择了 Unity3D 。在处理 Json 数据时，出现了一些问题。 我是通过 Newtonsoft.Json 这个包来处理 Json 的。 using Newtonsoft.Json; using Newtonsoft.Json.Linq; 在 Visual Studio 中，编写代码并没有报错，但是进入 Unity3
游戏引擎phaser.js3的使用之玩家和静态物理组碰撞
m0_61177996的博客
08-16 599
游戏引擎phaser.js3的使用之玩家和静态物理组碰撞
5G智慧农业大数据数字乡村乡村振兴整体建设方案.pdf
最新发布
08-24
5G智慧农业大数据数字乡村乡村振兴整体建设方案.pdf
unity中背包系统实现
03-23
在 Unity 中实现背包系统，可以使用数据结构来存储背包中的物品，比如使用数组或列表来存储物品的 ID 和数量。同时，可以使用 UI 组件来展示背包中的物品，比如使用 Grid Layout Group 来排列物品格子，使用 Image ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值