Unity简易存档系统实现

已于 2023-03-16 16:34:45 修改
阅读量1k 收藏 11
点赞数 3
文章标签： unity 游戏引擎
于 2023-03-15 08:47:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D_lxl/article/details/129538074
版权

 

此文章已废弃，存档系统已经做了很多修改。

源码

首先，先上源码，解释项目结构，后面再讲每个类、结构体和函数的作用

源代码分两个类：ArchiveManager.cs和ArchiveSO.cs

ArchiveManager.cs



using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using UnityEditor;
using UnityEngine;
using UnityEngine.SceneManagement;

public class ArchiveManager : MonoBehaviour
{

    #region 成员、属性

    #region 静态
    private static ArchiveManager instance;
    public static ArchiveManager Instance { get => instance; }
    public static ArchiveData CurrentArchive = ArchiveData.None;
    public static Scene CurrentScene;
    public ArchiveData SceneBuffer = new ArchiveData("Buffer","Buffer");
    #endregion

    #region 非静态
    [SerializeField]
    private ArchiveSO ArchiveSoData;

    #endregion

    #endregion
    #region 生命周期

    private void Awake()
    {
        InstanceInit();
    }

    private void OnEnable()
    {
        SceneManager.sceneUnloaded += SceneUnloaded;
        SceneManager.sceneLoaded += SceneLoaded;
    }


    private void OnDisable()
    {
        SceneManager.sceneUnloaded -= SceneUnloaded;
        SceneManager.sceneLoaded -= SceneLoaded;
    }

    #endregion
    #region 单例

    /// <summary>
    /// 实现单例
    /// </summary>
    private void InstanceInit()
    {
        if (instance != null)
        {
            Destroy(this);
        }
        instance = this;
        
        DontDestroyOnLoad(this);
    }
    #endregion
    /// <summary>
    /// 卸载场景前，对场景所有物体进行遍历，将其值存到缓存结构体中
    /// </summary>
    /// <param name="scene"></param>
    private void SceneUnloaded(Scene scene)
    {
        //TODO：装载场景里所有GameObject到缓存池中
        var objs = GameObject.FindObjectsOfType<MonoBehaviour>().OfType<IArchive>();
        SceneData sceneData = new SceneData(scene.name);
        foreach (var archive in objs)
        {
            long id = archive.GetComponent().GetOnlyID();
            string value = archive.Save();
            sceneData.SaveValue(id,value);
        }
        SceneBuffer.SaveValue(scene,sceneData);

    }
    /// <summary>
    /// 场景加载后，对场景所有物体进行遍历，调用接口赋值
    /// </summary>
    /// <param name="scene"></param>
    /// <param name="mode"></param>
    private void SceneLoaded(Scene scene, LoadSceneMode mode)
    {
        //TODO:加载数据到场景中
        if(CurrentArchive == ArchiveData.None)
            return;
        var sceneData = CurrentArchive.LoadValue(scene);
        if(sceneData == SceneData.None)
            return;
        var objs = GameObject.FindObjectsOfType<MonoBehaviour>().OfType<IArchive>();
        foreach (var archive in objs)
        {
            long key = archive.GetComponent().GetOnlyID();
            var value = sceneData.LoadValue(key);
            archive.Load(value);
        }

        CurrentScene = scene;
    }

    #region 函数
    /// <summary>
    /// 返回给UI去查看有哪些存档
    /// </summary>
    /// <returns></returns>
    public List<ArchiveData> GetArchiveList()
    {
        return ArchiveSoData.Archives;
    }

    public void LoadInIndex(int index)
    {
        if (index < 0 || index >= ArchiveSoData.Archives.Count)
        {
            Debug.LogError("下标不在范围内");
            return;
        }
        CurrentArchive = ArchiveSoData.Archives[index];
        CurrentArchive.ArchiveValue = CurrentArchive.FromJSON();
    }

    /// <summary>
    /// 保存为新存档
    /// </summary>
    public void SaveAsNew()
    {
        ArchiveSoData.Archives.Add(Save());
    }

    /// <summary>
    /// 替换存档
    /// </summary>
    /// <param name="index"></param>
    public void SaveInIndex(int index)
    {
        if(index < 0 || index >= ArchiveSoData.Archives.Count)
            return;
        ArchiveSoData.Archives[index] = Save();
    }

