tutorials/io/saving_games

[giscus[bot]]

tutorials/io/saving_games

Introduction: Save games can be complicated. For example, it may be desirable to store information from multiple objects across multiple levels. Advanced save game systems should allow for addition...

https://docs.godotengine.org/en/stable/tutorials/io/saving_games.html

[Tameno-01]

There are two arguably better ways to save and load games:

• Resources (used in conjuction with ResourceSaver and ResourceLoader)
• ConfigFiles

Both are significantly easier to save and load (one line of code) and provide easy storage of godot's more complex data types like Vector2s.

Resources provide extra type safety and allow for storage of sub-resources.

[flcoder]

No one can argue whether it is "more prudent" to use a "safe" save format like JSON, over the Godot resource format which executes arbitrary code. This issue is very frustrating for me. On the one hand, I do believe the end user should not be carelessly exchanging files from untrusted sources over the internet. On the other, you know they will. It drives me crazy that I cannot use this extremely convenient format to save my game data - because some people are irresponsible and another bunch are malicious. Unfortunately, this is reality. I think my original outburst was a knee-jerk reaction to that observation. I can only hope Godot developers will add a feature that will allow us to load resource files with an option to disable any script execution - that would make this issue entirely moot. I haven't looked under the hood, but it could be simple to implement (perhaps not), either way, it would be amazing if someone does it. I've never requested a feature before but I am considering learning how to do so. As for now, I've had to ditch a lot of code because as much as I want to argue my "feelings", reality is... people will be dumb and I have to account for that. I'd like to believe it's not my responsibility. But I keep imagining some kid crying about his hard drive getting wiped because he "played that game" - and of course leaving out all of his unsafe behavior. Seriously, this issue is giving me stress. But for now I think I've decided to just manually serialize/un-serialize the data. It's too much for a JSON file. It might be too much for resource files anyhow. I'm considering using mysql lite.

[flcoder]

Last thing. I promise. I feel bad about calling the video click bate. I was upset at the time. And I was wrong. I'm actually grateful that he brought up the issue. But I feel the suggested solution should not have been to say, so if you want to be a "responsible" developer, use JSON files... I think everyone should make a fuss to show they really really really would like the feature to turn off script execution upon resource loading.

[DylanBulfin]

That's fair enough, it can definitely be tedious to manually serialize in the way described here, even in smaller games.

The idea to disable scripts on resources loading has been discussed before without too much recent activity: godotengine/godot-proposals#4925

One suggestion from that discussion (albeit from a few years ago) is to use store_var and get_var from FileAccess. If you wanted to store a Resource-derived object you should be able to loop through properties recursively and use these methods, and it looks like they don't allow code execution unless you specifically tell them to. It seems like it would take less boilerplate than manual serialization, especially on large projects.

Another option is the godot-safe-resource-loader library. I know very little about it but it looks promising

[bypell]

