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

Mag gen & work towards AI

Browse Source
This commit is contained in:
Layla
2024-01-21 16:39:13 +01:00
parent 405b374b9a
commit 9e3deaf3b0
20 changed files with 341 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
scripts/v2/worldgen/standard/entity_marker.gd Normal file
View File

@ -0,0 +1,65 @@
class_name StandardEntityMarker
extends Node2D
enum SPAWN_METHOD {
ALL,
FURTHEST,
ONCE,
NONE
}
enum ENTITY_SELECTION_METHOD {
RANDOM,
POP
}
@export_category("Entity Spawning")
@export
var marker_id: String
@export
var entities: Array[PackedScene] = []
@export
var spawn_method: SPAWN_METHOD
@export_range(0, 1.0)
var spawn_chance: float = 1.0
@export
var entity_selection_method: ENTITY_SELECTION_METHOD
@export_category("Marker Debug")
@export
var debug_color: Color = Color.WHITE
@export
var marker_size: int = 16
func _ready() -> void:
self.add_to_group("genv2:entity_marker")
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:
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)
func _get_debug_texture() -> Texture2D:
var texture = GradientTexture2D.new()
var gradient = Gradient.new()
gradient.colors = [self.debug_color]
texture.gradient = gradient
texture.width = self.marker_size
texture.height = self.marker_size
return texture

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

@ -62,8 +62,10 @@ 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))
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))

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

@ -20,6 +20,8 @@ var _rooms_blocking: Array[PackedScene] = []
var _progress_tracker: ProgressTracker
var _markers: Dictionary = {}
func _generate(map: TileMap) -> void:
self._progress_tracker = ProgressTracker.new(1)
@ -32,6 +34,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()
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()
@ -163,5 +168,95 @@ func _get_rooms(exit: Vector2i) -> Array[PackedScene]:
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