【unity框架开发12】从零手搓unity存档存储数据持久化系统，实现对存档的创建，获取，保存，加载，删除，缓存，加密，支持多存档

已于 2024-10-11 20:03:37 修改
阅读量1.8k 收藏 29
点赞数 22
分类专栏： unity框架开发 文章标签： unity 缓存 开发语言 游戏引擎 存储 持久化 存档
于 2024-10-10 08:48:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36303853/article/details/142797499
版权

文章目录

前言

游戏存档不言而喻，是游戏设计中的重要元素，可以提高游戏的可玩性，为玩家提供更多的自由和控制权。

我们主要是实现对存档的创建，获取，保存，加载，删除，缓存，加密，支持多存档。存档有两类，一类是用户型存档，存储着某个游戏用户具体的信息，如血量，武器，游戏进度，一类是设置型存档，与任何用户存档都无关，是通用的存储信息，比如屏幕分辨率、音量设置等。

存档文件支持很多数据类似，这里我选择Json，可读性较强，易修改。

一、Unity对Json数据的操作

方法一、JsonUtility

它是Unty引擎中提供的一个用于序列化和反序列化JSON数据的工具类，该类提供了三个方法。

第一个函数ToJson可以将可序列化的对象转换为JSON字符串
第二个可选参数表示是否花费更多的性能将字符转换为更适合阅读的方式

//通过JS0N表示形式创建对象
string json = JsonUtility.ToJson(object obj, bool prettyPrint);

第二个函数FromJson可以将字符转换为对象
Playerlnfo是一个泛型参数，用于指定要将JSoN字符串转换为的对象类型

//生成对象的公共字段的JS0N表示形式
PlayerInfo playerInfo = JsonUtility.FromJson<PlayerInfo>(string json);

第三个函数则可以传入新的数据覆盖到已有对象中，而不是创建新的对象，在频繁读取数据时可以节省开销

//通过读取对象的JS0N表示形式覆盖其数据
JsonUtility.FromJsonOverwrite(string json, object objectTooverwrite);

方法二、Newtonsoft

前面使用JsonUtility进行json转化，遇到字典等无法序列化的数据是存不进去的，这里推荐使用Newtonsoft类库进行转化，可以很好解决这个问题。

安装插件支持
在这里插入图片描述

转换用户数据为JSON字符串

string jsonData = JsonConvert.SerializeObject(playerInfo);

将JSON字符串转换为unity对象数据

PlayerInfo playerInfo = JsonConvert.DeserializeObject<PlayerInfo>(jsonData);

二、持久化的数据路径

Application.persistentDataPath是一个持久化的数据路径，在不同的操作系统上，unity会为我们分配不同的持久化数据路径，这样可以确保应用程序在不同平台上都能正确保存和访问

//设置存档文件路径
savePath = Path.Combine(Application.persistentDataPath, "saveData.json");

不同平台存储的路径不一样，我们可以打印savePath查看自己的存储路径

比如我的就是
在这里插入图片描述

三、数据加密/解密

这里实现一个简单的加密和解密方法，使用了字符的异或（XOR）操作。

// 定义密钥字符
public static char[] keyChars = { 'a', 'b', 'c', 'd', 'e' };

// 加密方法
public static string Encrypt(string data)
{
    char[] dataChars = data.ToCharArray();
    for (int i = 0; i < dataChars.Length; i++)
    {
        char dataChar = dataChars[i];
        char keyChar = keyChars[i % keyChars.Length];
        // 重点： 通过亦或得到新的字符
        char newChar = (char)(dataChar ^ keyChar);
        dataChars[i] = newChar;
    }
    return new string(dataChars);
}

// 解密方法
public static string Decrypt(string data)
{
    return Encrypt(data);
}

加密方法

  • Encrypt 方法接收一个字符串 data 作为输入。
  • 将输入字符串转换为字符数组 dataChars。
  • 使用一个 for 循环遍历每个字符：
    • dataChar 是当前字符。
    • keyChar 是从密钥字符数组中获取的字符，使用 i % keyChars.Length 确保循环使用密钥字符，即如果数据长度超过密钥长度，会重复使用密钥。
    • newChar 是通过 dataChar 和 keyChar 的异或操作得到的新字符。异或操作的特点是相同的字符异或结果为0，而不同的字符异或结果为1，因此可以用这个特性进行简单的加密。
      最后将加密后的字符数组重新转换为字符串并返回。

解密方法

  • Decrypt 方法实际上调用了 Encrypt 方法。由于异或操作的特性，调用两次相同的异或操作可以恢复原始数据。因此，加密和解密过程是相同的。