    /// <summary>
    /// 创建新档
    /// </summary>
    public void CreatAsNew()
    {
        CurrentArchive = ArchiveData.None;
    }
    private ArchiveData Save()
    {
        var data = new ArchiveData(String.Empty,SceneManager.GetActiveScene().name);
        //更新当前场景的数据到缓存中
        SceneUnloaded(SceneManager.GetActiveScene());
        data.ArchiveValue = SceneBuffer.ArchiveValue;
        data.ArchiveValueJSON = data.ToJSON();
        return data;
    }
    #endregion

}
/// <summary>
/// 单个场景存储的信息
/// </summary>
[Serializable]
public struct SceneData
{
    public static SceneData None = new SceneData() { SceneName = null };
    /// <summary>
    /// 场景名称
    /// </summary>
    public string SceneName;
    /// <summary>
    /// 储存的数据
    /// </summary>
    public Dictionary<long, string> sceneValue;
        
    public SceneData(string sceneName)
    {
        this.SceneName = sceneName;
        sceneValue = new Dictionary<long, string>();
    }

    public static bool operator ==(SceneData data1, SceneData data2)
    {
        if (data1.SceneName == data2.SceneName)
            return true;
        return false;
    }
    public static bool operator !=(SceneData data1, SceneData data2)
    {
        if (data1.SceneName == data2.SceneName)
            return false;
        return true;
    }
}
/// <summary>
/// 单个存档的信息
/// </summary>
[Serializable]
public struct ArchiveData
{
    public static ArchiveData None = new ArchiveData();
    /// <summary>
    /// 当前存档名
    /// </summary>
    public string ArchiveName;

    /// <summary>
    /// 存档最后一次存储时间
    /// </summary>
    public string CurrentTime;

    /// <summary>
    /// 存档所处的场景
    /// </summary>
    public string CurrentSceneName;
    [TextArea]
    public string ArchiveValueJSON;

    
    public Dictionary<string, SceneData> ArchiveValue;

    public ArchiveData(string archiveName,string sceneName)
    {
        ArchiveName = archiveName;
        CurrentTime = System.DateTime.Now.ToString();
        CurrentSceneName = sceneName;
        ArchiveValue = new Dictionary<string, SceneData>();
        ArchiveValueJSON = String.Empty;
    }
    public static bool operator ==(ArchiveData data1, ArchiveData data2)
    {
        if (data1.ArchiveName == data2.ArchiveName && data1.ArchiveValue == data2.ArchiveValue)
            return true;
        return false;
    }
    public static bool operator !=(ArchiveData data1, ArchiveData data2)
    {
        if (data1.ArchiveName == data2.ArchiveName && data1.ArchiveValue == data2.ArchiveValue)
            return false;
        return true;
    }
}


public static class SceneDataExtension
{
    public static void SaveValue(this SceneData data, Component component, string jsonValue)
    {
        long onlyID = component.GetOnlyID();
        data.SaveValue(onlyID,jsonValue);
    }
    public static void SaveValue(this SceneData data, long id, string jsonValue)
    {
        if (data.sceneValue.ContainsKey(id))
            data.sceneValue[id] = jsonValue;
        else
            data.sceneValue.Add(id,jsonValue);
    }

    public static string LoadValue(this SceneData data, Component component)
    {
        long id = component.GetOnlyID();
        return data.LoadValue(id);
    }

    public static string LoadValue(this SceneData data, long id)
    {
        if(!data.sceneValue.ContainsKey(id))
            return String.Empty;
        return data.sceneValue[id];
    }
}

public static class ArchiveDataExtension
{
    public static void SaveValue(this ArchiveData data,string sceneName,SceneData sceneData)
    {
        if (data.ArchiveValue.ContainsKey(sceneName))
            data.ArchiveValue[sceneName] = sceneData;
        else
            data.ArchiveValue.Add(sceneName,sceneData);
    }

    public static void SaveValue(this ArchiveData data, Scene scene, SceneData sceneData)
    {
        data.SaveValue(scene.name,sceneData);
    }

    public static SceneData LoadValue(this ArchiveData data,string sceneName)
    {
        if(!data.ArchiveValue.ContainsKey(sceneName))
            return SceneData.None;
        return data.ArchiveValue[sceneName];
    }

    public static SceneData LoadValue(this ArchiveData data, Scene scene)
    {
        return data.LoadValue(scene.name);
    }

    public static string ToJSON(this ArchiveData data)
    {
        string value = JsonConvert.SerializeObject(data.ArchiveValue);
        return value;
    }

