layla/glitch-in-the-system
1
0
Fork 0
Code Issues 10 Pull Requests Packages Projects 1 Releases 1 Wiki Activity

General code improvements, progress step tracker implementation for worldgen, and work towards enemy behavior

Browse Source
This commit is contained in:
Layla
2024-01-23 21:45:52 +01:00
parent 3f465a708c
commit 49562ba9ce
11 changed files with 517 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
scripts/v2/worldgen/standard/entity_marker.gd
View File

@ -1,59 +1,67 @@
class_name StandardEntityMarker
extends Node2D
enum SPAWN_METHOD {
ALL,
FURTHEST,
ONCE,
NONE
}
## The method used to spawn entities
##
## ALL: Spawns all entities in the list
## FURTHEST: Spawns the entity furthest from the player
## ONCE: Spawns the entity once at a random marker
## NONE: Does not spawn any entities
enum EntitySpawnMethod { ALL, FURTHEST, ONCE, NONE }
enum ENTITY_SELECTION_METHOD {
RANDOM,
POP
}
## The method used to select entities
##
## RANDOM: Selects a random entity from the list
## POP: Removes the entity from the list after it is selected
enum EntitySelectionMethod { RANDOM, POP }
@export_category("Entity Spawning")
@export
var marker_id: String
## The ID representing the type of this marker
@export var marker_id: String
@export
var entities: Array[PackedScene] = []
## The entities that can be spawned by this marker
@export var entities: Array[PackedScene] = []
@export
var spawn_method: SPAWN_METHOD
## The method used to spawn entities
@export var spawn_method: EntitySpawnMethod
@export_range(0, 1.0)
var spawn_chance: float = 1.0
## The chance that an entity will be spawned
@export_range(0, 1.0) var spawn_chance: float = 1.0
@export
var entity_selection_method: ENTITY_SELECTION_METHOD
## The method used to select entities
@export var entity_selection_method: EntitySelectionMethod
@export_category("Marker Debug")
@export
var debug_color: Color = Color.WHITE
## The color of the debug sprite
@export var debug_color: Color = Color.WHITE
## The size of the debug sprite
@export var marker_size: int = 16
@export
var marker_size: int = 16
func _ready() -> void:
self.add_to_group("genv2:entity_marker")
## Create a debug sprite if one doesn't exist
var sprite: Sprite2D = self.get_node_or_null("Sprite2D")
if not sprite:
sprite = Sprite2D.new()
sprite.texture = _get_debug_texture()
self.add_child(sprite)
func _register(gen: StandardWorldGenerator) -> void:
## Registers this marker with the world generator
func register(gen: StandardWorldGenerator) -> void:
if self.marker_id == "":
push_error("Marker ID is empty, this marker will not be used for spawning entities.")
return
gen._register_marker("genv2:entity_marker:%s" % self.marker_id, self)
gen.register_marker("genv2:entity_marker:%s" % self.marker_id, self)
## Generates a texture for the debug sprite
func _get_debug_texture() -> Texture2D:
var texture = GradientTexture2D.new()
var gradient = Gradient.new()
gradient.colors = [self.debug_color]
@ -61,5 +69,5 @@ func _get_debug_texture() -> Texture2D:
texture.width = self.marker_size
texture.height = self.marker_size
return texture

146
scripts/v2/worldgen/standard/room.gd
View File