四、条件编译指令限制仅在编辑器模式下进行加密/解密

为了保证数据的可读性，我们可能不希望在编辑器模式下，数据还被加密了，这样会影响我们测试

我们可以使用#if UNITY_EDITOR 条件编译指令，用于在 Unity 中编写代码时进行特定的编译和执行控制。这段代码只会在 Unity 编辑器中编译和执行，而不会在构建后的游戏中包含。这意味着你可以在编辑器环境中添加一些特定的功能，比如自定义工具、调试信息等，而这些功能在最终发布的版本中不会出现。

示例用法

#if !UNITY_EDITOR

// 放置加密/解密操作，这段代码不会在 Unity 编辑器中编译和执行

#endif

四、数据持久化管理器

1、存档工具类

/// <summary>
/// 存档工具类
/// </summary>
public static class IOTool
{
    // 定义密钥字符
    public static char[] keyChars = { 'x', 'y', 'f', 'r', 'a', 'm', 'e' };

    /// <summary>
    /// 保存Json数据
    /// </summary>
    /// <param name="saveObject">保存的对象</param>
    /// <param name="path">路径</param>
    public static void SaveJson(object saveObject, string path)
    {
        // string jsonData = JsonUtility.ToJson(saveObject);
        string jsonData = JsonConvert.SerializeObject(saveObject);
#if !UNITY_EDITOR
        jsonData = Encrypt(jsonData);//加密
#endif
        File.WriteAllText(path, jsonData);
    }

    /// <summary>
    /// 读取Json为指定的类型对象
    /// </summary>
    public static T LoadJson<T>(string path) where T : class
    {
        if (!File.Exists(path))
        {
            return null;
        }
        string jsonData = File.ReadAllText(path);
#if !UNITY_EDITOR
        jsonData = Decrypt(jsonData);//解密
#endif
        // return JsonUtility.FromJson<T>(jsonData);
        return JsonConvert.DeserializeObject<T>(jsonData);
    }

    /// <summary>
    /// 加密方法
    /// </summary>
    public static string Encrypt(string data)
    {
        char[] dataChars = data.ToCharArray();
        for (int i = 0; i < dataChars.Length; i++)
        {
            char dataChar = dataChars[i];
            char keyChar = keyChars[i % keyChars.Length];
            // 重点： 通过亦或得到新的字符
            char newChar = (char)(dataChar ^ keyChar);
            dataChars[i] = newChar;
        }
        return new string(dataChars);
    }

    /// <summary>
    /// 解密方法
    /// </summary>
    public static string Decrypt(string data)
    {
        return Encrypt(data);
    }
}

2、一个存档数据

/// <summary>
/// 一个存档数据
/// </summary>
[Serializable]
public class SaveItem
{
     // 存档ID
    public int saveID;

    // 私有字段，最后保存时间
    private DateTime lastSaveTime;

    // 公共属性，获取最后保存时间
    public DateTime LastSaveTime
    {
        get
        {
            // 如果 lastSaveTime 是默认值，则尝试将字符串解析为 DateTime
            if (lastSaveTime == default(DateTime))
            {
                DateTime.TryParse(lastSaveTimeString, out lastSaveTime);
            }
            return lastSaveTime; // 返回最后保存时间
        }
    }

    // 用于持久化的字符串，Json不支持 DateTime 类型
    [SerializeField] private string lastSaveTimeString;

    // 构造函数，初始化存档ID和最后保存时间
    public SaveItem(int saveID, DateTime lastSaveTime)
    {
        this.saveID = saveID; // 设置存档ID
        this.lastSaveTime = lastSaveTime; // 设置最后保存时间
        lastSaveTimeString = lastSaveTime.ToString(); // 将 DateTime 转换为字符串
    }

    // 更新最后保存时间
    public void UpdateTime(DateTime lastSaveTime)
    {
        this.lastSaveTime = lastSaveTime; // 更新最后保存时间
        lastSaveTimeString = lastSaveTime.ToString(); // 将新的 DateTime 转换为字符串
    }
}

3、存档系统数据类

/// <summary>
/// 存档系统数据类
/// </summary>
[Serializable]
public class SaveSystemData
{
    // 当前的存档ID
    public int currID = 0;
    // 所有存档的列表
    public List<SaveItem> saveItemList = new List<SaveItem>();
}

4、数据存档存储持久化管理器

/// <summary>
/// 数据存档存储持久化管理器
/// </summary>
public class SaveManager : Singleton<SaveManager>
{
    private SaveSystemData saveSystemData;//存档系统数据

