Unity3D学习笔记（二十六）：MVC框架下的背包系统（1）

MVC背包

需求：

1、背包格子的装备是可以拖动的

2、装备栏的装备也是可以拖动的

3、当背包格子的装备拖动到装备栏时，如果是装备类型和装备栏类型是一致的能装上

4、背包的装备是按照顺序放在格子中的，有分页的功能

5、每件装备上有物品的属性加成

6、人物有基本的属性和装备加成的属性，界面显示就是基本属性+ 加成属性（绿色标识）

7、当你拖动背包的装备时，对应能装备该物品的装备栏要提示

8、不光需要拖动才能装备，鼠标右键点击装备也能装备或卸下

9、背包是通过负重来显示装备的多少的

10、背包的装备拖动到非背包区域，可以销毁

11、鼠标悬停装备时，显示装备的属性信息

12、一件整理，把相同类型的装备放在一起（考虑权重）

13、一件出售

MVC结构

Model（数据层）

1、每一件装备需要一个类来存储属性信息

2、人物的基本属性，和身上的装备，装备的加成需要一个类来存储

3、背包里的装备和背包的负重需要一个类来存储

View（视图层）

1、每个格子是可以拖动装备的，对于背包的格子和装备栏的格子拖动的功能是一致的，但是拖动结束时的判断不一致，我们可以把共有的功能抽象出来一个基类，两个子类分别继承基类。

2、对于人物显示的界面，需要一个类来管理装备栏的装备，显示人物的属性。

3、需要一个背包的类来管理每个格子，显示页数，负重等信息。

4、当鼠标放在装备上时，显示装备的基本信息也需要一个类来做处理。

Control（控制层）

需要一个控制层来做数据的交换，删除等等

界面搭建

画布尺寸1920x1080

字体锚点

字体自适应10-20

限制列数，中心对齐

Model

ItemData，物品信息类

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4/// <summary>
5/// 该类用于存储装备的基本属性
6/// </summary>
7[System.Serializable]
8public class ItemData
9{
10    #region 私有变量
11    [SerializeField]
12    private int id;//作为物品的唯一标识
13    [SerializeField]
14    private string itemName;//物品的名字
15    [SerializeField]
16    private string iconName;//物品显示图片的名字
17    [SerializeField]
18    private float atk;//攻击力加成
19    [SerializeField]
20    private float def;//防御力加成
21    [SerializeField]
22    private float thump;//暴击率加成
23    [SerializeField]
24    private float hp;//血量加成
25    [SerializeField]
26    private float mp;//加成
27    [SerializeField]
28    private float anger;//怒气加成
29    [SerializeField]
30    private float weight;//重量
31    [SerializeField]
32    private ItemType type;//物品的类型
33    #endregion
34    #region 属性
35    public int Id
36    {
37        get
38        {
39            return id;
40        }
41    }
42    public string ItemName
43    {
44        get
45        {
46            return itemName;
47        }
48    }
49    public string IconName
50    {
51        get
52        {
53            return iconName;
54        }
55    }
56    public float Atk
57    {
58        get
59        {
60            return atk;
61        }
62    }
63    public float Def
64    {
65        get
66        {
67            return def;
68        }
69    }
70    public float Thump
71    {
72        get
73        {
74            return thump;
75        }
76    }
77    public float Hp
78    {
79        get
80        {
81            return hp;
82        }
83    }
84    public float Mp
85    {
86        get
87        {
88            return mp;
89        }
90    }
91    public float Anger
92    {
93        get
94        {
95            return anger;
96        }
97    }
98    public float Weight
99    {
100        get
101        {
102            return weight;
103        }
104    }
105    public ItemType Type
106    {
107        get
108        {
109            return type;
110        }
111    }
112    #endregion
113    #region 构造函数
114    public ItemData() { }
115    public ItemData(int id, string itemName, string iconName, float atk,
116        float def, float thump, float hp, float mp, float anger, float weight, ItemType type)
117    {
118        this.id = id;
119        this.itemName = itemName;
120        this.iconName = iconName;
121        this.atk = atk;
122        this.def = def;
123        this.thump = thump;
124        this.hp = hp;
125        this.mp = mp;
126        this.anger = anger;
127        this.weight = weight;
128        this.type = type;
129    }
130    #endregion
131}