@ -9,18 +9,27 @@ const TILEMAP_LAYER = 0
@export var top: bool = false
@export var bottom: bool = false
var room_size: Vector2i
var cell_size: Vector2i
## The rect that the room occupies in the map
## from 0, 0 to room_size.x, room_size.y
var room_size: Vector2i
## The size of each tile in the room
var cell_size: Vector2i
func _init() -> void:
self.room_size = self.get_used_rect().size
self.cell_size = self.tile_set.tile_size
## Returns true when the room has no exits
func is_block() -> bool:
if self.left or self.right or self.top or self.bottom:
return false
return true
## Get the position of the exit in the room
func get_exits() -> Array[Vector2i]:
var exits: Array[Vector2i] = []
if self.left:
@ -33,6 +42,8 @@ func get_exits() -> Array[Vector2i]:
exits.append(Vector2i.DOWN)
return exits
## Get the position of the exit in the room
func get_exit_pos(exit: Vector2i) -> Vector2i:
var pos: Vector2i = Vector2i.ZERO
if exit == Vector2i.LEFT:
@ -45,75 +56,122 @@ func get_exit_pos(exit: Vector2i) -> Vector2i:
pos = Vector2i(self.room_size.x / 2, self.room_size.y - 1)
return pos
## Get the offset of the exit position from the edge of the room
func get_exit_pos_offset(edge_pos: Vector2i, exit: Vector2i) -> Vector2i:
match exit:
Vector2i.UP:
return edge_pos + Vector2i(self.room_size.x/-2, self.room_size.y * -1)
return edge_pos + Vector2i(self.room_size.x / -2, self.room_size.y * -1)
Vector2i.DOWN:
return edge_pos + Vector2i(self.room_size.x/-2, 1)
return edge_pos + Vector2i(self.room_size.x / -2, 1)
Vector2i.LEFT:
return edge_pos + Vector2i(-self.room_size.x, -self.room_size.y/2)
return edge_pos + Vector2i(-self.room_size.x, -self.room_size.y / 2)
Vector2i.RIGHT:
return edge_pos + Vector2i(1, -self.room_size.y/2)
return edge_pos + Vector2i(1, -self.room_size.y / 2)
_:
return Vector2i.ZERO
## Copy the room to the TileMap at a given position
func copy_to_map(map: TileMap) -> void:
for x in range(0, self.room_size.x):
for y in range(0, self.room_size.y):
var tile = self.get_cell_source_id(TILEMAP_LAYER, Vector2i(x, y))
var alt = self.get_cell_alternative_tile(TILEMAP_LAYER, Vector2i(x, y))
if tile != -1:
map.set_cell(TILEMAP_LAYER, Vector2i(position.x + x, position.y + y), tile, Vector2i(0, 0), alt)
else:
map.set_cell(TILEMAP_LAYER, Vector2i(position.x + x, position.y + y), -1, Vector2i(0, 0))
if tile != -1:
map.set_cell(
TILEMAP_LAYER,
Vector2i(position.x + x, position.y + y),
tile,
Vector2i(0, 0),
alt
)
else:
map.set_cell(
TILEMAP_LAYER, Vector2i(position.x + x, position.y + y), -1, Vector2i(0, 0)
)
## Seal the exit of a room by placing a tile over it
func seal_exit(map: TileMap, pos: Vector2i, exit: Vector2i) -> void:
var exit_pos = get_exit_pos(exit)
var seal_tile_id = 0
match exit:
Vector2i.UP:
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x - 1, pos.y), seal_tile_id, Vector2i(0, 0))
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y), seal_tile_id, Vector2i(0, 0))
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x + 1, pos.y), seal_tile_id, Vector2i(0, 0))
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x - 1, pos.y), seal_tile_id, Vector2i(0, 0)
)
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y), seal_tile_id, Vector2i(0, 0)
)
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x + 1, pos.y), seal_tile_id, Vector2i(0, 0)
)
Vector2i.DOWN:
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x - 1, pos.y), seal_tile_id, Vector2i(0, 0))
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y), seal_tile_id, Vector2i(0, 0))
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x + 1, pos.y), seal_tile_id, Vector2i(0, 0))
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x - 1, pos.y), seal_tile_id, Vector2i(0, 0)
)
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y), seal_tile_id, Vector2i(0, 0)
)
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x + 1, pos.y), seal_tile_id, Vector2i(0, 0)
)
Vector2i.RIGHT:
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y - 1), seal_tile_id, Vector2i(0, 0))
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y), seal_tile_id, Vector2i(0, 0))
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y + 1), seal_tile_id, Vector2i(0, 0))
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y - 1), seal_tile_id, Vector2i(0, 0)
)
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y), seal_tile_id, Vector2i(0, 0)
)
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y + 1), seal_tile_id, Vector2i(0, 0)
)
Vector2i.LEFT:
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y - 1), seal_tile_id, Vector2i(0, 0))
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y), seal_tile_id, Vector2i(0, 0))
map.set_cell(TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y + 1), seal_tile_id, Vector2i(0, 0))
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y - 1), seal_tile_id, Vector2i(0, 0)
)
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y), seal_tile_id, Vector2i(0, 0)
)
map.set_cell(
TILEMAP_LAYER, exit_pos + Vector2i(pos.x, pos.y + 1), seal_tile_id, Vector2i(0, 0)
)
## Check if the room overlaps with any tiles in the map
func is_overlapping(map: TileMap) -> bool:
for x in range(0, self.room_size.x):
for y in range(0, self.room_size.y):
var tile = map.get_cell_source_id(TILEMAP_LAYER, Vector2i(self.position.x + x, self.position.y + y))
var tile = map.get_cell_source_id(
TILEMAP_LAYER, Vector2i(self.position.x + x, self.position.y + y)
)
if tile != -1:
return true
return false
# Validate room by checking that the top left tile is at 0, 0 and all exits are valid
func _validate() -> bool:
# Check for tiles where x is negative
pass
# Check for tiles where y is negative
pass
## Validate room by checking that the top left tile is at 0, 0 and all exits are valid
func _validate() -> bool:
# If exit on left, check that the middle tile on the left is empty
if self.left and self.get_cell_source_id(TILEMAP_LAYER, Vector2i(0, self.room_size.y / 2)) != -1:
if (
self.left
and self.get_cell_source_id(TILEMAP_LAYER, Vector2i(0, self.room_size.y / 2)) != -1
):
push_error("Room with exit on left must have empty middle tile on left")
return false
# If exit on right, check that the middle tile on the right is empty
if self.right and self.get_cell_source_id(TILEMAP_LAYER, Vector2i(self.room_size.x - 1, self.room_size.y / 2)) != -1:
if (
self.right
and (
self.get_cell_source_id(
TILEMAP_LAYER, Vector2i(self.room_size.x - 1, self.room_size.y / 2)
)
!= -1
)
):
push_error("Room with exit on right must have empty middle tile on right")
return false
# If exit on top, check that the middle tile on the top is empty
@ -121,18 +179,32 @@ func _validate() -> bool:
push_error("Room with exit on top must have empty middle tile on top")
return false
# If exit on bottom, check that the middle tile on the bottom is empty
if self.bottom and self.get_cell_source_id(TILEMAP_LAYER, Vector2i(self.room_size.x / 2, self.room_size.y - 1)) != -1:
if (
self.bottom
and (
self.get_cell_source_id(
TILEMAP_LAYER, Vector2i(self.room_size.x / 2, self.room_size.y - 1)
)
!= -1
)
):
push_error("Room with exit on bottom must have empty middle tile on bottom")
return false
return true
## Flip a vector
func flip_vector(vector: Vector2i) -> Vector2i:
return Vector2i(vector.x * -1, vector.y * -1)
## Disable a room exit by setting the corresponding exit variable to false
func disable_room_exit_opposite(exit: Vector2i) -> void:
self.disable_room_exit(self.flip_vector(exit))
## Disable a room exit by setting the corresponding exit variable to false
func disable_room_exit(exit: Vector2i) -> void:
if exit == Vector2i.LEFT:
self.left = false

