extends Node3D class_name ProceduralMapGenerator @export_group("Player") @export var player_scene: PackedScene @export var player_spawn_height: float = 1.5 @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("Vining Rules") @export var max_attempts: int = 2000 @export var room_threshold: int = 20 @export var min_corridor_chain: int = 1 @export var max_corridor_chain: int = 4 var generated_rooms: Array[Node3D] = [] var open_connections: Array[Dictionary] = [] var total_pieces: int = 0 func _ready() -> void: generate_map() func generate_map() -> void: 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) _register_open_connections(start_room, "room", 0, 0) total_pieces += 1 var attempts = 0 while open_connections.size() > 0 and attempts < max_attempts: attempts += 1 var target_dict = open_connections.pop_back() var target_marker: Node3D = target_dict["marker"] if _is_marker_blocked(target_marker): continue var categories_to_try = _get_desired_categories(target_dict) var placed = false # Try to place pieces cleanly for category in categories_to_try: if _try_place_category(category, target_dict): placed = true break # THE ABSOLUTE FAILSAFE: # If it's a dead end and nothing fits cleanly, FORCE a cap so there are no voids! if not placed: _force_cap_on_marker(target_dict) _seal_remaining_connections() _cull_clipping_caps() print("Map Generation Complete! Total pieces: ", total_pieces) # Spawn the Player! if player_scene and generated_rooms.size() > 0: var player = player_scene.instantiate() get_tree().current_scene.add_child(player) player.global_position = generated_rooms[0].global_position + Vector3(0, player_spawn_height, 0) # --- VINING LOGIC --- func _get_desired_categories(target_dict: Dictionary) -> Array[String]: if total_pieces >= room_threshold: return ["cap"] var current = target_dict["current_chain"] var target = target_dict["target_chain"] if current < target: return ["corridor", "room", "cap"] else: return ["room", "cap"] func _register_open_connections(room: Node3D, type: String, current_chain: int, target_chain: int) -> void: var markers = _get_connection_markers(room) for marker in markers: var next_current = current_chain var next_target = target_chain if type == "room": next_current = 0 next_target = randi_range(min_corridor_chain, max_corridor_chain) elif type == "corridor": next_current += 1 open_connections.append({ "marker": marker, "type": type, "current_chain": next_current, "target_chain": next_target }) # --- PLACEMENT LOGIC --- func _try_place_category(category: String, target_dict: Dictionary) -> bool: var target_marker: Node3D = target_dict["marker"] var scenes_to_try: Array[PackedScene] = [] match category: "cap": scenes_to_try = [cap_scene] "corridor": scenes_to_try = corridor_scenes.duplicate() "room": scenes_to_try = room_scenes.duplicate() scenes_to_try.shuffle() for scene in scenes_to_try: var new_room = scene.instantiate() var new_room_markers = _get_connection_markers(new_room) if new_room_markers.is_empty() and category != "cap": new_room.queue_free() continue new_room_markers.shuffle() if new_room_markers.is_empty() and category == "cap": _align_room(new_room, new_room, target_marker) if not _do_rooms_overlap(new_room): _lock_in_piece(new_room, category, [], target_dict) return true new_room.queue_free() continue for incoming_marker in new_room_markers: _align_room(new_room, incoming_marker, target_marker) if not _do_rooms_overlap(new_room): if _can_seal_outgoing_doors(new_room, incoming_marker): var remaining_markers = new_room_markers.duplicate() remaining_markers.erase(incoming_marker) _lock_in_piece(new_room, category, remaining_markers, target_dict) return true new_room.queue_free() return false func _lock_in_piece(new_room: Node3D, category: String, remaining_markers: Array, target_dict: Dictionary) -> void: add_child(new_room) generated_rooms.append(new_room) total_pieces += 1 if category == "cap": new_room.set_meta("is_cap", true) # TAG THE CAP! else: new_room.set_meta("temp_markers", remaining_markers) _register_open_connections(new_room, category, target_dict["current_chain"], target_dict["target_chain"]) new_room.remove_meta("temp_markers") func _force_cap_on_marker(target_dict: Dictionary) -> void: var target_marker = target_dict["marker"] var cap = cap_scene.instantiate() var markers = _get_connection_markers(cap) if markers.size() > 0: _align_room(cap, markers[0], target_marker) else: _align_room(cap, cap, target_marker) add_child(cap) cap.set_meta("is_cap", true) # TAG THE FORCED CAP! generated_rooms.append(cap) total_pieces += 1 func _can_seal_outgoing_doors(new_room: Node3D, incoming_marker: Node3D) -> bool: var markers = _get_connection_markers(new_room) for out_marker in markers: if out_marker == incoming_marker: continue var test_cap = cap_scene.instantiate() var cap_markers = _get_connection_markers(test_cap) var cap_fits = false if cap_markers.size() > 0: _align_room(test_cap, cap_markers[0], out_marker) if not _do_rooms_overlap(test_cap): cap_fits = true else: _align_room(test_cap, test_cap, out_marker) if not _do_rooms_overlap(test_cap): cap_fits = true test_cap.queue_free() if not cap_fits: return false return true func _seal_remaining_connections() -> void: for i in range(open_connections.size() - 1, -1, -1): var target_dict = open_connections[i] if not _is_marker_blocked(target_dict["marker"]): if not _try_place_category("cap", target_dict): _force_cap_on_marker(target_dict) open_connections.clear() # --- MATH & BOUNDS --- func _align_room(new_room: Node3D, incoming_marker: Node3D, target_marker: Node3D) -> void: var target_global = _get_safe_global_transform(target_marker) var desired_incoming_transform = target_global.rotated_local(Vector3.UP, PI) var room_to_marker = incoming_marker.transform var parent = incoming_marker.get_parent() while parent and parent is Node3D and parent != new_room: room_to_marker = parent.transform * room_to_marker parent = parent.get_parent() new_room.transform = desired_incoming_transform * room_to_marker.affine_inverse() func _do_rooms_overlap(new_room: Node3D) -> bool: var aabb_new = _get_room_global_aabb(new_room) if aabb_new.size == Vector3.ZERO: return false aabb_new = _safe_shrink_aabb(aabb_new, 0.1) if aabb_new.size == Vector3.ZERO: return false for existing_room in generated_rooms: var aabb_existing = _get_room_global_aabb(existing_room) if aabb_existing.size != Vector3.ZERO: aabb_existing = _safe_shrink_aabb(aabb_existing, 0.1) if aabb_new.intersects(aabb_existing): return true return false # Godot 4 native bounding box shrinking func _safe_shrink_aabb(aabb: AABB, shrink_by: float) -> AABB: var new_aabb = aabb.grow(-shrink_by) # Prevent negative sizes which break overlap physics if new_aabb.size.x <= 0 or new_aabb.size.y <= 0 or new_aabb.size.z <= 0: return AABB(aabb.position, Vector3.ZERO) return new_aabb func _get_room_global_aabb(room: Node3D) -> AABB: var combined_aabb := AABB() var is_first_shape = true var volume_node = room.get_node_or_null("Volume") if not volume_node: return combined_aabb for child in volume_node.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 child_global_t = _get_safe_global_transform(child) var global_aabb = child_global_t * 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 func _is_marker_blocked(marker: Node3D) -> bool: for room in generated_rooms: var aabb = _get_room_global_aabb(room) if aabb.size != Vector3.ZERO: aabb = _safe_shrink_aabb(aabb, 0.1) if aabb.has_point(marker.global_position): return true return false func _get_connection_markers(room: Node3D) -> Array: if room.has_meta("temp_markers"): return room.get_meta("temp_markers") var markers = [] _find_markers_recursive(room, markers) return markers func _find_markers_recursive(node: Node, markers: Array) -> void: var is_valid_door = false if node is Marker3D: is_valid_door = true elif node is Node3D and ("Marker" in node.name or "WallHole" in node.name): is_valid_door = true if is_valid_door and not markers.has(node): markers.append(node) return # Prevents doubling-up if a WallHole contains a Marker inside it! for child in node.get_children(): _find_markers_recursive(child, markers) func _get_safe_global_transform(node: Node3D) -> Transform3D: if node.is_inside_tree(): return node.global_transform var t = node.transform var parent = node.get_parent() while parent and parent is Node3D: t = parent.transform * t parent = parent.get_parent() return t func _cull_clipping_caps() -> void: # Loop backward so we can safely delete items from the array while iterating for i in range(generated_rooms.size() - 1, -1, -1): var room = generated_rooms[i] # Only check the pieces we explicitly tagged as caps if room.has_meta("is_cap"): var cap_aabb = _get_room_global_aabb(room) if cap_aabb.size == Vector3.ZERO: continue var is_clipping = false # Check this cap against every other room in the map for j in range(generated_rooms.size()): if i == j: continue var other_room = generated_rooms[j] var other_aabb = _get_room_global_aabb(other_room) if other_aabb.size != Vector3.ZERO: # Shrink the other room's AABB. # This ensures caps sitting perfectly on the edge are ignored, # but caps shoved through the wall are caught! other_aabb = _safe_shrink_aabb(other_aabb, 0.4) if other_aabb.size != Vector3.ZERO and cap_aabb.intersects(other_aabb): is_clipping = true break # If it's inside another room, destroy it! if is_clipping: room.queue_free() generated_rooms.remove_at(i) total_pieces -= 1