Upgrade Godot Version & Work Towards Level Gen

scripts/v2/loading/progress_step_tracker.gd

@@ -0,0 +1,50 @@
+class_name ProgressStepTracker
+extends Object
+
+var _step_name: String = ""
+var _message: String = ""
+var _subset_index: int = 0
+var _subset_count: int = 0
+
+var _tracker: ProgressTracker = null
+
+func _init(tracker: ProgressTracker, step_name: String):
+	self._tracker = tracker
+	self._step_name = step_name
+
+# set_substeps: set the number of substeps for this step
+func set_substeps(substeps: int):
+	self._subset_count = substeps
+
+# substep: should be called when a substep is started
+func substep(message: String = ""):
+	self._subset_index += 1
+	self._message = message
+	self._tracker.progress_update.emit()
+
+# complete: should be called when this step is done
+func complete():
+	self._tracker.step_complete.emit()
+
+# get_step_name: get the name of this step
+func get_step_name() -> String:
+	return self._step_name	
+
+# get_message: get the message for this step
+func get_message() -> String:
+	return self._message
+
+# get_substep_index: get the index of the current substep
+func get_substep_index() -> int:
+	return self._subset_index
+
+# get_substep_count: get the number of substeps for this step
+func get_substep_count() -> int:
+	return self._subset_count
+
+# get_progress: get the progress of this step
+func get_progress() -> float:
+	if self._subset_count == 0:
+		return 0.0
+	else:
+		return float(self._subset_index) / float(self._subset_count)

scripts/v2/loading/progress_tracker.gd

@@ -0,0 +1,50 @@
+class_name ProgressTracker
+extends Object
+
+signal progress_update()
+signal step_change(step: int)
+signal complete()
+signal step_complete()
+
+var _current_step: ProgressStepTracker = null
+var _current_step_index: int = -1
+var _steps_count: int
+
+func _init(step_count: int = 0) -> void:
+	_steps_count = step_count
+	self.substep_complete.connect(self, "_on_substep_complete")
+
+func _on_step_complete() -> void:
+	if _current_step_index == _steps_count:
+		self.complete.emit()
+		return
+
+# next_step: should be called before the step is actually started
+func next_step(step_name: String = "") -> ProgressStepTracker:
+	_current_step_index += 1
+	if _current_step_index > _steps_count:
+		push_error("Number of steps tracked is larger than number of steps used!")
+	step_change.emit(_current_step_index)
+
+	self._current_step = ProgressStepTracker.new(self, step_name)
+	self.progress_update.emit()
+
+	return self._current_step
+	
+# step_complete: returns the progress of all steps
+func get_step_progress() -> float:
+	return float(_current_step_index) / float(_steps_count)
+
+# get_total_progress_percentage: returns the progress of all steps and substeps
+func get_total_progress_percentage() -> float:
+	return self.get_step_progress()
+
+# get_progress_data: returns a dictionary with data about the current progress for the UI
+func get_progress_data() -> Dictionary:
+	return {
+		"step_name": self._current_step.get_step_name(),
+		"message": self._current_step.get_message(),
+		"substeps": self._current_step.get_substeps(),
+		"current_substep": self._current_step.get_substep_index(),
+		"total_progress":self.get_total_progress_percentage()		
+	}

scripts/v2/worldgen/standard/room.gd

@@ -0,0 +1,19 @@
+class_name StandardRoom
+extends TileMap
+
+@export_category("Room Openings")
+@export var left: bool = false
+@export var right: bool = false
+@export var top: bool = false
+@export var bottom: bool = false
+
+
+@onready
+var room_size: Vector2i = self.get_used_rect().size
+@onready
+var cell_size: Vector2i = self.tile_set.tile_size
+
+func is_block() -> bool:
+	if self.left or self.right or self.top or self.bottom:
+		return false
+	return true

scripts/v2/worldgen/standard_generator.gd

@@ -2,7 +2,49 @@ class_name StandardWorldGenerator
 extends WorldGenerator
 
 @export
-var parts: Array[PackedScene] = []
+var rooms: Array[PackedScene] = []
+
+var _rooms_left: Array[PackedScene] = []
+var _rooms_right: Array[PackedScene] = []
+var _rooms_top: Array[PackedScene] = []
+var _rooms_bottom: Array[PackedScene] = []
+var _rooms_blocking: Array[PackedScene] = []
+
+var _progress_tracker: ProgressTracker = ProgressTracker.new(1)
 
 func _generate(map: TileMap) -> void:
-	pass
+	self._sort_rooms(_progress_tracker.next_step("Sorting Rooms"))
+
+func _sort_rooms(step_tracker: ProgressStepTracker) -> void:
+	step_tracker.complete.call_deferred()
+	
+	step_tracker.set_substeps(len(self.rooms))
+	for room_scene in rooms:
+		step_tracker.substep(room_scene.get_name())
+		var room: StandardRoom = room_scene.instantiate()
+		if room.left:
+			self._rooms_left.append(room_scene)
+		if room.right:
+			self._rooms_right.append(room_scene)
+		if room.top:
+			self._rooms_top.append(room_scene)
+		if room.bottom:
+			self._rooms_bottom.append(room_scene)
+		if room.is_block():
+			self._rooms_blocking.append(room_scene)
+			
+		room.queue_free()
+	
+	if len(self._rooms_left) == 0:
+		push_error("0 left rooms!")
+	if len(self._rooms_right) == 0:
+		push_error("0 right rooms!")
+	if len(self._rooms_top) == 0:
+		push_error("0 top rooms!")
+	if len(self._rooms_bottom) == 0:
+		push_error("0 bottom rooms!")
+	if len(self._rooms_blocking) == 0:
+		push_warning("0 blocking rooms!")
+
+func _get_progress_tracker() -> ProgressTracker:
+	return self._progress_tracker

scripts/v2/worldgen/world_generator.gd

@@ -7,3 +7,10 @@ func generate(map: TileMap) -> void:
 		return
 
 	self.call("_generate", map)
+
+func get_progress_tracker() -> ProgressTracker:
+	if not self.has_method("_get_progress_tracker"):
+		push_error("Generator missing `_get_progress_tracker` method")
+		return null
+	
+	return self.call("_get_progress_tracker")