ItemType，物品类型类

1/// <summary>
2/// 物品的类型, 装备栏能装备的类型
3/// </summary>
4public enum ItemType
5{
6    Weapon,//武器
7    Cap,//头盔
8    Armour,//铠甲
9    Ring,//戒指
10    Belt,//腰带
11    Necklace,//项链
12    Shoe,//鞋子
13    Headwear,//头饰
14}

PlayerData，角色装备类

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4public class PlayerData
5{
6    #region 单例
7    private static PlayerData instance;//这个数据类的单例，从文件中反序列化来的
8    public static PlayerData Instance
9    {
10        get
11        {
12            return instance;
13        }
14    }
15    private PlayerData() { }
16    /// <summary>
17    /// 对单例进行赋值
18    /// </summary>
19    /// <param name="data"></param>
20    public static void SetInstance(PlayerData data)
21    {
22        if (null == data)
23        {
24            instance = new PlayerData();
25        }
26        else
27        {
28            instance = data;
29        }
30    }
31    #endregion
32    #region 私有变量
33    [SerializeField]
34    private List<ItemData> items;//人物身上穿戴的装备
35    [SerializeField]
36    private float atk;//基础攻击力
37    [SerializeField]
38    private float def;//基础防御力
39    [SerializeField]
40    private float thump;//基础暴击率
41    [SerializeField]
42    private float hp;//基础血量
43    [SerializeField]
44    private float mp;//基础魔法
45    [SerializeField]
46    private float anger;//基础怒气
47    //装备的属性加成都是装备的装备计算出来的
48    private float addAtk;//装备攻击力加成
49    private float addDef;//
50    private float addThump;//
51    private float addHp;//
52    private float addMp;//
53    private float addAnger;//
54    #endregion
55    #region 属性
56    public float Atk
57    {
58        get
59        {
60            return atk;
61        }
62    }
63    public float Def
64    {
65        get
66        {
67            return def;
68        }
69    }
70    public float Thump
71    {
72        get
73        {
74            return thump;
75        }
76    }
77    public float Hp
78    {
79        get
80        {
81            return hp;
82        }
83    }
84    public float Mp
85    {
86        get
87        {
88            return mp;
89        }
90    }
91    public float Anger
92    {
93        get
94        {
95            return anger;
96        }
97    }
98    public float AddAtk
99    {
100        get
101        {
102            return addAtk;
103        }
104    }
105    public float AddDef
106    {
107        get
108        {
109            return addDef;
110        }
111    }
112    public float AddThump
113    {
114        get
115        {
116            return addThump;
117        }
118    }
119    public float AddHp
120    {
121        get
122        {
123            return addHp;
124        }
125    }
126    public float AddMp
127    {
128        get
129        {
130            return addMp;
131        }
132    }
133    public float AddAnger
134    {
135        get
136        {
137            return addAnger;
138        }
139    }
140    public List<ItemData> Items
141    {
142        get
143        {
144            return items;
145        }
146    }
147    #endregion
148    #region 提供一些访问或删除装备的方法
149    /// <summary>
150    /// 通过装备的ID来访问装备
151    /// </summary>
152    /// <param name="id"></param>
153    /// <returns></returns>
154    public ItemData GetItem(int id)
155    {
156        return null;
157    }
158    /// <summary>
159    /// 通过装备的类型来访问装备
160    /// </summary>
161    /// <param name="type"></param>
162    /// <returns></returns>
163    public ItemData GetItem(ItemType type)
164    {
165        return null;
166    }
167    /// <summary>
168    /// 添加装备
169    /// </summary>
170    /// <param name="data"></param>
171    public void AddItem(ItemData data)
172    {
173    }
174    /// <summary>
175    /// 删除装备
176    /// </summary>
177    /// <param name="data"></param>
178    public void RemoveItem(ItemData data)
179    {
180    }
181    /// <summary>
182    /// 通过ID删除装备
183    /// </summary>
184    /// <param name="id"></param>
185    public void RemoveItem(int id)
186    {
187    }
188    /// <summary>
189    /// 通过装备类型删除装备
190    /// </summary>
191    /// <param name="type"></param>
192    public void RemoveItem(ItemType type)
193    {
194    }
195    #endregion
196    public void Init()
197    {
198        UpdateAdditionData();
199    }
200    /// <summary>
201    /// 计算装备的加成数据, 每次当数据发生改变的时候调用
202    /// </summary>
203    void UpdateAdditionData()
204    {
205        this.addAtk = 0;
206        this.addDef = 0;
207        this.addThump = 0;
208        this.addHp = 0;
209        this.addMp = 0;
210        this.addAnger = 0;
211        //把每一件装备的加成数据加给实际的数据
212        for (int i = 0; i < items.Count; i++)
213        {
214            this.addAtk += items[i].Atk;
215            this.addDef += items[i].Def;
216            this.addThump += items[i].Thump;
217            this.addHp += items[i].Hp;
218            this.addMp += items[i].Mp;
219            this.addAnger += items[i].Anger;
220        }
221    }
222}

