Chunk Loading System not saving chunks correctly

Gallus17 · November 17, 2025, 3:51pm

Godot Version

Godot 4.5.1.stable.official

Question

I’ve created my own chunk-saving/loading system based on pre-determined` chunks saved as individual scenes, which load in a 3x3 square around (0,0) at runtime. As the player moves, the chunk manager unloads and reloads chunks, ensuring a 3x3 square of chunks surrounding them is always instanced. When a chunk is unloaded, it’s saved to disk as a .res file. When a chunk is loaded for the first time, it’s loaded from the scene, but any subsequent loads are from the disk. The issue I’m having is that when (0,0) is unloaded, the unload function indicates that it’s being saved, and the .res file exists; however, when it’s loaded again, it’s not there.

Node structure for test scene:

Basic Node Structure for each chunk, though the save load system should be able toaccount for any number of children:

Relevant functions:

func load_chunks():
	for dx in range(-1, 2):  # -1, 0, 1
		for dy in range(-1, 2):
			var chunk_x = PLAYER_CHUNK.x + dx
			var chunk_y = PLAYER_CHUNK.y + dy
			var coords = Vector2i(chunk_x, chunk_y)
			
			# Construct save file path
			var save_path = GlobalData.global_save_path + "chunk_" + str(coords.x) + "_" + str(coords.y) + ".res"
			
			var chunk_instance = null
			
			# First try to load from JSON if it exists
			if FileAccess.file_exists(save_path):
				#print('loading from disk: ', coords)
				var packed_scene = load(save_path)  # returns PackedScene
				if packed_scene:
					chunk_instance = packed_scene.instantiate()
				#else:
				#	print("Failed to load saved chunk:", save_path)
				
			#else:
				#print('file does not exist: ', save_path)
			# If no saved JSON, load from scene
			if chunk_instance == null:
				#print('loading from scene')
				var scene_path = "res://test_chunk(" + str(coords.x) + "," + str(coords.y) + ").tscn"
				var chunk_scene = load(scene_path)
				if chunk_scene:
					chunk_instance = chunk_scene.instantiate()
				#else:
					#print("Failed to load chunk scene:", scene_path)
			
			# Add to scene if we successfully loaded or instantiated it
			if chunk_instance:
				$"Chunks".add_child(chunk_instance)

				
func save_node_to_disk(chunk):
	var save_path = GlobalData.global_save_path
	var coords = Vector2i(0, 0)
	if "," in chunk.name:
		coords.x = int(chunk.name.get_slice(",", 0))
		coords.y = int(chunk.name.get_slice(",", 1))

	var save_location = save_path + "chunk_" + str(coords.x) + "_" + str(coords.y) + ".res"
	
	# Ensure children have correct owner for packing
	for child in chunk.get_children():
		child.owner = chunk
	
	var packed = PackedScene.new()
	var err = packed.pack(chunk)  # returns an int error code
	if err != OK:
		#print("Failed to pack chunk:", err)
		return
	
	ResourceSaver.save(packed, save_location)
	#print("Saved chunk as PackedScene:", save_location)

orwinsen · November 22, 2025, 1:34pm

i think your save_node_to_disk always falls back to coords = Vector2i(0,0) because the chunk.name parsing fails (your scene root name contains parentheses/prefix like test_chunk(0,0)), so every chunk gets saved as chunk_0_0.res. Later you try to load chunk_x_y.res which doesn’t exist.

Quick fixes

Store coords on the chunk (best): set a property or meta when instancing and read that when saving. e.g. when you instance:

chunk.set_meta(“coords”, Vector2i(x,y))
then in save: var coords = chunk.get_meta(“coords”)

Or robustly parse the name (if you prefer):

var coords = Vector2i(0,0)
if "(" in chunk.name and "," in chunk.name:
    var inside = chunk.name.get_slice("(",1).get_slice(")",0) # "0,0"
    var parts = inside.split(",")
    coords.x = int(parts[0])
    coords.y = int(parts[1])

Check save success: inspect err = ResourceSaver.save(…) return and packed.pack() error. Log them.

Paths: ensure GlobalData.global_save_path is a valid path (ends with / and uses user:// or res:// you expect). Use ResourceLoader.load(save_location) or load(save_location) consistently.

That should fix it — you’re basically overwriting chunk_0_0.res. Fix coords source and verify save return values.

Gallus17 · November 22, 2025, 3:31pm

I decided to add the new parsing code, and that doesn’t seem to have fixed it. Could you explain how I check the save success? The save path is valid.

Edit:

I added debug statements, and the script returned this for 0,0:

— Processing chunk:(0, 0)—
Save path:user://SquirrelGame-VersionBeta5-5/Chunks/chunk_0_0.res
File exists on disk, attempting to load.
Loaded saved chunk successfully.
Adding chunk to scene:(0, 0)

Despite this, the tilemap isn’t appearing. Photos for reference:

At runtime:

After 0,0 is unloaded and reloaded:

pizza_delivery_man · November 22, 2025, 4:00pm

How do you add the newly instantiated packed scene to the world? Theres a global function i used that calls

X.get_current_scene().add_child(new_node)

(Or similar). I cant remember what X stands for, but hopfully someone can fix your problem before i go back onto PC.

Gallus17 · November 22, 2025, 4:12pm

in my load chunks function, i have this:

# Add to scene
			if chunk_instance:
				print("Adding chunk to scene:", coords)
				$"Chunks".add_child(chunk_instance)
			else:
				print("ERROR: No instance created, chunk NOT added:", coords)

pizza_delivery_man · November 23, 2025, 3:55am

I would suggest a redesign. Or at least first prove that the chunks can be accessed in that way without save/load.

You should maybe use the absolute world coordinates of the chunk instead of setting the chunk underneath the player position as (0,0). I would avoid the brackets in the node name too.

So for example, if you had a world size of (128, 128) tiles and the tile size was 4, then the world size is 128×4=512.

When the player is at global_position 49.2, 27.9 then you compute (floor(49.2/tile_size) , floor (27.9/tile_size)) so the player is on tile index (12,6)

Then if you apply the pattern subtracting dx and dy as in your code above, you can retrieve tiles
(11,5), (12,5), (13,5),(11,6),(12, 6),(13,6), (11,7) … etc.

Then load them in … perhaps the map could be stored on disk or even generated procedurally.
If you call them 0_0 instead of 12_6 its easy to make an error.

Also with packed scenes loading and intiating in seperate threads doesnt work the same way with the rendering server.

github.com/godotengine/godot

PackedScene loading and instancing in separate threads respectively triggers thread guards

opened 10:07AM - 08 Jul 23 UTC

felbecker

discussion topic:core documentation needs testing

### Godot version 4.1 ### System information Windows 11 64 Bit ### Issue des…cription I have a 2D world streaming system with 2 background threads that queue the following kind of jobs: - The first thread just loads `PackedScene`s. - The second thread calls `instantiate()`, decomposes the scene into smaller pieces following specific rules and adds the pieces savely (`call_deferred`) to the main scene with some delay between them. This system stopped working (error spam of this kind: `get_use_parent_material: This function in this node (TileMap) can only be accessed from either the main thread or a thread group. Use call_deferred() instead.`) when migrating from 4.0 to 4.1 because of the new thread guards. It worked fine in 4.0 and also works fine in 4.1 with `set_thread_safety_checks_enabled(false)`. Still, I was trying to make it work with active checks to be absolutely sure about thread safety. Doing that, I stumbled over this issue: Apparently the thread guard errors I observe stem from the specific situation when **loading a scene in one thread and then instantiate it in another**. In principle (according to [Thread-safe APIs](https://docs.godotengine.org/en/stable/tutorials/performance/thread_safe_apis.html) and my own experience) instantiating a `PackedScene` in a thread other than the main thread is safe (can someone confirm this for 4.1 in all cases (rendering, collision ect) ?). **The thread guard errors disappear if I move the instancing to the loading thread.** Otherwise there are 2 kinds of settings: 1. Someone can confirm that the guards are correct: Scenes should be instantiated in the thread that loaded them. In this case, I would refactor my system and move the instancing to the loading thread and the issue is fixed. 2. The guards should not trigger. Instancing is meant to be safe no matter the thread. In this case, this is a bug report. ### Steps to reproduce This script reproduces the error. In my case `complex.tscn` is a large 2D scene with particle systems, tilemaps, sprites, collision ect, which I can not provide. If required, I can try to put a test scene together that triggers the issue. ``` extends Node2D var thread_load var thread_instantiate func _ready(): thread_load = Thread.new() thread_instantiate = Thread.new() thread_load.start(_load.bind(self)) func _load(parent): var scene = load("res://complex.tscn") thread_instantiate.start(_instantiate_add.bind(scene, parent)) func _instantiate_add(scene, parent): var instance = scene.instantiate() parent.call_deferred("add_child", instance) ``` ### Minimal reproduction project -

Gallus17 · November 23, 2025, 3:21pm

I’m currently calculating the player’s chunk here:

var current_chunk_x = floor(player.global_position.x - player_start_pos.x) * chunk_size.x / tile_size/2 
var current_chunk_y = floor(player.global_position.y - player_start_pos.y) * chunk_size.y / tile_size/2

var current_chunk: Vector2i = Vector2i(current_chunk_x, current_chunk_y)

Is that how I should be doing it according to your redesign?

pizza_delivery_man · November 23, 2025, 7:43pm

Yeah, maybe you should try loading pre-defined chunks instead of saving them first.

Start by fetching them from pre-loaded memory, then load from the file, then rebuild the component after every stage has been tested.

pizza_delivery_man · November 23, 2025, 8:54pm

I dont know what you are calling a chunk, but im putting the division inside the floor() function because 27.9/4 = 6 + 3.9/4, and rounding to an int could get the ceiling() on some platforms.

pizza_delivery_man · November 23, 2025, 9:55pm

If chunk size is 2×2 tiles, then,

tiles_per_chunk_x =2

if you are on tile (12, 6) then the chunk is

chunk_x = floor(12 / tiles_per_chunk_x)

So the complete calculation

var tile_size = 4
var tiles_per_chunk =2
var tile_x = floor(player.global_position.x/tile_size)
var chunk_x =floor( tile_x / tiles_per_chunk)

Gallus17 · November 23, 2025, 9:59pm

here is tile_size just tiles_per_chunk_x * tiles_per_chunk_y?

Gallus17 · November 23, 2025, 10:09pm

I just implemented it, and it seems to be more responsive than my old chunk calculating! However, it didn’t fix my initial issue. You mentioned loading predefined chunks before saving them, and I thought that’s what my load function was doing. If it isn’t, please let me know how to fix it!!

pizza_delivery_man · November 23, 2025, 10:11pm

No i was saying, if you had a chunk of 4 tiles in a 2*2 square, then tile_size would be the actual size of a tile in world units …

So ive defined a grid of tiles on a floating point space, and then a grid of larger tiles called chunks defined on the grid of tiles. The chunk_size is just tile_size ×2 in this case

Gallus17 · November 23, 2025, 10:12pm

Ok, thanks!

pizza_delivery_man · November 23, 2025, 10:15pm

Ok i think you should

1 ) start with a function that does not load or save, just get the tiles from an array and instantiate them then draw them.

once you are confident that you can instantiate chunks in position, define some in files that you can load up to check the load function. Then …
check the save function writes persistant storage.

Gallus17 · November 23, 2025, 10:18pm

ok, for step 1 should the tiles be indiviual scenes?

pizza_delivery_man · November 23, 2025, 11:06pm

I would have chunks as individual scenes, assuming tiles are the smallest measurable world element. Then the chunks contain some tiles, pre-arranged into position.

Gallus17 · November 25, 2025, 1:55am

I got through steps one and two all right, but while trying to check if the file writes persistent storage, I tried to find the files on my computer and couldn’t. The function says the directory exists and is correctly writing files, but I can’t find them anywhere on my Mac. Any advice for finding them? the function writes the files to “user://SquirrelGame-VersionBeta5-5/Chunks/”.

pizza_delivery_man · November 25, 2025, 3:41pm

Perhaps try writing them to a local directory, within the game res:// folder.

Gallus17 · November 25, 2025, 7:20pm

I saved them locally, and it is writing persistent storage. is there any way to check the content of a tilemap remotely during runtime? The only reason it still wouldn’t be appearing is that the tile map data is saving improperly, but only for 0,0 for some reason.