Old thread and we may be past that, but I don't think a single player would expect a save file to easily execute any code. It's understood as being a simple container for data, not an executable/mod. Sharing save files is not considered very risky by the vast majority of players (because it isn't in most games) so making it risky and saying "I don't care, your fault for downloading a file from the internet!" sounds very irresponsible.

[MichaelrMentele]

I'd say using resources for saving as the default and (using other methods if requirements demand it) is a good rule of thumb.

Using resources for saving has many advantages while the main drawback is malicious code injection + easily edited text files that can be used for cheating.

If it ain't broke, don't fix it

It's worth noting for many games, this downside doesn't matter:

1. if saved data is stored on a cloud hosted server
2. locally hosted games where sharing saves/mods/files isn't part of the game it's not your problem any more than malicious pdf files are

When to deal with code injection

• single player games with competitive achievements (don't want them to write in infinite health for themselves)
• any p2p multiplayer game
• ???

Offline Mitigations

• use https://godotengine.org/asset-library/asset/2249 to address many of these issues
• implement your own file scanning / schema checking package, share it with the community
• make it too annoying to figure out -- you could hash the save files and then save an encrypted copy of just the hash files separately to cross check etc. -- they can scan and find encryption keys potentially but this is just one idea for obfuscation
• not much else you can do if you have a strict offline requirement

For cloud games, you can control this pretty readily:

• hash the save files and store the hash value on the cloud
• p2p quorum -- store files hash between multiplayer peers and have them all agree on the hash or throw an error

So, for myself, for most cases, using the built-in resources seems too nice to pass up but it depends on the situation.

[P5ina]

There's an error in load save file example: json.get_data() method no longer exists. Instead you should use json.data property

[Calinou]

Pull request opened:

• Fix outdated get_data() JSON method usage in Saving games godot-docs#9967

[mlaass]

There's an error for me with this code, where I get duplicate copies of the saved objects.
The fix for me was to await until the queue_free operation was successful:

var save_nodes = get_tree().get_nodes_in_group("Persist")
for node in save_nodes:
    node.queue_free()
    await node.tree_exited

Hope this helps!

[StorySword]

I am extremely sorry for not understanding where I am failing, however once corrected I hope this can be a simple example for others.

The error is as follows:
Invalid Access to property or key "increase_score" on a base object of type "nil"
Meaning (as I understand) that it is trying to send info to the old Main node(the one the save_game instance has), not to the new one (the reference of the new/current main)...

ok: sorry for the bookoo load of code that follows, but its skeletonized and focused on the example problem within the larger portion of my game....blargh sorry I'm on hour 42 and am yelling at my dogs, please tell me I'm missing something simple

2 scenes: Main (not group: Persist) and instantiated_save_game_node (scene is group "Persist"-global)

#main.gd
extends Node2D

#main.gd
extends Node2D

signal increase_score
@onready var saveNode := preload("res://instantiated_save_load_node.tscn")


# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	var pleaseSave = saveNode.instantiate()
	pleaseSave.creator_id = self
	pleaseSave.update_scores.connect(update_score_label)
	add_child(pleaseSave)
	print(pleaseSave)
	pass # Replace with function body.


# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
	pass

func call_to_save():
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		save()
	save_game()
	
func update_score_label(score,highscore):
	print(score," ",highscore)
	$LabelScore.text = str(score)
	$LabelHighScore.text = str(highscore)
	pass
	
func _on_button_increase_score_pressed() -> void:
	increase_score.emit()
	print("increase_score_signal_emitted_from_main")
	pass # Replace with function body.
	
func _on_button_save_game_pressed() -> void:
	call_to_save()
	pass # Replace with function body.

	
func _on_button_load_game_pressed() -> void:
	load_game()
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		doOnLoadSave()
	#need a way to tell the "newly" re-made saveScoreNode to resend the updateLabels update_scores.emit(score,highscore)
	pass # Replace with function body.
	
#again sense im calling from this node i must have a "dummy" function,
#have this function in every node that has Persist monaker, and is presumably saving info
#do this when you load :).....biatch! only 1 week now...roughly 40 hours over 6 days
func doOnLoadSave():
	#do a thing on loadSaveGame...
	#iterate through all nodes in Persist group and do the thing, if nothing to do just have pass here
	#update_scores.emit(score,highscore)
	pass


# Note: This can be called from anywhere inside the tree. This function is
# path independent.
# Go through everything in the persist category and ask them to return a
# dict of relevant variables.
func save_game():
	var save_file = FileAccess.open("user://savegame.save", FileAccess.WRITE)
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		# Check the node is an instanced scene so it can be instanced again during load.
		if node.scene_file_path.is_empty():
			print("persistent node '%s' is not an instanced scene, skipped" % node.name)
			continue

		# Check the node has a save function.
		if !node.has_method("save"):
			print("persistent node '%s' is missing a save() function, skipped" % node.name)
			continue

		# Call the node's save function.
		var node_data = node.call("save")

		# JSON provides a static method to serialized JSON string.
		var json_string = JSON.stringify(node_data)

		# Store the save dictionary as a new line in the save file.
		save_file.store_line(json_string)
		
# Note: This can be called from anywhere inside the tree. This function
# is path independent.
func load_game():
	if not FileAccess.file_exists("user://savegame.save"):
		return # Error! We don't have a save to load.

	# We need to revert the game state so we're not cloning objects
	# during loading. This will vary wildly depending on the needs of a
	# project, so take care with this step.
	# For our example, we will accomplish this by deleting saveable objects.
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for i in save_nodes:
		i.queue_free()
		#as suggested by comment above
		await i.tree_exited

	# Load the file line by line and process that dictionary to restore
	# the object it represents.
	var save_file = FileAccess.open("user://savegame.save", FileAccess.READ)
	while save_file.get_position() < save_file.get_length():
		var json_string = save_file.get_line()

		# Creates the helper class to interact with JSON.
		var json = JSON.new()

		# Check if there is any error while parsing the JSON string, skip in case of failure.
		var parse_result = json.parse(json_string)
		if not parse_result == OK:
			print("JSON Parse Error: ", json.get_error_message(), " in ", json_string, " at line ", json.get_error_line())
			continue

		# Get the data from the JSON object.
		var node_data = json.data

		# Firstly, we need to create the object and add it to the tree and set its position.
		var new_object = load(node_data["filename"]).instantiate()
		get_node(node_data["parent"]).add_child(new_object)
		new_object.position = Vector2(node_data["pos_x"], node_data["pos_y"])

		# Now we set the remaining variables.
		for i in node_data.keys():
			if i == "filename" or i == "parent" or i == "pos_x" or i == "pos_y":
				continue
			new_object.set(i, node_data[i])

#even though I'm not saving this node, because I am saving FROM this node, I need to have a dummy/skeleton save command
func save():
	var save_dict = {
		"filename" : get_scene_file_path(),
		"parent" : get_parent().get_path(),
		"pos_x" : position.x, # Vector2 is not supported by JSON
		"pos_y" : position.y,
		}
	return save_dict

and

#main.gd
extends Node2D

signal increase_score
@onready var saveNode := preload("res://instantiated_save_load_node.tscn")


# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	var pleaseSave = saveNode.instantiate()
	pleaseSave.creator_id = self
	pleaseSave.update_scores.connect(update_score_label)
	add_child(pleaseSave)
	print(pleaseSave)
	pass # Replace with function body.


# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
	pass

func call_to_save():
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		save()
	save_game()
	
func update_score_label(score,highscore):
	print(score," ",highscore)
	$LabelScore.text = str(score)
	$LabelHighScore.text = str(highscore)
	pass
	
func _on_button_increase_score_pressed() -> void:
	increase_score.emit()
	print("increase_score_signal_emitted_from_main")
	pass # Replace with function body.
	
func _on_button_save_game_pressed() -> void:
	call_to_save()
	pass # Replace with function body.

	
func _on_button_load_game_pressed() -> void:
	load_game()
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		doOnLoadSave()
	#need a way to tell the "newly" re-made saveScoreNode to resend the updateLabels update_scores.emit(score,highscore)
	pass # Replace with function body.
	
#again sense im calling from this node i must have a "dummy" function,
#have this function in every node that has Persist monaker, and is presumably saving info
#do this when you load :).....biatch! only 1 week now...roughly 40 hours over 6 days
func doOnLoadSave():
	#do a thing on loadSaveGame...
	#iterate through all nodes in Persist group and do the thing, if nothing to do just have pass here
	#update_scores.emit(score,highscore)
	pass


# Note: This can be called from anywhere inside the tree. This function is
# path independent.
# Go through everything in the persist category and ask them to return a
# dict of relevant variables.
func save_game():
	var save_file = FileAccess.open("user://savegame.save", FileAccess.WRITE)
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		# Check the node is an instanced scene so it can be instanced again during load.
		if node.scene_file_path.is_empty():
			print("persistent node '%s' is not an instanced scene, skipped" % node.name)
			continue

		# Check the node has a save function.
		if !node.has_method("save"):
			print("persistent node '%s' is missing a save() function, skipped" % node.name)
			continue

		# Call the node's save function.
		var node_data = node.call("save")

		# JSON provides a static method to serialized JSON string.
		var json_string = JSON.stringify(node_data)

		# Store the save dictionary as a new line in the save file.
		save_file.store_line(json_string)
		
# Note: This can be called from anywhere inside the tree. This function
# is path independent.
func load_game():
	if not FileAccess.file_exists("user://savegame.save"):
		return # Error! We don't have a save to load.

	# We need to revert the game state so we're not cloning objects
	# during loading. This will vary wildly depending on the needs of a
	# project, so take care with this step.
	# For our example, we will accomplish this by deleting saveable objects.
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for i in save_nodes:
		i.queue_free()
		#as suggested by comment above
		await i.tree_exited

	# Load the file line by line and process that dictionary to restore
	# the object it represents.
	var save_file = FileAccess.open("user://savegame.save", FileAccess.READ)
	while save_file.get_position() < save_file.get_length():
		var json_string = save_file.get_line()

		# Creates the helper class to interact with JSON.
		var json = JSON.new()

		# Check if there is any error while parsing the JSON string, skip in case of failure.
		var parse_result = json.parse(json_string)
		if not parse_result == OK:
			print("JSON Parse Error: ", json.get_error_message(), " in ", json_string, " at line ", json.get_error_line())
			continue

		# Get the data from the JSON object.
		var node_data = json.data

		# Firstly, we need to create the object and add it to the tree and set its position.
		var new_object = load(node_data["filename"]).instantiate()
		get_node(node_data["parent"]).add_child(new_object)
		new_object.position = Vector2(node_data["pos_x"], node_data["pos_y"])

		# Now we set the remaining variables.
		for i in node_data.keys():
			if i == "filename" or i == "parent" or i == "pos_x" or i == "pos_y":
				continue
			new_object.set(i, node_data[i])

#even though I'm not saving this node, because I am saving FROM this node, I need to have a dummy/skeleton save command
func save():
	var save_dict = {
		"filename" : get_scene_file_path(),
		"parent" : get_parent().get_path(),
		"pos_x" : position.x, # Vector2 is not supported by JSON
		"pos_y" : position.y,
		}
	return save_dict

[StorySword]

a fix maybe

func _on_button_load_game_pressed() -> void:
	load_game()
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		node.mainId = self
		node.doOnLoadSave()
	#need a way to tell the "newly" re-made saveScoreNode to resend the updateLabels update_scores.emit(score,highscore)
	pass # Replace with function body.

#constructor in saveNode
@onready var mainId := get_parent()

#ready() in saveNode
mainId.increase_score.connect(scoreUp)

[StorySword]

#smash face on keyboard... I've got to be over complicating this... and no I dont want to use resources, or anything else, just this Json example.
Goal is:
1)affect something in my game
2)affect hundreds of things in tens of thousands of units
3)save an arbitrary number of stuffs in an arbitrary number of units with possibly a score keeper on the side cause
everyone(mostly) likes to track scores/stats
4)Load things like upgrades, unlocks, level progression, or even entire mid-game maps, aswell as be able to reset the map to check points (whole nother set of code)
5)Thank the developers of godot with money made from a published-earning game... ... ... ... ?!

