breadwinner/maps/procedural_map_parts_ver_premade/map_generator.gd
2026-08-08 01:55:16 +02:00

225 lines
6.9 KiB
GDScript

extends Node3D
@export_group("Map Pieces")
@export var start_room_scene: PackedScene
@export var cap_scene: PackedScene
@export var room_scenes: Array[PackedScene]
@export var corridor_scenes: Array[PackedScene]
@export_group("Generation Rules")
@export_range(0.0, 1.0) var corridor_chance: float = 0.5
@export var room_threshold: int = 15
@export_range(0.0, 1.0) var stop_chance_step: float = 0.1
var generated_rooms: Array[Node3D] = []
var open_connections: Array[Dictionary] = []
var total_pieces: int = 0
func _ready() -> void:
generate_map()
func draw_connection_laser(pos1: Vector3, pos2: Vector3):
var mesh_instance = MeshInstance3D.new()
var cylinder = CylinderMesh.new()
# Make a thin, long laser beam
cylinder.top_radius = 0.05
cylinder.bottom_radius = 0.05
cylinder.height = pos1.distance_to(pos2)
var material = StandardMaterial3D.new()
material.albedo_color = Color.GREEN
material.emission_enabled = true
material.emission = Color.GREEN
cylinder.surface_set_material(0, material)
mesh_instance.mesh = cylinder
get_tree().current_scene.add_child(mesh_instance)
# Position it exactly between the two markers and make it look at the target
mesh_instance.global_position = pos1.lerp(pos2, 0.5)
mesh_instance.look_at(pos2, Vector3.UP)
# Cylinder meshes stand up (Y) by default, we need it to point forward (Z)
mesh_instance.rotate_object_local(Vector3.RIGHT, PI/2)
func generate_map():
if not start_room_scene or not cap_scene:
push_error("MapGenerator needs both a Start Room Scene and a Cap Scene!")
return
var start_room = start_room_scene.instantiate()
add_child(start_room)
generated_rooms.append(start_room)
add_open_connections(start_room, "room")
total_pieces += 1
var attempts = 0
while open_connections.size() > 0 and attempts < 2000:
attempts += 1
var target_dict = open_connections.pick_random()
var target_marker = target_dict["marker"]
var target_type = target_dict["type"]
if is_marker_blocked(target_marker):
open_connections.erase(target_dict)
continue
# 1. Decide what category we are TRYING to spawn
var spawn_category = "room"
var cap_probability = 0.0
if total_pieces > room_threshold:
cap_probability = (total_pieces - room_threshold) * stop_chance_step
if randf() < cap_probability:
spawn_category = "cap"
elif target_type == "room" and randf() < corridor_chance and corridor_scenes.size() > 0:
spawn_category = "corridor"
# 2. Gather all scenes for that category and SHUFFLE them
var scenes_to_try = []
if spawn_category == "cap":
scenes_to_try = [cap_scene]
elif spawn_category == "corridor":
scenes_to_try = corridor_scenes.duplicate()
scenes_to_try.shuffle() # Randomize the order we try the corridors
else:
scenes_to_try = room_scenes.duplicate()
scenes_to_try.shuffle() # Randomize the order we try the rooms
var placed_successfully = false
# 3. Try EVERY scene until one fits
for scene in scenes_to_try:
if placed_successfully:
break
var new_room = scene.instantiate()
add_child(new_room)
var new_room_markers = new_room.connection_markers.duplicate()
if new_room_markers.is_empty():
new_room.free()
continue
new_room_markers.shuffle() # Try the new room's doors in random order too!
# 4. Try EVERY door on the chosen scene
for incoming_marker in new_room_markers:
align_room(new_room, incoming_marker, target_marker)
var overlaps = false
for existing_room in generated_rooms:
if do_rooms_overlap(new_room, existing_room):
overlaps = true
break
if not overlaps:
# IT FITS! Lock it in.
generated_rooms.append(new_room)
# DRAW THE LASER!
draw_connection_laser(target_marker.global_position, new_room.global_position)
total_pieces += 1
open_connections.erase(target_dict)
new_room_markers.erase(incoming_marker)
for marker in new_room_markers:
open_connections.append({"marker": marker, "type": spawn_category})
placed_successfully = true
break # Break out of the door loop
if not placed_successfully:
new_room.free() # None of the doors on this scene fit, destroy it and try the next scene
# 5. Failsafe: If literally NO room and NO door fits in this spot, CAP IT instantly!
if not placed_successfully and spawn_category != "cap":
force_cap_on_marker(target_dict)
seal_remaining_connections()
print("Map Generation Complete! Total pieces: ", total_pieces)
func force_cap_on_marker(target_dict: Dictionary):
var target_marker = target_dict["marker"]
var cap = cap_scene.instantiate()
add_child(cap)
var incoming_marker = cap.connection_markers[0]
align_room(cap, incoming_marker, target_marker)
generated_rooms.append(cap)
open_connections.erase(target_dict)
func seal_remaining_connections():
for i in range(open_connections.size() - 1, -1, -1):
var target_dict = open_connections[i]
var target_marker = target_dict["marker"]
if is_marker_blocked(target_marker):
open_connections.remove_at(i)
continue
force_cap_on_marker(target_dict)
open_connections.clear()
func add_open_connections(room: Node3D, type: String):
if room.connection_markers != null:
for marker in room.connection_markers:
open_connections.append({"marker": marker, "type": type})
func is_marker_blocked(marker: Marker3D) -> bool:
for room in generated_rooms:
var aabb = get_room_global_aabb(room)
aabb.position += Vector3(0.1, 0.1, 0.1)
aabb.size -= Vector3(0.2, 0.2, 0.2)
if aabb.has_point(marker.global_position):
return true
return false
func align_room(new_room: Node3D, incoming_marker: Marker3D, target_marker: Marker3D):
var desired_incoming_transform = target_marker.global_transform.rotated_local(Vector3.UP, PI)
var room_to_marker = new_room.global_transform.affine_inverse() * incoming_marker.global_transform
new_room.global_transform = desired_incoming_transform * room_to_marker.affine_inverse()
func do_rooms_overlap(room_a: Node3D, room_b: Node3D) -> bool:
var aabb_a = get_room_global_aabb(room_a)
var aabb_b = get_room_global_aabb(room_b)
if aabb_a.size == Vector3.ZERO or aabb_b.size == Vector3.ZERO:
return false
# Increased the margin slightly to ensure corridors pass smoothly
var shrink_margin = Vector3(0.2, 0.2, 0.2)
aabb_a.position += shrink_margin / 2.0
aabb_a.size -= shrink_margin
return aabb_a.intersects(aabb_b)
func get_room_global_aabb(room: Node3D) -> AABB:
var combined_aabb := AABB()
var is_first_shape = true
for child in room.volume.get_children():
if child is CollisionShape3D and child.shape is BoxShape3D:
var shape = child.shape as BoxShape3D
var local_aabb = AABB(-shape.size / 2.0, shape.size)
var global_aabb = child.global_transform * local_aabb
if is_first_shape:
combined_aabb = global_aabb
is_first_shape = false
else:
combined_aabb = combined_aabb.merge(global_aabb)
return combined_aabb