📝 Lesson 4.3: Saving and Loading

What Persistence Means

Everything so far lives in memory and vanishes when the game closes — the GameManager's score, the player's position, unlocked levels. Persistence means writing that data somewhere durable (the disk) so it can be read back next session.

Two questions shape every save system:

PlayerPrefs for Settings

PlayerPrefs is Unity's built-in key-value store for small, simple values — volume, difficulty, a high score. It handles the file for you; you just get and set by string key.

using UnityEngine;

// Save
PlayerPrefs.SetInt("HighScore", 1200);
PlayerPrefs.SetFloat("Volume", 0.8f);
PlayerPrefs.SetString("PlayerName", "Ray");
PlayerPrefs.Save();   // flush to disk (also happens on normal quit)

// Load — the second argument is the default if the key doesn't exist yet.
int highScore = PlayerPrefs.GetInt("HighScore", 0);
float volume  = PlayerPrefs.GetFloat("Volume", 1f);

if (PlayerPrefs.HasKey("PlayerName"))
    Debug.Log(PlayerPrefs.GetString("PlayerName"));

💡 Default values matter: always pass a default to GetInt/GetFloat/GetString. On a first run the key doesn't exist, and the default is what a new player gets. PlayerPrefs.DeleteKey("HighScore") or DeleteAll() clears values (handy for a "reset progress" button).

JSON Serialization

Real save data is structured — a level number, a score, a position, a list of unlocked items. The clean approach: put it all in a plain data class, then convert that class to a JSON string with JsonUtility.

First, a serializable data class. The [System.Serializable] attribute tells Unity it can turn this into JSON (and show it in the Inspector):

using System;
using UnityEngine;

[Serializable]
public class SaveData
{
    public int level;
    public int score;
    public Vector3 playerPosition;
    public string[] unlockedItems;
}

Then convert to and from JSON text with two static methods:

SaveData data = new SaveData
{
    level = 3,
    score = 1500,
    playerPosition = player.transform.position,
    unlockedItems = new[] { "sword", "shield" }
};

// Object → JSON string (the 'true' pretty-prints with indentation).
string json = JsonUtility.ToJson(data, true);

// JSON string → object.
SaveData loaded = JsonUtility.FromJson<SaveData>(json);
Debug.Log($"Level {loaded.level}, score {loaded.score}");

The resulting JSON is human-readable text — great for debugging:

{
    "level": 3,
    "score": 1500,
    "playerPosition": { "x": 4.0, "y": 0.0, "z": -2.0 },
    "unlockedItems": ["sword", "shield"]
}

Writing to Disk

JSON is just a string; now write it to a file. The one Unity-specific rule: save to Application.persistentDataPath, a per-user, writable folder that survives app updates and differs per platform (Unity picks the correct location on each device).

using System.IO;   // File, Path — standard .NET (Intermediate C#)
using UnityEngine;

string path = Path.Combine(Application.persistentDataPath, "save.json");

// Write
File.WriteAllText(path, json);

// Read (only if it exists)
if (File.Exists(path))
{
    string loadedJson = File.ReadAllText(path);
    SaveData data = JsonUtility.FromJson<SaveData>(loadedJson);
}

A SaveManager

Wrap all of this in a single manager (Lesson 4.1) so the rest of your game just calls SaveManager.Instance.Save() / Load() and never touches paths or JSON directly.

using System.IO;
using UnityEngine;

public class SaveManager : MonoBehaviour
{
    public static SaveManager Instance { get; private set; }

    private string SavePath => Path.Combine(Application.persistentDataPath, "save.json");

    void Awake()
    {
        if (Instance != null && Instance != this) { Destroy(gameObject); return; }
        Instance = this;
        DontDestroyOnLoad(gameObject);
    }

    public void Save(SaveData data)
    {
        string json = JsonUtility.ToJson(data, true);
        File.WriteAllText(SavePath, json);
        Debug.Log($"Saved to {SavePath}");
    }

    public SaveData Load()
    {
        if (!File.Exists(SavePath))
            return null;   // no save yet — caller starts fresh

        string json = File.ReadAllText(SavePath);
        return JsonUtility.FromJson<SaveData>(json);
    }

    public bool HasSave() => File.Exists(SavePath);

    public void DeleteSave()
    {
        if (File.Exists(SavePath)) File.Delete(SavePath);
    }
}

💡 When to save: at checkpoints, on level complete, or on quit (OnApplicationQuit / OnApplicationPause on mobile). Avoid saving every frame — disk writes are slow and cause hitches.

Limits & Gotchas

JsonUtility is fast and built-in, but deliberately minimal. Know its edges before you hit them:

Exercise & Quiz

using System;
using UnityEngine;

[Serializable]
public class SaveData
{
    public int version = 1;
    public int level;
    public int score;
    public Vector3 playerPosition;
}

public class SaveManager : MonoBehaviour
{
    public static SaveManager Instance { get; private set; }

    void Awake()
    {
        // TODO: singleton guard + DontDestroyOnLoad.
    }

    // TODO: Save(SaveData), Load(), HasSave() using JsonUtility + File + persistentDataPath.
}

using System;
using System.IO;
using UnityEngine;

[Serializable]
public class SaveData
{
    public int version = 1;
    public int level;
    public int score;
    public Vector3 playerPosition;
}

public class SaveManager : MonoBehaviour
{
    public static SaveManager Instance { get; private set; }
    private string SavePath => Path.Combine(Application.persistentDataPath, "save.json");

    void Awake()
    {
        if (Instance != null && Instance != this) { Destroy(gameObject); return; }
        Instance = this;
        DontDestroyOnLoad(gameObject);
    }

    public void Save(SaveData data)
    {
        File.WriteAllText(SavePath, JsonUtility.ToJson(data, true));
        Debug.Log($"Saved to {SavePath}");
    }

    public SaveData Load()
    {
        if (!File.Exists(SavePath)) return null;
        return JsonUtility.FromJson<SaveData>(File.ReadAllText(SavePath));
    }

    public bool HasSave() => File.Exists(SavePath);
}

using UnityEngine;

public class SaveTester : MonoBehaviour
{
    [SerializeField] private Transform player;
    [SerializeField] private int level = 1;
    [SerializeField] private int score;

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.F5))
        {
            SaveManager.Instance.Save(new SaveData
            {
                level = level,
                score = score,
                playerPosition = player.position
            });
        }

        if (Input.GetKeyDown(KeyCode.F9))
        {
            SaveData data = SaveManager.Instance.Load();
            if (data != null)
            {
                level = data.level;
                score = data.score;
                player.position = data.playerPosition;
                Debug.Log($"Loaded: level {level}, score {score}");
            }
        }
    }
}

Summary

📚 Additional Resources

• Scripting Reference — JsonUtility
• Scripting Reference — PlayerPrefs
• Scripting Reference — Application.persistentDataPath
• Manual — JSON Serialization

🚀 What's Next?

That completes Module 4 — Systems and Managers: state, UI, and persistence — the scaffolding of a complete game. Module 5 sharpens quality. Lesson 5.1, Unity Performance and Memory, tackles the GC and per-frame costs we've been flagging all course — caching, avoiding allocations in Update, and object pooling.