263 lines
8.5 KiB
GDScript
263 lines
8.5 KiB
GDScript
class_name StandardWorldGenerator
|
|
extends WorldGenerator
|
|
|
|
@export
|
|
var rooms: Array[PackedScene] = []
|
|
|
|
@export
|
|
var max_room_path_length: int = 10
|
|
|
|
@export
|
|
var spawn_room: PackedScene = null
|
|
|
|
# Rooms are sorted into these arrays based on their exits
|
|
# Each PackedScene is a StandardRoom
|
|
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
|
|
|
|
var _markers: Dictionary = {}
|
|
|
|
func _generate(map: TileMap) -> void:
|
|
self._progress_tracker = ProgressTracker.new(1)
|
|
|
|
self._sort_rooms(_progress_tracker.next_step("Sorting Rooms"))
|
|
|
|
# Create initial room
|
|
var init_room = self._create_initial_room(map, self.spawn_room, _progress_tracker.next_step("Creating Initial Room"))
|
|
init_room.queue_free.call_deferred()
|
|
|
|
# Create rooms
|
|
self._create_rooms(map, init_room, self.max_room_path_length, _progress_tracker.next_step("Creating Rooms"))
|
|
map.update_internals()
|
|
|
|
self._spawn_entities(map, _progress_tracker.next_step("Spawning Entities"))
|
|
map.update_internals()
|
|
|
|
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!")
|
|
|
|
# Create initial room
|
|
func _create_initial_room(map: TileMap, room: PackedScene, step_tracker: ProgressStepTracker) -> StandardRoom:
|
|
step_tracker.complete.call_deferred()
|
|
|
|
# Instantiate spawn room
|
|
var init_room: StandardRoom = room.instantiate()
|
|
|
|
# Copy spawn room into map
|
|
init_room.copy_to_map(map)
|
|
|
|
return init_room
|
|
|
|
|
|
# Create rooms by randomly selecting from the available rooms in every direction with openings from the current room
|
|
# where the maximum path length has not been exceeded and the room does not overlap with any other room.
|
|
#
|
|
# Each room is marked with boolean flags for each direction that it has an opening to another room.
|
|
#
|
|
# This is done recursively until the maximum path length is exceeded or there are no more rooms to add
|
|
func _create_rooms(map: TileMap, parent_room: StandardRoom, max_path_length: int, step_tracker: ProgressStepTracker) -> void:
|
|
step_tracker.complete.call_deferred()
|
|
|
|
var exits: Array[Vector2i] = parent_room.get_exits()
|
|
|
|
# If the maximum path length has been exceeded, stop
|
|
if max_path_length <= 0:
|
|
for exit in exits:
|
|
parent_room.seal_exit(map, parent_room.position, exit)
|
|
return
|
|
|
|
# If there are no more exits, stop
|
|
if len(exits) == 0:
|
|
return
|
|
|
|
# If there are no more rooms to add, stop
|
|
if len(self._rooms_left) == 0 and len(self._rooms_right) == 0 and len(self._rooms_top) == 0 and len(self._rooms_bottom) == 0:
|
|
push_warning("No more rooms to add!")
|
|
return
|
|
|
|
# For every exit, try to add a room
|
|
for exit in exits:
|
|
# Find exit pos in current room
|
|
var exit_pos: Vector2i = parent_room.get_exit_pos(exit)
|
|
|
|
var room_edge_pos: Vector2i = exit_pos + Vector2i(parent_room.position)
|
|
|
|
# Get the rooms that can be added in this direction
|
|
var possible_rooms: Array[PackedScene] = self._get_rooms(parent_room.flip_vector(exit)).duplicate()
|
|
|
|
# If there are no rooms that can be added in this direction, skip it
|
|
if len(possible_rooms) == 0:
|
|
continue
|
|
|
|
# Get the room to add
|
|
var room_instance: StandardRoom = null
|
|
while len(possible_rooms) != 0 and room_instance == null:
|
|
var i = randi() % len(possible_rooms)
|
|
var possible_room = possible_rooms.pop_at(i).instantiate()
|
|
var origin_pos: Vector2i = possible_room.get_exit_pos_offset(room_edge_pos, exit)
|
|
possible_room.position = origin_pos
|
|
|
|
if possible_room.is_overlapping(map):
|
|
continue
|
|
|
|
|
|
room_instance = possible_room
|
|
|
|
if room_instance == null:
|
|
parent_room.seal_exit(map, parent_room.position, exit)
|
|
continue
|
|
room_instance.queue_free.call_deferred()
|
|
|
|
# Disable direction that the room was added from
|
|
# since the parent room will already be there
|
|
room_instance.disable_room_exit_opposite(exit)
|
|
|
|
# Copy the room into the map
|
|
room_instance.copy_to_map(map)
|
|
|
|
# Create rooms from the exits of the room that was just added
|
|
step_tracker.substep("Creating Rooms")
|
|
self._create_rooms(map, room_instance, max_path_length - 1, step_tracker)
|
|
|
|
# If there are no more exits, stop
|
|
return
|
|
|
|
func _get_rooms(exit: Vector2i) -> Array[PackedScene]:
|
|
if exit == Vector2i.LEFT:
|
|
return self._rooms_left
|
|
elif exit == Vector2i.RIGHT:
|
|
return self._rooms_right
|
|
elif exit == Vector2i.UP:
|
|
return self._rooms_top
|
|
elif exit == Vector2i.DOWN:
|
|
return self._rooms_bottom
|
|
else:
|
|
push_error("Invalid exit: " + str(exit))
|
|
return []
|
|
|
|
func _register_marker(group: String, marker: Node2D) -> void:
|
|
if not group in self._markers:
|
|
self._markers[group] = [marker]
|
|
else:
|
|
self._markers[group].append(marker)
|
|
|
|
func _spawn_entities(map: TileMap, step_tracker: ProgressStepTracker) -> void:
|
|
var tree = map.get_tree()
|
|
|
|
# Register entity markers
|
|
for entity_marker in tree.get_nodes_in_group("genv2:entity_marker"):
|
|
if entity_marker is StandardEntityMarker:
|
|
entity_marker._register(self)
|
|
|
|
for marker_id in self._markers:
|
|
var sample_marker: StandardEntityMarker = self._markers[marker_id][0]
|
|
|
|
match sample_marker.spawn_method:
|
|
StandardEntityMarker.SPAWN_METHOD.ALL:
|
|
for marker in self._markers[marker_id]:
|
|
map.erase_cell.call_deferred(0, map.local_to_map(marker.position))
|
|
|
|
var packed_entity: PackedScene = _select_entity(marker.entity_selection_method, marker.entities)
|
|
if packed_entity == null:
|
|
continue
|
|
|
|
var entity: Node2D = packed_entity.instantiate()
|
|
entity.position = marker.position
|
|
map.add_child(entity)
|
|
StandardEntityMarker.SPAWN_METHOD.FURTHEST:
|
|
var furthest_marker: StandardEntityMarker = self._markers[marker_id].pop_back()
|
|
var furthest_distance: float = furthest_marker.position.distance_to(Vector2.ZERO)
|
|
|
|
# Calculate furthest marker and destroy others
|
|
for marker in self._markers[marker_id]:
|
|
var calc_distance: float = marker.position.distance_to(Vector2.ZERO)
|
|
if calc_distance > furthest_distance:
|
|
map.erase_cell(0, map.local_to_map(furthest_marker.position))
|
|
furthest_marker = marker
|
|
furthest_distance = calc_distance
|
|
else:
|
|
map.erase_cell(0, map.local_to_map(marker.position))
|
|
|
|
# Erase furthest marker
|
|
map.erase_cell.call_deferred(0, map.local_to_map(furthest_marker.position))
|
|
|
|
# Get entity
|
|
var packed_entity: PackedScene = _select_entity(furthest_marker.entity_selection_method, furthest_marker.entities)
|
|
if packed_entity == null:
|
|
continue
|
|
|
|
var entity: Node2D = packed_entity.instantiate()
|
|
entity.position = furthest_marker.position
|
|
map.add_child(entity)
|
|
|
|
|
|
StandardEntityMarker.SPAWN_METHOD.ONCE:
|
|
var i = randi() % len(self._markers[marker_id])
|
|
var marker = self._markers[marker_id][i]
|
|
|
|
var packed_entity: PackedScene = _select_entity(marker.entity_selection_method, marker.entities)
|
|
if packed_entity != null:
|
|
var entity: Node2D = packed_entity.instantiate()
|
|
entity.position = marker.position
|
|
map.add_child(entity)
|
|
|
|
for _marker in self._markers[marker_id]:
|
|
map.erase_cell(0, map.local_to_map(_marker.position))
|
|
|
|
StandardEntityMarker.SPAWN_METHOD.NONE:
|
|
for marker in self._markers[marker_id]:
|
|
map.erase_cell(0, map.local_to_map(marker.position))
|
|
_:
|
|
push_error("Invalid spawning method!")
|
|
continue
|
|
|
|
func _select_entity(mode: StandardEntityMarker.ENTITY_SELECTION_METHOD, entities: Array) -> PackedScene:
|
|
if len(entities) == 0:
|
|
return null
|
|
|
|
match mode:
|
|
StandardEntityMarker.ENTITY_SELECTION_METHOD.RANDOM:
|
|
var i = randi() % len(entities)
|
|
return entities[i]
|
|
StandardEntityMarker.ENTITY_SELECTION_METHOD.POP:
|
|
var i = randi() % len(entities)
|
|
return entities.pop_at(i)
|
|
|
|
return null
|
|
|
|
func _get_progress_tracker() -> ProgressTracker:
|
|
return self._progress_tracker
|