Unity 2D Game Development, Save and Load System Implementing the ability to save and load the game's progress.

One of the most important elements in game development is the ability to save and load the player’s progress. This ensures the continuity of the game and allows players to pause the game at any time and resume later. In this post, we will discuss in detail how to implement a save and load system in Unity 2D game development.

1. The Necessity of a Save System

The save system in a game is necessary for several reasons:

Preserving the player’s progress
Saving various settings according to game progress
Providing user convenience

Without these features, players would have to start over every time they begin the game, which could diminish the enjoyment of the game. Therefore, implementing a save and load system is essential.

2. Implementing a Save and Load System

There are primarily two methods that can be used to implement a save and load system in Unity:

Saving using JSON files
Using PlayerPrefs for simple data storage

In this article, we will explain how to use JSON files and PlayerPrefs step by step.

2.1. Saving Using JSON Files

JSON is a method to save data structurally, allowing various data formats to be easily stored and read. Commonly used in-game data includes:

Player’s position
Player’s score
Current level

2.1.1. Creating a Data Model

First, you need to create a class that defines the data to be saved. For example, a class for saving the player’s state can be defined as follows:

using System;
using UnityEngine;

[Serializable]
public class PlayerData
{
    public float positionX;
    public float positionY;
    public int score;
    public int level;

    public PlayerData(float posX, float posY, int scr, int lvl)
    {
        positionX = posX;
        positionY = posY;
        score = scr;
        level = lvl;
    }
}

2.1.2. Saving Data

This is a method to save the player’s data in JSON format. Let’s write a class for this purpose.

using System.IO;
using UnityEngine;

public class SaveSystem : MonoBehaviour
{
    public void SavePlayer(PlayerData playerData)
    {
        string json = JsonUtility.ToJson(playerData);
        File.WriteAllText(Application.persistentDataPath + "/player.json", json);
        Debug.Log("Player data saved to: " + Application.persistentDataPath + "/player.json");
    }
}

2.1.3. Loading Data

This is the method to read the saved JSON data back. You can read the data with the following code.

public PlayerData LoadPlayer()
{
    string path = Application.persistentDataPath + "/player.json";

    if (File.Exists(path))
    {
        string json = File.ReadAllText(path);
        PlayerData playerData = JsonUtility.FromJson(json);
        Debug.Log("Player data loaded from: " + path);
        return playerData;
    }
    else
    {
        Debug.LogError("Player data not found in " + path);
        return null;
    }
}

2.2. Saving Using PlayerPrefs

PlayerPrefs is a simple save system provided by Unity. It is primarily used for saving game settings or small amounts of data.

2.2.1. Saving Data

This is how to save simple variables using PlayerPrefs.

public void SavePlayerPref(string playerName, int playerScore)
{
    PlayerPrefs.SetString("PlayerName", playerName);
    PlayerPrefs.SetInt("PlayerScore", playerScore);
    PlayerPrefs.Save();
    Debug.Log("Player preferences saved");
}

2.2.2. Loading Data

The method to load data from saved PlayerPrefs is as follows.

public void LoadPlayerPref()
{
    string playerName = PlayerPrefs.GetString("PlayerName", "DefaultName");
    int playerScore = PlayerPrefs.GetInt("PlayerScore", 0);
    Debug.Log("Loaded Player Name: " + playerName);
    Debug.Log("Loaded Player Score: " + playerScore);
}

3. Example Project: Implementing a Save and Load System

Now, based on the content explained above, let’s add the save and load system to a simple Unity 2D game example project.

3.1. Setting Up the Unity Project

First, create a 2D project in Unity. Then create the PlayerData and SaveSystem classes that we implemented above.

3.2. Implementing the Game Loop

Let’s create a simple game loop where the player earns points and levels up. Write the script as follows.

using UnityEngine;

public class GameManager : MonoBehaviour
{
    private SaveSystem saveSystem;
    private PlayerData playerData;

    void Start()
    {
        saveSystem = new SaveSystem();
        LoadGame();
    }

    void Update()
    {
        // Example that increases the score by 1
        if (Input.GetKeyDown(KeyCode.Space))
        {
            playerData.score += 1;
            Debug.Log("Score: " + playerData.score);
        }

        // Save the game
        if (Input.GetKeyDown(KeyCode.S))
        {
            saveSystem.SavePlayer(playerData);
        }

        // Load the game
        if (Input.GetKeyDown(KeyCode.L))
        {
            LoadGame();
        }
    }

    void LoadGame()
    {
        playerData = saveSystem.LoadPlayer();
        if (playerData == null)
        {
            playerData = new PlayerData(0, 0, 0, 1); // Initialize with default values
        }
    }
}

4. Conclusion

In this post, we learned how to implement a save and load system in Unity 2D game development. Using JSON files and PlayerPrefs, data can be easily saved and loaded. It is important to understand the pros and cons of each method and choose the appropriate one to apply.

Now you can enhance your game’s user experience by adding save and load functionality. If you have any additional questions or requests, please leave a comment!

5. Additional Resources

The following resources will provide a deeper understanding of save and load systems:

Unity 2D Game Development, Save and Load System Implementing the ability to save and load the game’s progress.