[StorySword]

OK, thinking about it, basically their are four nodes in the full equation: 1)original Main, 2)Original saveNode, 3)New Main, 4)New save Mode
And when we load in Orignal saveNode (deleting new saveNode in the process), we lose BOTH the signal connections, FROM AND TO the New Main and Original saveNode.
The work around I'm using (cause it may not be best practise) is:

1. when loading (and creating all the disconnects) I add in to the for loop: node.mainId = self
   2)this gives me a reference to the new Main node, inside all of the "old"/(loaded) instances
   3)I update the old instance connections via the for loop that I added in the load_game() and add in the saveNode: mainId.increase_score.connect(scoreUp)
   which for this one instance, but I plan on changing this to a variable, so it will work with all signal functions within any node by adding an array of signals within node and looping through them #more code upfront, but less down the line
   4Update the new mainNode via calling mainId.update_signal_connections(self) in the ready() of the allSaveNodes(in the old saveNode this dosnt hurt anything, and when we load/instantiate the new saveNode it reestablishes the new mainNode with the Old saveNode()
   5)Then resend an update signal to the new mainNode from the oldSave node re-establishing the score in the labels
   when I have a complete re work I'll place as a reply, and admins can do what they want with all this....

okay done did... but I'm having to click the load button twice before things work, so gonna hunt that problem down! but big progress!