    public static  Dictionary<string, SceneData> FromJSON(this ArchiveData data)
    {
        if(data.ArchiveValueJSON == String.Empty)
            return null;
        Dictionary<string, SceneData> datas =
            JsonConvert.DeserializeObject<Dictionary<string, SceneData>>(data.ArchiveValueJSON);
        return datas;
    }
}

public static class ComponentExtension
{
    public static long GetOnlyID(this Component component)
    {
        long onlyID = component.GetInstanceID() - component.gameObject.GetInstanceID();
        string s = onlyID.ToString() + component.GetLocalID();
        onlyID = Convert.ToInt64(s);
        return onlyID;
    }

    public static int GetLocalID(this Component component)
    {
        PropertyInfo info = typeof(SerializedObject).GetProperty("inspectorMode", BindingFlags.NonPublic | BindingFlags.Instance);
        SerializedObject sObj = new SerializedObject(component);
        info.SetValue(sObj, InspectorMode.Debug, null);
        SerializedProperty localIdProp = sObj.FindProperty("m_LocalIdentfierInFile");
        return localIdProp.intValue;
    }
}

public interface IArchive
{
    public void Load(string jsonValue);
    public string Save();
    public Component GetComponent();
}

 此文件包含

        一个单例：ArchiveManager，

        两个结构体定义：ArchiveData、SceneData

        一个接口：IArchive

        三个拓展类：SceneDataExtension、ArchiveDataExtension、ComponentExtension

ArchiveSO.cs

using System.Collections.Generic;
using UnityEngine;
[CreateAssetMenu(fileName = "ArchiveSO", menuName = "Data/ArchiveSO")]
public class ArchiveSO : ScriptableObject
{
    public List<ArchiveData> Archives = new List<ArchiveData>();
}

此文件包含

        一个继承SciptableObject的类：ArchiveSO

存储原理

        该系统本着可拓展，简易，低耦合的理念（实际上是我不会）

        其核心存储介质其实就是ScriptableObject，数据类型是Json。

        本来是打算用PlayerPrefs做存储介质，但项目开工前做技术调查发现，好像PlayerPrefs的SetString有点问题，且加上这个类是静态类不方便我管理和查看（可视化），所以最终使用ScriptableObject作为存储介质。

数据架构

从上往下

 

代码解释

SceneData(struct)

[Serializable]
public struct SceneData
{
    public static SceneData None = new SceneData() { SceneName = null };
    /// <summary>
    /// 场景名称
    /// </summary>
    public string SceneName;
    /// <summary>
    /// 储存的数据
    /// </summary>
    public Dictionary<long, string> sceneValue;
        
    public SceneData(string sceneName)
    {
        this.SceneName = sceneName;
        sceneValue = new Dictionary<long, string>();
    }

    public static bool operator ==(SceneData data1, SceneData data2)
    {
        if (data1.SceneName == data2.SceneName)
            return true;
        return false;
    }
    public static bool operator !=(SceneData data1, SceneData data2)
    {
        if (data1.SceneName == data2.SceneName)
            return false;
        return true;
    }
}

SceneData结构体主要用于存储单个场景里需要保存的信息，其主要由一个SceneName(string)记录场景名，和一个sceneValue(Dictionary<long, string>)字典，主要讲解一下这个字典存的什么东西。

public Dictionary<long, string> sceneValue

        在讲解这个字典前，我们需要先理清一下思路：

首先，我们使用

GameObject.FindObjectsOfType<MonoBehaviour>().OfType<IArchive>();

 查找场景内，所有实例中，带有继承了IArchive接口的组件的实例。

然后调用其接口，把每一个实例需要保存的JSON数据存在当前场景的SceneData的字典中。

那么问题来了，我们应该如何设置字典的key值，以达到每一个实例的每一个脚本（Component）都独一无二，能精准在字典里获取其独有的数据。

可能稍微了解过一点GameObject类的读者会想到，使用gameObject.Getinstance()作为字典的key值。

确实，在Unity编辑器的Inspector的Debug模式下，我们可以看到，一个GameObject的每个组件的InstanceID都是互不相同的。但我们需要注意一个点，我们这里的key，需要保证在整个项目里独一无二。但我们可以看官方API文档解释

618dd7f7605d4766963a0e82373d1b26.png

 这一句：The instance ID of an object is always unique.

翻译中文：对象的实例 ID 始终是唯一的。

只是看这句话，很多人可能都会和我一样被这句话误导，会以为每个对象的InstanceID在这个对象被创立的时候就固定不变了。