    // 存档的保存
    private const string saveDirName = "saveData";
    // 设置的保存：1.全局数据的保存（分辨率、按键设置） 2.存档的设置保存。
    // 常规情况下，存档系统自行维护
    private const string settingDirName = "setting";

    // 存档文件夹路径
    private string saveDirPath = Application.persistentDataPath + "/" + saveDirName;
    private string settingDirPath = Application.persistentDataPath + "/" + settingDirName;

    // 存档中对象的缓存字典 
    // <存档ID,<文件名称，实际的对象>>
    private Dictionary<int, Dictionary<string, object>> cacheDic = new Dictionary<int, Dictionary<string, object>>();

    #region 初始化
    public SaveManager()
    {
        Debug.Log("存储管理器初始化成功");
        Init();
    }
    public void Init()
    {
        //检查路径并创建目录
        CheckAndCreateDir();
        // 初始化SaveSystemData
        InitSaveSystemData();
        // 清除存档缓存
        CleanCache();
    }
    #endregion

    #region 保存、获取全局设置存档
    /// <summary>
    /// 加载设置，全局生效，不关乎任何一个存档
    /// </summary>
    public T LoadSetting<T>(string fileName) where T : class
    {
        return LoadFile<T>(settingDirPath + "/" + fileName);
    }
    /// <summary>
    /// 加载设置，全局生效，不关乎任何一个存档
    /// </summary>
    public T LoadSetting<T>() where T : class
    {
        return LoadSetting<T>(typeof(T).Name);
    }
    /// <summary>
    /// 保存设置，全局生效，不关乎任何一个存档
    /// </summary>
    public void SaveSetting(object saveObject, string fileName)
    {
        SaveFile(saveObject, settingDirPath + "/" + fileName);
    }

    /// <summary>
    /// 保存设置，全局生效，不关乎任何一个存档
    /// </summary>
    public void SaveSetting(object saveObject)
    {
        SaveSetting(saveObject, saveObject.GetType().Name);
    }

    /// <summary>
    /// 删除所有设置存档
    /// </summary>
    public void DeleteAllSetting()
    {
        if (Directory.Exists(settingDirPath))
        {
            // 直接删除目录
            Directory.Delete(settingDirPath, true);
        }
        CheckAndCreateDir();
    }
    #endregion

     #region 创建、获取、删除某一项用户存档
    /// <summary>
    /// 获取SaveItem
    /// </summary>
    public SaveItem GetSaveItem(int id)
    {
        for (int i = 0; i < saveSystemData.saveItemList.Count; i++)
        {
            if (saveSystemData.saveItemList[i].saveID == id)
            {
                return saveSystemData.saveItemList[i];
            }
        }
        return null;
    }
    /// <summary>
    /// 获取SaveItem
    /// </summary>
    public SaveItem GetSaveItem(SaveItem saveItem)
    {
        GetSaveItem(saveItem.saveID);
        return null;
    }

    /// <summary>
    /// 添加一个存档
    /// </summary>
    /// <returns></returns>
    public SaveItem CreateSaveItem()
    {
        SaveItem saveItem = new SaveItem(saveSystemData.currID, DateTime.Now);
        saveSystemData.saveItemList.Add(saveItem);
        saveSystemData.currID += 1;
        // 更新SaveSystemData 写入磁盘
        UpdateSaveSystemData();
        return saveItem;
    }

    /// <summary>
    /// 删除存档
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteSaveItem(int saveID)
    {
        string itemDir = GetSavePath(saveID, false);
        // 如果路径存在 且 有效
        if (itemDir != null)
        {
            // 把这个存档下的文件递归删除
            Directory.Delete(itemDir, true);
        }
        saveSystemData.saveItemList.Remove(GetSaveItem(saveID));
        // 移除缓存
        RemoveCache(saveID);
        // 更新SaveSystemData 写入磁盘
        UpdateSaveSystemData();
    }
    /// <summary>
    /// 删除存档
    /// </summary>
    public void DeleteSaveItem(SaveItem saveItem)
    {
        DeleteSaveItem(saveItem.saveID);
    }
    #endregion

    #region 保存、获取、删除用户存档中某一对象
    /// <summary>
    /// 保存对象至某个存档中
    /// </summary>
    /// <param name="saveObject">要保存的对象</param>
    /// <param name="saveFileName">保存的文件名称</param>
    /// <param name="saveID">存档的ID</param>
    public void SaveObject(object saveObject, string saveFileName, int saveID = 0)
    {
        // 存档所在的文件夹路径
        string dirPath = GetSavePath(saveID, true);
        // 具体的对象要保存的路径
        string savePath = dirPath + "/" + saveFileName;
        // 具体的保存
        SaveFile(saveObject, savePath);
        // 更新存档时间
        GetSaveItem(saveID).UpdateTime(DateTime.Now);
        // 更新SaveSystemData 写入磁盘
        UpdateSaveSystemData();

        // 更新缓存
        SetCache(saveID, saveFileName, saveObject);

    }