204
scripts/v2/worldgen/standard_generator.gd
View File

@ -1,14 +1,14 @@
class_name StandardWorldGenerator
extends WorldGenerator
@export
var rooms: Array[PackedScene] = []
## Rooms used to generate the map
@export var rooms: Array[PackedScene] = []
@export
var max_room_path_length: int = 10
## Maximum length of a path of rooms
@export var max_room_path_length: int = 10
@export
var spawn_room: PackedScene = null
## Room used to spawn the player
@export var spawn_room: PackedScene = null
# Rooms are sorted into these arrays based on their exits
# Each PackedScene is a StandardRoom
@ -18,33 +18,48 @@ var _rooms_top: Array[PackedScene] = []
var _rooms_bottom: Array[PackedScene] = []
var _rooms_blocking: Array[PackedScene] = []
## Number of total generated rooms
var _room_count: int = 0
## Progress tracker
var _progress_tracker: ProgressTracker
## Marker groups
var _markers: Dictionary = {}
func _generate(map: TileMap) -> void:
self._progress_tracker = ProgressTracker.new(1)
func _init() -> void:
self._progress_tracker = ProgressTracker.new(4)
## Generates a map
func _generate(map: TileMap) -> void:
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"))
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"))
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()
## Sorts rooms into arrays based on their exits
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()
step_tracker.substep(room.name)
if room.left:
self._rooms_left.append(room_scene)
if room.right:
@ -55,9 +70,9 @@ func _sort_rooms(step_tracker: ProgressStepTracker) -> void:
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:
@ -69,27 +84,34 @@ func _sort_rooms(step_tracker: ProgressStepTracker) -> void:
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:
## 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)
self._room_count += 1
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()
## Creates rooms from the exits of the given room
func _create_rooms(
map: TileMap, parent_room: StandardRoom, max_path_length: int, step_tracker: ProgressStepTracker
) -> void:
if step_tracker.get_substep_count() == 0:
step_tracker.complete.call_deferred()
## This is an approximation of the number of rooms that will be created
step_tracker.set_substeps(
(max_path_length * (max_path_length + 1) / 2) * len(parent_room.get_exits())
)
var exits: Array[Vector2i] = parent_room.get_exits()
@ -98,30 +120,37 @@ func _create_rooms(map: TileMap, parent_room: StandardRoom, max_path_length: int
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:
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()
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:
@ -133,9 +162,8 @@ func _create_rooms(map: TileMap, parent_room: StandardRoom, max_path_length: int
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
@ -144,63 +172,76 @@ func _create_rooms(map: TileMap, parent_room: StandardRoom, max_path_length: int
# 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)
self._room_count += 1
step_tracker.substep("%s rooms" % self._room_count)
# 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:
## Returns the rooms that can be added in the given direction
func _get_rooms(exit: Vector2i) -> Array[PackedScene]:
match exit:
Vector2i.LEFT:
return self._rooms_left
Vector2i.RIGHT:
return self._rooms_right
Vector2i.UP:
return self._rooms_top
Vector2i.DOWN:
return self._rooms_bottom
push_error("Invalid exit: " + str(exit))
return []
## Registers a marker with the world generator
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:
## Spawns entities in the map
func _spawn_entities(map: TileMap, _step_tracker: ProgressStepTracker) -> void:
_step_tracker.complete.call_deferred()
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)
entity_marker.register(self)
_step_tracker.set_substeps(len(self._markers.keys()))
for marker_id in self._markers:
_step_tracker.substep.call_deferred(marker_id)
var sample_marker: StandardEntityMarker = self._markers[marker_id][0]
match sample_marker.spawn_method:
StandardEntityMarker.SPAWN_METHOD.ALL:
StandardEntityMarker.EntitySpawnMethod.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)
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:
StandardEntityMarker.EntitySpawnMethod.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)
@ -215,48 +256,57 @@ func _spawn_entities(map: TileMap, step_tracker: ProgressStepTracker) -> void:
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)
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:
StandardEntityMarker.EntitySpawnMethod.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)
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:
StandardEntityMarker.EntitySpawnMethod.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:
## Selects an entity from the given array based on the given selection method
func _select_entity(
mode: StandardEntityMarker.EntitySelectionMethod, entities: Array
) -> PackedScene:
if len(entities) == 0:
return null
match mode:
StandardEntityMarker.ENTITY_SELECTION_METHOD.RANDOM:
StandardEntityMarker.EntitySelectionMethod.RANDOM:
var i = randi() % len(entities)
return entities[i]
StandardEntityMarker.ENTITY_SELECTION_METHOD.POP:
StandardEntityMarker.EntitySelectionMethod.POP:
var i = randi() % len(entities)
return entities.pop_at(i)
return null
## Returns the progress tracker for this world generator
func _get_progress_tracker() -> ProgressTracker:
return self._progress_tracker

5
scripts/v2/worldgen/world_generator.gd
View File

@ -1,6 +1,7 @@
class_name WorldGenerator
extends Resource
## Generates a world to the given TileMap.
func generate(map: TileMap) -> void:
if not self.has_method("_generate"):
push_error("Generator missing `_generate` method")
@ -8,9 +9,11 @@ func generate(map: TileMap) -> void:
self.call("_generate", map)
## Returns the progress tracker for this generator.
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")