实际上不是的，如果我们单只开一个场景查看，不管怎么重启项目，移动实例，确实它的InstanceID始终是不变的，但如果我们尝试使用SceneManagment卸载加载场景，我们会发现它的InstanceID发生了改变。

如果读者愿意再去查查，会发现Unity的实例的InstanceID并不是固定存在，而是通过两个值计算而来：GUID、LocalID。

GUID读者可以自行百度，该系统没有使用到该属性就不做讲解。

如果我们再仔细查看，我们可以发现

314adfb605334f7ea2f8a71b133f078a.png

组件属性里有一个Local Identfier In File的属性，这个属性值无论怎么切换场景，重启项目，值都是不变的，根据官方说法，这个值是存在Asset下，至于具体怎么存的我们先不管。 然后就是我们可以看到这个值在整个GameObject中所有组件包括GameObject都是一样的，所以可以知道这个是指的GameObject实例的localID。

这个ID的获取，Unity并没有提供方法，我们需要使用C#的反射来获取

    public static int GetLocalID(this Component component)
    {
        PropertyInfo info = typeof(SerializedObject).GetProperty("inspectorMode", BindingFlags.NonPublic | BindingFlags.Instance);
        SerializedObject sObj = new SerializedObject(component);
        info.SetValue(sObj, InspectorMode.Debug, null);
        SerializedProperty localIdProp = sObj.FindProperty("m_LocalIdentfierInFile");
        return localIdProp.intValue;
    }

如此，我们就获取了GameObject实例的唯一ID。

接下来，我们需要解决的是，单个实例下，多个相同组件的唯一问题。

其实解决方法很简单，组件Component有自己的InstanceID，GameObject也有自己的InstanceID，这两者并不相同，而且通过实验，组件的id和组件附属的GameObject的id之间的差值，其实是固定的，也就是：

long onlyID = component.GetInstanceID() - component.gameObject.GetInstanceID()；

 这里使用long数据类型来储存，为后面的处理做准备。

然后将onlyID和LocalID组合一下，就得到该组件的唯一ID；

拓展方法如下

public static class ComponentExtension
{
    public static long GetOnlyID(this Component component)
    {
        long onlyID = component.GetInstanceID() - component.gameObject.GetInstanceID();
        string s = onlyID.ToString() + component.GetLocalID();
        onlyID = Convert.ToInt64(s);
        return onlyID;
        
    }

    public static int GetLocalID(this Component component)
    {
        PropertyInfo info = typeof(SerializedObject).GetProperty("inspectorMode", BindingFlags.NonPublic | BindingFlags.Instance);
        SerializedObject sObj = new SerializedObject(component);
        info.SetValue(sObj, InspectorMode.Debug, null);
        SerializedProperty localIdProp = sObj.FindProperty("m_LocalIdentfierInFile");
        return localIdProp.intValue;
    }
}

综上，sceneValue的key就可以确定好了。

然后就是value，文章开头已经解释了，该存档系统的存储数据格式就是JSON字符串，所以这里的value也就是字符串，不过是序列化成json格式的字符串。

SceneData函数拓展

public static class SceneDataExtension
{
    public static void SaveValue(this SceneData data, Component component, string jsonValue)
    {
        long onlyID = component.GetOnlyID();
        data.SaveValue(onlyID,jsonValue);
    }
    public static void SaveValue(this SceneData data, long id, string jsonValue)
    {
        if (data.sceneValue.ContainsKey(id))
            data.sceneValue[id] = jsonValue;
        else
            data.sceneValue.Add(id,jsonValue);
    }

    public static string LoadValue(this SceneData data, Component component)
    {
        long id = component.GetOnlyID();
        return data.LoadValue(id);
    }

    public static string LoadValue(this SceneData data, long id)
    {
        if(!data.sceneValue.ContainsKey(id))
            return String.Empty;
        return data.sceneValue[id];
    }
}

ArchiveData(Struct)

[Serializable]
public struct ArchiveData
{
    public static ArchiveData None = new ArchiveData();
    /// <summary>
    /// 当前存档名
    /// </summary>
    public string ArchiveName;

    /// <summary>
    /// 存档最后一次存储时间
    /// </summary>
    public string CurrentTime;

    /// <summary>
    /// 存档所处的场景
    /// </summary>
    public string CurrentSceneName;
    [TextArea]
    public string ArchiveValueJSON;

    
    public Dictionary<string, SceneData> ArchiveValue;