[StorySword]

!!!!Finished/Fixed!!!! It was the signal connections and a few other little bits here and their. The following is the completed, reworked, WORKING!!!, and commented version.

#main.gd
extends Node2D
#this is a simplified example, the smallest "game" I could think of
#press a button to increase a score
#the button pressed action emits a signal from main
#the saveScoreNode (instantiated_save_load_node...sorry) updates the score and highscore
#then returns a signal with arguments(score/highscore) to main
#main then updates the labels
#this is not the cleanest version of these tasks but broken up to be easily replaceable/re-writable for
#making other games or tying into an half-built exsisting game

signal increase_score
@onready var saveNode := preload("res://instantiated_save_load_node.tscn")
var transfer_node

func _ready() -> void:
	var pleaseSave = saveNode.instantiate()
	pleaseSave.update_scores.connect(update_score_label)
	print("ready-main-",pleaseSave)
	add_child(pleaseSave)


func _process(delta: float) -> void:
	pass

	
#using this to update the new signal handshake from old save instance to new main
#sence the old saveNode was passed the new mainNode's refernce in the load_game() function
#I'm sending the call function method from the old saveNode, to the new mainNode passing the
#old saveNodes reference as an argument, then connecting
#remember I'm trying to fix reference paths both up and down stream using signals
#because get_node ($) wont work on instantiated nodes let alone ones with wrong refernce paths
func update_signal_connections(newSignalNode):
	newSignalNode.update_scores.connect(update_score_label)