    /// <summary>
    /// 保存对象至某个存档中
    /// </summary>
    /// <param name="saveObject">要保存的对象</param>
    /// <param name="saveFileName">保存的文件名称</param>
    public void SaveObject(object saveObject, string saveFileName, SaveItem saveItem)
    {
        SaveObject(saveObject, saveFileName, saveItem.saveID);
    }
    /// <summary>
    /// 保存对象至某个存档中
    /// </summary>
    /// <param name="saveObject">要保存的对象</param>
    /// <param name="saveID">存档的ID</param>
    public void SaveObject(object saveObject, int saveID = 0)
    {
        SaveObject(saveObject, saveObject.GetType().Name, saveID);
    }
    /// <summary>
    /// 保存对象至某个存档中
    /// </summary>
    /// <param name="saveObject">要保存的对象</param>
    /// <param name="saveID">存档的ID</param>
    public void SaveObject(object saveObject, SaveItem saveItem)
    {
        SaveObject(saveObject, saveObject.GetType().Name, saveItem);
    }

    /// <summary>
    /// 从某个具体的存档中加载某个对象
    /// </summary>
    /// <typeparam name="T">要返回的实际类型</typeparam>
    /// <param name="saveFileName">文件名称</param>
    /// <param name="id">存档ID</param>
    public T LoadObject<T>(string saveFileName, int saveID = 0) where T : class
    {
        T obj = GetCache<T>(saveID, saveFileName);
        if (obj == null)
        {
            // 存档所在的文件夹路径
            string dirPath = GetSavePath(saveID);
            if (dirPath == null) return null;
            // 具体的对象要保存的路径
            string savePath = dirPath + "/" + saveFileName;
            obj = LoadFile<T>(savePath);
            SetCache(saveID, saveFileName, obj);
        }
        return obj;
    }

    /// <summary>
    /// 从某个具体的存档中加载某个对象
    /// </summary>
    /// <typeparam name="T">要返回的实际类型</typeparam>
    /// <param name="saveFileName">文件名称</param>
    public T LoadObject<T>(string saveFileName, SaveItem saveItem) where T : class
    {
        return LoadObject<T>(saveFileName, saveItem.saveID);
    }


    /// <summary>
    /// 从某个具体的存档中加载某个对象
    /// </summary>
    /// <typeparam name="T">要返回的实际类型</typeparam>
    /// <param name="id">存档ID</param>
    public T LoadObject<T>(int saveID = 0) where T : class
    {
        return LoadObject<T>(typeof(T).Name, saveID);
    }

    /// <summary>
    /// 从某个具体的存档中加载某个对象
    /// </summary>
    /// <typeparam name="T">要返回的实际类型</typeparam>
    /// <param name="saveItem">存档项</param>
    public T LoadObject<T>(SaveItem saveItem) where T : class
    {
        return LoadObject<T>(typeof(T).Name, saveItem.saveID);
    }

    /// <summary>
    /// 删除某个存档中的某个对象
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteObject<T>(string saveFileName, int saveID) where T : class
    {
        //清空缓存中对象
        if (GetCache<T>(saveID, saveFileName) != null)
        {
            RemoveCache(saveID, saveFileName);
        }
        // 存档对象所在的文件路径
        string dirPath = GetSavePath(saveID);
        string savePath = dirPath + "/" + saveFileName;
        //删除对应的文件
        File.Delete(savePath);

    }

    /// <summary>
    /// 删除某个存档中的某个对象
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteObject<T>(string saveFileName, SaveItem saveItem) where T : class
    {
        DeleteObject<T>(saveFileName, saveItem.saveID);
    }

    /// <summary>
    /// 删除某个存档中的某个对象
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteObject<T>(int saveID) where T : class
    {
        DeleteObject<T>(typeof(T).Name, saveID);
    }

    /// <summary>
    /// 删除某个存档中的某个对象
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteObject<T>(SaveItem saveItem) where T : class
    {
        DeleteObject<T>(typeof(T).Name, saveItem.saveID);
    }
    #endregion

    #region 获取、删除所有用户存档

    /// <summary>
    /// 获取所有存档
    /// 最新的在最后面
    /// </summary>
    /// <returns></returns>
    public List<SaveItem> GetAllSaveItem()
    {
        return saveSystemData.saveItemList;
    }