BagData，背包物品类

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4public class BagData
5{
6    #region 单例
7    private static BagData instance;//从文件中反序列化来的
8    public static BagData Instance
9    {
10        get
11        {
12            return instance;
13        }
14    }
15    private BagData() { }
16    public static void SetInstance(BagData data)
17    {
18        if (data == null)
19        {
20            data = new BagData();
21            data.items = new List<ItemData>();
22        }
23        else
24        {
25            instance = data;
26        }
27    }
28    #endregion
29    #region 私有变量
30    [SerializeField]
31    private List<ItemData> items;//当前的所有的装备
32    [SerializeField]
33    private float maxCapacity;//最大容量, 从文件中读取进来的
34    private float currentCapacity;//当前容量, 根据当前背包的装备计算出来的
35    #endregion
36    #region 属性
37    public float MaxCapacity
38    {
39        get
40        {
41            return maxCapacity;
42        }
43    }
44    public float CurrentCapacity
45    {
46        get
47        {
48            return currentCapacity;
49        }
50    }
51    public List<ItemData> Items
52    {
53        get
54        {
55            return items;
56        }
57    }
58    #endregion
59    #region 提供一些操作背包装备的方法
60    /// <summary>
61    /// 使用ID访问背包中的装备
62    /// </summary>
63    /// <param name="id"></param>
64    /// <returns></returns>
65    public ItemData GetItem(int id)
66    {
67        return null;
68    }
69    /// <summary>
70    /// 添加装备
71    /// </summary>
72    /// <param name="id"></param>
73    public void AddItem(ItemData data)
74    {
75    }
76    /// <summary>
77    /// 删除装备
78    /// </summary>
79    /// <param name="data"></param>
80    public void RemoveItem(ItemData data)
81    {
82    }
83    /// <summary>
84    /// 删除指定ID的装备
85    /// </summary>
86    /// <param name="id"></param>
87    public void RemoveItem(int id)
88    {
89    }
90    #endregion
91    public void UpdateCurrentCapacity()
92    {
93        currentCapacity = 0;
94        //把每一件装备的负重累加在一起，就是当前的负重
95        for (int i = 0; i < items.Count; i++)
96        {
97            currentCapacity += items[i].Weight;
98        }
99    }
100}

View：人物界面UI：属性，装备

GridBase，格子基类