#this just updates the score labels, as they are static down the tree from main
func update_score_label(score,highscore):
	print("mainNode-update_score_label: ",score," ",highscore)
	$LabelScore.text = str(score)
	$LabelHighScore.text = str(highscore)


#our basic custom signal emitting so we can change the "score" number and have visual reference that things are working properly
func _on_button_increase_score_pressed() -> void:
	increase_score.emit()
	print("main-increase_score.emit()")


func _on_button_save_game_pressed() -> void:
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		node.save() #gather the save_dict(ionaries) from all the nodes group-marked Persist
	save_game() #save_game function collects them, parse to json(object to line), and opens n writes to file


func _on_button_load_game_pressed() -> void:
	load_game() #will go through all things in file and load them up
	var save_nodes = get_tree().get_nodes_in_group("Persist") #may mess up if their are persist files that werent saved... not sure why that'd be though
	for node in save_nodes:
		node.mainId = self #gives the loaded old saved nodes a reference to this New Game/New Scene main node
		node.doOnLoadSave() #sends back a new main node references from the loaded old save nodes, 
		#be sure to have a method here to call, to re-connect the signal with the loaded old node reference, anyone have a better way?
		#and runs any updates  that those nodes control, in this case resends the update_score_labe(score,highscore)
		#to update the loaded score/highscore...lol should be just the highscore ROFL

#a newer version may add what I've done to the save_game() / load_game() functions...but I am mentally
#exhausted... maybe later will update, or would love if someone else would?