    public ArchiveData(string archiveName,string sceneName)
    {
        ArchiveName = archiveName;
        CurrentTime = System.DateTime.Now.ToString();
        CurrentSceneName = sceneName;
        ArchiveValue = new Dictionary<string, SceneData>();
        ArchiveValueJSON = String.Empty;
    }
    public static bool operator ==(ArchiveData data1, ArchiveData data2)
    {
        if (data1.ArchiveName == data2.ArchiveName && data1.ArchiveValue == data2.ArchiveValue)
            return true;
        return false;
    }
    public static bool operator !=(ArchiveData data1, ArchiveData data2)
    {
        if (data1.ArchiveName == data2.ArchiveName && data1.ArchiveValue == data2.ArchiveValue)
            return false;
        return true;
    }
}

ArchiveData结构体是单个存档的数据结构，内容和SceneData相似。

存档名称、存档最后一次存储时间、存档最后一次存储时的场景名称三个属性就不一一描述了，都是string类型，最后一个场景名称就是Scene.name，主要方便告诉场景管理器这个存档最后一次存储时所在的场景，如果游戏有需要，可以选择加载存档时加载到该场景。

主要讲解内容是

ArchiveValueJSON(string)
ArchiveValue(Dictionary<string, SceneData>)

可能会有读者会有疑惑，ArchiveValueJSON的作用是什么，不是已经有一个字典存数据了嘛。

这里就涉及到一个Unity理论知识，根据官方定义，Unity的ScriptableObject只能存储可序列化的数据，也就是那个标签[Serializable]。

熟悉Unity序列化的读者都知道，Unity的字典是没有被序列化的，可能会有人想到Odin的对字典序列化。

但我这里为了降低耦合度，非必要我是不会使用非官方插件，而且Odin的序列化只在Odin插件中有效，如果要存储到ScriptableObject中，可能需要重写一些东西（没仔细研究过Odin）。

所以，字典的数据最终是不会被存储到ScriptableObject中，所以这里我们使用Newtonsoft.Json库的Json序列化字典为json格式字符串并储存，读取时再取出来反序列化为字典。

ArchiveData函数拓展

public static class ArchiveDataExtension
{
    public static void SaveValue(this ArchiveData data,string sceneName,SceneData sceneData)
    {
        if (data.ArchiveValue.ContainsKey(sceneName))
            data.ArchiveValue[sceneName] = sceneData;
        else
            data.ArchiveValue.Add(sceneName,sceneData);
    }

    public static void SaveValue(this ArchiveData data, Scene scene, SceneData sceneData)
    {
        data.SaveValue(scene.name,sceneData);
    }

    public static SceneData LoadValue(this ArchiveData data,string sceneName)
    {
        if(!data.ArchiveValue.ContainsKey(sceneName))
            return SceneData.None;
        return data.ArchiveValue[sceneName];
    }

    public static SceneData LoadValue(this ArchiveData data, Scene scene)
    {
        return data.LoadValue(scene.name);
    }

    public static string ToJSON(this ArchiveData data)
    {
        string value = JsonConvert.SerializeObject(data.ArchiveValue);
        return value;
    }

    public static  Dictionary<string, SceneData> FromJSON(this ArchiveData data)
    {
        if(data.ArchiveValueJSON == String.Empty)
            return null;
        Dictionary<string, SceneData> datas =
            JsonConvert.DeserializeObject<Dictionary<string, SceneData>>(data.ArchiveValueJSON);
        return datas;
    }
}

ArchiveSO(ScriptableObject)

using System.Collections.Generic;
using UnityEngine;
[CreateAssetMenu(fileName = "ArchiveSO", menuName = "Data/ArchiveSO")]
public class ArchiveSO : ScriptableObject
{
    public List<ArchiveData> Archives = new List<ArchiveData>();
}

这个就没必要多解释，一个list列表。

ArchiveManager(MonoBehaviour)

public class ArchiveManager : MonoBehaviour
{
    // public ButtonFunction 保存存档;
    #region 成员、属性

    #region 静态
    private static ArchiveManager instance;
    public static ArchiveManager Instance { get => instance; }
    public static ArchiveData CurrentArchive = ArchiveData.None;
    public static Scene CurrentScene;
    public ArchiveData SceneBuffer = new ArchiveData("Buffer","Buffer");
    #endregion

    #region 非静态
    [SerializeField]
    private ArchiveSO ArchiveSoData;

    #endregion

