Playerprefs Vs Custom Save Files: What’S Best For Saving Progress In Unity Games

Storing Game Data: The Core Problem

A key consideration when developing any video game is how to persistently store game data and player progress between sessions. When a player closes and reopens a game, they reasonably expect that their progress, settings, unlocked items, and other data will be preserved. As such, choosing an appropriate system for serializing and saving game state is an important part of development.

Unity provides two primary options for saving data: PlayerPrefs and custom serialization systems. PlayerPrefs offers an easy built-in solution for storing simple game data, automatically handling file storage and providing a player-centric data structure. Custom serialization gives developers more control for saving complex data types, but requires building a custom save file format and manual file handling logic.

PlayerPrefs: Unity’s Default Solution

PlayerPrefs is Unity’s default system for saving data in a key-value store format, designed specifically for storing user preferences and basic game state data. Enabled by default in all Unity projects, it provides a lightweight serialization API that automatically saves data to a platform-dependent location that persists between game sessions.

Using PlayerPrefs is as simple as assigning values to keyed entries, which are then automatically serialized and written to storage. For example:

PlayerPrefs.SetInt("Health", 100);
PlayerPrefs.SetFloat("Volume", 0.5f);  
PlayerPrefs.SetString("Name", "John");

PlayerPrefs requires minimal implementation effort, handles file IO automatically, and provides isolated storage for each player profile. However, data is stored in a disorganized dictionary structure, offers limited data types, and has a max size limit of 1MB on desktop platforms.

Implementing Custom Serialization

For games with more complex save data requirements, custom serialization can be implemented to leverage file formats like JSON and XML along with custom data schemas. This offers enhanced flexibility and control compared to PlayerPrefs.

JSON is a lightweight data format that maps directly to Unity data types, making it easy to serialize custom objects and classes. The following demonstrates saving an inventory data object using JsonUtility:

[System.Serializable] 
public class InventoryData {
  public string[] itemIds; 
  public int[] quantities;
}

public void SaveInventory(InventoryData inventory) {
  
  string json = JsonUtility.ToJson(inventory);
  
  File.WriteAllText(Application.persistentDataPath + "/savefile.json", json);

}  

With a custom serialization system, developers can design their own save data schema, have full control over where save files are written to disk, and serialize a wide range of complex data types.

Choosing the Right Approach

Determining whether to use Unity’s built-in PlayerPrefs system or implement custom serialization comes down to weighing the technical requirements and skill level of a project against the effort involved.

PlayerPrefs is an accessible option well-suited for beginners and game jams thanks to its automatic functionality. The simplicity it offers works best on small scale projects targeting mobile or web, where data storage needs are minimal. However, it may not suffice for experienced developers creating games with elaborate progression systems and numerous unlockables.

Custom serialization better handles large save data sets and complex object types at the cost of increased complexity. The flexibility it provides caters well to hardcore RPGs and action games with extensive progression tracking. However, it requires advanced programming knowledge and robust save logic.

In many cases, a hybrid approach utilizing both systems may strike the right balance. PlayerPrefs could store key player preferences and global flags, while a custom system handles detailed progression tracking and inventory data.

Override Unity’s Default Save Behavior

While PlayerPrefs provides built-in save capabilities, even games utilizing it may require custom save handling logic. By overriding Unity’s default serialization behavior, extra features can be implemented.

By implementing the optional ISaveHandler interface, a game can intercept Unity’s serialization process to introduce customized systems. For example, an auto-saving routine could serialize data at fixed intervals without player input by registering a MonoBehaviour subclass:

public class AutoSaveHandler : MonoBehaviour, ISaveHandler {

  public void OnBeforeSerialize() {    
    SaveGameData();
  }

  public void OnAfterDeserialize() {
    // Load data after scene load
  }  

}

Other use cases could include versioning save data for backward compatibility, encrypting save files, or tracking save histories for backup purposes. Customizing save logic provides flexibility beyond what the default PlayerPrefs system allows.