#only change to save_game(), load_game() was 
#for i in save_nodes:
		#i.queue_free()
		#await i.tree_exited
#in load_game() due to above comment from mlaass due to duplicate instances being created/deleted

# Note: This can be called from anywhere inside the tree. This function is
# path independent.
# Go through everything in the persist category and ask them to return a
# dict of relevant variables.
func save_game():
	var save_file = FileAccess.open("user://savegame.save", FileAccess.WRITE)
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for node in save_nodes:
		# Check the node is an instanced scene so it can be instanced again during load.
		if node.scene_file_path.is_empty():
			print("persistent node '%s' is not an instanced scene, skipped" % node.name)
			continue

		# Check the node has a save function.
		if !node.has_method("save"):
			print("persistent node '%s' is missing a save() function, skipped" % node.name)
			continue

		# Call the node's save function.
		var node_data = node.call("save")

		# JSON provides a static method to serialized JSON string.
		var json_string = JSON.stringify(node_data)

		# Store the save dictionary as a new line in the save file.
		save_file.store_line(json_string)
		
# Note: This can be called from anywhere inside the tree. This function
# is path independent.
func load_game():
	if not FileAccess.file_exists("user://savegame.save"):
		return # Error! We don't have a save to load.

	# We need to revert the game state so we're not cloning objects
	# during loading. This will vary wildly depending on the needs of a
	# project, so take care with this step.
	# For our example, we will accomplish this by deleting saveable objects.
	var save_nodes = get_tree().get_nodes_in_group("Persist")
	for i in save_nodes:
		i.queue_free()
		##as suggested by comment above
		#go rid of because it stops for whatever reason the labels from updating with one press of load_game() button
		#await i.tree_exited

	# Load the file line by line and process that dictionary to restore
	# the object it represents.
	var save_file = FileAccess.open("user://savegame.save", FileAccess.READ)
	while save_file.get_position() < save_file.get_length():
		var json_string = save_file.get_line()

		# Creates the helper class to interact with JSON.
		var json = JSON.new()

		# Check if there is any error while parsing the JSON string, skip in case of failure.
		var parse_result = json.parse(json_string)
		if not parse_result == OK:
			print("JSON Parse Error: ", json.get_error_message(), " in ", json_string, " at line ", json.get_error_line())
			continue

		# Get the data from the JSON object.
		var node_data = json.data

		# Firstly, we need to create the object and add it to the tree and set its position.
		var new_object = load(node_data["filename"]).instantiate()
		get_node(node_data["parent"]).add_child(new_object)
		new_object.position = Vector2(node_data["pos_x"], node_data["pos_y"])

		# Now we set the remaining variables.
		for i in node_data.keys():
			if i == "filename" or i == "parent" or i == "pos_x" or i == "pos_y":
				continue
			new_object.set(i, node_data[i])

saveNode

#instantiated_save_load_node.gd
extends Node2D

#dont forget to type-reference( := ),( : type =) for sanity sake when dynamic programming assumes wrong, sometimes!
var score : int = 0
var highscore : int = 0
signal update_scores(arg1,arg2)
#could just use parent, untill we have to do alot of re-referncing when we load_game()
@onready var mainId := get_parent()

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	print("saveNode-mainId: ",mainId)
	mainId.increase_score.connect(scoreUp)
	mainId.update_signal_connections(self)
	pass # Replace with function body.


# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
	pass

func scoreUp():
	score += 1
	if score > highscore:
		highscore = score
		"saveNode-highscore=score"
	update_scores.emit(score,highscore)
	print("saveNode-scoreUp().emit",score," ",highscore)
		
