Let’s Learn Godot 4 by Making an RPG — Part 20: Persistent Saving & Loading System🤠
Tags: gamedev, programming, beginners, tutorial
Published: 2023-07-08 03:14:00

In this part, we’ll be adding the ability for our players to save and load their game. When we save the game, we need to store all the necessary variables from all of our different scripts to save the current state of those variables.

---

>  **WHAT YOU WILL LEARN IN THIS PART:**
>  · How to create persistent saving and loading systems
>  · How to parse JSON files.
>  · How to read and write files using the FileAccess object.
>  · How to save/load game variables.

---

We’ll save these variables in a [dictionary](https://docs.godotengine.org/en/stable/classes/class_dictionary.html), which will store our values as keys. The syntax of [Dictionaries](https://gdscript.com/tutorials/dictionaries/) is similar to JSON, which is beneficial to us since we will be saving our save_file into a JSON format. JSON is an open standard file format and data interchange format that uses human-readable text to store and transmit data objects consisting of attribute–value pairs and arrays. This is useful for serializing data to save to a file or send over the network.

**Our save file will follow the following format:**
```json
    save_dictionary = {
      "variable name": variable reference,
      "player_health": health
    }
```
![Save system overview](https://cdn-images-1.medium.com/max/2000/1*UPerNKb532DFSuBiH5kL0w.png)
> Save system overview

To load the game from our save file that we’ll create, we’ll have to convert the JSON file back into dictionary format. We’ll do this via a function that will load the data from the JSON file.

**Our load function will follow the following format:**
```json
    func load_save_file(data):
      variable name = data.variable reference
      player_health = data.health
```
![Load System Overview](https://cdn-images-1.medium.com/max/2000/1*ncYX1E_r75DglfAQnEPhAg.png)
> Load system overview

Let’s get started with our Saving functionality!

## SAVING THE GAME

In our Global script, let’s create a new variable that will hold the save path of our JSON save file. We will set our path to be under “user://dusty_trails_save.json”.

On a Windows machine, this save file will be found under **%APPDATA%\Roaming\Godot\app_userdata\Dusty-Trails**.
```python
    ### Global.gd
    
    # older code
    
    # Saving & Loading
    var save_path = "user://dusty_trails_save.json"
```
To save our game, we need to go and create a dictionary in each script to store our values. We’ll then store all these dictionaries in another dictionary in our Main scene which will compile all the separate dictionaries into a singular structure which will then be stored in our JSON file.

**We want to save the following values from the following scripts:**

* Player -> position, health, pickups, stamina, xp, and level

* Enemy -> position, health

* EnemySpawner -> spawned enemies

* NPC -> position, quest status, quest completion state

At the end of each of these scripts, let’s create these dictionaries to store these values. We’ll store the enemies in our EnemySpawner as an array so that when we load our enemies our spawner knows how many to continue counting from to add/remove enemy counts. We’ll also append the enemy data from the Enemy scripts data_to_save() function in the EnemySpawner’s save function. Therefore, our spawner saves our enemy count plus each enemy’s health and position values.

```python   
    ### Player.gd
    
    #older code
    
    # -------------------------------- Saving & Loading -----------------------
    #data to save
    func data_to_save():
        return {
            "position" : [position.x, position.y],
            "health" : health,
            "max_health" : max_health,
            "stamina" : stamina,
            "max_stamina" : max_stamina,
            "xp" : xp,
            "xp_requirements" : xp_requirements,
            "level" : level,
            "ammo_pickup" : ammo_pickup,
            "health_pickup" : health_pickup,
            "stamina_pickup" : stamina_pickup
        }
```
```python

    ### NPC.gd
    
    #older code
    
    # -------------------------------- Saving & Loading -----------------------
    #data to save
    func data_to_save():
        return {
            "position" : [position.x, position.y],
            "quest_status": quest_status,
            "quest_complete": quest_complete
        }
```

```python
    ### Enemy.gd
    
    #older code
    
    # -------------------------------- Saving & Loading -----------------------
    #data to save
    func data_to_save():
        return {
            "position" : [position.x, position.y],
            "health" : health,
            "max_health" : max_health
        }
```

```python
    ### EnemySpawner.gd
    
    #older code
    
    # -------------------------------- Saving & Loading -----------------------
    #data to save
    func data_to_save():
        var enemies = []
        for enemy in spawned_enemies.get_children():
            #saves enemy amount, plus their stored health & position values
            if enemy.name.find("Enemy") >= 0:
                enemies.append(enemy.data_to_save())
        return enemies
```

Now in our Global script, we need to create a new function that will save our game. In this function, we’ll need to create a dictionary of items to save, and that will include the dictionaries we added in our Player, EnemySpawner, and NPC scripts. We also only save the data if the nodes are present in the current scene. This means that it will only save NPC data if we have a npc in our scene. If we don’t, it will skip the data for that NPC and save the other valid data fields. In summary, this function saves the game by retrieving the current scene, collecting data from specific nodes within the scene, converting the data to JSON format, and storing it in a file. The data saved includes the scene name, player data, NPC data, and enemy spawner data if they exist in the current scene.

To save a file to this path, we will have to use the [FileAccess](https://docs.godotengine.org/en/stable/classes/class_fileaccess.html) object. We’ll first need to convert our “data” dictionary to a JSON string. We can do this by using the [stringify](https://docs.godotengine.org/en/stable/classes/class_json.html) method, which converts the data to a JSON-formatted string.

Then we will use our [.open](https://docs.godotengine.org/en/stable/classes/class_fileaccess.html) method from our FileAccess object to open our save_path file. Opening this file allows us to read or write to it. In this instance, we will use the [FileAccess.WRITE](https://docs.godotengine.org/en/stable/classes/class_fileaccess.html) method to specify that the file should be opened in write mode.

After it has been opened, we will write to this file using the [store_line](https://docs.godotengine.org/en/stable/classes/class_fileaccess.html#class-fileaccess-method-store-line) function that writes a string to the file and adds a new line character at the end.

After all that’s been done, we need to [close](https://docs.godotengine.org/en/stable/classes/class_fileaccess.html#class-fileaccess-method-close) the file. This is important to ensure that all data is written and resources are released.
```python
    # ------------------------ Saving & Loading --------------------------
    # save game 
    func save():
        var current_scene = get_tree().get_current_scene()
        if current_scene != null:
            current_scene_name = current_scene.name
            # data to save
            var data = {
                "scene_name" : current_scene_name,
            }
            #check if nodes exist before saving
            if current_scene.has_node("Player"):
                var player = get_tree().get_root().get_node("%s/Player" % current_scene_name)
                print("Player exists: ", player != null)
                data["player"] = player.data_to_save()   
            if current_scene.has_node("SpawnedNPC/NPC"):
                var npc = get_tree().get_root().get_node("%s/SpawnedNPC/NPC" % current_scene_name)
                print("NPC exists: ", npc != null)
                data["npc"] = npc.data_to_save()
            if current_scene.has_node("EnemySpawner"):
                var enemy_spawner = get_tree().get_root().get_node("%s/EnemySpawner" % current_scene_name)
                print("EnemySpawner exists: ", enemy_spawner != null)
                data["enemies"] = enemy_spawner.data_to_save()     
            # converts dictionary (data) into json
            var json = JSON.new()
            var to_json = json.stringify(data)
            # opens save file for writing
            var file = FileAccess.open(save_path, FileAccess.WRITE)
            # writes to save file
            file.store_line(to_json)
            # close the file
            file.close()
        else:
            print("No active scene. Cannot save.")
```
Now we will save our game when we change scenes. This will prevent our game from returning NULL values for our scene paths. It also helps us carry over the last captured player data from the previous scene into the new scene.
```python
    ### Global.gd
    
    # older code
    
     # Change scene
    func change_scene(scene_path):
        save()
        # Get the current scene
        current_scene_name = scene_path.get_file().get_basename()
        var current_scene = get_tree().get_root().get_child(get_tree().get_root().get_child_count() - 1)
        # Free it for the new scene
        current_scene.queue_free()
        # Change the scene
        var new_scene = load(scene_path).instantiate()
        get_tree().get_root().call_deferred("add_child", new_scene) 
        get_tree().call_deferred("set_current_scene", new_scene)    
        call_deferred("post_scene_change_initialization")
    
    func post_scene_change_initialization():
        scene_changed.emit()
```
Now we need to go back to our Player script and call our save function from our Global script if we press our save button.
```python
    ### Player.gd
    
    # older code
    
    # save game
    func _on_save_pressed():
        Global.save()
```
If you now play your game and you save your save file should be created. The save file will look like this if you open it (your values will be different from mine):

![Godot RPG](https://cdn-images-1.medium.com/max/2000/1*Ez4WFY2SlJeacjFemlNf4w.png)
```json
    JSON SAVE FILE DATA:
    
    {"enemies":[],"player":{"ammo_pickup":13,"health":100,"health_pickup":2,"level":1,"max_health":100,"max_stamina":100,"position":[439,154],"stamina":100,"stamina_pickup":2,"xp":0,"xp_requirements":100},"scene_name":"Main"}
```
## LOADING THE GAME

To load our game, we will have to go to each of our scripts once again and define the values that we want to load from them.

**We want to load the following values from the following scripts:**

· Player -> position, health, pickups, stamina, xp, and level

· Enemy -> position, health

· EnemySpawner -> spawned enemies

· NPC -> position, quest status, quest completion state

We’ll do this by creating a function in each of our Player, NPC, Enemy, and EnemySpawner scripts. This function will pass the “data” parameter, which will reference the saved values from our “data” dictionary that we created in our Main scene.
```python
    ### Player.gd
    
    #older code
    
    #loads data from saved data
    func data_to_load(data):
        position = Vector2(data.position[0], data.position[1])
        health = data.health
        max_health = data.max_health
        stamina = data.stamina
        max_stamina = data.max_stamina
        xp = data.xp
        xp_requirements = data.xp_requirements
        level = data.level
        ammo_pickup = data.ammo_pickup
        health_pickup = data.health_pickup
        stamina_pickup = data.stamina_pickup
```

```python
    ### EnemySpawner.gd
    
    #older code
    
    #load data from save file
    func data_to_load(data):
        enemy_count = data.size()
        for enemy_data in data:
            var enemy = Global.enemy_scene.instantiate()
            enemy.data_to_load(enemy_data)
            add_child(enemy)
```

```python
    ### NPC.gd
    
    #older code
    
    #loads data from save
    func data_to_load(data):
        position = Vector2(data.position[0], data.position[1])
        quest_status = int(data.quest_status)
        quest_complete = data.quest_complete
```    

```python
    ### Enemy.gd
    
    #older code
    
    #data to load from save file
    func data_to_load(data):
        position = Vector2(data.position[0], data.position[1])
        health = data.health
        max_health = data.max_health
```
Now, we want to load our entire game data. In our load function, we will load a saved game state by reading our JSON-formatted save file, loading the corresponding scene, adding it to the scene tree, setting it as the current scene, and loading the saved data into specific nodes within the scene. We’ll only load the data for our respective nodes (such as npc, player, and enemy) if the data is present in our save file.

We can do this via the [file_exists](https://docs.godotengine.org/en/stable/classes/class_fileaccess.html#class-fileaccess-method-file-exists) method.If the file does exist, we need to open our file and read its content. We can do this by specifying that we want to read the file via the FileAccess.READ method. After we open it, we need to read the entire contents of the file as text using [file.get_as_text()](https://docs.godotengine.org/en/stable/classes/class_fileaccess.html#class-fileaccess-method-get-file-as-string) and parse it as JSON using [JSON.parse_string()](https://docs.godotengine.org/en/stable/classes/class_json.html#class-json-method-parse-string).

We then need to close our file. After we’ve read the file, we need to load our data from our player, enemy spawner, and npc from the parsed JSON. If the quest state is set to complete, we also need to remove the quest item from the scene. You can also do the same for your pickups, but I want our pickups to respawn on load.
```python
    ### Global.gd
    
    #older code
    
    # Saving & Loading
    var save_path = "user://dusty_trails_save.json"
    var loading = false
    
    # older code
    
    
    func load_game():
        if loading and FileAccess.file_exists(save_path):
            print("Save file found!")
            var file = FileAccess.open(save_path, FileAccess.READ)
            var data = JSON.parse_string(file.get_as_text())
            file.close()
            # Load the saved scene
            var scene_path = "res://Scenes/%s.tscn" % data["scene_name"]
            print(scene_path)
            var game_resource = load(scene_path)
            var game = game_resource.instantiate()
            # Change to the loaded scene
            get_tree().root.call_deferred("add_child", game)        
            get_tree().call_deferred("set_current_scene", game)
            current_scene_name = game.name
            # Now you can load data into the nodes
            var player = game.get_node("Player")    
            var npc = game.get_node("SpawnedNPC/NPC") 
            var enemy_spawner = game.get_node("EnemySpawner")
            #checks if they are valid before loading their data
            if player:
                player.data_to_load(data["player"])
            if npc:
                npc.data_to_load(data["npc"])
            if enemy_spawner:
                enemy_spawner.data_to_load(data["enemies"])
            if(npc and npc.quest_complete):
                game.get_node("SpawnedQuestItems/QuestItem").queue_free()
        else:
            print("Save file not found!")
```
We also need to create a function that will load our player’s data when they enter a new scene. This function will load our player data (such as their health, ammo, and coin count from the previous scene) when entering a new scene by checking if a save file exists, reading and parsing the file to obtain the player data, and loading the data into the “Player” node of the current scene if it exists. This will allow our UI components to show the correct values on game load.
```python
    ## Global.gd
    
    #player data to load when changing scenes
    func load_data():
        var current_scene = get_tree().get_current_scene()
        if current_scene and FileAccess.file_exists(save_path):
            print("Save file found!")
            var file = FileAccess.open(save_path, FileAccess.READ)
            var data = JSON.parse_string(file.get_as_text())
            file.close()
            
            # Now you can load data into the nodes
            var player = current_scene.get_node("Player")
            if player and data.has("player"):
                player.values_to_load(data["player"])
        else:
            print("Save file not found!")
```
When this function loads our player data, it looks for a function inside of our Player script called *values_to_load().* This is a new function that loads all of our Player’s data except its position since we don’t want our position to load in some random area on the map (which could be an area that is our of bounds)! In your Player script, let’s create this function.
```python
    ## Player.gd
    
    # older code
    
    func values_to_load(data):
        health = data.health
        max_health = data.max_health
        stamina = data.stamina
        max_stamina = data.max_stamina
        xp = data.xp
        xp_requirements = data.xp_requirements
        level = data.level
        ammo_pickup = data.ammo_pickup
        health_pickup = data.health_pickup
        stamina_pickup = data.stamina_pickup    
        coins = data.coins
    
        # Emit signals to update UI
        health_updated.emit(health, max_health)
        stamina_updated.emit(stamina, max_stamina)
        ammo_pickups_updated.emit(ammo_pickup)
        health_pickups_updated.emit(health_pickup)
        stamina_pickups_updated.emit(stamina_pickup)
        xp_updated.emit(xp)
        level_updated.emit(level)
        coins_updated.emit(coins)
    
        # Update UI components directly
        $UI/AmmoAmount/Value.text = str(data.ammo_pickup)
        $UI/StaminaAmount/Value.text =  str(data.stamina_pickup)
        $UI/HealthAmount/Value.text =  str(data.health_pickup)
        $UI/XP/Value.text =  str(data.xp)
        $UI/XP/Value2.text =  "/ " + str(data.xp_requirements)
        $UI/Level/Value.text = str(data.level)
        $UI/CoinAmount/Value.text = str(data.coins)
```
We now also need to update our MainMenu script’s code to call our newly created functions. Our load button will call our *load_game()* function from our Global script.
```python
    ### MainScene.gd
    
    extends Node2D
    
    func _ready():
        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
    
    # New game
    func _on_new_pressed():
        Global.change_scene("res://Scenes/Main.tscn")
        Global.scene_changed.connect(_on_scene_changed)
    
    # Load game  
    func _on_load_pressed():
        Global.loading = true
        Global.load_game()
        queue_free()
    
    # Quit Game
    func _on_quit_pressed():
        get_tree().quit()
        
    #only after scene has been changed, do we free our resource     
    func _on_scene_changed():
        queue_free()
```
Finally, we need to also load our data when we change the scene to keep our data persistent.
```python
    ### Global.gd
    
    # older code
    
    # ----------------------- Scene handling ----------------------------
    #set current scene on load
    func _ready():
        current_scene_name = get_tree().get_current_scene().name
    
    
     # Change scene
    func change_scene(scene_path):
        save()
        # Get the current scene
        current_scene_name = scene_path.get_file().get_basename()
        var current_scene = get_tree().get_root().get_child(get_tree().get_root().get_child_count() - 1)
        # Free it for the new scene
        current_scene.queue_free()
        # Change the scene
        var new_scene = load(scene_path).instantiate()
        get_tree().get_root().call_deferred("add_child", new_scene) 
        get_tree().call_deferred("set_current_scene", new_scene)    
        call_deferred("post_scene_change_initialization")
    
    func post_scene_change_initialization():
        load_data()
        scene_changed.emit()
```
We also need to set our player’s UI values in their ready function to update the values when they enter a new scene.
```python
    ### Player.gd
    
    # older code
    
    func _ready():
        # Connect the signals to the UI components' functions
        health_updated.connect(health_bar.update_health_ui)
        stamina_updated.connect(stamina_bar.update_stamina_ui)
        ammo_pickups_updated.connect(ammo_amount.update_ammo_pickup_ui)
        health_pickups_updated.connect(health_amount.update_health_pickup_ui)
        stamina_pickups_updated.connect(stamina_amount.update_stamina_pickup_ui)
        xp_updated.connect(xp_amount.update_xp_ui)
        xp_requirements_updated.connect(xp_amount.update_xp_requirements_ui)
        level_updated.connect(level_amount.update_level_ui)
        coins_updated.connect(coin_amount.update_coin_amount_ui)
        
        # Reset color
        animation_sprite.modulate = Color(1,1,1,1)
        Input.set_mouse_mode(Input.MOUSE_MODE_HIDDEN)
    
        #update ui components to show correct loaded data   
        $UI/AmmoAmount/Value.text = str(ammo_pickup)
        $UI/StaminaAmount/Value.text =  str(stamina_pickup)
        $UI/HealthAmount/Value.text =  str(health_pickup)
        $UI/XP/Value.text =  str(xp)
        $UI/XP/Value2.text =  "/ " + str(xp_requirements)
        $UI/Level/Value.text = str(level)
```
Now if you run your scene, you should be able to save/load as per usual. You should also be able to change scenes, and your data from the previous scene should carry over!

![Godot RPG](https://cdn-images-1.medium.com/max/3840/1*ktDhk0bpPr1N4sQFQeHBCA.png)

![Godot RPG](https://cdn-images-1.medium.com/max/3840/1*rprCPUxJbb5EOB24wjkTEw.png)

Congratulations, you now have a persistent saving and loading system! Remember to save your project, and I’ll see you in the next part.

The final source code for this part should look like [this.](https://github.com/christinec-dev/DustyTrails_RPG_Parts/tree/main/Part_20)

<a href='https://ko-fi.com/J3J2LP2U5' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://storage.ko-fi.com/cdn/kofi2.png?v=3' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>

---
### FULL TUTORIAL

![Godot RPG](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pd9n6khb9jtaj0bynp7e.png)

The tutorial series has 23 chapters. I’ll be releasing all of the chapters in sectional daily parts over the next couple of weeks.

If you like this series or want to skip the wait and access the offline, full version of the tutorial series, you can support me by buying the offline booklet for just $4 on [Ko-fi!](https://ko-fi.com/s/19c32424e5)😊

You can find the updated list of the tutorial links for all 23 parts in this series [here.](https://oops-i-devd.gitbook.io/oops-i-devd/godot-tutorials/dusty-trails/tutorial)