PlayerGridUI，格子子类-玩家

BagGridUI，格子子类-背包

PlayerUI，玩家界面

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4using UnityEngine.UI;
5public class PlayerUI : MonoBehaviour {
6    private GridBase[] grids;//所有的装备栏
7    //所有显示属性的Text
8    private Text atkText;
9    private Text defText;
10    private Text thumpText;
11    private Text hpText;
12    private Text mpText;
13    private Text angerText;
14    void Awake()
15    {
16        //在子物体里获取所有的GridBase这个组件，返回的是一个数组
17        grids = gameObject.GetComponentsInChildren<GridBase>();
18        atkText = transform.Find("MessageUI/Message/AtkText").GetComponent<Text>();
19        defText = transform.Find("MessageUI/Message/DefText").GetComponent<Text>();
20        thumpText = transform.Find("MessageUI/Message/ThumpText").GetComponent<Text>();
21        hpText = transform.Find("MessageUI/Message/HPText").GetComponent<Text>();
22        mpText = transform.Find("MessageUI/Message/MPText").GetComponent<Text>();
23        angerText = transform.Find("MessageUI/Message/AngerText").GetComponent<Text>();
24        //新建Json的小技巧
25        //ItemData data = new ItemData();
26        //Debug.Log(JsonUtility.ToJson(data, true));
27    }
28    private void Start()
29    {
30        UpdatePanel();
31    }
32    /// <summary>
33    /// 更新界面的方法
34    /// </summary>
35    void UpdatePanel()
36    {
37        //把人物身上装备的物品显示， 所有属性显示
38        atkText.text = "攻击力：" + PlayerData.Instance.Atk + "<color=\"green\"> + "
39            + PlayerData.Instance.AddAtk + "</color>";
40        defText.text = "防御力：" + PlayerData.Instance.Def + "<color=\"green\"> + "
41            + PlayerData.Instance.AddDef + "</color>";
42        thumpText.text = "暴击率：" + PlayerData.Instance.Thump + "<color=\"green\"> + "
43            + PlayerData.Instance.AddThump + "</color>";
44        hpText.text = "生命值：" + PlayerData.Instance.Hp + "<color=\"green\"> + "
45            + PlayerData.Instance.AddHp + "</color>";
46        mpText.text = "魔法值：" + PlayerData.Instance.Mp + "<color=\"green\"> + "
47            + PlayerData.Instance.AddMp + "</color>";
48        angerText.text = "怒气值：" + PlayerData.Instance.Anger + "<color=\"green\"> + "
49            + PlayerData.Instance.AddAnger + "</color>";
50    }
51}