    #endregion
    #region 生命周期

    private void Awake()
    {
        InstanceInit();
        // 保存存档 = new ButtonFunction(this,"保存新档", SaveAsNew);
    }

    private void OnEnable()
    {
        SceneManager.sceneUnloaded += SceneUnloaded;
        SceneManager.sceneLoaded += SceneLoaded;
    }


    private void OnDisable()
    {
        SceneManager.sceneUnloaded -= SceneUnloaded;
        SceneManager.sceneLoaded -= SceneLoaded;
    }

    #endregion
    #region 单例

    /// <summary>
    /// 实现单例
    /// </summary>
    private void InstanceInit()
    {
        if (instance != null)
        {
            Destroy(this);
        }
        instance = this;
        
        DontDestroyOnLoad(this);
    }
    #endregion
    /// <summary>
    /// 卸载场景前，对场景所有物体进行遍历，将其值存到缓存结构体中
    /// </summary>
    /// <param name="scene"></param>
    private void SceneUnloaded(Scene scene)
    {
        //TODO：装载场景里所有GameObject到缓存池中
        var objs = GameObject.FindObjectsOfType<MonoBehaviour>().OfType<IArchive>();
        SceneData sceneData = new SceneData(scene.name);
        foreach (var archive in objs)
        {
            long id = archive.GetComponent().GetOnlyID();
            string value = archive.Save();
            sceneData.SaveValue(id,value);
        }
        SceneBuffer.SaveValue(scene,sceneData);

    }
    /// <summary>
    /// 场景加载后，对场景所有物体进行遍历，调用接口赋值
    /// </summary>
    /// <param name="scene"></param>
    /// <param name="mode"></param>
    private void SceneLoaded(Scene scene, LoadSceneMode mode)
    {
        //TODO:加载数据到场景中
        if(CurrentArchive == ArchiveData.None)
            return;
        var sceneData = CurrentArchive.LoadValue(scene);
        if(sceneData == SceneData.None)
            return;
        var objs = GameObject.FindObjectsOfType<MonoBehaviour>().OfType<IArchive>();
        foreach (var archive in objs)
        {
            long key = archive.GetComponent().GetOnlyID();
            var value = sceneData.LoadValue(key);
            archive.Load(value);
        }

        CurrentScene = scene;
    }

    #region 函数
    /// <summary>
    /// 返回给UI去查看有哪些存档
    /// </summary>
    /// <returns></returns>
    public List<ArchiveData> GetArchiveList()
    {
        return ArchiveSoData.Archives;
    }

   

    /// <summary>
    /// 保存为新存档
    /// </summary>
    public void SaveAsNew()
    {
        ArchiveSoData.Archives.Add(Save());
    }

    /// <summary>
    /// 替换存档
    /// </summary>
    /// <param name="index"></param>
    public void SaveInIndex(int index)
    {
        if(index < 0 || index >= ArchiveSoData.Archives.Count)
            return;
        ArchiveSoData.Archives[index] = Save();
    }

    /// <summary>
    /// 创建新档
    /// </summary>
    public void LoadAsNew()
    {
        CurrentArchive = ArchiveData.None;
    }
     public void LoadInIndex(int index)
    {
        if (index < 0 || index >= ArchiveSoData.Archives.Count)
        {
            Debug.LogError("下标不在范围内");
            return;
        }
        CurrentArchive = ArchiveSoData.Archives[index];
        CurrentArchive.ArchiveValue = CurrentArchive.FromJSON();
    }
    private ArchiveData Save()
    {
        var data = new ArchiveData(String.Empty,SceneManager.GetActiveScene().name);
        //更新当前场景的数据到缓存中
        SceneUnloaded(SceneManager.GetActiveScene());
        data.ArchiveValue = SceneBuffer.ArchiveValue;
        data.ArchiveValueJSON = data.ToJSON();
        return data;
    }
    #endregion

}

ArchiveManager类作为管理类，其使用单例模式保证项目里只会有一个实例。

我们先讲该类的运行逻辑再根据逻辑衍生去讲属性和函数的意义。

程序逻辑

当我们新建存档后，就加载进游戏场景，然后根据游戏需求，可能会存在卸载场景，加载场景的步骤。根据官方api文档介绍，SceneManager.sceneUnloaded

SceneManager.sceneLoaded

两个事件分别对应场景卸载前和场景加载后(?加载后还有待商议，为进行大场景测试)。