#this function is ran from main, in all Persist-grouped nodes, 
#after using the load_game, to replace all old nodes with the new ones
func doOnLoadSave():
	#when nodes are loaded the signal connections are "lost" between
	#persisted and non persisted nodes this is my attempt at reconnecting them
	
	
	#mainId should be updated as it is updated and passed in the load_game() function in main
	#updates signal connection between this old saveNode and the new mainNode
	mainId.increase_score.connect(scoreUp)
	#updates signal connection between new mainNode with this old saveNode 
	#(old because we already loaded the old saved node)
	mainId.update_signal_connections(self)
	#on load_game make sure to call functions to update hud labels
	update_scores.emit(score,highscore)
	#just making sure everyting is pressing along
	print("saveNode@doOnLoadSave: ",score," ",highscore)
	
#remember the following code goes into EVERY node you are saving via node-group-"Persist"
func save():
	var save_dict = {
		"filename" : get_scene_file_path(),
		"parent" : get_parent().get_path(),
		"pos_x" : position.x, # Vector2 is not supported by JSON
		"pos_y" : position.y,
		#the above are requireed while below is saving info
		"score" : score,
		"highscore" : highscore
		}
	return save_dict #BE CAREFUL TO ADD THIS RETURN!!! IF MISSED LOTS OF UNSEEN PAIN!!!!!

I do still get two errors but dosn't seem harmful:

E 0:00:27:0540   instantiated_save_load_node.gd:40 @ doOnLoadSave(): Signal 'increase_score' is already connected to given callable 'Node2D(instantiated_save_load_node.gd)::scoreUp' in that object.
  <C++ Error>    Method/function failed. Returning: ERR_INVALID_PARAMETER
  <C++ Source>   core/object/object.cpp:1402 @ connect()
  <Stack Trace>  instantiated_save_load_node.gd:40 @ doOnLoadSave()
                 main.gd:62 @ _on_button_load_game_pressed()

and:

E 0:00:27:0540   main.gd:34 @ update_signal_connections(): Signal 'update_scores' is already connected to given callable 'Node2D(main.gd)::update_score_label' in that object.
  <C++ Error>    Method/function failed. Returning: ERR_INVALID_PARAMETER
  <C++ Source>   core/object/object.cpp:1402 @ connect()
  <Stack Trace>  main.gd:34 @ update_signal_connections()
                 instantiated_save_load_node.gd:43 @ doOnLoadSave()
                 main.gd:62 @ _on_button_load_game_pressed()

Thank you, please leave comments on how to improve, or if this is all simplified by pushing one simple button somewhere. Thank you!

[Calinou]