BagUI，背包UI

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4using UnityEngine.UI;
5public class BagUI : MonoBehaviour {
6    private GridBase[] grids;
7    private Text weightText;
8    private Text numText;
9    private Button rightButton;
10    private Button leftButton;
11    private Button clearUpButton;
12    private int currentNum;
13    private int maxNum;//根据背包里物品数量与当前有多少个格子比较
14    void Awake()
15    {
16        //获取所有的格子
17        grids = gameObject.GetComponentsInChildren<GridBase>();
18        weightText = transform.Find("Capacity/Text").GetComponent<Text>();
19        numText = transform.Find("Page/PageNum/Text").GetComponent<Text>();
20        rightButton = transform.Find("Page/RightButton").GetComponent<Button>();
21        leftButton = transform.Find("Page/LeftButton").GetComponent<Button>();
22        clearUpButton = transform.Find("ClearUpButton").GetComponent<Button>();
23        //按钮注册事件
24        rightButton.onClick.AddListener(RightClick);
25        leftButton.onClick.AddListener(LeftClick);
26        clearUpButton.onClick.AddListener(ClearUpClick);
27    }
28    private void Start()
29    {
30        //maxNum = (int)Mathf.Ceil(BagData.Instance.Items.Count / (float)grids.Length);
31        currentNum = 1;//界面一开始，当前页是1
32        //UpdatePanel();
33    }
34    /// <summary>
35    /// 更新界面
36    /// </summary>
37    void UpdatePanel()
38    {
39        //更新当前页数的物品， 更新当前页数， 更新当前的负重
40        //计算当前的最大页数
41        maxNum = (int)Mathf.Ceil(BagData.Instance.Items.Count / (float)grids.Length);
42        weightText.text = "负重：" + BagData.Instance.CurrentCapacity + "/" +
43            BagData.Instance.MaxCapacity;
44        numText.text = currentNum + "/" + maxNum;
45        //显示当前的页数的物品
46        //根据当前页数，确定第一个位置应该排背包数据的里的第几个索引（起始索引）
47        //模拟 格子: 20   当第一页是起始索引为0， 当第二页时起始索引为20
48        int startIndex = (currentNum - 1) * grids.Length;//（当前页数 - 1） * 格子数量
49        //把从起始索引开始，依次的把物品放在对应的格子上
50        for (int i = 0; i < grids.Length; i++)
51        {
52            //当i= 0时，证明是第一个格子，对应的物品索引 startIndex = startIndex + i
53            //当i= 1时，证明是第二各格子，对应的物品索引 startIndex + 1 =  startIndex + i
54            //....
55            //当i = grids.Length - 1时， 最后一个格子， 对应的物品索引 startIndex + grids.Length - 1 =  startIndex + i
56            //如果startIndex + i 超出了物品的数量， 证明这个格子没有物品
57            //如果startIndex + i 没有超出物品的数量， 这个这个格子有物品
58            if (startIndex + i >= BagData.Instance.Items.Count)
59            {
60                //超出了物品的数量，该格子没有物品
61                grids[i].UpdateItem(-1, "");
62            }
63            else
64            {
65                grids[i].UpdateItem(BagData.Instance.Items[startIndex + i].Id,
66                    BagData.Instance.Items[startIndex + i].IconName);
67            }
68        }
69    }
70    /// <summary>
71    /// 翻页的右按钮
72    /// </summary>
73    void RightClick()
74    {
75        Debug.Log("RightClick");
76    }
77    /// <summary>
78    /// 翻页的左按钮
79    /// </summary>
80    void LeftClick()
81    {
82        Debug.Log("LeftClick");
83    }
84    /// <summary>
85    /// 整理按钮
86    /// </summary>
87    void ClearUpClick()
88    {
89        Debug.Log("ClearUpClick");
90    }
91}

GridBase