    /// <summary>
    /// 获取所有存档
    /// 创建最新的在最前面
    /// </summary>
    /// <returns></returns>
    public List<SaveItem> GetAllSaveItemByCreatTime()
    {
        List<SaveItem> saveItems = new List<SaveItem>(saveSystemData.saveItemList.Count);

        for (int i = 0; i < saveSystemData.saveItemList.Count; i++)
        {
            saveItems.Add(saveSystemData.saveItemList[saveSystemData.saveItemList.Count - (i + 1)]);
        }
        return saveItems;
    }

    /// <summary>
    /// 获取所有存档
    /// 最新更新的在最上面
    /// </summary>
    /// <returns></returns>
    public List<SaveItem> GetAllSaveItemByUpdateTime()
    {
        List<SaveItem> saveItems = new List<SaveItem>(saveSystemData.saveItemList.Count);
        for (int i = 0; i < saveSystemData.saveItemList.Count; i++)
        {
            saveItems.Add(saveSystemData.saveItemList[i]);
        }
        OrderByUpdateTimeComparer orderBy = new OrderByUpdateTimeComparer();
        saveItems.Sort(orderBy);
        return saveItems;
    }

    private class OrderByUpdateTimeComparer : IComparer<SaveItem>
    {
        public int Compare(SaveItem x, SaveItem y)
        {
            if (x.LastSaveTime > y.LastSaveTime)
            {
                return -1;
            }
            else
            {
                return 1;
            }
        }
    }

    /// <summary>
    /// 获取所有存档
    /// 万能解决方案
    /// </summary>
    public List<SaveItem> GetAllSaveItem<T>(Func<SaveItem, T> orderFunc, bool isDescending = false)
    {
        if (isDescending)
        {
            return saveSystemData.saveItemList.OrderByDescending(orderFunc).ToList();
        }
        else
        {
            return saveSystemData.saveItemList.OrderBy(orderFunc).ToList();
        }

    }

    /// <summary>
    /// 删除所有用户存档信息
    /// </summary>
    public void DeleteAllSaveItem()
    {
        if (Directory.Exists(saveDirPath))
        {            
            // 直接删除目录
            Directory.Delete(saveDirPath, true);
        }
        CheckAndCreateDir();
        InitSaveSystemData();
    }

    /// <summary>
    /// 删除所有存档信息
    /// </summary>
    public void DeleteAll()
    {
        CleanCache();
        DeleteAllSaveItem();
        DeleteAllSetting();
    }
    #endregion