PS: In the future, you can edit posts by viewing the comments on the GitHub Discussions interface and clicking the Edit button that is located behind the ... icon in the top-right corner of your comments (it doesn't appear on the Giscus frontend used in the docs).

[tombasche]

The C# example is interesting and doesn't look very idiomatic to me; would a better approach be to have Nodes that can save and load, implement an interface (ISaveable) and the Save() method can do this instead:

        if (saveNode is ISaveable saveableNode)
        {
            var nodeData = saveableNode.Save()
        }
        else
        {
            GD.Print($"persistent node '{saveNode.Name}' doesn't implement a saveable interface, skipped");
            continue;
        }

[OS-of-S]

Note that not all properties are included. Only properties that are configured with the PROPERTY_USAGE_STORAGE flag set will be serialized. You can add a new usage flag to a property by overriding the _get_property_list method in your class. You can also check how property usage is configured by calling Object._get_property_list. See PropertyUsageFlags for the possible usage flags.

What does it mean? Does it mean that it includes variables and scripts not included by default? Or that if I saving an object (a scene for exemple) it would save all the data including scripts if it saved inside of scenes? Does binary have any security benefits???

(I actually didn't expect saving the game would be such a mess! :D)

[OS-of-S]

I've done a little experiments on binary serialisation and found a non-obvious thing. It seems that users can't serialize objects wich linked with sources outside of res:// folder.

That's a test script I made for it:

data_to_store = {"Player0" : "AMONGUS 0_0", "Player1" : RefCounted.new()}
var script_path = "user://saves_test_script.gd"
var script_file = FileAccess.open(script_path, FileAccess.WRITE)
var script_sorce = '''
extends RefCounted
func hack_test():
	print("\\n(」°ロ°)」 HACKER ATTAK!!! ＼(º □ º )/")
'''
script_file.store_string(script_sorce)
script_file.close()
var script = load(script_path)
data_to_store["Player1"].set_script(script)
var file_path = "user://test.save"
save_file = FileAccess.open(file_path, FileAccess.WRITE)
save_file.store_var(data_to_store, true)
save_file.close()

save_file = FileAccess.open(file_path, FileAccess.READ)
var a =save_file.get_var(true)
print("\nREADING FROM FILE: ", a)
if a!=null and a["Player1"].has_method("hack_test"):
	a["Player1"].hack_test()

In theory a vulnerability message should be displayed in the console after loading the saved object, but it isn't! Instead the output is READING FROM FILE: <null> despite the fact that full_obects is true during both reading and writing. The reason actually in storing data, because if I open user://test.save I see that save file is empty.

Of course, if I change save_file.store_var(data_to_store, true) to save_file.store_var(data_to_store, false) it saves my dictionary is saved as it should be - without a reference to the script and therefore no message is printed. But if I change var script_path = "user://saves_test_script.gd" to var script_path = "res://saves_test_script.gd" - it works perfectly as I expected a message "(」°ロ°)」 HACKER ATTAK!!! ＼(º □ º )/" is displayed.

[OS-of-S]

I tried to pick around PropertyUsageFlags, but it seems that for asigning them a script needed, so I can't set usage for a script property if script is not loaded, if I get it right.

Actually, I don't know why is it happening. Maybe that's an artificial restriction for safety reasons? Then it's better to indicate this fact in the documentation. Also this does not shed light on the security level of the binary save format. Is it completely impossible to execute arbitrary script via this format, or it's just Godot does not allow saving a potentially virus file?

[Stan-Stani]

I'm unsure why the tutorial doesn't talk about using str_to_var("Vector3(3,3,3)").

Also the save file generated here is actually invalid JSON. Why not save each node in an array instead of using line breaks to separate them?

[HolonProduction]

No, str_to_var is no great idea:

str_to_var('Object(RefCounted,"script":Object(GDScript,"script/source":"@tool extends RefCounted;func _init(): print(\'hello\')"))')

[TranquilMarmot]

@HolonProduction thanks, I was trying to figure out how to do the injection!

I'm curious if you could do the same with var_to_bytes

var t := Transform3D()
        
# save this as a string to JSON
var encoded := var_to_bytes(t).hex_encode()

# read it back out into a Transform3D
var decoded = bytes_to_var(encoded.hex_decode())

I have a hunch it has the same vulnerability just with extra steps.

[Stan-Stani]

Ah so the problem would be if someone downloaded a save it could inject malicious code?

[TranquilMarmot]

@Stan-Stani yes, same issue as with using Resource as a save file

[StorySword]

Time to go back to nes days, where we just have a serialized code, that tells the game where we are, what of what we have, and what flags have been set deset, then scramble it. Tell the player if you wanna save or even play on someone elses computer just copy/paste the serialized crypto-code, but then we get shark-attacks for sega...

[nakano15]

Saving games tutorial lacks telling about the usage of "var_to_str" and "str_to_var" methods for when saving and loading values from variables types like Vector3 and more.

[uwu-420]

For everyone who prefers watching a video about this topic, I can highly recommend Saving and loading games with Godot by Godotneers.

[jkulawik]

It is worth noting that you can mix and match binary and text approaches to saving by encoding binary blobs (e.g. as base64: Marshalls.variant_to_base64) and putting them in JSON, similarly to how gltf works.

As far as I can tell this is safe because the function mentioned above requires you to supply allow_objects=true to make it load anything potentially malicious - it internally uses the same function (bytes_to_var) as store_var. This approach requires less code and disk space than storing in pure JSON, for example with data such as Transforms.