根据我们的框架逻辑：场景卸载前遍历场景实例储存数据到临时的ArchiveData容器，场景加载后遍历场景实例加载当前存档数据到实例中。

于是我们就可以订阅这两个事件，让框架自动在切换场景时存储和加载数据。

PS，笔者能力、时间有限，为进行大场景测试，所有这里笔者推荐大家不要使用框架的自动读取加载，而是自己手动控制流程

如

 

然后介绍一下几个公共函数接口

GetArchiveList ：返回存档的列表

SaveAsNew ：保存为新建存档

SaveInIndex(int index)：替换存档列表里下标为index的存档为当前存档。

LoadAsNew：新建存档时调用此函数，重置存档管理器的临时存档。

LoadInIndex(int index)：加载下标index的存档

 

透明Loong
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Unity游戏存档和读档教程.rar
07-01
Unity游戏存档和读档教程.rar
Unity简单本地存档系统
m0_73087695的博客
01-12 2017
因为一边备考一边钻研这个存档系统，所以考试没考好，研究也没研究出什么。但是收获还是很多，由于是个人的总结笔记，文中出现的任何觉得有问题的点请随时找我。下面就是我自己对存档系统的总结：涉及到的现在这个系统只是一个雏形，而且仅适用于本地，对于数据库端的存储应该截然不同，好在我目前只需要用到这种程度。对于进一步对该系统的构建有大致几个可能和设想：1.更换JsonUtility为其他上限更高的序列化具体方法，或者完善JsonUtility的不足，比如不能存储字典之类的嵌套数据类型。
[Unity存档系统]简单介绍Unity常见存档系统之一PlayerPrefs以及使用方法
dangoxiba的博客
05-20 7509
学习目标： 如果你和我同样苦恼于游戏相关的数据怎么存储与读取，那么不妨看看这个up主有关Unity存档系统的教程。[Unity] 存档系统 Part 1 | PlayerPrefs | Unity初学者系列教程 | 数据存取 | 存档读档 | Save&Load_哔哩哔哩_bilibili在本视频中你将学到Unity引擎中三种常见的数据存储方式中的第一种：PlayerPrefs主要内容：什么是PlayerPrefs如何使用PlayerPrefsPlayerPrefs的优缺点以及适用范围构建一个.
Unity存档
gmf532196的专栏
08-25 5107
参考https://docs.unity3d.com/Manual/ExecutionOrder.html
Unity简单的存档系统
ranger_desk的博客
01-28 492
这里使用了const关键字是因为const关键字限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性。JsonUtility只能将带可序列化的public，[SerializeField]private转化为json格式。一个简单的计数器，点击加号数字加一，点击减号数字减一，一个存档按钮一个读档按钮。使用Unity的JsonUtility来进行存储和读取存档。创建存档系统脚本（包含加号的方法和减号的方法）1.创建一个文件保存的路径。可以看到存档系统正常运行。
unity实现简单抽奖系统
08-26
Unity实现简单抽奖系统 本文通过Unity引擎实现了一个简单的抽奖系统，系统具有随机抽奖、旋转指针、停止转动等功能。该系统使用了两张图片，一个指针和一个圆形图片，通过预制体和脚本实现了抽奖系统的逻辑。 知识...
Unity实现游戏存档框架
12-23
我在这里对实现方法进行简单的解析。注意这里主要演示算法，所以，效率上并不是最佳。一个游戏中，可能有成百上千个物体需要存储，而且有几十种类型，接下来就用一个简单的例子来解释。一个很简单的例子，有一个Unit...
Unity RTS建造系统资源源码
07-13
教程地址 ：https://www.bilibili.com/video/BV1b5411P7NE?spm_id_from=333.1007.top_right_bar_window_custom_collection.content.click 根据视频教程写的工程
Unity游戏存档与读档
qq_62947569的博客
03-01 4693
Unity的读档与存档
Unity进阶，Unity存档系统(Json可序列化存档,AES加密)
qq_63486332的博客
04-04 1262
我们知道Json有一个优点，那就是直观易读，但是在存档系统中，Json的这个有点将成为致命的缺点，那就是其他人也是易读的，这样就会造成一种结果，那就是存档后，将存档文件修改，就可以做到开G。JsonUtility可以将可序列对象转化为Json格式的文件，那么，使用JsonUtility搭建存档系统的核心思路就是。写一个函数，需要传递两个参数，一个是保存的存档文件的文件名，另一个是需要存档的数据文件，为object类型。所以，为了避免这种情况，我们将使用AES进行加密，其他的加密方式也可以，具体看自己需求。
新手向 使用C#自带方法制作unity存档系统（无插件）
wsxybz的博客
12-29 1532
新手向 详细教程 使用C#自带方法制作unity存档系统（无插件）
Unity多存档编辑器工具
热门推荐
legroft的博客
08-30 1万+
由于在开发游戏时需要反复重新游戏走一遍流程来测试游戏，但是游戏目前没有做多存档的计划，所以先整了个这么个编辑器工具 原理非常暴力，就是读取不同的存档文件 首先定义一个存档槽类，用来对 存档进行保存，读取等操作，保存时将原本的存档文件复制一份，并截图到Assets目录下，读取时将该文件覆盖 原来的文件即可 存档的路径 与文件名 需要根据自身项目修改 另外需要保存存档时的截屏并显示出来，所以要用到协程读取保存的资源图片，直接按顺序写代码是读取不出来的，用到了github上的一个编辑器携程工具 https://
Unity游戏开发之游戏存档方式
hfh1999的博客
04-09 5343
介绍了Unity目前使用中的集中游戏存档的方式
unity实现存档系统
最新发布
qq_73619184的博客
04-08 597
由于存档内容通常不会单一，而且可能存在多个存档文件，因此我们需要一种通用的方法来管理存档。通过接口，我们可以实现多态性，使得不同的类能够以统一的方式进行存档操作。通过接口调用函数的形式，不同的类可以实现不同的存档逻辑。
[独游开发210105]Unity基于LitJson的存档系统
NoMonSterhunterL的博客
01-05 262
Unity基于LitJson的存档系统： 描述： 最近在做自己的第一个游戏，因为之前都是随便玩玩的，所以并不是很深入。昨天看了LitJson的数据持久化，今天就试着去做了下，从早上干到现在，虽说代码可能不足，但起码功能实现了，后续再加修改不是大事。其中我也总结了一些坑。 LitJson的简单使用 下载一个LitJson.dll，放在Assets/Plugins下 在脚本中using LitJson 创建好SL类，来保存需要存储的数据。要序列化[System.Serializable] SaveO
Unity中使用的四种存档和读档方式
weixin_50837893的博客
03-25 8396
这里会列举四种存档方式,并且以简单的项目展示出效果。 这里我会写的简单易懂些,希望大家学到的是存档与读档的逻辑。 1.第一种方式： Unity自带的存档方式 干货：PlayerPrefs：数据持久化方案。 采用键值对的方式对数据进行存储。 eg:PlayerPrefs.SetInt("Index",1); 可以存储Int, Float, String类型的数据。 eg:PlayerPrefs
unity游戏存档修改_从0开始做游戏系列-Section3
weixin_39682511的博客
12-04 4238
最近正在学习unity游戏研发，因此跟随着Udemy上畅销课程一起学习怎么制作2D游戏链接如下：C# Unity Developer 2D: Learn to Code by Making Video Games​www.udemy.com由于我只是记录自己的学习过程，本人也只是小白级别，如果大家有疑问的话，我尽可能去回答，不过有条件的话可以一起购入课程，一起学习。为什么一开头就是Section3...
Unity通过序列化存储复杂数据
dickredone的博客
12-27 672
一、情景 Unity拥有PlayerPrefs，可以很方便地保存一些简单的数据。但是实际开发中，只使用PlayerPrefs是无法保存很多类型的数据的。所以需要
[Unity存档系统]简单介绍Unity常见存档系统二JSON以及使用方法
dangoxiba的博客
05-20 4861
学习目标： 如果你和我同样苦恼于游戏相关的数据怎么存储与读取，那么不妨看看这个up主有关Unity存档系统的教程。[Unity] 存档系统 Part 1 | PlayerPrefs | Unity初学者系列教程 | 数据存取 | 存档读档 | Save&Load_哔哩哔哩_bilibili在本视频中你将学到Unity引擎中三种常见的数据存储方式中的第一种：PlayerPrefs主要内容：什么是PlayerPrefs如何使用PlayerPrefsPlayerPrefs的优缺点以及适用范围构建一个基.
unity中背包系统实现
03-23
在 Unity 中实现背包系统，可以使用数据结构来存储背包中的物品，比如使用数组或列表来存储物品的 ID 和数量。同时，可以使用 UI 组件来展示背包中的物品，比如使用 Grid Layout Group 来排列物品格子，使用 Image ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值