Saving and Loading Stats in Unity: A Persistence Guide for Attributes and Talents

Implementing a Save/Load system for an RPG is a technical rite of passage for any indie developer. However, what starts as a simple health variable quickly becomes a maze of modifiers, equipment bonuses, talent trees, and derived stats that must be perfectly restored. A single synchronization error and the player will lose hours of progress or, even worse, find exploits that break your game’s balance.

The Challenge: What should we actually save?

The most common mistake is trying to serialize the final state of a character. If you save that the player has 150 ‘Strength’, but you don’t save where that value comes from (is it base?, is it from a talent?, is it a temporary buff?), when you load the game and re-apply talents, you could end up with 200 Strength. This phenomenon is known as ‘Double Dipping’ and is the terror of persistence systems.

The Solution: MAS Modular Architecture

Our ‘Modular Attributes & Stats’ (MAS) asset was specifically designed to solve this problem through a clear data hierarchy. To persist a character created with MAS, you only need to focus on three pillars:

• Base Attributes: We only save the ‘BaseValue’ (the natural maximum) and the ‘CurrentValue’ (the current resource).
• Talent Ranks: We save the level invested in each talent.
• Progression: Current level and accumulated experience.

Why is this efficient? Because Derived Attributes (like Attack Power which depends on Strength) and Modifiers are automatically recalculated as soon as the system detects that base values have been loaded.

Technical Implementation: The Saving Flow

To save the data, we recommend creating a simple data transfer object (DTO) that is easily serializable to JSON. Here is an example of how to structure the logic:

[System.Serializable]
public class SaveData {
  public List<AttributeSave> attributes;
  public List<TalentSave> talents;
}

public void Save(AttributeManager manager, TalentAttributeManager talents) {
  // We only save the essentials
  var data = new SaveData();
  foreach(var attr in manager.BaseAttributes) {
    data.attributes.Add(new AttributeSave(attr.Name, attr.BaseValue, attr.CurrentValue));
  }
  // ... serialize to JSON ...
}

Restoring State Without Bugs

When loading, the order of operations matters. The correct flow with MAS is:

1. Load Base Attribute values.
2. Set Talent ranks using ‘SetRankDirectly’.
3. Allow the ‘AttributeManager’ to trigger its global ‘OnAttributeChanged’ event.

By following this order, MAS detects the new talent ranks, generates the corresponding modifiers, and updates all Derived Attributes in a single frame. The result is a clean, optimized restoration free of value duplication.

Performance Optimization

Thanks to MAS’s reactive model, you don’t need to run heavy save code every frame. You can trigger saves only at ‘Checkpoints’ or when a critical event occurs. Additionally, by not having to save Derived Attributes, the size of your save files is significantly reduced, which is vital if you plan to use cloud saving or mobile platforms.

Persisting stats doesn’t have to be the hardest part of your RPG. With a modular and reactive architecture, you can focus on designing epic talents while MAS ensures every health point is exactly where it should be.