Unity foundation 3- data persistence

ScriptableObject

Save common data types , Can be in inspector View in window , for example
Put the monster 、 The player's attributes are saved as ScriptableObject
《 Wheat field story 》 In the series , Save the item data as ScriptableObject Similar to the following

using UnityEngine;
using System.Collections.Generic;

[CreateAssetMenu(fileName = "CropData", menuName = "CropData/CropData", order = 0)]
public class CropDataList_SO : ScriptableObject
{
    
    /// <summary>
    ///  Crop database 
    /// </summary>
    public List<CropDetails> cropDetailsList;
}

And then you can do it in project Window , Right click to create ItemData
Fill in the data and use public ItemData itemDataList;

PlayerPrefs

Here is 3DRPG In the basic series 《SaveManager.cs》 An example of saving player data
Save the key-value pair , But it can cooperate JsonUtility To save objects

	private void Save(Object data, string key)
    {
    
        var jsonData = JsonUtility.ToJson(data);
        PlayerPrefs.SetString(key, jsonData);
        PlayerPrefs.SetString(sceneName, SceneManager.GetActiveScene().name);
        PlayerPrefs.Save();
    }
    private void Load(Object data, string key)
    {
    
        if (PlayerPrefs.HasKey(key))
        {
    
            JsonUtility.FromJsonOverwrite(PlayerPrefs.GetString(key), data);
        }
    }

Another layer of encapsulation is used

	public void LoadPlayerData()
    {
    
        var data = GameManager.Instance.playerStats.characterData;
        Load(data, data.name);
    }

    public void SavePlayerData()
    {
    
        var data = GameManager.Instance.playerStats.characterData;
        Save(data, data.name);
    }

Different operating systems have different save paths

File systems store data

Use official JSON package Newtonsoft Json
The following example is 《 Wheat field story 》 in , Use 3 An archive bar saves data
Use the interface for different objects that need archiving function （GUID） Expand the archiving function

	public interface ISaveable
    {
    
        string GUID {
     get; }
        GameSaveData GenerateSaveData();
        void RestoreSaveData(GameSaveData saveData);
        //  since  C Sharp 9.0  After version , You can implement methods in an interface 
        //  Write a registration method in this interface 
        void RegisterSaveable()
        {
    
            SaveLoadManager.Instance.RegisterSaveable(this);
        }
    }

obtain GUID

using UnityEngine;
[ExecuteAlways]
public class DataGUID : MonoBehaviour
{
    
    //  Mount on the object that needs to be stored , Realize the uniqueness of stored data 
    public string guid;
    private void Awake() {
    
        if (guid==string.Empty)
        {
    
            // 16  Bit length string 
            guid = System.Guid.NewGuid().ToString();
        }
    }
}

Read and write data

		private void Save(int index)
        {
    
            //  Where to save it 
            DataSlot data = new DataSlot();

            foreach (var saveable in saveableList)
            {
    
                data.dataSlotDict.Add(saveable.GUID, saveable.GenerateSaveData());
            }

            dataSlotList[index] = data;

            //  After serialization, write to the file to store 

            //  The final path 
            var resultPath = jsonFolder + "data" + index + ".sav";
            //  Store in indented format   Serialized data 
            var jsonData = JsonConvert.SerializeObject(dataSlotList[index], Formatting.Indented);
            if (!File.Exists(resultPath))
            {
    
                Directory.CreateDirectory(jsonFolder);
            }
            //  write file 
            File.WriteAllText(resultPath, jsonData);
        }

Reading data

		public void Load(int index)
        {
    
            currentDataIndex = index;

            var resultPath = jsonFolder + "data" + index + ".sav";

            if (File.Exists(resultPath))
            {
    
                var stringData = File.ReadAllText(resultPath);

                //  Deserialization 
                var jsonData = JsonConvert.DeserializeObject<DataSlot>(stringData);

                foreach (var saveable in saveableList)
                {
    
                    saveable.RestoreSaveData(jsonData.dataSlotDict[saveable.GUID]);
                }
            }
            else
            {
    
                Debug.LogError(" The archive file is missing ");
            }

        }

When using interfaces , Register first , Then implement the corresponding method
public class TransitionManager : Singleton<TransitionManager>, ISaveable

		void Start()
        {
    
            ISaveable saveable = this;
            saveable.RegisterSaveable();

            fadeCanvasGroup = FindObjectOfType<CanvasGroup>();
        }

		public GameSaveData GenerateSaveData()
        {
    
            GameSaveData saveData = new GameSaveData();
            saveData.dataSceneName = sceneName;
            return saveData;
        }
        public void RestoreSaveData(GameSaveData saveData)
        {
    
            // Debug.Log(" Reload scene ");
            sceneName = saveData.dataSceneName;
            //  Archive by game , Reload the scene content 
            StartCoroutine(LoadSaveDataScene(sceneName));
        }