1using System;
2using System.Collections;
3using System.Collections.Generic;
4using UnityEngine;
5using UnityEngine.UI;
6using UnityEngine.EventSystems;
7public class GridBase : MonoBehaviour,
8    IPointerEnterHandler,
9    IPointerExitHandler,
10    IPointerClickHandler,
11    IBeginDragHandler,
12    IDragHandler,
13    IEndDragHandler
14{
15    public int itemID = -1;// 规定-1  那么这个格子空的
16    public Transform tempParent;//拖动时临时的父物体
17    private Image image;//显示装备的图片
18    private Vector2 outPos;//转换之后的坐标
19    private Vector2 offset;//鼠标偏移量
20    private RectTransform parentRT;
21    protected void Init()
22    {
23        image = transform.Find("Item").GetComponent<Image>();
24        image.raycastTarget = false;
25        parentRT = tempParent as RectTransform;
26    }
27    /// <summary>
28    /// 更新自己本身的物品
29    /// </summary>
30    /// <param name="itemID"></param>
31    /// <param name="iconName"></param>
32    public void UpdateItem(int itemID, string iconName)
33    {
34        if (this.itemID == itemID)
35        {
36            return;
37        }
38        this.itemID = itemID;
39        if (itemID < 0)//没有物品
40        {
41            image.enabled = false;
42        }
43        else
44        {
45            image.enabled = true;
46            if (image.sprite.name != iconName)
47            {
48                Sprite sp = Resources.Load<Sprite>("Texture/Icon/" + iconName);
49                image.sprite = sp;
50            }
51        }
52    }
53    #region 接口的虚方法
54    //开始拖动的虚方法
55    protected virtual void BeginDrag(PointerEventData eventData)
56    {
57        //Debug.Log("父类：BeginDrag");
58        //image.transform.parent = tempParent;
59        image.transform.SetParent(tempParent);
60        if (RectTransformUtility.ScreenPointToLocalPointInRectangle(parentRT,
61            eventData.position, eventData.enterEventCamera, out outPos))
62        {
63            offset = outPos - new Vector2(image.transform.localPosition.x, image.transform.localPosition.y);
64        }
65    }
66    //拖动的虚方法
67    protected virtual void Drag(PointerEventData eventData)
68    {
69        //Debug.Log("父类：Drag");
70        if (RectTransformUtility.ScreenPointToLocalPointInRectangle(parentRT,
71            eventData.position, eventData.enterEventCamera, out outPos))
72        {
73            image.transform.localPosition = outPos - offset;
74        }
75    }
76    //拖动结束时的虚方法
77    protected virtual void EndDrag(PointerEventData eventData)
78    {
79        //Debug.Log("父类：EndDrag");
80        //image.transform.parent = transform;
81        image.transform.SetParent(transform);
82        image.transform.localPosition = Vector3.zero;
83    }
84    //点击的虚方法
85    protected virtual void Click(PointerEventData eventData)
86    {
87        //Debug.Log("父类：Click");
88    }
89    //进入的虚方法
90    protected virtual void Enter(PointerEventData eventData)
91    {
92        //Debug.Log("父类：Enter");
93        //Debug.Log("显示信息");
94    }
95    //出去的虚方法
96    protected virtual void Exit(PointerEventData eventData)
97    {
98        //Debug.Log("父类：Exit");
99        //Debug.Log("隐藏信息");
100    }
101    #endregion
102    #region 实现的接口
103    public void OnBeginDrag(PointerEventData eventData)
104    {
105        BeginDrag(eventData);
106    }
107    public void OnDrag(PointerEventData eventData)
108    {
109        Drag(eventData);
110    }
111    public void OnEndDrag(PointerEventData eventData)
112    {
113        EndDrag(eventData);
114    }
115    public void OnPointerClick(PointerEventData eventData)
116    {
117        Click(eventData);
118    }
119    public void OnPointerEnter(PointerEventData eventData)
120    {
121        Enter(eventData);
122    }
123    public void OnPointerExit(PointerEventData eventData)
124    {
125        Exit(eventData);
126    }
127    #endregion
128}

PlayerGridUI

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4using UnityEngine.UI;
5using UnityEngine.EventSystems;
6public class PlayerGridUI : GridBase
7{
8    public ItemType gridType;
9    private Text text;
10    // Use this for initialization
11    void Awake()
12    {
13        base.Init();
14        text = transform.Find("Text").GetComponent<Text>();
15        gameObject.tag = "PlayerGrid";
16    }
17    protected override void Click(PointerEventData eventData)
18    {
19        if (eventData.button == PointerEventData.InputButton.Right)
20        {
21            Debug.Log("卸下： " + itemID);
22        }
23    }
24    protected override void EndDrag(PointerEventData eventData)
25    {
26        base.EndDrag(eventData);
27        if (eventData.pointerCurrentRaycast.gameObject != null &&
28            eventData.pointerCurrentRaycast.gameObject.CompareTag("BagGrid"))
29        {
30            Debug.Log("卸下装备");
31        }
32    }
33}