    #region 更新、获取、删除用户存档缓存
    /// <summary>
    /// 设置缓存
    /// </summary>
    /// <param name="saveID">存档ID</param>
    /// <param name="fileName">文件名称</param>
    /// <param name="saveObject">要缓存的对象</param>
    private void SetCache(int saveID, string fileName, object saveObject)
    {
        // 缓存字典中是否有这个SaveID
        if (cacheDic.ContainsKey(saveID))
        {
            // 这个存档中有没有这个文件
            if (cacheDic[saveID].ContainsKey(fileName))
            {
                cacheDic[saveID][fileName] = saveObject;
            }
            else
            {
                cacheDic[saveID].Add(fileName, saveObject);
            }
        }
        else
        {
            cacheDic.Add(saveID, new Dictionary<string, object>() { { fileName, saveObject } });
        }
    }

    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="saveID">存档ID</param>
    /// <param name="saveObject">要缓存的对象</param>
    private T GetCache<T>(int saveID, string fileName) where T : class
    {
        // 缓存字典中是否有这个SaveID
        if (cacheDic.ContainsKey(saveID))
        {
            // 这个存档中有没有这个文件
            if (cacheDic[saveID].ContainsKey(fileName))
            {
                return cacheDic[saveID][fileName] as T;
            }
            else
            {
                return null;
            }
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 移除缓存
    /// </summary>
    private void RemoveCache(int saveID)
    {
        cacheDic.Remove(saveID);
    }

    /// <summary>
    /// 移除缓存中的某一个对象
    /// </summary>
    private void RemoveCache(int saveID, string fileName)
    {
        cacheDic[saveID].Remove(fileName);
    }

    /// <summary>
    /// 清除存档缓存
    /// </summary>
    public void CleanCache()
    {
        cacheDic.Clear();
    }
    #endregion

    #region 内部工具函数
    /// <summary>
    /// 获取存档系统数据
    /// </summary>
    /// <returns></returns>
    private void InitSaveSystemData()
    {
        saveSystemData = LoadFile<SaveSystemData>(saveDirPath + "/SaveSystemData");
        if (saveSystemData == null)
        {
            saveSystemData = new SaveSystemData();
            UpdateSaveSystemData();
        }
    }

    /// <summary>
    /// 更新存档系统数据
    /// </summary>
    private void UpdateSaveSystemData()
    {
        SaveFile(saveSystemData, saveDirPath + "/SaveSystemData");
    }

    /// <summary>
    /// 检查路径并创建目录
    /// </summary>
    private void CheckAndCreateDir()
    {
        // 确保路径的存在
        if (Directory.Exists(saveDirPath) == false)
        {
            Directory.CreateDirectory(saveDirPath);
        }
        if (Directory.Exists(settingDirPath) == false)
        {
            Directory.CreateDirectory(settingDirPath);
        }
    }

    /// <summary>
    /// 获取某个存档的路径
    /// </summary>
    /// <param name="saveID">存档ID</param>
    /// <param name="createDir">如果不存在这个路径，是否需要创建</param>
    /// <returns></returns>
    private string GetSavePath(int saveID, bool createDir = true)
    {
        // 验证是否有某个存档
        if (GetSaveItem(saveID) == null) Debug.LogWarning("saveID 存档不存在！");

        string saveDir = saveDirPath + "/" + saveID;
        // 确定文件夹是否存在
        if (Directory.Exists(saveDir) == false)
        {
            if (createDir)
            {
                Directory.CreateDirectory(saveDir);
            }
            else
            {
                return null;
            }
        }

        return saveDir;
    }

    /// <summary>
    /// 保存文件
    /// </summary>
    /// <param name="saveObject">保存的对象</param>
    /// <param name="path">保存的路径</param>
    private void SaveFile(object saveObject, string path)
    {
        IOTool.SaveJson(saveObject, path);
    }

    /// <summary>
    /// 加载文件
    /// </summary>
    /// <typeparam name="T">加载后要转为的类型</typeparam>
    /// <param name="path">加载路径</param>
    private T LoadFile<T>(string path) where T : class
    {
        return IOTool.LoadJson<T>(path);
    }
    #endregion
}

5、测试调用

// GameSetting类中存储着游戏名称，作为全局数据
[Serializable]
public class GameSetting
{
    public string gameName;
}

[Serializable]
public class GameSetting2
{
    public string gameName;
}

public class SaveTest : MonoBehaviour {
    GameSetting gameSetting;
    GameSetting2 gameSetting2;
    SaveItem saveItem;
    Dictionary<string, string> info = new Dictionary<string,string>();
    private void Awake() {
        //添加测试数据
        gameSetting = new GameSetting();
        gameSetting.gameName = "测试";

        gameSetting2 = new GameSetting2();
        gameSetting2.gameName = "测试2"; 
    }

    private void OnGUI()
    {
        GUIStyle buttonStyle = new GUIStyle(GUI.skin.button);   
        buttonStyle.fontSize = 25; // 设置字体大小
        int width = 400;
        int height = 150;

        //设置型存档 
        if (GUI.Button(new Rect(0, 0, width, height), "保存设置数据1", buttonStyle))
        {
            SaveManager.Instance.SaveSetting(gameSetting);
        }
        if (GUI.Button(new Rect(0, height, width, height), "追加设置数据2", buttonStyle))
        {
            SaveManager.Instance.SaveSetting(gameSetting2);
        }
        if (GUI.Button(new Rect(0, height*2, width, height), "加载设置数据1", buttonStyle))
        {
            string gameName = SaveManager.Instance.LoadSetting<GameSetting>().gameName;
            Debug.Log("gameName: " + gameName);
        }
        if (GUI.Button(new Rect(0, height*3, width, height), "删除设置存档", buttonStyle))
        {
            SaveManager.Instance.DeleteAllSetting();
        }

        //用户存档
        if (GUI.Button(new Rect(width, 0, width, height), "添加一个存档", buttonStyle))
        {
            saveItem = SaveManager.Instance.CreateSaveItem();
        }
        if (GUI.Button(new Rect(width, height, width, height), "保存用户存档数据1", buttonStyle))
        {
            info["name"] = "小明";
            info["age"] = "15";
            info["heright"] = "180";
            SaveManager.Instance.SaveObject(info, saveItem);
        }
        if (GUI.Button(new Rect(width, height*2, width, height), "追加数据2", buttonStyle))
        {
            SaveManager.Instance.SaveObject(gameSetting, saveItem);
        }
        if (GUI.Button(new Rect(width, height*3, width, height), "打印用户存档数据1", buttonStyle))
        {
            Dictionary<string, string> info = SaveManager.Instance.LoadObject<Dictionary<string, string>>(saveItem);
            Debug.Log("姓名：" + info["name"] + "，年龄：" + info["age"] + "，身高：" + info["heright"]);
        }
        if (GUI.Button(new Rect(width, height*4, width, height), "获取所有用户存档", buttonStyle))
        {
            SaveManager.Instance.GetAllSaveItem();//最新的在最后面
            SaveManager.Instance.GetAllSaveItemByCreatTime();//最近创建的在最前面
            SaveManager.Instance.GetAllSaveItem();//最近更新的在最前面
        }

        //删除用户存档
        if (GUI.Button(new Rect(width*2, 0, width, height), "删除用户存档数据1", buttonStyle))
        {
            SaveManager.Instance.DeleteObject<Dictionary<string, string>>(saveItem);
        }

        if (GUI.Button(new Rect(width*2, height, width, height), "删除所有用户存档", buttonStyle))
        {
            SaveManager.Instance.DeleteAllSaveItem();
        }
        if (GUI.Button(new Rect(width*2, height*2, width, height), "删除某一个用户存档", buttonStyle))
        {
            SaveManager.Instance.DeleteSaveItem(saveItem);
        }

        //删除所有存档 用户+设置
        if (GUI.Button(new Rect(width*3, 0, width, height), "删除所有存档", buttonStyle))
        {
            SaveManager.Instance.DeleteAll();
        }
    }
}

运行效果
在这里插入图片描述

SaveData和setting分别存储用户存档和设置型存档。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
用户存档下根据saveID分成若干文件夹用于存储具体的对象。

完结

赠人玫瑰，手有余香！如果文章内容对你有所帮助，请不要吝啬你的点赞评论和关注，你的每一次支持都是我不断创作的最大动力。当然如果你发现了文章中存在错误或者有更好的解决方法，也欢迎评论私信告诉我哦！

好了，我是向宇，https://xiangyu.blog.csdn.net

一位在小公司默默奋斗的开发者，闲暇之余，边学习边记录分享，站在巨人的肩膀上，通过学习前辈们的经验总是会给我很多帮助和启发！如果你遇到任何问题，也欢迎你评论私信或者加群找我， 虽然有些问题我也不一定会，但是我会查阅各方资料，争取给出最好的建议，希望可以帮助更多想学编程的人，共勉~
在这里插入图片描述

Unity简单的存档系统
ranger_desk的博客
01-28 538
这里使用了const关键字是因为const关键字限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性。JsonUtility只能将带可序列化的public，[SerializeField]private转化为json格式。一个简单的计数器，点击加号数字加一，点击减号数字减一，一个存档按钮一个读档按钮。使用Unity的JsonUtility来进行存储和读取存档。创建存档系统脚本（包含加号的方法和减号的方法）1.创建一个文件保存的路径。可以看到存档系统正常运行。
unity的存档方式
菜菜的程序媛的博客
08-19 851
停止游戏的时间： //时间缩放比例，0暂停游戏的时间,1开始         Time.timeScale = 0; //unity存储方法的储存 //保存音乐开关的状态，0代表关闭状态，1开启             PlayerPrefs.SetInt(PreKey.MUSICON, 1); //unity的PlayerPrefs存储方法的读取   if (PlayerPre...
Unity3D游戏开发数据持久化PlayerPrefs的用法详解
12-31
小编今天研究了在Unity3D中的数据持久化问题。数据持久化在任何一个开发领域都是一个值得关注的问题，小到一个应用中配置文件的读写，大到数据库的管理维护，都可以看到数据持久化的身影。小编在《C#基于Linq和反射实现数据持久化框架Xml4DB》这篇文章中曾介绍了博主在寒假期间开发的Xml4DB框架，这是一个基于Xml的轻量级数据持久化框架，可以采用面向对象的方式来处理数据。数据持久化从某种意义上来说，就是序列化和反序列化化的过程。在.NET中我们可以将对象序列化为Xml、Json、二进制。然后通过反序列化重新获得对象。同样，在Android中我们可以通过使用Preferences来存储键值型数
Unity实现游戏存档框架
08-25
主要为大家详细介绍了Unity实现游戏存档框架，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
[Unity存档系统]简单介绍Unity常见存档系统二JSON以及使用方法
dangoxiba的博客
05-20 5251
学习目标： 如果你和我同样苦恼于游戏相关的数据怎么存储与读取，那么不妨看看这个up主有关Unity存档系统的教程。[Unity] 存档系统 Part 1 | PlayerPrefs | Unity初学者系列教程 | 数据存取 | 存档读档 | Save&Load_哔哩哔哩_bilibili在本视频中你将学到Unity引擎中三种常见的数据存储方式中的第一种：PlayerPrefs主要内容：什么是PlayerPrefs如何使用PlayerPrefsPlayerPrefs的优缺点以及适用范围构建一个基.
Unity学习笔记_简易的存档系统
最新发布
2301_80342725的博客
08-27 1937
存档系统是一个游戏必不可少的组成，这里会说明如何创建一个简易的存档系统。
Unity简单本地存档系统
m0_73087695的博客
01-12 2771
因为一边备考一边钻研这个存档系统，所以考试没考好，研究也没研究出什么。但是收获还是很多，由于是个人的总结笔记，文中出现的任何觉得有问题的点请随时找我。下面就是我自己对存档系统的总结：涉及到的现在这个系统只是一个雏形，而且仅适用于本地，对于数据库端的存储应该截然不同，好在我目前只需要用到这种程度。对于进一步对该系统的构建有大致几个可能和设想：1.更换JsonUtility为其他上限更高的序列化具体方法，或者完善JsonUtility的不足，比如不能存储字典之类的嵌套数据类型。
Unity 3D 存档实现
zhhf96的博客
09-01 1788
今天想和大家分享的内容是RPG游戏中游戏存档的实现，因为最近在做一个RPG游戏的项目，所以遇到这个问题就随时记录下来，在对知识进行总结的同时可以将这种思路或者想法分享给大家，这是一件快乐而幸运的事情。我讨厌写按部就班的技术教程，因为我觉得学习是一种自我的探索行为，如果一切都告诉你了，探索的过程便会变得没有意义了。 游戏存档是一种在单机游戏中特别常见的机制，这种机制是你在玩网络游戏的时候无法体
[Unity存档系统]简单介绍Unity常见存档系统之一PlayerPrefs以及使用方法
dangoxiba的博客
05-20 7991
学习目标： 如果你和我同样苦恼于游戏相关的数据怎么存储与读取，那么不妨看看这个up主有关Unity存档系统的教程。[Unity] 存档系统 Part 1 | PlayerPrefs | Unity初学者系列教程 | 数据存取 | 存档读档 | Save&Load_哔哩哔哩_bilibili在本视频中你将学到Unity引擎中三种常见的数据存储方式中的第一种：PlayerPrefs主要内容：什么是PlayerPrefs如何使用PlayerPrefsPlayerPrefs的优缺点以及适用范围构建一个.
Unity游戏存档与读档
qq_62947569的博客
03-01 5138
Unity的读档与存档
Unity存储介绍
03-18
Unity做为EMC中端存储阵列的最新成员，旨在为中小企业IT部门提供经济实惠的文件级和块级存储。相比较与上一代VNX2中端存储，Unity在多个方面进行了升级换代，其中包括使用最新的硬件设备以提供更强的性能，通过统一存储资源池的方式简化设备的复杂度，引入新的64位文件系统架构提高文件系统的扩展性等等。
unity 数据持久化 json 存档与读档
04-10
通过unity JsonUtility 将信息存储，借助存档列表查看并读取存档
Unity3D之游戏场景的切换与持久化简单数据的储存
11-08
Unity3D之游戏场景的切换与持久化简单数据的储存，Unity最新的场景切换形式，以及实现PlayerPrefs数据的保存与读取。
untiy 移动端持久化保存数据Demo.unitypackage
10-27
unity 移动端持久化保存数据demo,有一个简单的数据加密功能, 在demo场景里有个案例
Unity游戏开发之游戏存档方式
hfh1999的博客
04-09 5717
介绍了Unity目前使用中的集中游戏存档的方式
[Unity][存档]
BuladeMian的博客，菜得抠脚，菜得真实
08-11 542
      InstanceID是每个物体唯一的ID。 因此存档 读档的时候 都是可以用来识别物体的 存储内容。 gameObject.GetInstanceID()            
Unity简易存档系统实现
D_lxl的博客
03-15 1143
首先，先上源码，解释项目结构，后面再讲每个类、结构体和函数的作用源代码分两个类：ArchiveManager.cs和ArchiveSO.cs此文件包含一个单例：ArchiveManager，两个结构体定义：ArchiveData、SceneData一个接口：IArchive三个拓展类：SceneDataExtension、ArchiveDataExtension、ComponentExtension此文件包含一个继承SciptableObject的类：ArchiveSO。
unity存储系统(Save)
weixin_44746864的博客
12-30 1056
unity存储系统
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

向宇it

创作不易，感谢你的鼓励

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值