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

Working map generator

Browse Source
This commit is contained in:
Layla
2024-01-21 00:42:57 +01:00
parent cd80ab3357
commit 405b374b9a
17 changed files with 240 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
scripts/v2/loading/progress_tracker.gd
View File

@ -12,7 +12,7 @@ var _steps_count: int
func _init(step_count: int = 0) -> void:
_steps_count = step_count
self.substep_complete.connect(self, "_on_substep_complete")
#self.substep_complete.connect(self, "_on_substep_complete")
func _on_step_complete() -> void:
if _current_step_index == _steps_count:

5
scripts/v2/world.gd
View File

@ -8,3 +8,8 @@ var map: TileMap
func _ready() -> void:
self.generator.generate(map)
func _process(_delta: float) -> void:
if Input.is_action_just_pressed("jump"):
map.clear()
self.generator.generate(map)

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

@ -9,11 +9,12 @@ const TILEMAP_LAYER = 0
@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
var room_size: Vector2i
var cell_size: Vector2i
func _init() -> void:
self.room_size = self.get_used_rect().size
self.cell_size = self.tile_set.tile_size
func is_block() -> bool:
if self.left or self.right or self.top or self.bottom:
@ -44,19 +45,62 @@ func get_exit_pos(exit: Vector2i) -> Vector2i:
pos = Vector2i(self.room_size.x / 2, self.room_size.y - 1)
return pos
func copy_to_map(map: TileMap, pos: Vector2i) -> void:
for x in range(self.room_size.x):
for y in range(self.room_size.y):
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)
Vector2i.DOWN:
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)
Vector2i.RIGHT:
return edge_pos + Vector2i(1, -self.room_size.y/2)
_:
return Vector2i.ZERO
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))
if tile.tile_set:
map.set_cell(TILEMAP_LAYER, Vector2i(pos.x + x, pos.y + y), tile.tile_id)
if tile != -1:
map.set_cell(TILEMAP_LAYER, Vector2i(position.x + x, position.y + y), tile, Vector2i(0, 0))
else:
map.set_cell(TILEMAP_LAYER, Vector2i(pos.x + x, pos.y + y), -1)
map.set_cell(TILEMAP_LAYER, Vector2i(position.x + x, position.y + y), -1, Vector2i(0, 0))
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))
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))
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))
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))
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))
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 of tiles where x is negative
# Check for tiles where x is negative
pass
# Check for tiles where y is negative
@ -80,3 +124,19 @@ func _validate() -> bool:
return false
return true
func flip_vector(vector: Vector2i) -> Vector2i:
return Vector2i(vector.x * -1, vector.y * -1)
func disable_room_exit_opposite(exit: Vector2i) -> void:
self.disable_room_exit(self.flip_vector(exit))
func disable_room_exit(exit: Vector2i) -> void:
if exit == Vector2i.LEFT:
self.left = false
elif exit == Vector2i.RIGHT:
self.right = false
elif exit == Vector2i.UP:
self.top = false
elif exit == Vector2i.DOWN:
self.bottom = false

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

@ -18,9 +18,10 @@ var _rooms_top: Array[PackedScene] = []
var _rooms_bottom: Array[PackedScene] = []
var _rooms_blocking: Array[PackedScene] = []
var _progress_tracker: ProgressTracker = ProgressTracker.new(1)
var _progress_tracker: ProgressTracker
func _generate(map: TileMap) -> void:
self._progress_tracker = ProgressTracker.new(1)
self._sort_rooms(_progress_tracker.next_step("Sorting Rooms"))
@ -30,8 +31,9 @@ func _generate(map: TileMap) -> void:
# Create rooms
self._create_rooms(map, init_room, self.max_room_path_length, _progress_tracker.next_step("Creating Rooms"))
map.update_internals()
func _sort_rooms(step_tracker: ProgressStepTracker, validate: bool = false) -> void:
func _sort_rooms(step_tracker: ProgressStepTracker) -> void:
step_tracker.complete.call_deferred()
step_tracker.set_substeps(len(self.rooms))
@ -67,12 +69,12 @@ func _create_initial_room(map: TileMap, room: PackedScene, step_tracker: Progres
step_tracker.complete.call_deferred()
# Instantiate spawn room
var spawn_room: StandardRoom = room.instance()
var init_room: StandardRoom = room.instantiate()
# Copy spawn room into map
spawn_room.copy_to_map(map, Vector2i(0, 0))
init_room.copy_to_map(map)
return spawn_room
return init_room
# Create rooms by randomly selecting from the available rooms in every direction with openings from the current room
@ -88,6 +90,8 @@ func _create_rooms(map: TileMap, parent_room: StandardRoom, max_path_length: int
# 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
@ -106,30 +110,42 @@ func _create_rooms(map: TileMap, parent_room: StandardRoom, max_path_length: int
var room_edge_pos: Vector2i = exit_pos + Vector2i(parent_room.position)
# If there is already a room at this position, skip it
if map.get_cellv(room_edge_pos) != -1:
continue
# Get the rooms that can be added in this direction
var rooms: Array[PackedScene] = self._get_rooms(exit)
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(rooms) == 0:
if len(possible_rooms) == 0:
continue
# Get the room to add
var room: PackedScene = rooms[randi() % len(rooms)]
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
# Instantiate the room
var room_instance: StandardRoom = room.instance()
room_instance.position = room_edge_pos + (room_instance.size / 2)
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, Vector2i(room_instance.position))
room_instance.copy_to_map(map)
# Create rooms from the exits of the room that was just added
self._create_rooms(map, room_instance, max_path_length - 1, step_tracker.next_step("Creating Rooms"))
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

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

@ -2,7 +2,7 @@ class_name WorldGenerator
extends Resource
func generate(map: TileMap) -> void:
if self.has_method("_generate"):
if not self.has_method("_generate"):
push_error("Generator missing `_generate` method")
return