BagGridUI

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4using UnityEngine.EventSystems;
5public class BagGridUI : GridBase
6{
7    void Awake()
8    {
9        base.Init();
10        gameObject.tag = "BagGrid";
11    }
12    protected override void Click(PointerEventData eventData)
13    {
14        if (eventData.button == PointerEventData.InputButton.Right)
15        {
16            Debug.Log("装备： " + itemID);
17        }
18    }
19    protected override void EndDrag(PointerEventData eventData)
20    {
21        base.EndDrag(eventData);
22        if (eventData.pointerCurrentRaycast.gameObject == null)//当拖出背包区域时
23        {
24            Debug.Log("卖出物品");
25        }
26        else if (eventData.pointerCurrentRaycast.gameObject.CompareTag("PlayerGrid"))
27        {
28            Debug.Log("装备物品");
29        }
30    }
31}

Json：StreamingAssets -> Json -> PlayerData -> UTF-8

SaveManeger

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4public class SaveManager
5{
6    #region 单例
7    private static SaveManager instance;
8    public static SaveManager Instance
9    {
10        get
11        {
12            if (null == instance)
13            {
14                instance = new SaveManager();
15            }
16            return instance;
17        }
18    }
19    private SaveManager() { }
20    #endregion
21    /// <summary>
22    /// 初始化数据
23    /// </summary>
24    public void InitData()
25    {
26        //初始化人物的数据
27        string playerJson = FileTools.ReadJson(Application.streamingAssetsPath + "/Json/PlayerData.txt");
28        if (playerJson == "")
29        {
30            PlayerData.SetInstance(null);
31        }
32        else
33        {
34            PlayerData.SetInstance(JsonUtility.FromJson<PlayerData>(playerJson));
35        }
36        PlayerData.Instance.Init();
37        ////初始化背包数据
38        //string bagJson = FileTools.ReadJson(Application.streamingAssetsPath + "/Json/Bag.txt");
39        //if (bagJson == "")
40        //{
41        //    BagData.SetInstance(null);
42        //}
43        //else
44        //{
45        //    BagData.SetInstance(JsonUtility.FromJson<BagData>(bagJson));
46        //}
47        //BagData.Instance.UpdateCurrentCapacity();//更新一次负重
48    }
49    /// <summary>
50    /// 保存数据
51    /// </summary>
52    public void SaveData()
53    {
54    }
55}

GameManeger

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4public class GameManager : MonoBehaviour
5{
6    // Use this for initialization
7    void Awake()
8    {
9        DontDestroyOnLoad(gameObject);
10        SaveManager.Instance.InitData();
11    }
12    // Update is called once per frame
13    void OnDestroy()
14    {
15        SaveManager.Instance.SaveData();
16    }
17}

FileTools

1using System.Collections;
2using System.Collections.Generic;
3using UnityEngine;
4using System.IO;
5using System.Text;
6public static class FileTools
7{
8    /// <summary>
9    /// 读取指定路径的json文件
10    /// </summary>
11    /// <param name="path"></param>
12    /// <returns></returns>
13    public static string ReadJson(string path)
14    {
15        if (!File.Exists(path))
16        {
17            return "";
18        }
19        string json = "";
20        StreamReader sr = new StreamReader(path, Encoding.UTF8);
21        try
22        {
23            json = sr.ReadToEnd();
24        }
25        catch (System.Exception e)
26        {
27            Debug.Log(e.ToString());
28        }
29        sr.Close();
30        return json;
31    }
32    /// <summary>
33    /// 把json写入指定的文件a
34    /// </summary>
35    /// <param name="path"></param>
36    /// <param name="json"></param>
37    public static void WriteJson(string path, string json)
38    {
39        if (!File.Exists(path))
40        {
41            FileStream fs = File.Create(path);
42            fs.Close();
43        }
44        StreamWriter sw = new StreamWriter(path, false, Encoding.UTF8);
45        try
46        {
47            sw.Write(json);
48        }
49        catch (System.Exception e)
50        {
51            Debug.Log(e.ToString());
52        }
53        sw.Close();
54    }
55}