2728 lines
128 KiB
GDScript3
2728 lines
128 KiB
GDScript3
extends RefCounted
|
|
|
|
# Dungeon Generator for RPG DUNGEON VOL 3 tilemap
|
|
# Tiles are 16x16 pixels
|
|
# Walls are 32x32 pixels (2x2 tiles)
|
|
# Ground is 1 tile (16x16)
|
|
|
|
# Tile coordinates for RPG DUNGEON VOL 3
|
|
# Coordinates are (x, y) where x is column, y is row in the tileset
|
|
# Tiles are 16x16 pixels each
|
|
|
|
# Room wall tiles (outer walls)
|
|
# Walls are 2 tiles tall (upper and lower parts) or 2 tiles wide (left and right parts)
|
|
# Corner tiles are 2x2 (4 tiles total)
|
|
|
|
# Top-left corner (2x2): (0,0), (1,0), (0,1), (1,1)
|
|
const WALL_TOP_LEFT_TOP_LEFT = Vector2i(5, 0) # Top-left corner, top-left part
|
|
const WALL_TOP_LEFT_TOP_RIGHT = Vector2i(1, 0) # Top-left corner, top-right part
|
|
const WALL_TOP_LEFT_BOTTOM_LEFT = Vector2i(0, 1) # Top-left corner, bottom-left part
|
|
const WALL_TOP_LEFT_BOTTOM_RIGHT = Vector2i(1, 1) # Top-left corner, bottom-right part
|
|
|
|
# Top-right corner (2x2): (3,0), (4,0), (3,1), (4,1)
|
|
const WALL_TOP_RIGHT_TOP_LEFT = Vector2i(3, 0) # Top-right corner, top-left part
|
|
const WALL_TOP_RIGHT_TOP_RIGHT = Vector2i(4, 0) # Top-right corner, top-right part
|
|
const WALL_TOP_RIGHT_BOTTOM_LEFT = Vector2i(3, 1) # Top-right corner, bottom-left part
|
|
const WALL_TOP_RIGHT_BOTTOM_RIGHT = Vector2i(4, 1) # Top-right corner, bottom-right part
|
|
|
|
# Top wall (1x2 tile - spans 2 tiles tall)
|
|
const WALL_TOP_UPPER = Vector2i(2, 0) # Top wall, upper part
|
|
const WALL_TOP_LOWER = Vector2i(2, 1) # Top wall, lower part
|
|
|
|
# Left wall (2 tiles wide - spans 2 tiles horizontally)
|
|
const WALL_LEFT_LEFT = Vector2i(0, 2) # Left wall, left part
|
|
const WALL_LEFT_RIGHT = Vector2i(1, 2) # Left wall, right part
|
|
|
|
# Right wall (2 tiles wide - spans 2 tiles horizontally)
|
|
const WALL_RIGHT_LEFT = Vector2i(3, 2) # Right wall, left part
|
|
const WALL_RIGHT_RIGHT = Vector2i(4, 2) # Right wall, right part
|
|
|
|
# Bottom-left corner (2x2): (0,3), (1,3), (0,4), (1,4)
|
|
const WALL_BOTTOM_LEFT_TOP_LEFT = Vector2i(0, 3) # Bottom-left corner, top-left part
|
|
const WALL_BOTTOM_LEFT_TOP_RIGHT = Vector2i(1, 3) # Bottom-left corner, top-right part
|
|
const WALL_BOTTOM_LEFT_BOTTOM_LEFT = Vector2i(0, 4) # Bottom-left corner, bottom-left part
|
|
const WALL_BOTTOM_LEFT_BOTTOM_RIGHT = Vector2i(1, 4) # Bottom-left corner, bottom-right part
|
|
|
|
# Bottom-right corner (2x2): (3,3), (4,3), (3,4), (4,4)
|
|
const WALL_BOTTOM_RIGHT_TOP_LEFT = Vector2i(3, 3) # Bottom-right corner, top-left part
|
|
const WALL_BOTTOM_RIGHT_TOP_RIGHT = Vector2i(4, 3) # Bottom-right corner, top-right part
|
|
const WALL_BOTTOM_RIGHT_BOTTOM_LEFT = Vector2i(3, 4) # Bottom-right corner, bottom-left part
|
|
const WALL_BOTTOM_RIGHT_BOTTOM_RIGHT = Vector2i(4, 4) # Bottom-right corner, bottom-right part
|
|
|
|
# Bottom wall (1x2 tile - spans 2 tiles tall)
|
|
const WALL_BOTTOM_UPPER = Vector2i(2, 3) # Bottom wall, upper part
|
|
const WALL_BOTTOM_LOWER = Vector2i(2, 4) # Bottom wall, lower part
|
|
|
|
# Inner wall tiles (for non-rectangular rooms)
|
|
const INNER_WALL_TOP_LEFT = Vector2i(1, 6)
|
|
const INNER_WALL_TOP_RIGHT = Vector2i(3, 6)
|
|
const INNER_WALL_BOTTOM_LEFT = Vector2i(1, 8)
|
|
const INNER_WALL_BOTTOM_RIGHT = Vector2i(3, 8)
|
|
|
|
# Door tiles
|
|
const DOOR_UP_START = Vector2i(7, 0) # 3x2 large
|
|
const DOOR_LEFT_START = Vector2i(5, 2) # 2x3 large
|
|
const DOOR_RIGHT_START = Vector2i(10, 2) # 2x3 large
|
|
const DOOR_BOTTOM_START = Vector2i(7, 5) # 3x2 large
|
|
|
|
# Stairs tiles (exit room) - similar to doors but different middle frame tile
|
|
const STAIRS_UP_START = Vector2i(7, 0) # 3x2 large, middle tile is (10,0) instead of (8,0)
|
|
const STAIRS_LEFT_START = Vector2i(5, 2) # 2x3 large, middle tile is (5,1) instead of (5,3)
|
|
const STAIRS_RIGHT_START = Vector2i(10, 2) # 2x3 large, middle tile is (11,1) instead of (11,3)
|
|
const STAIRS_DOWN_START = Vector2i(7, 5) # 3x2 large, middle tile is (6,6) instead of (8,6)
|
|
|
|
# Ground/floor tiles (random selection)
|
|
const FLOOR_TILES = [Vector2i(9, 8), Vector2i(14, 8), Vector2i(6, 11)]
|
|
|
|
# Room generation parameters
|
|
# Minimum room size is 3x3 floor tiles, but rooms need 2-tile walls on each side
|
|
# So minimum room size including walls is 3 + 2*2 = 7 tiles (3 floor + 2 walls on each side)
|
|
# But we want at least 3x3 floor, so room size should be at least 7x7 total
|
|
const MIN_ROOM_SIZE = 7 # Minimum room size in tiles (includes walls, so 3x3 floor minimum)
|
|
const MAX_ROOM_SIZE = 12 # Maximum room size in tiles
|
|
const MIN_HOLE_SIZE = 9 # Minimum hole size in rooms (9x9 tiles)
|
|
const DOOR_MIN_WIDTH = 3 # Minimum width for door frames
|
|
const DOOR_MAX_WIDTH = 5 # Maximum width for door frames
|
|
const CORRIDOR_WIDTH = 1 # Corridor width in tiles (1 tile)
|
|
|
|
# Main generation function
|
|
func generate_dungeon(map_size: Vector2i, seed_value: int = 0, level: int = 1) -> Dictionary:
|
|
var rng = RandomNumberGenerator.new()
|
|
if seed_value > 0:
|
|
rng.seed = seed_value
|
|
else:
|
|
rng.randomize()
|
|
|
|
# Calculate target room count based on level
|
|
# Level 1: 7-8 rooms, then increase by 2-3 rooms per level
|
|
var target_room_count = 7 + (level - 1) * 2 + rng.randi_range(0, 1) # Level 1: 7-8, Level 2: 9-10, etc.
|
|
LogManager.log("DungeonGenerator: Level " + str(level) + " - Target room count: " + str(target_room_count), LogManager.CATEGORY_DUNGEON)
|
|
|
|
# Initialize grid (0 = wall, 1 = floor, 2 = door, 3 = corridor)
|
|
var grid = []
|
|
var tile_grid = [] # Actual tile coordinates (Vector2i) for rendering
|
|
for x in range(map_size.x):
|
|
grid.append([])
|
|
tile_grid.append([])
|
|
for y in range(map_size.y):
|
|
grid[x].append(0) # Start with all walls
|
|
tile_grid[x].append(Vector2i(0, 0)) # Default wall tile (will be set properly later)
|
|
|
|
var all_rooms = []
|
|
var all_doors = []
|
|
|
|
# 1. Create first room at a random position
|
|
var first_w = rng.randi_range(MIN_ROOM_SIZE, MAX_ROOM_SIZE)
|
|
var first_h = rng.randi_range(MIN_ROOM_SIZE, MAX_ROOM_SIZE)
|
|
var first_room = {
|
|
"x": rng.randi_range(4, map_size.x - first_w - 4),
|
|
"y": rng.randi_range(4, map_size.y - first_h - 4),
|
|
"w": first_w,
|
|
"h": first_h,
|
|
"modifiers": []
|
|
}
|
|
|
|
_set_floor(first_room, grid, tile_grid, map_size, rng)
|
|
all_rooms.append(first_room)
|
|
|
|
# 2. Try to place rooms until we reach target count or can't fit any more
|
|
var attempts = 1000
|
|
while attempts > 0 and all_rooms.size() < target_room_count and all_rooms.size() > 0:
|
|
var source_room = all_rooms[rng.randi() % all_rooms.size()]
|
|
var new_room = _try_place_room_near(source_room, grid, map_size, rng)
|
|
|
|
if new_room.w > 0:
|
|
_set_floor(new_room, grid, tile_grid, map_size, rng)
|
|
all_rooms.append(new_room)
|
|
|
|
attempts -= 1
|
|
|
|
LogManager.log("DungeonGenerator: Generated " + str(all_rooms.size()) + " rooms (target was " + str(target_room_count) + ")", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# 3. Connect rooms with corridors/doors
|
|
if all_rooms.size() > 1:
|
|
_connect_rooms(all_rooms, grid, tile_grid, map_size, all_doors, rng)
|
|
|
|
# 4. Add random holes in some rooms (minimum 9x9 tiles)
|
|
for room in all_rooms:
|
|
if rng.randf() < 0.3: # 30% chance for a hole
|
|
_add_hole_to_room(room, grid, tile_grid, map_size, rng)
|
|
|
|
# 5. Mark start room (random room for variety)
|
|
var start_room_index = rng.randi() % all_rooms.size()
|
|
var exit_room_index = -1 # Declare exit_room_index early to avoid scope issues
|
|
all_rooms[start_room_index].modifiers.append({"type": "START"})
|
|
|
|
# 6. Mark exit room (farthest REACHABLE room from start)
|
|
# First find all reachable rooms from start
|
|
var reachable_rooms = _find_reachable_rooms(all_rooms[start_room_index], all_rooms, all_doors)
|
|
LogManager.log("DungeonGenerator: Found " + str(reachable_rooms.size()) + " reachable rooms from start (out of " + str(all_rooms.size()) + " total)", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# CRITICAL: Remove inaccessible rooms (rooms not reachable from start)
|
|
# Store the start room before filtering (it should always be reachable)
|
|
var start_room_ref = all_rooms[start_room_index]
|
|
var inaccessible_count = 0
|
|
|
|
# Create new array with only reachable rooms
|
|
# Use value-based comparison (x, y, w, h) to check if room is reachable
|
|
var filtered_rooms = []
|
|
for room in all_rooms:
|
|
var is_reachable = false
|
|
# Check if this room is in the reachable_rooms list by comparing values
|
|
for reachable_room in reachable_rooms:
|
|
if reachable_room.x == room.x and reachable_room.y == room.y and \
|
|
reachable_room.w == room.w and reachable_room.h == room.h:
|
|
is_reachable = true
|
|
break
|
|
|
|
if is_reachable:
|
|
filtered_rooms.append(room)
|
|
else:
|
|
inaccessible_count += 1
|
|
LogManager.log("DungeonGenerator: Removing inaccessible room at (" + str(room.x) + ", " + str(room.y) + ") - no corridor connection", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# Update all_rooms to only include reachable rooms
|
|
all_rooms = filtered_rooms
|
|
|
|
if inaccessible_count > 0:
|
|
LogManager.log("DungeonGenerator: Removed " + str(inaccessible_count) + " inaccessible room(s). Remaining rooms: " + str(all_rooms.size()), LogManager.CATEGORY_DUNGEON)
|
|
|
|
# Update start_room_index after filtering (find start room in new array using value-based comparison)
|
|
start_room_index = -1
|
|
for i in range(all_rooms.size()):
|
|
var room = all_rooms[i]
|
|
if room.x == start_room_ref.x and room.y == start_room_ref.y and \
|
|
room.w == start_room_ref.w and room.h == start_room_ref.h:
|
|
start_room_index = i
|
|
break
|
|
|
|
if start_room_index == -1:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Start room was removed! This should never happen!", LogManager.CATEGORY_DUNGEON)
|
|
start_room_index = 0 # Fallback
|
|
|
|
# Also remove doors connected to inaccessible rooms (clean up all_doors)
|
|
var filtered_doors = []
|
|
var doors_removed = 0
|
|
for door in all_doors:
|
|
var door_room1_reachable = false
|
|
var door_room2_reachable = false
|
|
|
|
# Check if door's connected rooms are in the filtered reachable rooms list (all_rooms now only contains reachable rooms)
|
|
# Compare rooms by properties (x, y, w, h) since dictionary comparison might not work
|
|
# Check both room1 and room2 against all reachable rooms
|
|
if "room1" in door and door.room1 is Dictionary and not door.room1.is_empty():
|
|
for room in all_rooms:
|
|
if door.room1.x == room.x and door.room1.y == room.y and \
|
|
door.room1.w == room.w and door.room1.h == room.h:
|
|
door_room1_reachable = true
|
|
break # Found room1, no need to keep checking
|
|
|
|
if "room2" in door and door.room2 is Dictionary and not door.room2.is_empty():
|
|
for room in all_rooms:
|
|
if door.room2.x == room.x and door.room2.y == room.y and \
|
|
door.room2.w == room.w and door.room2.h == room.h:
|
|
door_room2_reachable = true
|
|
break # Found room2, no need to keep checking
|
|
|
|
# Only keep doors that connect two reachable rooms
|
|
if door_room1_reachable and door_room2_reachable:
|
|
filtered_doors.append(door)
|
|
else:
|
|
doors_removed += 1
|
|
LogManager.log("DungeonGenerator: Removing door - room1 reachable: " + str(door_room1_reachable) + ", room2 reachable: " + str(door_room2_reachable), LogManager.CATEGORY_DUNGEON)
|
|
|
|
all_doors = filtered_doors
|
|
if doors_removed > 0:
|
|
LogManager.log("DungeonGenerator: Removed " + str(doors_removed) + " door(s) connected to inaccessible rooms. Remaining doors: " + str(all_doors.size()), LogManager.CATEGORY_DUNGEON)
|
|
|
|
# Find the farthest reachable room (now all rooms are reachable, but find farthest)
|
|
# Make sure we have at least 2 rooms (start and exit must be different)
|
|
# exit_room_index is already declared at function level
|
|
if all_rooms.size() < 2:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Not enough reachable rooms! Need at least 2 (start + exit), but only have " + str(all_rooms.size()), LogManager.CATEGORY_DUNGEON)
|
|
# Use start room as exit if only one room exists (shouldn't happen, but handle gracefully)
|
|
if all_rooms.size() == 1:
|
|
exit_room_index = 0
|
|
else:
|
|
# No rooms at all - this is a critical error
|
|
LogManager.log_error("DungeonGenerator: CRITICAL ERROR - No rooms left after filtering!", LogManager.CATEGORY_DUNGEON)
|
|
return {} # Return empty dungeon
|
|
else:
|
|
exit_room_index = _find_farthest_room(all_rooms, start_room_index)
|
|
|
|
# Make sure exit room is different from start room
|
|
if exit_room_index == start_room_index and all_rooms.size() > 1:
|
|
# If exit is same as start, find second farthest
|
|
var max_distance = 0
|
|
var second_farthest = -1
|
|
for i in range(all_rooms.size()):
|
|
if i == start_room_index:
|
|
continue
|
|
var distance = abs(all_rooms[i].x - all_rooms[start_room_index].x) + abs(all_rooms[i].y - all_rooms[start_room_index].y)
|
|
if distance > max_distance:
|
|
max_distance = distance
|
|
second_farthest = i
|
|
if second_farthest != -1:
|
|
exit_room_index = second_farthest
|
|
|
|
all_rooms[exit_room_index].modifiers.append({"type": "EXIT"})
|
|
LogManager.log("DungeonGenerator: Selected exit room at index " + str(exit_room_index) + " position: " + str(all_rooms[exit_room_index].x) + "," + str(all_rooms[exit_room_index].y), LogManager.CATEGORY_DUNGEON)
|
|
|
|
# 7. Render walls around rooms
|
|
_render_room_walls(all_rooms, grid, tile_grid, map_size, rng)
|
|
|
|
# 7.5. Place stairs in exit room BEFORE placing torches (so torches don't overlap stairs)
|
|
var stairs_data = _place_stairs_in_exit_room(all_rooms[exit_room_index], grid, tile_grid, map_size, all_doors, rng)
|
|
if stairs_data.is_empty():
|
|
LogManager.log_error("DungeonGenerator: ERROR - Failed to place stairs in exit room! Room size: " + str(all_rooms[exit_room_index].w) + "x" + str(all_rooms[exit_room_index].h) + " Doors: " + str(all_doors.size()), LogManager.CATEGORY_DUNGEON)
|
|
# CRITICAL: Force place stairs - we MUST have an exit!
|
|
LogManager.log("DungeonGenerator: FORCING stairs placement in exit room center", LogManager.CATEGORY_DUNGEON)
|
|
stairs_data = _force_place_stairs(all_rooms[exit_room_index], grid, tile_grid, map_size, all_doors, rng)
|
|
if stairs_data.is_empty():
|
|
LogManager.log_error("DungeonGenerator: CRITICAL ERROR - Could not place stairs even with force placement!", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# 8. Place torches in rooms (AFTER stairs, so torches don't overlap stairs)
|
|
var all_torches = []
|
|
for room in all_rooms:
|
|
var room_torches = _place_torches_in_room(room, grid, all_doors, map_size, rng)
|
|
all_torches.append_array(room_torches)
|
|
|
|
# 11. Place blocking doors on existing tile doors (after everything else is created)
|
|
# IMPORTANT: This must happen BEFORE placing enemies, so we know which rooms have monster spawner puzzles
|
|
var blocking_doors_result = _place_blocking_doors(all_rooms, all_doors, grid, map_size, rng, start_room_index, exit_room_index)
|
|
var blocking_doors = blocking_doors_result.doors if blocking_doors_result.has("doors") else blocking_doors_result
|
|
var room_puzzle_data = blocking_doors_result.puzzle_data if blocking_doors_result.has("puzzle_data") else {}
|
|
|
|
# Extract rooms with monster spawner puzzles (these should NOT have pre-spawned enemies)
|
|
var rooms_with_spawner_puzzles = []
|
|
var blocking_doors_array = blocking_doors if blocking_doors is Array else blocking_doors.doors
|
|
for door_data in blocking_doors_array:
|
|
if "puzzle_type" in door_data and door_data.puzzle_type == "enemy":
|
|
if "blocking_room" in door_data and not door_data.blocking_room.is_empty():
|
|
var puzzle_room = door_data.blocking_room
|
|
# Check if this room is already in the list (avoid duplicates)
|
|
var already_in_list = false
|
|
for existing_room in rooms_with_spawner_puzzles:
|
|
if existing_room.x == puzzle_room.x and existing_room.y == puzzle_room.y and \
|
|
existing_room.w == puzzle_room.w and existing_room.h == puzzle_room.h:
|
|
already_in_list = true
|
|
break
|
|
if not already_in_list:
|
|
rooms_with_spawner_puzzles.append(puzzle_room)
|
|
LogManager.log("DungeonGenerator: Room (" + str(puzzle_room.x) + ", " + str(puzzle_room.y) + ") has monster spawner puzzle - will skip pre-spawning enemies", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# 9. Place enemies in rooms (scaled by level, excluding start and exit rooms, and rooms with spawner puzzles)
|
|
var all_enemies = []
|
|
for i in range(all_rooms.size()):
|
|
var room = all_rooms[i]
|
|
# Skip start room and exit room
|
|
if i != start_room_index and i != exit_room_index:
|
|
# CRITICAL: Skip rooms that have monster spawner puzzles (these will spawn enemies when player enters)
|
|
var has_spawner_puzzle = false
|
|
for spawner_room in rooms_with_spawner_puzzles:
|
|
if spawner_room.x == room.x and spawner_room.y == room.y and \
|
|
spawner_room.w == room.w and spawner_room.h == room.h:
|
|
has_spawner_puzzle = true
|
|
LogManager.log("DungeonGenerator: Skipping pre-spawned enemies for room (" + str(room.x) + ", " + str(room.y) + ") - has monster spawner puzzle", LogManager.CATEGORY_DUNGEON)
|
|
break
|
|
|
|
if not has_spawner_puzzle:
|
|
var room_enemies = _place_enemies_in_room(room, grid, map_size, rng, level)
|
|
all_enemies.append_array(room_enemies)
|
|
|
|
# 9.5. Place interactable objects in rooms (excluding start and exit rooms)
|
|
var all_interactable_objects = []
|
|
for i in range(all_rooms.size()):
|
|
var room = all_rooms[i]
|
|
# Skip start room and exit room
|
|
if i != start_room_index and i != exit_room_index:
|
|
var room_objects = _place_interactable_objects_in_room(room, grid, map_size, all_doors, all_enemies, rng, room_puzzle_data)
|
|
all_interactable_objects.append_array(room_objects)
|
|
|
|
# NOTE: Stairs placement was moved earlier (step 7.5, before torches) to prevent torch overlap
|
|
# NOTE: Blocking doors placement was moved earlier (step 11, before enemy placement) to identify spawner puzzle rooms
|
|
|
|
return {
|
|
"rooms": all_rooms,
|
|
"doors": all_doors,
|
|
"torches": all_torches,
|
|
"enemies": all_enemies,
|
|
"interactable_objects": all_interactable_objects,
|
|
"stairs": stairs_data,
|
|
"blocking_doors": blocking_doors,
|
|
"grid": grid,
|
|
"tile_grid": tile_grid,
|
|
"map_size": map_size,
|
|
"start_room": all_rooms[start_room_index],
|
|
"exit_room": all_rooms[exit_room_index]
|
|
}
|
|
|
|
func _set_floor(room: Dictionary, grid: Array, tile_grid: Array, map_size: Vector2i, rng: RandomNumberGenerator):
|
|
# Set floor tiles for the room (interior only, walls will be set separately)
|
|
# Leave 2 tile border for walls (walls are 2 tiles tall)
|
|
for x in range(room.x + 2, room.x + room.w - 2):
|
|
for y in range(room.y + 2, room.y + room.h - 2):
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
grid[x][y] = 1 # Floor
|
|
# Random floor tile variation
|
|
var floor_tile = FLOOR_TILES[rng.randi() % FLOOR_TILES.size()]
|
|
tile_grid[x][y] = floor_tile
|
|
|
|
func _try_place_room_near(source_room: Dictionary, grid: Array, map_size: Vector2i, rng: RandomNumberGenerator) -> Dictionary:
|
|
var attempts = 20
|
|
while attempts > 0:
|
|
var w = rng.randi_range(MIN_ROOM_SIZE, MAX_ROOM_SIZE)
|
|
var h = rng.randi_range(MIN_ROOM_SIZE, MAX_ROOM_SIZE)
|
|
|
|
# Try all four sides of the source room
|
|
var sides = ["N", "S", "E", "W"]
|
|
sides.shuffle()
|
|
|
|
for side in sides:
|
|
var x = source_room.x
|
|
var y = source_room.y
|
|
|
|
match side:
|
|
"N":
|
|
x = source_room.x + rng.randi_range(0, max(1, source_room.w - w))
|
|
y = source_room.y - h - 4 # 4 tiles gap
|
|
"S":
|
|
x = source_room.x + rng.randi_range(0, max(1, source_room.w - w))
|
|
y = source_room.y + source_room.h + 4
|
|
"W":
|
|
x = source_room.x - w - 4
|
|
y = source_room.y + rng.randi_range(0, max(1, source_room.h - h))
|
|
"E":
|
|
x = source_room.x + source_room.w + 4
|
|
y = source_room.y + rng.randi_range(0, max(1, source_room.h - h))
|
|
|
|
var new_room = {"x": x, "y": y, "w": w, "h": h, "modifiers": []}
|
|
if _is_valid_room_position(new_room, grid, map_size):
|
|
return new_room
|
|
|
|
attempts -= 1
|
|
|
|
return {"x": 0, "y": 0, "w": 0, "h": 0, "modifiers": []}
|
|
|
|
func _is_valid_room_position(room: Dictionary, grid: Array, map_size: Vector2i) -> bool:
|
|
# Check bounds with buffer
|
|
if room.x < 4 or room.y < 4 or room.x + room.w >= map_size.x - 4 or room.y + room.h >= map_size.y - 4:
|
|
return false
|
|
|
|
# Check if room overlaps with existing rooms (with 4-tile buffer)
|
|
for x in range(room.x - 4, room.x + room.w + 4):
|
|
for y in range(room.y - 4, room.y + room.h + 4):
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
if grid[x][y] != 0: # Not empty (wall)
|
|
return false
|
|
|
|
return true
|
|
|
|
func _connect_rooms(all_rooms: Array, grid: Array, tile_grid: Array, map_size: Vector2i, all_doors: Array, rng: RandomNumberGenerator):
|
|
# First pass: connect each room to closest neighbors
|
|
var connected_rooms = {}
|
|
for room in all_rooms:
|
|
connected_rooms[room] = []
|
|
|
|
for room in all_rooms:
|
|
var closest_rooms = _find_closest_rooms(room, all_rooms)
|
|
var connection_attempts = 0
|
|
var max_connections = 3
|
|
|
|
for target_room in closest_rooms:
|
|
if connection_attempts >= max_connections:
|
|
break
|
|
|
|
if not _rooms_are_connected(room, target_room, all_doors):
|
|
var door = _create_corridor_between_rooms(room, target_room, grid, tile_grid, map_size, all_rooms, rng)
|
|
if door.size() > 0:
|
|
all_doors.append(door)
|
|
connected_rooms[room].append(target_room)
|
|
connected_rooms[target_room].append(room)
|
|
connection_attempts += 1
|
|
|
|
# Second pass: ensure all rooms are connected
|
|
var attempts = 100
|
|
while attempts > 0:
|
|
var reachable = _find_reachable_rooms(all_rooms[0], all_rooms, all_doors)
|
|
|
|
if reachable.size() == all_rooms.size():
|
|
break
|
|
|
|
# Find unreachable room and connect it
|
|
for room in all_rooms:
|
|
if not reachable.has(room):
|
|
for target_room in reachable:
|
|
var door = _create_corridor_between_rooms(room, target_room, grid, tile_grid, map_size, all_rooms, rng)
|
|
if door.size() > 0:
|
|
all_doors.append(door)
|
|
break
|
|
break
|
|
|
|
attempts -= 1
|
|
|
|
func _create_corridor_between_rooms(room1: Dictionary, room2: Dictionary, grid: Array, tile_grid: Array, map_size: Vector2i, all_rooms: Array, rng: RandomNumberGenerator) -> Dictionary:
|
|
var dx = abs(room2.x - room1.x)
|
|
var dy = abs(room2.y - room1.y)
|
|
|
|
# Check if rooms are too far apart
|
|
if dx > 20 or dy > 20:
|
|
return {}
|
|
|
|
# Helper function to check if a corridor path intersects any room's floor area except room1 and room2
|
|
# Corridors should not pass through the floor area of other rooms (walls are OK)
|
|
var corridor_intersects_other_room = func(corridor_start_x: int, corridor_start_y: int, corridor_end_x: int, corridor_end_y: int, is_horizontal: bool) -> bool:
|
|
if is_horizontal:
|
|
# Horizontal corridor: check all tiles from start_x to end_x at y = corridor_y
|
|
var corridor_y = corridor_start_y
|
|
for check_x in range(min(corridor_start_x, corridor_end_x), max(corridor_start_x, corridor_end_x) + 1):
|
|
# Check if this tile is inside any room's floor area (except room1 and room2)
|
|
for other_room in all_rooms:
|
|
if other_room == room1 or other_room == room2:
|
|
continue
|
|
# Check if the corridor tile is inside this room's floor area (excluding walls)
|
|
# Floor area starts at room.x+2 and room.y+2 (after 2-tile wall) and ends before walls
|
|
if check_x >= other_room.x + 2 and check_x < other_room.x + other_room.w - 2 and \
|
|
corridor_y >= other_room.y + 2 and corridor_y < other_room.y + other_room.h - 2:
|
|
return true
|
|
else:
|
|
# Vertical corridor: check all tiles from start_y to end_y at x = corridor_x
|
|
var corridor_x = corridor_start_x
|
|
for check_y in range(min(corridor_start_y, corridor_end_y), max(corridor_start_y, corridor_end_y) + 1):
|
|
# Check if this tile is inside any room's floor area (except room1 and room2)
|
|
for other_room in all_rooms:
|
|
if other_room == room1 or other_room == room2:
|
|
continue
|
|
# Check if the corridor tile is inside this room's floor area (excluding walls)
|
|
# Floor area starts at room.x+2 and room.y+2 (after 2-tile wall) and ends before walls
|
|
if corridor_x >= other_room.x + 2 and corridor_x < other_room.x + other_room.w - 2 and \
|
|
check_y >= other_room.y + 2 and check_y < other_room.y + other_room.h - 2:
|
|
return true
|
|
return false
|
|
|
|
if dx > dy:
|
|
# Horizontal corridor
|
|
var left_room = room1 if room1.x < room2.x else room2
|
|
var right_room = room2 if room1.x < room2.x else room1
|
|
|
|
if right_room.x - (left_room.x + left_room.w) > 20:
|
|
return {}
|
|
|
|
# Door position - IN THE MIDDLE OF THE WALL (replacing part of the wall)
|
|
# For horizontal doors (left/right), door is 2x3 tiles (2 wide, 3 tall)
|
|
# The wall is 2 tiles wide (at left_room.x + left_room.w - 2 and left_room.x + left_room.w - 1)
|
|
# Door must be at least 1 tile away from corners (corners are 2x2, so start at y+2)
|
|
var wall_x = left_room.x + left_room.w - 1 # Right wall of left room (wall is at room.x + room.w - 1)
|
|
var min_y = max(left_room.y + 2, right_room.y + 2) # At least 1 tile from top corner (corner is 2 tiles)
|
|
var max_y = min(left_room.y + left_room.h - 5, right_room.y + right_room.h - 5) # At least 1 tile from bottom corner, and room for 3-tile tall door
|
|
|
|
if max_y < min_y:
|
|
return {}
|
|
|
|
var door_y = min_y + rng.randi_range(0, max(0, max_y - min_y))
|
|
var door_width = rng.randi_range(DOOR_MIN_WIDTH, DOOR_MAX_WIDTH)
|
|
var corridor_length = right_room.x - (left_room.x + left_room.w)
|
|
|
|
# Check if corridor path would intersect any other rooms
|
|
var corridor_start_x = wall_x + 1
|
|
var corridor_end_x = wall_x + corridor_length
|
|
var corridor_y = door_y + 1
|
|
if corridor_intersects_other_room.call(corridor_start_x, corridor_y, corridor_end_x, corridor_y, true):
|
|
return {} # Corridor would pass through another room, skip this connection
|
|
|
|
# Create corridor (1 tile wide) - use floor tiles
|
|
# Corridor is between the rooms, after the door
|
|
for x in range(wall_x + 1, wall_x + corridor_length + 1): # Corridor starts after the wall
|
|
if x >= 0 and x < map_size.x and door_y + 1 >= 0 and door_y + 1 < map_size.y:
|
|
grid[x][door_y + 1] = 3 # Corridor (middle row of door)
|
|
var floor_tile = FLOOR_TILES[rng.randi() % FLOOR_TILES.size()]
|
|
tile_grid[x][door_y + 1] = floor_tile
|
|
|
|
# Create door on RIGHT wall of left room (2x3 tiles - 2 wide, 3 tall)
|
|
# Door is placed ON the wall, replacing the 2-tile wide wall
|
|
# The wall is at wall_x (left_room.x + left_room.w - 1) and wall_x - 1 (left_room.x + left_room.w - 2)
|
|
# This is the RIGHT wall of the left room, so use DOOR_RIGHT_START (10,2 to 11,4)
|
|
var door_start_x = wall_x - 1 # Door starts at the left wall tile (2 tiles wide)
|
|
var door_start_y = door_y # Start from door_y position
|
|
var door_tile_start = DOOR_RIGHT_START # Use RIGHT door for right wall (2x3: 10,2 to 11,4)
|
|
for door_dx in range(2): # Door is 2 tiles wide
|
|
for door_dy in range(3): # Door is 3 tiles tall
|
|
var x = door_start_x + door_dx
|
|
var y = door_start_y + door_dy
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
grid[x][y] = 2 # Door area (replaces wall)
|
|
# Use door tile coordinates (10,2) + offset for 2x3 door
|
|
tile_grid[x][y] = door_tile_start + Vector2i(door_dx, door_dy)
|
|
if door_dx == 0 and door_dy == 1:
|
|
grid[x][y] = 1 # Floor
|
|
var floor_tile = FLOOR_TILES[rng.randi() % FLOOR_TILES.size()]
|
|
tile_grid[x][y] = floor_tile
|
|
|
|
|
|
# Also create door on LEFT wall of right room (if there's a gap)
|
|
if corridor_length > 0:
|
|
var right_wall_x = right_room.x # Left wall of right room
|
|
var right_door_start_x = right_wall_x # Door starts at the left wall tile (2 tiles wide)
|
|
var right_door_tile_start = DOOR_LEFT_START # Use LEFT door for left wall (2x3: 5,2 to 6,4)
|
|
for door_dx in range(2): # Door is 2 tiles wide
|
|
for door_dy in range(3): # Door is 3 tiles tall
|
|
var x = right_door_start_x + door_dx
|
|
var y = door_start_y + door_dy
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
grid[x][y] = 2 # Door area (replaces wall)
|
|
# Use door tile coordinates (5,2) + offset for 2x3 door
|
|
tile_grid[x][y] = right_door_tile_start + Vector2i(door_dx, door_dy)
|
|
if door_dx == 1 and door_dy == 1:
|
|
grid[x][y] = 1 # Floor
|
|
var floor_tile = FLOOR_TILES[rng.randi() % FLOOR_TILES.size()]
|
|
tile_grid[x][y] = floor_tile
|
|
|
|
# CRITICAL: room1 = room the door is ON (left room for horizontal doors)
|
|
# room2 = room the door leads TO (right room for horizontal doors)
|
|
# For a door on the RIGHT wall of the left room, room1 = left_room, room2 = right_room
|
|
var door_room1 = left_room # Door is ON the left room's right wall
|
|
var door_room2 = right_room # Door leads TO the right room
|
|
|
|
return {
|
|
"x": door_start_x,
|
|
"y": door_y,
|
|
"w": door_width,
|
|
"h": 1,
|
|
"dir": "E",
|
|
"room1": door_room1, # CRITICAL: Door is IN the left room (on its right wall)
|
|
"room2": door_room2 # Door leads TO the right room
|
|
}
|
|
else:
|
|
# Vertical corridor
|
|
var top_room = room1 if room1.y < room2.y else room2
|
|
var bottom_room = room2 if room1.y < room2.y else room1
|
|
|
|
if bottom_room.y - (top_room.y + top_room.h) > 20:
|
|
return {}
|
|
|
|
# Door position - IN THE MIDDLE OF THE WALL (replacing part of the wall)
|
|
# For vertical doors (up/down), door is 3x2 tiles (3 wide, 2 tall)
|
|
# The wall is 2 tiles tall (at top_room.y + top_room.h - 2 and top_room.y + top_room.h - 1)
|
|
# Door must be at least 1 tile away from corners (corners are 2x2, so start at x+2)
|
|
var wall_y = top_room.y + top_room.h - 1 # Bottom wall of top room (wall is at room.y + room.h - 1)
|
|
var min_x = max(top_room.x + 2, bottom_room.x + 2) # At least 1 tile from left corner (corner is 2 tiles)
|
|
var max_x = min(top_room.x + top_room.w - 5, bottom_room.x + bottom_room.w - 5) # At least 1 tile from right corner, and room for 3-tile wide door
|
|
|
|
if max_x < min_x:
|
|
return {}
|
|
|
|
var door_x = min_x + rng.randi_range(0, max(0, max_x - min_x))
|
|
var door_height = rng.randi_range(DOOR_MIN_WIDTH, DOOR_MAX_WIDTH)
|
|
var corridor_length = bottom_room.y - (top_room.y + top_room.h)
|
|
|
|
# Check if corridor path would intersect any other rooms
|
|
var corridor_start_y = wall_y + 1
|
|
var corridor_end_y = wall_y + corridor_length
|
|
var corridor_x = door_x + 1
|
|
if corridor_intersects_other_room.call(corridor_x, corridor_start_y, corridor_x, corridor_end_y, false):
|
|
return {} # Corridor would pass through another room, skip this connection
|
|
|
|
# Create corridor (1 tile wide) - use floor tiles
|
|
# Corridor is between the rooms, after the door
|
|
for y in range(wall_y + 1, wall_y + corridor_length + 1): # Corridor starts after the wall
|
|
if door_x + 1 >= 0 and door_x + 1 < map_size.x and y >= 0 and y < map_size.y:
|
|
grid[door_x + 1][y] = 3 # Corridor (middle column of door)
|
|
var floor_tile = FLOOR_TILES[rng.randi() % FLOOR_TILES.size()]
|
|
tile_grid[door_x + 1][y] = floor_tile
|
|
|
|
# Create door on BOTTOM wall of top room (3x2 tiles - 3 wide, 2 tall)
|
|
# Door is placed ON the wall, replacing the 2-tile tall wall
|
|
# The wall is at wall_y (top_room.y + top_room.h - 1) and wall_y - 1 (top_room.y + top_room.h - 2)
|
|
# This is the BOTTOM wall of the top room, so use DOOR_BOTTOM_START (7,5 to 9,6)
|
|
var door_start_x = door_x # Start from door_x position
|
|
var door_start_y = wall_y - 1 # Door starts at the upper wall tile (2 tiles tall)
|
|
var door_tile_start = DOOR_BOTTOM_START # Use BOTTOM door for bottom wall (3x2: 7,5 to 9,6)
|
|
for door_dx in range(3): # Door is 3 tiles wide
|
|
for door_dy in range(2): # Door is 2 tiles tall
|
|
var x = door_start_x + door_dx
|
|
var y = door_start_y + door_dy
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
grid[x][y] = 2 # Door area (replaces wall)
|
|
# Use door tile coordinates (7,5) + offset for 3x2 door
|
|
tile_grid[x][y] = door_tile_start + Vector2i(door_dx, door_dy)
|
|
if door_dx == 1 and door_dy == 0:
|
|
grid[x][y] = 1 # Floor
|
|
var floor_tile = FLOOR_TILES[rng.randi() % FLOOR_TILES.size()]
|
|
tile_grid[x][y] = floor_tile
|
|
|
|
# Also create door on TOP wall of bottom room (if there's a gap)
|
|
if corridor_length > 0:
|
|
var bottom_wall_y = bottom_room.y # Top wall of bottom room
|
|
var bottom_door_start_y = bottom_wall_y # Door starts at the top wall tile (2 tiles tall)
|
|
var bottom_door_tile_start = DOOR_UP_START # Use UP door for top wall (3x2: 7,0 to 9,1)
|
|
for door_dx in range(3): # Door is 3 tiles wide
|
|
for door_dy in range(2): # Door is 2 tiles tall
|
|
var x = door_start_x + door_dx
|
|
var y = bottom_door_start_y + door_dy
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
grid[x][y] = 2 # Door area (replaces wall)
|
|
# Use door tile coordinates (7,0) + offset for 3x2 door
|
|
tile_grid[x][y] = bottom_door_tile_start + Vector2i(door_dx, door_dy)
|
|
if door_dx == 1 and door_dy == 1:
|
|
grid[x][y] = 1 # Floor
|
|
var floor_tile = FLOOR_TILES[rng.randi() % FLOOR_TILES.size()]
|
|
tile_grid[x][y] = floor_tile
|
|
|
|
# CRITICAL: room1 = room the door is ON (top room for vertical doors)
|
|
# room2 = room the door leads TO (bottom room for vertical doors)
|
|
# For a door on the BOTTOM wall of the top room, room1 = top_room, room2 = bottom_room
|
|
var door_room1 = top_room # Door is ON the top room's bottom wall
|
|
var door_room2 = bottom_room # Door leads TO the bottom room
|
|
|
|
return {
|
|
"x": door_x,
|
|
"y": door_start_y,
|
|
"w": 1,
|
|
"h": door_height,
|
|
"dir": "S",
|
|
"room1": door_room1, # CRITICAL: Door is IN the top room (on its bottom wall)
|
|
"room2": door_room2 # Door leads TO the bottom room
|
|
}
|
|
|
|
func _find_closest_rooms(room: Dictionary, all_rooms: Array) -> Array:
|
|
if all_rooms.size() <= 1:
|
|
return []
|
|
|
|
var distances = []
|
|
for other in all_rooms:
|
|
if other == room:
|
|
continue
|
|
var dist = abs(room.x - other.x) + abs(room.y - other.y)
|
|
distances.append({"room": other, "distance": dist})
|
|
|
|
if distances.size() > 0:
|
|
distances.sort_custom(func(a, b): return a.distance < b.distance)
|
|
return distances.map(func(item): return item.room)
|
|
|
|
return []
|
|
|
|
func _rooms_are_connected(room1: Dictionary, room2: Dictionary, doors: Array) -> bool:
|
|
for door in doors:
|
|
if (door.room1 == room1 and door.room2 == room2) or \
|
|
(door.room1 == room2 and door.room2 == room1):
|
|
return true
|
|
return false
|
|
|
|
func _place_torches_in_room(room: Dictionary, grid: Array, all_doors: Array, _map_size: Vector2i, rng: RandomNumberGenerator) -> Array:
|
|
# Place 0 to 4 torches randomly on walls of the room
|
|
# Torches cannot be placed exactly on doors
|
|
var torches = []
|
|
var num_torches = rng.randi_range(0, 4)
|
|
|
|
# Collect valid wall positions (excluding doors)
|
|
var valid_wall_positions = []
|
|
var tile_size = 16
|
|
|
|
# Calculate the torch Y position relative to floor (8 pixels down from top wall center)
|
|
# This ensures all torches have the same distance to the floor
|
|
var torch_y_offset = 8 # Pixels down from top wall center
|
|
var torch_y_from_floor = room.y * tile_size + tile_size / 2.0 + torch_y_offset
|
|
|
|
# Top wall (y = room.y, x from room.x+2 to room.x+room.w-2, excluding corners)
|
|
for x in range(room.x + 2, room.x + room.w - 2):
|
|
if _is_valid_torch_position(x, room.y, grid, all_doors):
|
|
var world_pos = Vector2(x * tile_size + tile_size / 2.0, torch_y_from_floor)
|
|
valid_wall_positions.append({"pos": world_pos, "wall": "top", "rotation": 0})
|
|
|
|
# Bottom wall (y = room.y + room.h - 1, x from room.x+2 to room.x+room.w-2)
|
|
# Place torches at the same distance from floor as top wall torches
|
|
# Bottom wall center is at: (room.y + room.h - 1) * tile_size + tile_size / 2.0
|
|
# To get same distance from floor as top wall: room.y * tile_size + tile_size / 2.0 + 8
|
|
# But we need to place it on the bottom wall, so use bottom wall's Y position
|
|
# Calculate: bottom_wall_y_world - (room.h * tile_size) + torch_y_offset
|
|
# This gives us the same distance from floor
|
|
# Bottom wall torches should be 8 pixels up from bottom wall center (closer to floor)
|
|
# Bottom wall center is at: (room.y + room.h - 1) * tile_size + tile_size / 2.0
|
|
# To get same distance from floor as top wall: move up 8 pixels from bottom wall center
|
|
var bottom_wall_center_y = (room.y + room.h - 1) * tile_size + tile_size / 2.0
|
|
var bottom_torch_y = bottom_wall_center_y - torch_y_offset # Move up 8 pixels from bottom wall center
|
|
for x in range(room.x + 2, room.x + room.w - 2):
|
|
# Check if this is a valid bottom wall position (check the lower part of bottom wall)
|
|
var bottom_wall_y = room.y + room.h - 1
|
|
if _is_valid_torch_position(x, bottom_wall_y, grid, all_doors):
|
|
# Place at bottom wall Y position, but 8 pixels up from center (closer to floor)
|
|
var world_pos = Vector2(x * tile_size + tile_size / 2.0, bottom_torch_y)
|
|
valid_wall_positions.append({"pos": world_pos, "wall": "bottom", "rotation": 180})
|
|
|
|
# Left wall (2 tiles wide: room.x and room.x + 1)
|
|
# Place torches at the same Y position as top wall torches (same distance from floor)
|
|
# torch_y_from_floor = room.y * tile_size + tile_size / 2.0 + 8
|
|
# Left wall has two parts: room.x (left part, also corner) and room.x + 1 (right part, actual wall)
|
|
# We should place torches on room.x + 1 (the right part of the 2-tile wide left wall), not on room.x (corner)
|
|
# Find which Y tile position matches torch_y_from_floor
|
|
# torch_y_from_floor = room.y * tile_size + 8 + 8 = room.y * tile_size + 16
|
|
# target_y_tile = int((room.y * 16 + 16) / 16) = room.y + 1
|
|
# But we need to check if room.y + 1 is in the valid range (room.y + 2 to room.y + room.h - 2)
|
|
# Actually, torch_y_from_floor is 8 pixels down from top wall center, which is still in the top wall tile
|
|
# So target_y_tile = room.y + 1, but we need to check if it's >= room.y + 2 (excluding corners)
|
|
# Since target_y_tile = room.y + 1, and we check >= room.y + 2, it will always fail!
|
|
# We need to check all valid Y positions on the left/right walls and place at torch_y_from_floor
|
|
# Left/right walls are valid from room.y + 2 to room.y + room.h - 2 (skipping 2-tile corners)
|
|
for y in range(room.y + 2, room.y + room.h - 2):
|
|
# First check if there's a door at this Y position on the left wall
|
|
# Left door (dir="W") is 3 tiles tall, so check if y is in any door's Y range
|
|
var has_door_at_y = false
|
|
for door in all_doors:
|
|
var door_dir = door.dir if "dir" in door else ""
|
|
if door_dir == "W" and door.x == room.x:
|
|
# Left door at room.x, check if y is within door's Y range (door.y to door.y + 3)
|
|
if y >= door.y and y <= door.y + 3:
|
|
has_door_at_y = true
|
|
break
|
|
if has_door_at_y:
|
|
continue # Skip this Y position if there's a door here
|
|
|
|
# Check if this is a valid left wall position
|
|
# Left wall has 2 tiles: room.x and room.x + 1
|
|
# Check both tiles to ensure we're not placing on a door
|
|
# Use room.x + 1 (the right part of the left wall) for torch placement
|
|
if _is_valid_torch_position(room.x, y, grid, all_doors) and _is_valid_torch_position(room.x + 1, y, grid, all_doors):
|
|
# Calculate torch world position
|
|
# X position is on the left wall: (room.x + 1) * tile_size + tile_size / 2.0
|
|
# Move it further to the left (negative X) to position it better on the wall
|
|
var left_wall_x = (room.x + 1) * tile_size + tile_size / 2.0 - 8 # Move 8 pixels to the left
|
|
# Y position should be at the same distance from floor: y * tile_size + tile_size / 2.0 + 8
|
|
var left_wall_y = y * tile_size + tile_size / 2.0 + torch_y_offset
|
|
var world_pos = Vector2(left_wall_x, left_wall_y)
|
|
|
|
# CRITICAL: Check if torch's 16x16 pixel bounding box overlaps with any door
|
|
# Torch is 16x16 pixels, so it extends 8 pixels in each direction from its center
|
|
# Torch bounding box: from (left_wall_x - 8, left_wall_y - 8) to (left_wall_x + 8, left_wall_y + 8)
|
|
var torch_bbox_min_x = left_wall_x - 8
|
|
var torch_bbox_max_x = left_wall_x + 8
|
|
var torch_bbox_min_y = left_wall_y - 8
|
|
var torch_bbox_max_y = left_wall_y + 8
|
|
|
|
# Check if torch bounding box overlaps with any door's bounding box
|
|
# Only check doors that are on the left wall of this room (dir="W")
|
|
var overlaps_door = false
|
|
var tile_size_check = 16
|
|
for door in all_doors:
|
|
var door_dir = door.dir if "dir" in door else ""
|
|
if door_dir != "W": # Only check left doors (dir="W")
|
|
continue
|
|
|
|
# Check if this door is on the left wall of this room
|
|
# Left door is on the left wall, so door.x should be room.x (the left tile of the left wall)
|
|
var door_x_match = (door.x == room.x)
|
|
if not door_x_match:
|
|
continue # This door is not on this room's left wall
|
|
|
|
# Left door (dir="W"): 2 tiles wide, 3 tiles tall
|
|
# Door position is at door.x, door.y (upper-left tile)
|
|
# Door occupies tiles: x from door.x to door.x + 2, y from door.y to door.y + 3
|
|
# Door world bounding box: from (door.x * 16, door.y * 16) to ((door.x + 2) * 16, (door.y + 3) * 16)
|
|
# CRITICAL: A torch is 16x16 pixels (8px in each direction), so expand door bounds by 8px in ALL directions
|
|
# Door occupies columns room.x (0) and room.x + 1 (1), so torch at room.x + 1 can overlap if it extends left
|
|
var door_min_x = door.x * tile_size_check - 8
|
|
var door_max_x = (door.x + 2) * tile_size_check + 8
|
|
var door_min_y = door.y * tile_size_check - 8
|
|
var door_max_y = (door.y + 3) * tile_size_check + 8
|
|
|
|
# Check if torch bounding box overlaps with door bounding box (non-overlapping means torch is safe)
|
|
# Overlap exists if NOT (torch_max < door_min OR torch_min > door_max)
|
|
var x_overlap = not (torch_bbox_max_x < door_min_x or torch_bbox_min_x > door_max_x)
|
|
var y_overlap = not (torch_bbox_max_y < door_min_y or torch_bbox_min_y > door_max_y)
|
|
if x_overlap and y_overlap:
|
|
overlaps_door = true
|
|
break
|
|
|
|
if not overlaps_door:
|
|
valid_wall_positions.append({"pos": world_pos, "wall": "left", "rotation": 270})
|
|
break # Only add one torch per wall
|
|
|
|
# Right wall (2 tiles wide: room.x + room.w - 2 and room.x + room.w - 1)
|
|
# Place torches at the same distance from floor as top wall torches
|
|
# Right wall has two parts: room.x + room.w - 2 (left part, actual wall) and room.x + room.w - 1 (right part, also corner)
|
|
# We should place torches on room.x + room.w - 2 (the left part of the 2-tile wide right wall), not on room.x + room.w - 1 (corner)
|
|
# Check all valid Y positions on the right wall
|
|
# CRITICAL: Check both tiles of the right wall (similar to left wall) to ensure we're not placing on a door
|
|
for y in range(room.y + 2, room.y + room.h - 2):
|
|
# Check if this is a valid right wall position
|
|
# Right wall has 2 tiles: room.x + room.w - 2 (left part) and room.x + room.w - 1 (right part/corner)
|
|
# Check both tiles to ensure we're not placing on a door
|
|
# Use room.x + room.w - 2 (the left part of the right wall) for torch placement
|
|
if _is_valid_torch_position(room.x + room.w - 2, y, grid, all_doors) and _is_valid_torch_position(room.x + room.w - 1, y, grid, all_doors):
|
|
# Calculate torch world position
|
|
# X position is on the right wall: (room.x + room.w - 2) * tile_size + tile_size / 2.0
|
|
# Move it further to the right (positive X) to position it better on the wall
|
|
var right_wall_x = (room.x + room.w - 2) * tile_size + tile_size / 2.0 + 8 # Move 8 pixels to the right
|
|
# Y position should be at the same distance from floor: y * tile_size + tile_size / 2.0 + 8
|
|
var right_wall_y = y * tile_size + tile_size / 2.0 + torch_y_offset
|
|
var world_pos = Vector2(right_wall_x, right_wall_y)
|
|
|
|
# CRITICAL: Check if torch's 16x16 pixel bounding box overlaps with any door
|
|
# Torch is 16x16 pixels, so it extends 8 pixels in each direction from its center
|
|
# Torch bounding box: from (right_wall_x - 8, right_wall_y - 8) to (right_wall_x + 8, right_wall_y + 8)
|
|
var torch_bbox_min_x = right_wall_x - 8
|
|
var torch_bbox_max_x = right_wall_x + 8
|
|
var torch_bbox_min_y = right_wall_y - 8
|
|
var torch_bbox_max_y = right_wall_y + 8
|
|
|
|
# Check if torch bounding box overlaps with any door's bounding box
|
|
# Only check doors that are on the right wall of this room (dir="E")
|
|
var overlaps_door = false
|
|
var tile_size_check = 16
|
|
for door in all_doors:
|
|
var door_dir = door.dir if "dir" in door else ""
|
|
if door_dir != "E": # Only check right doors (dir="E")
|
|
continue
|
|
|
|
# Check if this door is on the right wall of this room
|
|
# Right door is on the right wall, so door.x should be room.x + room.w - 2 (the left part of the right wall)
|
|
var door_x_match = (door.x == room.x + room.w - 2)
|
|
if not door_x_match:
|
|
continue # This door is not on this room's right wall
|
|
|
|
# Right door (dir="E"): 2 tiles wide, 3 tiles tall
|
|
# Door position is at door.x, door.y (upper-left tile)
|
|
# Door occupies tiles: x from door.x to door.x + 2, y from door.y to door.y + 3
|
|
# Door world bounding box: from (door.x * 16, door.y * 16) to ((door.x + 2) * 16, (door.y + 3) * 16)
|
|
var door_min_x = door.x * tile_size_check
|
|
var door_max_x = (door.x + 2) * tile_size_check
|
|
var door_min_y = door.y * tile_size_check
|
|
var door_max_y = (door.y + 3) * tile_size_check
|
|
|
|
# Check if torch bounding box overlaps with door bounding box
|
|
if not (torch_bbox_max_x < door_min_x or torch_bbox_min_x > door_max_x or \
|
|
torch_bbox_max_y < door_min_y or torch_bbox_min_y > door_max_y):
|
|
overlaps_door = true
|
|
break
|
|
|
|
if not overlaps_door:
|
|
valid_wall_positions.append({"pos": world_pos, "wall": "right", "rotation": 90})
|
|
break # Only add one torch per wall
|
|
|
|
# Randomly select torch positions
|
|
if valid_wall_positions.size() == 0:
|
|
return torches
|
|
|
|
valid_wall_positions.shuffle()
|
|
for i in range(min(num_torches, valid_wall_positions.size())):
|
|
var torch_data = valid_wall_positions[i]
|
|
torches.append({
|
|
"position": torch_data.pos,
|
|
"rotation": torch_data.rotation
|
|
})
|
|
|
|
return torches
|
|
|
|
func _is_valid_torch_position(x: int, y: int, grid: Array, all_doors: Array) -> bool:
|
|
# Check if position is within bounds
|
|
if x < 0 or y < 0:
|
|
return false
|
|
|
|
if x >= grid.size() or y >= grid[x].size():
|
|
return false
|
|
|
|
# Check grid value - torches can only be placed on wall tiles (grid_value == 0)
|
|
# Cannot place on: doors (2), corridors (3), stairs (4), or floor (1)
|
|
var grid_value = grid[x][y]
|
|
if grid_value != 0: # Only wall tiles (0) are valid for torches
|
|
# Specifically check for stairs (4) to prevent overlap
|
|
if grid_value == 4:
|
|
return false # Stairs tile
|
|
if grid_value == 2:
|
|
return false # Door tile
|
|
# Any other non-wall value is invalid
|
|
return false
|
|
|
|
# Also check if position is within door area from door dictionaries
|
|
# This is a backup check in case door grid values aren't set yet
|
|
for door in all_doors:
|
|
var door_x = door.x
|
|
var door_y = door.y
|
|
var door_dir = door.dir if "dir" in door else ""
|
|
|
|
# Calculate actual door dimensions based on direction
|
|
# Horizontal doors (E/W): actually 2-3 tiles wide and 3 tiles tall in grid
|
|
# Vertical doors (N/S): actually 3 tiles wide and 2-3 tiles tall in grid
|
|
var door_w = door.w if "w" in door else 2
|
|
var door_h = door.h if "h" in door else 3
|
|
var actual_w = door_w
|
|
var actual_h = door_h
|
|
|
|
if door_dir == "E" or door_dir == "W":
|
|
# Horizontal door: w is correct (2 or 3), but h is actually 3 in grid (not 1)
|
|
actual_h = 3
|
|
elif door_dir == "N" or door_dir == "S":
|
|
# Vertical door: h is correct (2 or 3), but w is actually 3 in grid (not 1)
|
|
actual_w = 3
|
|
|
|
# Check if (x, y) is within door area
|
|
if x >= door_x and x < door_x + actual_w and y >= door_y and y < door_y + actual_h:
|
|
return false
|
|
|
|
return true
|
|
|
|
func _find_reachable_rooms(start_room: Dictionary, _all_rooms: Array, all_doors: Array) -> Array:
|
|
var reachable = [start_room]
|
|
var queue = [start_room]
|
|
|
|
# Helper function to check if a room is already in the reachable list (value-based comparison)
|
|
var is_room_in_list = func(room_list: Array, room: Dictionary) -> bool:
|
|
if not room or room.is_empty():
|
|
return false
|
|
for r in room_list:
|
|
if r.x == room.x and r.y == room.y and r.w == room.w and r.h == room.h:
|
|
return true
|
|
return false
|
|
|
|
while queue.size() > 0:
|
|
var current = queue.pop_front()
|
|
for door in all_doors:
|
|
var next_room = null
|
|
# Use value-based comparison for room matching
|
|
if "room1" in door and door.room1 is Dictionary:
|
|
if door.room1.x == current.x and door.room1.y == current.y and \
|
|
door.room1.w == current.w and door.room1.h == current.h:
|
|
next_room = door.room2 if "room2" in door else null
|
|
if next_room == null and "room2" in door and door.room2 is Dictionary:
|
|
if door.room2.x == current.x and door.room2.y == current.y and \
|
|
door.room2.w == current.w and door.room2.h == current.h:
|
|
next_room = door.room1 if "room1" in door else null
|
|
|
|
if next_room != null and next_room is Dictionary and not next_room.is_empty():
|
|
if not is_room_in_list.call(reachable, next_room):
|
|
reachable.append(next_room)
|
|
queue.append(next_room)
|
|
|
|
return reachable
|
|
|
|
func _add_hole_to_room(room: Dictionary, grid: Array, tile_grid: Array, map_size: Vector2i, rng: RandomNumberGenerator):
|
|
# Add a hole (minimum 9x9 tiles) somewhere in the room
|
|
# Holes should only be placed in the floor area (not in walls)
|
|
# Floor area is from room.x + 2 to room.x + room.w - 2, and room.y + 2 to room.y + room.h - 2
|
|
var floor_min_x = room.x + 2
|
|
var floor_min_y = room.y + 2
|
|
var floor_max_x = room.x + room.w - 2
|
|
var floor_max_y = room.y + room.h - 2
|
|
var floor_w = floor_max_x - floor_min_x
|
|
var floor_h = floor_max_y - floor_min_y
|
|
|
|
if floor_w < MIN_HOLE_SIZE or floor_h < MIN_HOLE_SIZE:
|
|
return # Room too small for hole
|
|
|
|
var hole_size = rng.randi_range(MIN_HOLE_SIZE, min(floor_w, floor_h, 12))
|
|
|
|
# Position hole within floor area (with 1 tile margin from floor edges)
|
|
var max_x = floor_max_x - hole_size
|
|
var max_y = floor_max_y - hole_size
|
|
|
|
if max_x < floor_min_x or max_y < floor_min_y:
|
|
return # Floor area too small for hole
|
|
|
|
var hole_x = rng.randi_range(floor_min_x, max_x)
|
|
var hole_y = rng.randi_range(floor_min_y, max_y)
|
|
|
|
# Create hole (back to wall) - use inner wall tiles
|
|
# Only create hole if the position is currently a floor tile
|
|
for x in range(hole_x, hole_x + hole_size):
|
|
for y in range(hole_y, hole_y + hole_size):
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
# Only create hole if it's currently a floor tile
|
|
if grid[x][y] == 1: # Floor
|
|
grid[x][y] = 0 # Wall
|
|
# Use inner wall tiles for holes
|
|
if x == hole_x and y == hole_y:
|
|
tile_grid[x][y] = INNER_WALL_TOP_LEFT
|
|
elif x == hole_x + hole_size - 1 and y == hole_y:
|
|
tile_grid[x][y] = INNER_WALL_TOP_RIGHT
|
|
elif x == hole_x and y == hole_y + hole_size - 1:
|
|
tile_grid[x][y] = INNER_WALL_BOTTOM_LEFT
|
|
elif x == hole_x + hole_size - 1 and y == hole_y + hole_size - 1:
|
|
tile_grid[x][y] = INNER_WALL_BOTTOM_RIGHT
|
|
else:
|
|
# Use default wall tile for interior of hole
|
|
tile_grid[x][y] = WALL_TOP_UPPER
|
|
|
|
func _find_farthest_room(all_rooms: Array, start_index: int) -> int:
|
|
var start_room = all_rooms[start_index]
|
|
var max_distance = 0
|
|
var farthest_index = 0
|
|
|
|
for i in range(all_rooms.size()):
|
|
if i == start_index:
|
|
continue
|
|
var room = all_rooms[i]
|
|
var distance = abs(room.x - start_room.x) + abs(room.y - start_room.y)
|
|
if distance > max_distance:
|
|
max_distance = distance
|
|
farthest_index = i
|
|
|
|
return farthest_index
|
|
|
|
func _find_farthest_room_from_list(all_rooms: Array, start_index: int, reachable_rooms: Array) -> int:
|
|
# Find the farthest room from the start room, but only from the reachable rooms list
|
|
var start_room = all_rooms[start_index]
|
|
var max_distance = 0
|
|
var farthest_index = -1
|
|
|
|
for i in range(all_rooms.size()):
|
|
if i == start_index:
|
|
continue
|
|
var room = all_rooms[i]
|
|
# Only consider reachable rooms
|
|
if not reachable_rooms.has(room):
|
|
continue
|
|
|
|
var distance = abs(room.x - start_room.x) + abs(room.y - start_room.y)
|
|
if distance > max_distance:
|
|
max_distance = distance
|
|
farthest_index = i
|
|
|
|
return farthest_index
|
|
|
|
func _render_room_walls(all_rooms: Array, grid: Array, tile_grid: Array, map_size: Vector2i, _rng: RandomNumberGenerator):
|
|
# Render walls around each room
|
|
# All walls are 2 tiles tall (upper and lower parts)
|
|
# Walls are placed at room boundaries (room.x, room.y, etc.)
|
|
# IMPORTANT: Only render walls where grid[x][y] == 0 (wall) or grid[x][y] == 2 (door)
|
|
# Do NOT overwrite floor tiles (grid[x][y] == 1) or corridors (grid[x][y] == 3)
|
|
for room in all_rooms:
|
|
# Top-left corner (2x2): (room.x, room.y), (room.x+1, room.y), (room.x, room.y+1), (room.x+1, room.y+1)
|
|
# Only render if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
if room.x >= 0 and room.x < map_size.x and room.y >= 0 and room.y < map_size.y:
|
|
if grid[room.x][room.y] == 0 or grid[room.x][room.y] == 2: # Wall or door
|
|
if grid[room.x][room.y] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[room.x][room.y] = WALL_TOP_LEFT_TOP_LEFT
|
|
if room.x + 1 >= 0 and room.x + 1 < map_size.x and room.y >= 0 and room.y < map_size.y:
|
|
if grid[room.x + 1][room.y] == 0 or grid[room.x + 1][room.y] == 2: # Wall or door
|
|
if grid[room.x + 1][room.y] != 2: # Not a door
|
|
tile_grid[room.x + 1][room.y] = WALL_TOP_LEFT_TOP_RIGHT
|
|
if room.x >= 0 and room.x < map_size.x and room.y + 1 >= 0 and room.y + 1 < map_size.y:
|
|
if grid[room.x][room.y + 1] == 0 or grid[room.x][room.y + 1] == 2: # Wall or door
|
|
if grid[room.x][room.y + 1] != 2: # Not a door
|
|
tile_grid[room.x][room.y + 1] = WALL_TOP_LEFT_BOTTOM_LEFT
|
|
if room.x + 1 >= 0 and room.x + 1 < map_size.x and room.y + 1 >= 0 and room.y + 1 < map_size.y:
|
|
if grid[room.x + 1][room.y + 1] == 0 or grid[room.x + 1][room.y + 1] == 2: # Wall or door
|
|
if grid[room.x + 1][room.y + 1] != 2: # Not a door
|
|
tile_grid[room.x + 1][room.y + 1] = WALL_TOP_LEFT_BOTTOM_RIGHT
|
|
|
|
# Top-right corner (2x2): (room.x+room.w-2, room.y), (room.x+room.w-1, room.y), (room.x+room.w-2, room.y+1), (room.x+room.w-1, room.y+1)
|
|
# Only render if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
var top_right_x_left = room.x + room.w - 2
|
|
var top_right_x_right = room.x + room.w - 1
|
|
if top_right_x_left >= 0 and top_right_x_left < map_size.x and room.y >= 0 and room.y < map_size.y:
|
|
if grid[top_right_x_left][room.y] == 0 or grid[top_right_x_left][room.y] == 2: # Wall or door
|
|
if grid[top_right_x_left][room.y] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[top_right_x_left][room.y] = WALL_TOP_RIGHT_TOP_LEFT
|
|
if top_right_x_right >= 0 and top_right_x_right < map_size.x and room.y >= 0 and room.y < map_size.y:
|
|
if grid[top_right_x_right][room.y] == 0 or grid[top_right_x_right][room.y] == 2: # Wall or door
|
|
if grid[top_right_x_right][room.y] != 2: # Not a door
|
|
tile_grid[top_right_x_right][room.y] = WALL_TOP_RIGHT_TOP_RIGHT
|
|
if top_right_x_left >= 0 and top_right_x_left < map_size.x and room.y + 1 >= 0 and room.y + 1 < map_size.y:
|
|
if grid[top_right_x_left][room.y + 1] == 0 or grid[top_right_x_left][room.y + 1] == 2: # Wall or door
|
|
if grid[top_right_x_left][room.y + 1] != 2: # Not a door
|
|
tile_grid[top_right_x_left][room.y + 1] = WALL_TOP_RIGHT_BOTTOM_LEFT
|
|
if top_right_x_right >= 0 and top_right_x_right < map_size.x and room.y + 1 >= 0 and room.y + 1 < map_size.y:
|
|
if grid[top_right_x_right][room.y + 1] == 0 or grid[top_right_x_right][room.y + 1] == 2: # Wall or door
|
|
if grid[top_right_x_right][room.y + 1] != 2: # Not a door
|
|
tile_grid[top_right_x_right][room.y + 1] = WALL_TOP_RIGHT_BOTTOM_RIGHT
|
|
|
|
# Top wall (2 tiles tall) - between corners
|
|
for x in range(room.x + 2, room.x + room.w - 2):
|
|
# Upper part of top wall (at room.y)
|
|
if x >= 0 and x < map_size.x and room.y >= 0 and room.y < map_size.y:
|
|
# Only render wall if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
if grid[x][room.y] == 0 or grid[x][room.y] == 2: # Wall or door
|
|
if grid[x][room.y] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[x][room.y] = WALL_TOP_UPPER
|
|
|
|
# Lower part of top wall (at room.y + 1)
|
|
if x >= 0 and x < map_size.x and room.y + 1 >= 0 and room.y + 1 < map_size.y:
|
|
# Only render wall if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
if grid[x][room.y + 1] == 0 or grid[x][room.y + 1] == 2: # Wall or door
|
|
if grid[x][room.y + 1] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[x][room.y + 1] = WALL_TOP_LOWER
|
|
|
|
# Bottom-left corner (2x2): (room.x, room.y+room.h-2), (room.x+1, room.y+room.h-2), (room.x, room.y+room.h-1), (room.x+1, room.y+room.h-1)
|
|
# Only render if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
var bottom_y = room.y + room.h - 1
|
|
var bottom_y_upper = room.y + room.h - 2
|
|
if room.x >= 0 and room.x < map_size.x and bottom_y_upper >= 0 and bottom_y_upper < map_size.y:
|
|
if grid[room.x][bottom_y_upper] == 0 or grid[room.x][bottom_y_upper] == 2: # Wall or door
|
|
if grid[room.x][bottom_y_upper] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[room.x][bottom_y_upper] = WALL_BOTTOM_LEFT_TOP_LEFT
|
|
if room.x + 1 >= 0 and room.x + 1 < map_size.x and bottom_y_upper >= 0 and bottom_y_upper < map_size.y:
|
|
if grid[room.x + 1][bottom_y_upper] == 0 or grid[room.x + 1][bottom_y_upper] == 2: # Wall or door
|
|
if grid[room.x + 1][bottom_y_upper] != 2: # Not a door
|
|
tile_grid[room.x + 1][bottom_y_upper] = WALL_BOTTOM_LEFT_TOP_RIGHT
|
|
if room.x >= 0 and room.x < map_size.x and bottom_y >= 0 and bottom_y < map_size.y:
|
|
if grid[room.x][bottom_y] == 0 or grid[room.x][bottom_y] == 2: # Wall or door
|
|
if grid[room.x][bottom_y] != 2: # Not a door
|
|
tile_grid[room.x][bottom_y] = WALL_BOTTOM_LEFT_BOTTOM_LEFT
|
|
if room.x + 1 >= 0 and room.x + 1 < map_size.x and bottom_y >= 0 and bottom_y < map_size.y:
|
|
if grid[room.x + 1][bottom_y] == 0 or grid[room.x + 1][bottom_y] == 2: # Wall or door
|
|
if grid[room.x + 1][bottom_y] != 2: # Not a door
|
|
tile_grid[room.x + 1][bottom_y] = WALL_BOTTOM_LEFT_BOTTOM_RIGHT
|
|
|
|
# Bottom-right corner (2x2): (room.x+room.w-2, room.y+room.h-2), (room.x+room.w-1, room.y+room.h-2), (room.x+room.w-2, room.y+room.h-1), (room.x+room.w-1, room.y+room.h-1)
|
|
# Only render if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
var bottom_right_x_left = room.x + room.w - 2
|
|
var bottom_right_x_right = room.x + room.w - 1
|
|
if bottom_right_x_left >= 0 and bottom_right_x_left < map_size.x and bottom_y_upper >= 0 and bottom_y_upper < map_size.y:
|
|
if grid[bottom_right_x_left][bottom_y_upper] == 0 or grid[bottom_right_x_left][bottom_y_upper] == 2: # Wall or door
|
|
if grid[bottom_right_x_left][bottom_y_upper] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[bottom_right_x_left][bottom_y_upper] = WALL_BOTTOM_RIGHT_TOP_LEFT
|
|
if bottom_right_x_right >= 0 and bottom_right_x_right < map_size.x and bottom_y_upper >= 0 and bottom_y_upper < map_size.y:
|
|
if grid[bottom_right_x_right][bottom_y_upper] == 0 or grid[bottom_right_x_right][bottom_y_upper] == 2: # Wall or door
|
|
if grid[bottom_right_x_right][bottom_y_upper] != 2: # Not a door
|
|
tile_grid[bottom_right_x_right][bottom_y_upper] = WALL_BOTTOM_RIGHT_TOP_RIGHT
|
|
if bottom_right_x_left >= 0 and bottom_right_x_left < map_size.x and bottom_y >= 0 and bottom_y < map_size.y:
|
|
if grid[bottom_right_x_left][bottom_y] == 0 or grid[bottom_right_x_left][bottom_y] == 2: # Wall or door
|
|
if grid[bottom_right_x_left][bottom_y] != 2: # Not a door
|
|
tile_grid[bottom_right_x_left][bottom_y] = WALL_BOTTOM_RIGHT_BOTTOM_LEFT
|
|
if bottom_right_x_right >= 0 and bottom_right_x_right < map_size.x and bottom_y >= 0 and bottom_y < map_size.y:
|
|
if grid[bottom_right_x_right][bottom_y] == 0 or grid[bottom_right_x_right][bottom_y] == 2: # Wall or door
|
|
if grid[bottom_right_x_right][bottom_y] != 2: # Not a door
|
|
tile_grid[bottom_right_x_right][bottom_y] = WALL_BOTTOM_RIGHT_BOTTOM_RIGHT
|
|
|
|
# Bottom wall (2 tiles tall) - between corners
|
|
for x in range(room.x + 2, room.x + room.w - 2):
|
|
# Upper part of bottom wall (at room.y + room.h - 2)
|
|
if x >= 0 and x < map_size.x and bottom_y_upper >= 0 and bottom_y_upper < map_size.y:
|
|
# Only render wall if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
if grid[x][bottom_y_upper] == 0 or grid[x][bottom_y_upper] == 2: # Wall or door
|
|
if grid[x][bottom_y_upper] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[x][bottom_y_upper] = WALL_BOTTOM_UPPER
|
|
|
|
# Lower part of bottom wall (at room.y + room.h - 1)
|
|
if x >= 0 and x < map_size.x and bottom_y >= 0 and bottom_y < map_size.y:
|
|
# Only render wall if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
if grid[x][bottom_y] == 0 or grid[x][bottom_y] == 2: # Wall or door
|
|
if grid[x][bottom_y] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[x][bottom_y] = WALL_BOTTOM_LOWER
|
|
|
|
# Left wall (2 tiles wide) - at room.x and room.x + 1 (left and right parts)
|
|
for y in range(room.y + 2, room.y + room.h - 2): # Skip corners (first 2 and last 2 rows)
|
|
# Left part of left wall (at room.x)
|
|
if room.x >= 0 and room.x < map_size.x and y >= 0 and y < map_size.y:
|
|
# Only render wall if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
if grid[room.x][y] == 0 or grid[room.x][y] == 2: # Wall or door
|
|
if grid[room.x][y] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[room.x][y] = WALL_LEFT_LEFT
|
|
|
|
# Right part of left wall (at room.x + 1)
|
|
if room.x + 1 >= 0 and room.x + 1 < map_size.x and y >= 0 and y < map_size.y:
|
|
# Only render wall if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
if grid[room.x + 1][y] == 0 or grid[room.x + 1][y] == 2: # Wall or door
|
|
if grid[room.x + 1][y] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[room.x + 1][y] = WALL_LEFT_RIGHT
|
|
|
|
# Right wall (2 tiles wide) - at room.x + room.w - 2 and room.x + room.w - 1 (left and right parts)
|
|
var right_x_left = room.x + room.w - 2
|
|
var right_x_right = room.x + room.w - 1
|
|
for y in range(room.y + 2, room.y + room.h - 2): # Skip corners (first 2 and last 2 rows)
|
|
# Left part of right wall (at room.x + room.w - 2)
|
|
if right_x_left >= 0 and right_x_left < map_size.x and y >= 0 and y < map_size.y:
|
|
# Only render wall if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
if grid[right_x_left][y] == 0 or grid[right_x_left][y] == 2: # Wall or door
|
|
if grid[right_x_left][y] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[right_x_left][y] = WALL_RIGHT_LEFT
|
|
|
|
# Right part of right wall (at room.x + room.w - 1)
|
|
if right_x_right >= 0 and right_x_right < map_size.x and y >= 0 and y < map_size.y:
|
|
# Only render wall if it's a wall (0) or door (2), not floor (1) or corridor (3)
|
|
if grid[right_x_right][y] == 0 or grid[right_x_right][y] == 2: # Wall or door
|
|
if grid[right_x_right][y] != 2: # Not a door (don't overwrite door tiles)
|
|
tile_grid[right_x_right][y] = WALL_RIGHT_RIGHT
|
|
|
|
func _place_enemies_in_room(room: Dictionary, grid: Array, map_size: Vector2i, rng: RandomNumberGenerator, level: int = 1) -> Array:
|
|
# Place enemies in a room, scaled by level
|
|
# Level 1: 0-2 enemies per room (fewer)
|
|
# Level 2+: 0-4 enemies per room, increasing max with level
|
|
# Returns array of enemy data dictionaries
|
|
var enemies = []
|
|
|
|
# Calculate max enemies based on level
|
|
# Level 1: max 2 enemies per room (fewer for first level)
|
|
# Level 2: max 3 enemies per room
|
|
# Level 3: max 4 enemies per room
|
|
# Level 4+: max 5-6 enemies per room (scales with level)
|
|
var max_enemies = 2 if level == 1 else min(1 + level, 6) # Level 1: 2, Level 2: 3, Level 3: 4, Level 4: 5, Level 5+: 6
|
|
var num_enemies = rng.randi_range(0, max_enemies)
|
|
|
|
# Available enemy types (scene paths)
|
|
var enemy_types = [
|
|
"res://scenes/enemy_rat.tscn",
|
|
"res://scenes/enemy_humanoid.tscn",
|
|
"res://scenes/enemy_slime.tscn",
|
|
"res://scenes/enemy_bat.tscn"
|
|
]
|
|
|
|
# Find valid floor positions in the room (excluding walls)
|
|
var valid_positions = []
|
|
var tile_size = 16
|
|
|
|
# Room interior is from room.x + 2 to room.x + room.w - 2 (excluding 2-tile walls)
|
|
for x in range(room.x + 2, room.x + room.w - 2):
|
|
for y in range(room.y + 2, room.y + room.h - 2):
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
# Check if it's a floor tile
|
|
if grid[x][y] == 1: # Floor
|
|
var world_x = x * tile_size + tile_size / 2.0
|
|
var world_y = y * tile_size + tile_size / 2.0
|
|
valid_positions.append(Vector2(world_x, world_y))
|
|
|
|
if valid_positions.size() == 0:
|
|
return enemies
|
|
|
|
# Shuffle positions to randomize enemy placement
|
|
valid_positions.shuffle()
|
|
|
|
# Place enemies
|
|
for i in range(min(num_enemies, valid_positions.size())):
|
|
var enemy_type = enemy_types[rng.randi() % enemy_types.size()]
|
|
var position = valid_positions[i]
|
|
|
|
# Randomize stats (similar to player but weaker)
|
|
# Base stats vary by enemy type
|
|
var max_health = rng.randf_range(18.0, 35.0) # Reduced from 30.0-60.0 for better balance
|
|
var move_speed: float
|
|
var damage = rng.randf_range(5.0, 15.0)
|
|
|
|
# Set appropriate move speed based on enemy type
|
|
if enemy_type.ends_with("bat.tscn"):
|
|
move_speed = rng.randf_range(35.0, 45.0) # Bats: slower
|
|
elif enemy_type.ends_with("slime.tscn"):
|
|
move_speed = rng.randf_range(18.0, 25.0) # Slimes: very slow (reduced from 30-40)
|
|
elif enemy_type.ends_with("rat.tscn"):
|
|
move_speed = rng.randf_range(40.0, 50.0) # Rats: slow
|
|
else:
|
|
move_speed = rng.randf_range(50.0, 80.0) # Other enemies (humanoids): faster
|
|
|
|
var enemy_data = {
|
|
"type": enemy_type,
|
|
"position": position,
|
|
"room": room, # Store reference to room for AI
|
|
"max_health": max_health,
|
|
"move_speed": move_speed,
|
|
"damage": damage
|
|
}
|
|
|
|
# If it's a humanoid enemy, randomize the humanoid_type
|
|
if enemy_type.ends_with("enemy_humanoid.tscn"):
|
|
# Random humanoid type: 0=CYCLOPS, 1=DEMON, 2=HUMANOID, 3=NIGHTELF, 4=GOBLIN, 5=ORC, 6=SKELETON
|
|
# Weight towards common types (goblins, humans, orcs) - 40% goblin, 30% humanoid, 20% orc, 10% other
|
|
var rand_val = rng.randf()
|
|
var humanoid_type = 2 # Default to HUMANOID
|
|
if rand_val < 0.4:
|
|
humanoid_type = 4 # GOBLIN (40%)
|
|
elif rand_val < 0.7:
|
|
humanoid_type = 2 # HUMANOID (30%)
|
|
elif rand_val < 0.9:
|
|
humanoid_type = 5 # ORC (20%)
|
|
else:
|
|
# 10% for other types (distributed evenly)
|
|
var other_types = [0, 1, 3, 6] # CYCLOPS, DEMON, NIGHTELF, SKELETON
|
|
humanoid_type = other_types[rng.randi() % other_types.size()]
|
|
enemy_data["humanoid_type"] = humanoid_type
|
|
|
|
enemies.append(enemy_data)
|
|
|
|
return enemies
|
|
|
|
func _place_stairs_in_exit_room(exit_room: Dictionary, grid: Array, tile_grid: Array, map_size: Vector2i, all_doors: Array, rng: RandomNumberGenerator) -> Dictionary:
|
|
# Place stairs in the exit room on one of the walls
|
|
# Stairs are rendered like doors but with different middle frame tile
|
|
# Choose a random wall to place stairs on (excluding corners)
|
|
# Make sure stairs don't overlap any doors
|
|
# Returns stairs data with position and size for Area2D creation
|
|
LogManager.log("DungeonGenerator: Placing stairs in exit room: " + str(exit_room.x) + "," + str(exit_room.y) + " size: " + str(exit_room.w) + "x" + str(exit_room.h) + " doors: " + str(all_doors.size()), LogManager.CATEGORY_DUNGEON)
|
|
|
|
var stairs_data: Dictionary = {}
|
|
var wall_choices = []
|
|
var tile_size = 16
|
|
|
|
# Helper function to check if stairs position overlaps with any door
|
|
# This checks if ANY tile of the stairs overlaps ANY tile of any door
|
|
# Doors are either 3x2 (vertical: N/S) or 2x3 (horizontal: E/W)
|
|
# CRITICAL: Must check ALL door tiles, not just door position!
|
|
# Uses both door dictionary AND grid check for reliability
|
|
var stairs_overlaps_door = func(stairs_x: int, stairs_y: int, stairs_w: int, stairs_h: int) -> bool:
|
|
# FIRST: Check grid - if any stairs tile is marked as a door (grid value 2), it's an overlap
|
|
for stairs_tile_x in range(stairs_x, stairs_x + stairs_w):
|
|
for stairs_tile_y in range(stairs_y, stairs_y + stairs_h):
|
|
if stairs_tile_x >= 0 and stairs_tile_x < map_size.x and stairs_tile_y >= 0 and stairs_tile_y < map_size.y:
|
|
if grid[stairs_tile_x][stairs_tile_y] == 2: # Grid value 2 = door
|
|
LogManager.log("DungeonGenerator: Stairs tile (" + str(stairs_tile_x) + "," + str(stairs_tile_y) + ") is marked as door in grid!", LogManager.CATEGORY_DUNGEON)
|
|
return true
|
|
|
|
# SECOND: Check door dictionary - verify against all known doors
|
|
for stairs_tile_x in range(stairs_x, stairs_x + stairs_w):
|
|
for stairs_tile_y in range(stairs_y, stairs_y + stairs_h):
|
|
# Check this stairs tile against all door tiles from door dictionary
|
|
for door in all_doors:
|
|
var door_x = door.x
|
|
var door_y = door.y
|
|
|
|
# Determine actual door dimensions and tile positions based on direction
|
|
# CRITICAL: Door x,y is the START position, but door spans multiple tiles!
|
|
var door_tiles: Array = [] # Array of {x, y} for each door tile
|
|
|
|
if "dir" in door:
|
|
match door.dir:
|
|
"E", "W":
|
|
# Horizontal doors (E/W): 2x3 tiles (2 wide, 3 tall)
|
|
# Door starts at (door_x, door_y) and spans 2x3
|
|
for door_dx in range(2):
|
|
for door_dy in range(3):
|
|
door_tiles.append({"x": door_x + door_dx, "y": door_y + door_dy})
|
|
"N", "S":
|
|
# Vertical doors (N/S): 3x2 tiles (3 wide, 2 tall)
|
|
# Door starts at (door_x, door_y) and spans 3x2
|
|
for door_dx in range(3):
|
|
for door_dy in range(2):
|
|
door_tiles.append({"x": door_x + door_dx, "y": door_y + door_dy})
|
|
_:
|
|
# Fallback: assume 3x2 (vertical)
|
|
for door_dx in range(3):
|
|
for door_dy in range(2):
|
|
door_tiles.append({"x": door_x + door_dx, "y": door_y + door_dy})
|
|
else:
|
|
# Fallback if no direction: assume 3x2 (vertical)
|
|
for door_dx in range(3):
|
|
for door_dy in range(2):
|
|
door_tiles.append({"x": door_x + door_dx, "y": door_y + door_dy})
|
|
|
|
# Check if this stairs tile matches any door tile
|
|
for door_tile in door_tiles:
|
|
if stairs_tile_x == door_tile.x and stairs_tile_y == door_tile.y:
|
|
var door_dir_str = str(door.dir) if "dir" in door else "unknown"
|
|
LogManager.log("DungeonGenerator: Stairs tile (" + str(stairs_tile_x) + "," + str(stairs_tile_y) + ") overlaps door tile (" + str(door_tile.x) + "," + str(door_tile.y) + ") from door at (" + str(door_x) + "," + str(door_y) + ") dir: " + door_dir_str, LogManager.CATEGORY_DUNGEON)
|
|
return true
|
|
return false
|
|
|
|
# Determine which walls are available (not blocked by doors)
|
|
# Use same logic as doors: at least 2 tiles from corners, 5 tiles from opposite edge
|
|
# If room is exactly 3 tiles wide/tall, stairs must be exactly in the middle
|
|
|
|
# Top wall - stairs are 3 tiles wide, need at least 2 tiles from corners (same as doors)
|
|
# Minimum room width: 2 (left buffer) + 3 (stairs) + 2 (right buffer) = 7 tiles
|
|
if exit_room.w >= 7: # Minimum room width for 3-tile stairs with corner buffers
|
|
var min_x = exit_room.x + 2 # At least 2 tiles from left corner
|
|
var max_x = exit_room.x + exit_room.w - 5 # At least 5 tiles from right edge (2 buffer + 3 stairs)
|
|
|
|
if max_x >= min_x:
|
|
wall_choices.append({
|
|
"dir": "UP",
|
|
"x_range": range(min_x, max_x + 1), # +1 because range is exclusive
|
|
"y": exit_room.y,
|
|
"tile_start": STAIRS_UP_START,
|
|
"w": 3,
|
|
"h": 2
|
|
})
|
|
|
|
# Bottom wall - stairs are 3 tiles wide, need at least 2 tiles from corners (same as doors)
|
|
# Minimum room width: 2 (left buffer) + 3 (stairs) + 2 (right buffer) = 7 tiles
|
|
# Use same logic as doors: at least 2 tiles from left corner, 5 tiles from right edge
|
|
if exit_room.w >= 7:
|
|
var min_x = exit_room.x + 2 # At least 2 tiles from left corner (same as doors)
|
|
var max_x = exit_room.x + exit_room.w - 5 # At least 5 tiles from right edge (2 buffer + 3 stairs)
|
|
|
|
if max_x >= min_x:
|
|
# Bottom wall: door is at exit_room.y + exit_room.h - 2 (upper tile) and exit_room.y + exit_room.h - 1 (lower tile)
|
|
# Stairs should start at the same position as doors
|
|
wall_choices.append({
|
|
"dir": "DOWN",
|
|
"x_range": range(min_x, max_x + 1),
|
|
"y": exit_room.y + exit_room.h - 2, # Start at upper wall tile (same as doors)
|
|
"tile_start": STAIRS_DOWN_START,
|
|
"w": 3,
|
|
"h": 2
|
|
})
|
|
|
|
# Left wall - stairs are 3 tiles tall, need at least 2 tiles from corners
|
|
# Minimum room height: 2 (top buffer) + 3 (stairs) + 2 (bottom buffer) = 7 tiles
|
|
if exit_room.h >= 7: # Minimum room height for 3-tile stairs with corner buffers
|
|
var min_y = exit_room.y + 2 # At least 2 tiles from top corner
|
|
var max_y = exit_room.y + exit_room.h - 5 # At least 5 tiles from bottom edge (2 buffer + 3 stairs)
|
|
|
|
if max_y >= min_y:
|
|
wall_choices.append({
|
|
"dir": "LEFT",
|
|
"y_range": range(min_y, max_y + 1),
|
|
"x": exit_room.x,
|
|
"tile_start": STAIRS_LEFT_START,
|
|
"w": 2,
|
|
"h": 3
|
|
})
|
|
|
|
# Right wall - stairs are 3 tiles tall, need at least 2 tiles from corners
|
|
# Minimum room height: 2 (top buffer) + 3 (stairs) + 2 (bottom buffer) = 7 tiles
|
|
if exit_room.h >= 7:
|
|
var min_y = exit_room.y + 2 # At least 2 tiles from top corner
|
|
var max_y = exit_room.y + exit_room.h - 5 # At least 5 tiles from bottom edge (2 buffer + 3 stairs)
|
|
|
|
if max_y >= min_y:
|
|
wall_choices.append({
|
|
"dir": "RIGHT",
|
|
"y_range": range(min_y, max_y + 1),
|
|
"x": exit_room.x + exit_room.w - 2, # Right wall is 2 tiles wide
|
|
"tile_start": STAIRS_RIGHT_START,
|
|
"w": 2,
|
|
"h": 3
|
|
})
|
|
|
|
if wall_choices.size() == 0:
|
|
LogManager.log_error("DungeonGenerator: ERROR - No valid walls for stairs! Exit room too small: " + str(exit_room.w) + "x" + str(exit_room.h), LogManager.CATEGORY_DUNGEON)
|
|
return {} # No valid walls for stairs
|
|
|
|
# Choose a random wall
|
|
var wall = wall_choices[rng.randi() % wall_choices.size()]
|
|
|
|
if wall.dir == "UP" or wall.dir == "DOWN":
|
|
# Horizontal stairs (3x2)
|
|
if wall.x_range.size() == 0:
|
|
LogManager.log_error("DungeonGenerator: ERROR - x_range is empty for " + str(wall.dir) + " stairs", LogManager.CATEGORY_DUNGEON)
|
|
return {}
|
|
|
|
# Try to find a position that doesn't overlap doors
|
|
var valid_positions = []
|
|
for test_x in wall.x_range:
|
|
var test_stairs_start_x = test_x - 1 # Start 1 tile to the left (3 tiles wide)
|
|
if not stairs_overlaps_door.call(test_stairs_start_x, wall.y, wall.w, wall.h):
|
|
valid_positions.append(test_x)
|
|
|
|
if valid_positions.size() == 0:
|
|
LogManager.log_error("DungeonGenerator: ERROR - No valid position found for " + str(wall.dir) + " stairs (all positions overlap doors)", LogManager.CATEGORY_DUNGEON)
|
|
# Don't allow stairs to overlap doors - this is a critical bug
|
|
# Instead, try the next wall or return empty to force placement elsewhere
|
|
return {} # No valid position found - will trigger _force_place_stairs
|
|
|
|
# Choose random valid position
|
|
var stairs_x = valid_positions[rng.randi() % valid_positions.size()]
|
|
var stairs_start_x = stairs_x - 1 # Start 1 tile to the left (3 tiles wide)
|
|
|
|
# Store stairs data for Area2D creation
|
|
stairs_data = {
|
|
"x": stairs_start_x,
|
|
"y": wall.y,
|
|
"w": wall.w,
|
|
"h": wall.h,
|
|
"dir": wall.dir,
|
|
"world_pos": Vector2((stairs_start_x + wall.w / 2.0) * tile_size, (wall.y + wall.h / 2.0) * tile_size),
|
|
"world_size": Vector2(wall.w * tile_size, wall.h * tile_size)
|
|
}
|
|
|
|
LogManager.log("DungeonGenerator: Placed " + str(wall.dir) + " stairs at tile (" + str(stairs_start_x) + "," + str(wall.y) + ") world pos: " + str(stairs_data.world_pos) + " in room (" + str(exit_room.x) + "," + str(exit_room.y) + ") size " + str(exit_room.w) + "x" + str(exit_room.h), LogManager.CATEGORY_DUNGEON)
|
|
|
|
# Mark grid cells as stairs (similar to doors)
|
|
for dx in range(wall.w):
|
|
for dy in range(wall.h):
|
|
var x = stairs_start_x + dx
|
|
var y = wall.y + dy
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
grid[x][y] = 4 # Stairs (use grid value 4)
|
|
# Render stairs tiles (similar to doors but with different middle frame)
|
|
if wall.dir == "UP":
|
|
if dy == 0: # First row
|
|
if dx == 1: # Middle tile
|
|
tile_grid[x][y] = Vector2i(10, 0) # Special middle tile for UP stairs
|
|
else:
|
|
tile_grid[x][y] = wall.tile_start + Vector2i(dx, dy)
|
|
else:
|
|
tile_grid[x][y] = wall.tile_start + Vector2i(dx, dy)
|
|
else: # DOWN
|
|
# For DOWN stairs, use same tiles as door DOWN
|
|
# Row 0 (dy=0): use door tiles
|
|
# Row 1 (dy=1): use door tiles, except middle tile (col 1, row 1) which is 6,6
|
|
if dy == 1 and dx == 1: # Second row, middle column (col 1, row 1)
|
|
tile_grid[x][y] = Vector2i(6, 6) # Special middle tile for DOWN stairs
|
|
else:
|
|
# Use door DOWN tiles (same as DOOR_BOTTOM_START = 7,5)
|
|
tile_grid[x][y] = wall.tile_start + Vector2i(dx, dy)
|
|
|
|
elif wall.dir == "LEFT" or wall.dir == "RIGHT":
|
|
# Vertical stairs (2x3)
|
|
if wall.y_range.size() == 0:
|
|
LogManager.log_error("DungeonGenerator: ERROR - y_range is empty for " + str(wall.dir) + " stairs", LogManager.CATEGORY_DUNGEON)
|
|
return {}
|
|
|
|
# Try to find a position that doesn't overlap doors
|
|
var valid_positions = []
|
|
for test_y in wall.y_range:
|
|
var test_stairs_start_y = test_y - 1 # Start 1 tile up (3 tiles tall)
|
|
if not stairs_overlaps_door.call(wall.x, test_stairs_start_y, wall.w, wall.h):
|
|
valid_positions.append(test_y)
|
|
|
|
if valid_positions.size() == 0:
|
|
LogManager.log_error("DungeonGenerator: ERROR - No valid position found for " + str(wall.dir) + " stairs (all positions overlap doors)", LogManager.CATEGORY_DUNGEON)
|
|
# Don't allow stairs to overlap doors - this is a critical bug
|
|
# Instead, try the next wall or return empty to force placement elsewhere
|
|
return {} # No valid position found - will trigger _force_place_stairs
|
|
|
|
# Choose random valid position
|
|
var stairs_y = valid_positions[rng.randi() % valid_positions.size()]
|
|
var stairs_start_y = stairs_y - 1 # Start 1 tile up (3 tiles tall)
|
|
|
|
# Store stairs data for Area2D creation
|
|
stairs_data = {
|
|
"x": wall.x,
|
|
"y": stairs_start_y,
|
|
"w": wall.w,
|
|
"h": wall.h,
|
|
"dir": wall.dir,
|
|
"world_pos": Vector2((wall.x + wall.w / 2.0) * tile_size, (stairs_start_y + wall.h / 2.0) * tile_size),
|
|
"world_size": Vector2(wall.w * tile_size, wall.h * tile_size)
|
|
}
|
|
|
|
LogManager.log("DungeonGenerator: Placed " + str(wall.dir) + " stairs at tile (" + str(wall.x) + "," + str(stairs_start_y) + ") world pos: " + str(stairs_data.world_pos) + " in room (" + str(exit_room.x) + "," + str(exit_room.y) + ") size " + str(exit_room.w) + "x" + str(exit_room.h), LogManager.CATEGORY_DUNGEON)
|
|
|
|
# Mark grid cells as stairs
|
|
for dx in range(wall.w):
|
|
for dy in range(wall.h):
|
|
var x = wall.x + dx
|
|
var y = stairs_start_y + dy
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
grid[x][y] = 4 # Stairs
|
|
# Render stairs tiles with special middle frame
|
|
if wall.dir == "LEFT":
|
|
if dx == 0: # First column
|
|
if dy == 1: # Middle tile (second row)
|
|
tile_grid[x][y] = Vector2i(5, 1) # Special middle tile for LEFT stairs
|
|
else:
|
|
tile_grid[x][y] = wall.tile_start + Vector2i(dx, dy)
|
|
else:
|
|
tile_grid[x][y] = wall.tile_start + Vector2i(dx, dy)
|
|
else: # RIGHT
|
|
if dx == 1: # Second column
|
|
if dy == 1: # Middle tile (second row)
|
|
tile_grid[x][y] = Vector2i(11, 1) # Special middle tile for RIGHT stairs
|
|
else:
|
|
tile_grid[x][y] = wall.tile_start + Vector2i(dx, dy)
|
|
else:
|
|
tile_grid[x][y] = wall.tile_start + Vector2i(dx, dy)
|
|
|
|
return stairs_data
|
|
|
|
func _force_place_stairs(exit_room: Dictionary, grid: Array, tile_grid: Array, map_size: Vector2i, all_doors: Array, _rng: RandomNumberGenerator) -> Dictionary:
|
|
# Force place stairs in exit room - used as fallback when normal placement fails
|
|
# Still tries to avoid door overlaps, but will place stairs even if room is small
|
|
# Uses same positioning logic as doors: at least 2 tiles from corners
|
|
LogManager.log("DungeonGenerator: Force placing stairs in exit room: " + str(exit_room.x) + "," + str(exit_room.y) + " size: " + str(exit_room.w) + "x" + str(exit_room.h), LogManager.CATEGORY_DUNGEON)
|
|
|
|
var stairs_data: Dictionary = {}
|
|
var tile_size = 16
|
|
|
|
# Helper function to check if stairs position overlaps with any door (same as in _place_stairs_in_exit_room)
|
|
# CRITICAL: Check each stairs tile against each door tile to ensure no overlap
|
|
# Uses both door dictionary AND grid check for reliability
|
|
var stairs_overlaps_door = func(test_x: int, test_y: int, test_w: int, test_h: int) -> bool:
|
|
# FIRST: Check grid - if any stairs tile is marked as a door (grid value 2), it's an overlap
|
|
for stairs_tile_x in range(test_x, test_x + test_w):
|
|
for stairs_tile_y in range(test_y, test_y + test_h):
|
|
if stairs_tile_x >= 0 and stairs_tile_x < map_size.x and stairs_tile_y >= 0 and stairs_tile_y < map_size.y:
|
|
if grid[stairs_tile_x][stairs_tile_y] == 2: # Grid value 2 = door
|
|
return true
|
|
|
|
# SECOND: Check door dictionary - verify against all known doors
|
|
for stairs_tile_x in range(test_x, test_x + test_w):
|
|
for stairs_tile_y in range(test_y, test_y + test_h):
|
|
# Check this stairs tile against all door tiles from door dictionary
|
|
for door in all_doors:
|
|
var door_x = door.x
|
|
var door_y = door.y
|
|
|
|
# Determine actual door tile positions based on direction
|
|
var door_tiles: Array = [] # Array of {x, y} for each door tile
|
|
|
|
if "dir" in door:
|
|
match door.dir:
|
|
"E", "W":
|
|
# Horizontal doors (E/W): 2x3 tiles (2 wide, 3 tall)
|
|
for door_dx in range(2):
|
|
for door_dy in range(3):
|
|
door_tiles.append({"x": door_x + door_dx, "y": door_y + door_dy})
|
|
"N", "S":
|
|
# Vertical doors (N/S): 3x2 tiles (3 wide, 2 tall)
|
|
for door_dx in range(3):
|
|
for door_dy in range(2):
|
|
door_tiles.append({"x": door_x + door_dx, "y": door_y + door_dy})
|
|
_:
|
|
# Fallback: assume 3x2 (vertical)
|
|
for door_dx in range(3):
|
|
for door_dy in range(2):
|
|
door_tiles.append({"x": door_x + door_dx, "y": door_y + door_dy})
|
|
else:
|
|
# Fallback: assume 3x2 (vertical)
|
|
for door_dx in range(3):
|
|
for door_dy in range(2):
|
|
door_tiles.append({"x": door_x + door_dx, "y": door_y + door_dy})
|
|
|
|
# Check if this stairs tile matches any door tile
|
|
for door_tile in door_tiles:
|
|
if stairs_tile_x == door_tile.x and stairs_tile_y == door_tile.y:
|
|
return true
|
|
return false
|
|
|
|
# Calculate safe position for stairs (3 tiles wide, 2 tiles tall)
|
|
# Try to place on top wall first, then bottom, then left, then right, then center floor
|
|
var stairs_x = 0
|
|
var stairs_y = 0
|
|
var stairs_w = 3
|
|
var stairs_h = 2
|
|
var stairs_dir = "UP"
|
|
var found_position = false
|
|
|
|
# Try top wall (preferred) - use same logic as doors
|
|
# Minimum room width: 2 (left buffer) + 3 (stairs) + 2 (right buffer) = 7 tiles
|
|
if exit_room.w >= 7:
|
|
var min_x = exit_room.x + 2 # At least 2 tiles from left corner
|
|
var max_x = exit_room.x + exit_room.w - 5 # At least 5 tiles from right edge (2 buffer + 3 stairs)
|
|
# Try multiple positions to avoid doors
|
|
for test_x in range(min_x, max_x + 1):
|
|
var test_stairs_start_x = test_x - 1 # Start 1 tile to the left (3 tiles wide)
|
|
if not stairs_overlaps_door.call(test_stairs_start_x, exit_room.y, stairs_w, stairs_h):
|
|
stairs_x = test_stairs_start_x
|
|
stairs_y = exit_room.y
|
|
stairs_dir = "UP"
|
|
found_position = true
|
|
break
|
|
# Don't place if all positions overlap - try next wall instead
|
|
|
|
# Try bottom wall
|
|
if not found_position and exit_room.w >= 7:
|
|
var min_x = exit_room.x + 2
|
|
var max_x = exit_room.x + exit_room.w - 5
|
|
for test_x in range(min_x, max_x + 1):
|
|
var test_stairs_start_x = test_x - 1
|
|
if not stairs_overlaps_door.call(test_stairs_start_x, exit_room.y + exit_room.h - stairs_h, stairs_w, stairs_h):
|
|
stairs_x = test_stairs_start_x
|
|
stairs_y = exit_room.y + exit_room.h - stairs_h
|
|
stairs_dir = "DOWN"
|
|
found_position = true
|
|
break
|
|
# Don't place if all positions overlap - try next wall instead
|
|
|
|
# Try left wall (vertical stairs)
|
|
# Minimum room height: 2 (top buffer) + 3 (stairs) + 2 (bottom buffer) = 7 tiles
|
|
if not found_position and exit_room.h >= 7:
|
|
var min_y = exit_room.y + 2
|
|
var max_y = exit_room.y + exit_room.h - 5
|
|
stairs_w = 2
|
|
stairs_h = 3
|
|
for test_y in range(min_y, max_y + 1):
|
|
var test_stairs_start_y = test_y - 1 # Start 1 tile up (3 tiles tall)
|
|
if not stairs_overlaps_door.call(exit_room.x, test_stairs_start_y, stairs_w, stairs_h):
|
|
stairs_x = exit_room.x
|
|
stairs_y = test_stairs_start_y
|
|
stairs_dir = "LEFT"
|
|
found_position = true
|
|
break
|
|
# Don't place if all positions overlap - try next wall instead
|
|
|
|
# Try right wall (vertical stairs)
|
|
if not found_position and exit_room.h >= 7:
|
|
var min_y = exit_room.y + 2
|
|
var max_y = exit_room.y + exit_room.h - 5
|
|
stairs_w = 2
|
|
stairs_h = 3
|
|
for test_y in range(min_y, max_y + 1):
|
|
var test_stairs_start_y = test_y - 1
|
|
if not stairs_overlaps_door.call(exit_room.x + exit_room.w - 2, test_stairs_start_y, stairs_w, stairs_h):
|
|
stairs_x = exit_room.x + exit_room.w - 2
|
|
stairs_y = test_stairs_start_y
|
|
stairs_dir = "RIGHT"
|
|
found_position = true
|
|
break
|
|
# Don't place if all positions overlap - try next wall instead
|
|
|
|
# Last resort: place in center of room floor (any room size)
|
|
# But ONLY if it doesn't overlap any doors!
|
|
if not found_position:
|
|
stairs_w = 3
|
|
stairs_h = 2
|
|
var center_x = exit_room.x + max(1, (exit_room.w - stairs_w) / 2)
|
|
var center_y = exit_room.y + max(1, (exit_room.h - stairs_h) / 2)
|
|
center_x = clamp(center_x, exit_room.x + 1, exit_room.x + exit_room.w - stairs_w - 1)
|
|
center_y = clamp(center_y, exit_room.y + 1, exit_room.y + exit_room.h - stairs_h - 1)
|
|
|
|
# Check if center position overlaps any doors
|
|
if not stairs_overlaps_door.call(center_x, center_y, stairs_w, stairs_h):
|
|
stairs_x = center_x
|
|
stairs_y = center_y
|
|
stairs_dir = "UP"
|
|
found_position = true
|
|
else:
|
|
# Try to find ANY free position in the room that doesn't overlap doors
|
|
for test_y in range(exit_room.y + 1, exit_room.y + exit_room.h - stairs_h):
|
|
for test_x in range(exit_room.x + 1, exit_room.x + exit_room.w - stairs_w):
|
|
if not stairs_overlaps_door.call(test_x, test_y, stairs_w, stairs_h):
|
|
stairs_x = test_x
|
|
stairs_y = test_y
|
|
stairs_dir = "UP"
|
|
found_position = true
|
|
break
|
|
if found_position:
|
|
break
|
|
|
|
# If still no valid position found, return empty (don't place stairs that overlap doors!)
|
|
if not found_position:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Could not find any position for stairs that doesn't overlap doors!", LogManager.CATEGORY_DUNGEON)
|
|
return {}
|
|
|
|
stairs_data = {
|
|
"x": stairs_x,
|
|
"y": stairs_y,
|
|
"w": stairs_w,
|
|
"h": stairs_h,
|
|
"dir": stairs_dir,
|
|
"world_pos": Vector2((stairs_x + stairs_w / 2.0) * tile_size, (stairs_y + stairs_h / 2.0) * tile_size),
|
|
"world_size": Vector2(stairs_w * tile_size, stairs_h * tile_size)
|
|
}
|
|
|
|
# Mark grid cells as stairs
|
|
for dx in range(stairs_data.w):
|
|
for dy in range(stairs_data.h):
|
|
var x = stairs_data.x + dx
|
|
var y = stairs_data.y + dy
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
grid[x][y] = 4 # Stairs
|
|
# Render stairs tiles based on direction (same as normal placement)
|
|
if stairs_dir == "UP":
|
|
if dy == 0: # First row
|
|
if dx == 1: # Middle tile
|
|
tile_grid[x][y] = Vector2i(10, 0) # Special middle tile for UP stairs
|
|
else:
|
|
tile_grid[x][y] = STAIRS_UP_START + Vector2i(dx, dy)
|
|
else:
|
|
tile_grid[x][y] = STAIRS_UP_START + Vector2i(dx, dy)
|
|
elif stairs_dir == "DOWN":
|
|
# For DOWN stairs, use same tiles as door DOWN
|
|
# Row 0 (dy=0): use door tiles
|
|
# Row 1 (dy=1): use door tiles, except middle tile (col 1, row 1) which is 6,6
|
|
if dy == 1 and dx == 1: # Second row, middle column (col 1, row 1)
|
|
tile_grid[x][y] = Vector2i(6, 6) # Special middle tile for DOWN stairs
|
|
else:
|
|
# Use door DOWN tiles (same as DOOR_BOTTOM_START = STAIRS_DOWN_START = 7,5)
|
|
tile_grid[x][y] = STAIRS_DOWN_START + Vector2i(dx, dy)
|
|
elif stairs_dir == "LEFT":
|
|
# Vertical stairs on left wall
|
|
if dx == 0: # First column
|
|
if dy == 1: # Middle tile (second row)
|
|
tile_grid[x][y] = Vector2i(5, 1) # Special middle tile for LEFT stairs
|
|
else:
|
|
tile_grid[x][y] = STAIRS_LEFT_START + Vector2i(dx, dy)
|
|
else:
|
|
tile_grid[x][y] = STAIRS_LEFT_START + Vector2i(dx, dy)
|
|
elif stairs_dir == "RIGHT":
|
|
# Vertical stairs on right wall
|
|
if dx == 1: # Second column
|
|
if dy == 1: # Middle tile (second row)
|
|
tile_grid[x][y] = Vector2i(11, 1) # Special middle tile for RIGHT stairs
|
|
else:
|
|
tile_grid[x][y] = STAIRS_RIGHT_START + Vector2i(dx, dy)
|
|
else:
|
|
tile_grid[x][y] = STAIRS_RIGHT_START + Vector2i(dx, dy)
|
|
else:
|
|
# Fallback: use UP stairs tiles
|
|
tile_grid[x][y] = STAIRS_UP_START + Vector2i(dx, dy)
|
|
|
|
LogManager.log("DungeonGenerator: Force placed " + str(stairs_dir) + " stairs at tile (" + str(stairs_data.x) + "," + str(stairs_data.y) + ") world pos: " + str(stairs_data.world_pos), LogManager.CATEGORY_DUNGEON)
|
|
return stairs_data
|
|
|
|
func _place_interactable_objects_in_room(room: Dictionary, grid: Array, map_size: Vector2i, all_doors: Array, all_enemies: Array, rng: RandomNumberGenerator, room_puzzle_data: Dictionary = {}) -> Array:
|
|
# Place interactable objects in a room
|
|
# Small rooms (7-8 tiles): 0-1 objects
|
|
# Medium rooms (9-10 tiles): 0-3 objects
|
|
# Large rooms (11-12 tiles): 0-8 objects
|
|
# Returns array of interactable object data dictionaries
|
|
# CRITICAL: If room has "switch_pillar" puzzle, MUST spawn at least 1 Pillar (regardless of room size)
|
|
var objects = []
|
|
var tile_size = 16
|
|
|
|
# Check if room has a "switch_pillar" puzzle - if so, we MUST spawn at least 1 pillar
|
|
var has_pillar_switch_puzzle = false
|
|
var matching_puzzle_room = null
|
|
if room_puzzle_data.size() > 0:
|
|
# Try direct lookup first (room dictionary as key)
|
|
if room_puzzle_data.has(room):
|
|
matching_puzzle_room = room
|
|
else:
|
|
# Fallback: find matching room by comparing values (x, y, w, h)
|
|
for puzzle_room in room_puzzle_data.keys():
|
|
# Compare rooms by values (x, y, w, h)
|
|
if puzzle_room.x == room.x and puzzle_room.y == room.y and \
|
|
puzzle_room.w == room.w and puzzle_room.h == room.h:
|
|
matching_puzzle_room = puzzle_room
|
|
break
|
|
|
|
if matching_puzzle_room != null:
|
|
var puzzle_info = room_puzzle_data[matching_puzzle_room]
|
|
LogManager.log("DungeonGenerator: Checking room (" + str(room.x) + "," + str(room.y) + ") - puzzle_room (" + str(matching_puzzle_room.x) + "," + str(matching_puzzle_room.y) + ") puzzle_type: " + str(puzzle_info.type), LogManager.CATEGORY_DUNGEON)
|
|
if puzzle_info.type == "switch_pillar":
|
|
has_pillar_switch_puzzle = true
|
|
LogManager.log("DungeonGenerator: Room (" + str(room.x) + "," + str(room.y) + ") has pillar switch puzzle - will spawn at least 1 pillar", LogManager.CATEGORY_DUNGEON)
|
|
else:
|
|
LogManager.log("DungeonGenerator: room_puzzle_data is empty for room (" + str(room.x) + "," + str(room.y) + ")", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# Calculate room floor area (excluding walls)
|
|
var floor_w = room.w - 4 # Excluding 2-tile walls on each side
|
|
var floor_h = room.h - 4
|
|
var floor_area = floor_w * floor_h
|
|
|
|
# Determine max objects based on room size
|
|
var max_objects: int = 0
|
|
if floor_area <= 16: # Small rooms (4x4 or smaller floor)
|
|
max_objects = 1
|
|
elif floor_area <= 36: # Medium rooms (up to 6x6 floor)
|
|
max_objects = 3
|
|
else: # Large rooms (7x7+ floor)
|
|
max_objects = 8
|
|
|
|
var num_objects = rng.randi_range(0, max_objects)
|
|
|
|
# CRITICAL: If room has pillar switch puzzle, ensure we spawn at least 1 pillar
|
|
# This MUST happen regardless of room size
|
|
if has_pillar_switch_puzzle:
|
|
# Set minimum to 1 if num_objects is 0
|
|
if num_objects == 0:
|
|
num_objects = 1
|
|
# The pillar will be placed FIRST in the objects list (before any other objects)
|
|
|
|
# Available object types and their setup functions
|
|
var object_types = [
|
|
{"type": "Pot", "setup": "setup_pot"},
|
|
{"type": "LiftableBarrel", "setup": "setup_liftable_barrel"},
|
|
{"type": "PushableBarrel", "setup": "setup_pushable_barrel"},
|
|
{"type": "Box", "setup": "setup_box"},
|
|
{"type": "Chest", "setup": "setup_chest"},
|
|
{"type": "Pillar", "setup": "setup_pillar"},
|
|
{"type": "PushableHighBox", "setup": "setup_pushable_high_box"}
|
|
]
|
|
|
|
# Find valid floor positions in the room (excluding walls, enemies, and door areas)
|
|
var valid_positions = []
|
|
|
|
# Room interior is from room.x + 2 to room.x + room.w - 2 (excluding 2-tile walls)
|
|
# CRITICAL: Also exclude last row/column of floor tiles to prevent objects from spawning in walls
|
|
# Objects are 16x16, so we need at least 1 tile buffer from walls
|
|
# Floor tiles are at: room.x+2, room.x+3, ..., room.x+room.w-3 (last floor tile before wall)
|
|
# To exclude last tile, we want: room.x+2, room.x+3, ..., room.x+room.w-4
|
|
var min_x = room.x + 2
|
|
var max_x = room.x + room.w - 4 # Exclude last 2 floor tiles (room.w-3 is last floor, room.w-4 is second-to-last)
|
|
var min_y = room.y + 2
|
|
var max_y = room.y + room.h - 4 # Exclude last 2 floor tiles (room.h-3 is last floor, room.h-4 is second-to-last)
|
|
|
|
for x in range(min_x, max_x + 1): # +1 because range is exclusive at end
|
|
for y in range(min_y, max_y + 1):
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
# Check if it's a floor tile
|
|
if grid[x][y] == 1: # Floor
|
|
# CRITICAL: Interactable objects are 16x16 pixels with origin at (0,0) (top-left)
|
|
# To center a 16x16 sprite in a 16x16 tile, we need to offset by 8 pixels into the tile
|
|
# Tile (x,y) spans from (x*16, y*16) to ((x+1)*16, (y+1)*16)
|
|
# Position sprite 8 pixels into the tile from top-left: (x*16 + 8, y*16 + 8)
|
|
var world_x = x * tile_size + 8
|
|
var world_y = y * tile_size + 8
|
|
var world_pos = Vector2(world_x, world_y)
|
|
|
|
# Check if position is valid (not blocked by door, not occupied by enemy)
|
|
if _is_valid_interactable_position(world_pos, all_doors, all_enemies, room):
|
|
valid_positions.append(world_pos)
|
|
|
|
# Early return if no valid positions (unless pillar is required, but that's handled below)
|
|
if valid_positions.size() == 0:
|
|
if has_pillar_switch_puzzle:
|
|
# CRITICAL: Pillar is REQUIRED, so we must find at least one position
|
|
# Try a more permissive search - use ALL floor tiles in the room (even if near doors/walls)
|
|
LogManager.log("DungeonGenerator: Room (" + str(room.x) + "," + str(room.y) + ") has pillar switch puzzle but no valid positions. Trying fallback search...", LogManager.CATEGORY_DUNGEON)
|
|
# Use same bounds but skip the position validation check
|
|
var found_fallback = false
|
|
for x in range(min_x, max_x + 1):
|
|
for y in range(min_y, max_y + 1):
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
if grid[x][y] == 1: # Floor
|
|
var world_x = x * tile_size + 8
|
|
var world_y = y * tile_size + 8
|
|
var world_pos = Vector2(world_x, world_y)
|
|
valid_positions.append(world_pos)
|
|
# Only need one position for the required pillar
|
|
found_fallback = true
|
|
break
|
|
if found_fallback:
|
|
break
|
|
|
|
if valid_positions.size() == 0:
|
|
push_warning("DungeonGenerator: Room (", room.x, ",", room.y, ") has pillar switch puzzle but NO floor tiles! Cannot place pillar.")
|
|
return objects
|
|
else:
|
|
LogManager.log("DungeonGenerator: Found fallback position for required pillar in room (" + str(room.x) + "," + str(room.y) + ")", LogManager.CATEGORY_DUNGEON)
|
|
else:
|
|
# No pillar required, safe to return
|
|
return objects
|
|
|
|
# Shuffle positions to randomize placement
|
|
valid_positions.shuffle()
|
|
|
|
# CRITICAL: If room has pillar switch puzzle, the FIRST object MUST be a Pillar
|
|
if has_pillar_switch_puzzle:
|
|
# Place pillar as the first object
|
|
var pillar_type_data = {"type": "Pillar", "setup": "setup_pillar"}
|
|
objects.append({
|
|
"type": pillar_type_data.type,
|
|
"setup_function": pillar_type_data.setup,
|
|
"position": valid_positions[0],
|
|
"room": room
|
|
})
|
|
|
|
# Place remaining objects (skip first position since it's used by the pillar)
|
|
# We need to place num_objects - 1 more objects (since pillar counts as 1)
|
|
var remaining_objects = num_objects - 1
|
|
var positions_index = 1 # Start from second position
|
|
for i in range(min(remaining_objects, valid_positions.size() - 1)):
|
|
if positions_index >= valid_positions.size():
|
|
break # No more valid positions
|
|
var object_type_data = object_types[rng.randi() % object_types.size()]
|
|
# Skip Pillar type for remaining objects (already placed one)
|
|
while object_type_data.type == "Pillar":
|
|
object_type_data = object_types[rng.randi() % object_types.size()]
|
|
|
|
objects.append({
|
|
"type": object_type_data.type,
|
|
"setup_function": object_type_data.setup,
|
|
"position": valid_positions[positions_index],
|
|
"room": room
|
|
})
|
|
positions_index += 1
|
|
else:
|
|
# Normal placement: no pillar requirement
|
|
for i in range(min(num_objects, valid_positions.size())):
|
|
var object_type_data = object_types[rng.randi() % object_types.size()]
|
|
var position = valid_positions[i]
|
|
|
|
objects.append({
|
|
"type": object_type_data.type,
|
|
"setup_function": object_type_data.setup,
|
|
"position": position,
|
|
"room": room
|
|
})
|
|
|
|
return objects
|
|
|
|
func _is_valid_interactable_position(world_pos: Vector2, all_doors: Array, all_enemies: Array, room: Dictionary) -> bool:
|
|
# Check if position is not blocked by a door or occupied by an enemy
|
|
var tile_size = 16
|
|
var tile_x = int(world_pos.x / tile_size)
|
|
var tile_y = int(world_pos.y / tile_size)
|
|
|
|
# Check if position is in front of a door (within 2 tiles of door center)
|
|
for door in all_doors:
|
|
var door_x = door.x
|
|
var door_y = door.y
|
|
|
|
# Determine actual door dimensions based on direction
|
|
var door_w: int
|
|
var door_h: int
|
|
if "dir" in door:
|
|
match door.dir:
|
|
"E", "W":
|
|
# Horizontal doors: 2x3
|
|
door_w = 2
|
|
door_h = 3
|
|
"N", "S":
|
|
# Vertical doors: 3x2
|
|
door_w = 3
|
|
door_h = 2
|
|
_:
|
|
door_w = door.w if "w" in door else 3
|
|
door_h = door.h if "h" in door else 2
|
|
else:
|
|
door_w = 3
|
|
door_h = 2
|
|
|
|
# Check if position is within door area
|
|
if tile_x >= door_x and tile_x < door_x + door_w and \
|
|
tile_y >= door_y and tile_y < door_y + door_h:
|
|
return false
|
|
|
|
# Check if position is within 2 tiles in front of door (based on door direction)
|
|
# Check if door connects to this room
|
|
var door_connects_to_room = false
|
|
if "room1" in door and door.room1 == room:
|
|
door_connects_to_room = true
|
|
elif "room2" in door and door.room2 == room:
|
|
door_connects_to_room = true
|
|
|
|
if door_connects_to_room:
|
|
# Check if position is within 2 tiles in front of door
|
|
if door.dir == "E" or door.dir == "W":
|
|
# Horizontal door
|
|
if door.dir == "E":
|
|
# Door on right wall, position should be to the left (inside room)
|
|
if tile_x >= door_x - 2 and tile_x < door_x and \
|
|
tile_y >= door_y - 1 and tile_y < door_y + door_h + 1:
|
|
return false
|
|
else: # W
|
|
# Door on left wall, position should be to the right (inside room)
|
|
if tile_x > door_x + door_w and tile_x <= door_x + door_w + 2 and \
|
|
tile_y >= door_y - 1 and tile_y < door_y + door_h + 1:
|
|
return false
|
|
else: # N or S
|
|
# Vertical door
|
|
if door.dir == "S":
|
|
# Door on bottom wall, position should be above (inside room)
|
|
if tile_y >= door_y - 2 and tile_y < door_y and \
|
|
tile_x >= door_x - 1 and tile_x < door_x + door_w + 1:
|
|
return false
|
|
else: # N
|
|
# Door on top wall, position should be below (inside room)
|
|
if tile_y > door_y + door_h and tile_y <= door_y + door_h + 2 and \
|
|
tile_x >= door_x - 1 and tile_x < door_x + door_w + 1:
|
|
return false
|
|
|
|
# Check if position is occupied by an enemy
|
|
for enemy in all_enemies:
|
|
if enemy.has("position") and enemy.position is Vector2:
|
|
var enemy_tile_x = int(enemy.position.x / tile_size)
|
|
var enemy_tile_y = int(enemy.position.y / tile_size)
|
|
# Check if within 1 tile (enemies and objects shouldn't overlap)
|
|
if abs(tile_x - enemy_tile_x) <= 1 and abs(tile_y - enemy_tile_y) <= 1:
|
|
return false
|
|
|
|
return true
|
|
|
|
func _find_rooms_before_door(door: Dictionary, start_room: Dictionary, _all_rooms: Array, all_doors: Array) -> Array:
|
|
# Find rooms that are reachable from start WITHOUT going through this door
|
|
# This is used to place keys before KeyDoors
|
|
var rooms_before_door = []
|
|
var visited = [start_room]
|
|
var queue = [start_room]
|
|
|
|
while queue.size() > 0:
|
|
var current = queue.pop_front()
|
|
|
|
# Add current room to result (it's reachable before the door)
|
|
# Don't include the rooms the door connects (need key before reaching them)
|
|
if current != door.room1 and current != door.room2:
|
|
if not rooms_before_door.has(current):
|
|
rooms_before_door.append(current)
|
|
|
|
# Check all doors connected to current room (except the blocked door)
|
|
for d in all_doors:
|
|
if d == door:
|
|
continue # Skip the blocked door
|
|
|
|
var next_room = null
|
|
if d.room1 == current:
|
|
next_room = d.room2
|
|
elif d.room2 == current:
|
|
next_room = d.room1
|
|
|
|
if next_room != null and not visited.has(next_room):
|
|
visited.append(next_room)
|
|
queue.append(next_room)
|
|
|
|
return rooms_before_door
|
|
|
|
func _place_blocking_doors(all_rooms: Array, all_doors: Array, grid: Array, map_size: Vector2i, rng: RandomNumberGenerator, start_room_index: int, exit_room_index: int) -> Dictionary:
|
|
# Place blocking doors on existing tile doors
|
|
# Returns array of blocking door data dictionaries
|
|
var blocking_doors = []
|
|
var tile_size = 16
|
|
|
|
# Get start and exit room references
|
|
var start_room = all_rooms[start_room_index]
|
|
var _exit_room = all_rooms[exit_room_index]
|
|
|
|
# Calculate reachability from start room to determine where keys can be placed
|
|
var _reachable_rooms_from_start = _find_reachable_rooms(start_room, all_rooms, all_doors)
|
|
|
|
# Track which rooms have puzzles and which doors are already assigned
|
|
var _rooms_with_puzzles = {} # room -> true
|
|
var assigned_doors = [] # Doors already assigned to a room puzzle
|
|
var room_puzzle_data = {} # room -> {type: "switch" or "enemy", doors: []}
|
|
|
|
# STEP 1: For each room (except start/exit), randomly decide if it has a door-puzzle
|
|
var puzzle_room_chance = 0.4 # 40% chance per room
|
|
LogManager.log("DungeonGenerator: Assigning puzzles to rooms (" + str(all_rooms.size()) + " total rooms, excluding start/exit)", LogManager.CATEGORY_DUNGEON)
|
|
for i in range(all_rooms.size()):
|
|
if i == start_room_index or i == exit_room_index:
|
|
continue # Skip start and exit rooms
|
|
|
|
var room = all_rooms[i]
|
|
|
|
if rng.randf() < puzzle_room_chance:
|
|
LogManager.log("DungeonGenerator: Room (" + str(room.x) + ", " + str(room.y) + ") selected for puzzle assignment", LogManager.CATEGORY_DUNGEON)
|
|
# This room has a puzzle!
|
|
# CRITICAL SAFETY CHECK: Never assign puzzles to start or exit rooms
|
|
# Double-check even though we skip them in the loop
|
|
if i == start_room_index or i == exit_room_index:
|
|
continue
|
|
|
|
# Find all doors that are connected to this puzzle room
|
|
var doors_in_room = []
|
|
for door in all_doors:
|
|
var door_room1 = door.room1 if ("room1" in door and door.room1 and not door.room1.is_empty()) else null
|
|
var door_room2 = door.room2 if ("room2" in door and door.room2 and not door.room2.is_empty()) else null
|
|
|
|
var room_matches = false
|
|
|
|
# Check if room1 matches puzzle room
|
|
if door_room1:
|
|
room_matches = (door_room1.x == room.x and door_room1.y == room.y and \
|
|
door_room1.w == room.w and door_room1.h == room.h)
|
|
|
|
# Check if room2 matches puzzle room
|
|
if not room_matches and door_room2:
|
|
room_matches = (door_room2.x == room.x and door_room2.y == room.y and \
|
|
door_room2.w == room.w and door_room2.h == room.h)
|
|
|
|
# Door is connected to puzzle room
|
|
if room_matches:
|
|
doors_in_room.append(door)
|
|
|
|
if doors_in_room.size() == 0:
|
|
LogManager.log("DungeonGenerator: Room (" + str(room.x) + ", " + str(room.y) + ") has no doors connected - skipping puzzle assignment", LogManager.CATEGORY_DUNGEON)
|
|
continue # No doors connected to this room, skip
|
|
|
|
LogManager.log("DungeonGenerator: Room (" + str(room.x) + ", " + str(room.y) + ") has " + str(doors_in_room.size()) + " doors - assigning puzzle", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# Decide puzzle type: 33% walk switch, 33% pillar switch, 33% enemy spawner (if room is large enough)
|
|
var can_have_enemies = false
|
|
var interior_width = room.w - 4 # Exclude 2-tile walls
|
|
var interior_height = room.h - 4
|
|
can_have_enemies = (interior_width >= 5 and interior_height >= 5)
|
|
|
|
var puzzle_type = ""
|
|
var rand_val = rng.randf()
|
|
if can_have_enemies and rand_val < 0.33:
|
|
puzzle_type = "enemy"
|
|
elif rand_val < 0.66:
|
|
puzzle_type = "switch_walk"
|
|
else:
|
|
puzzle_type = "switch_pillar"
|
|
|
|
# Store puzzle data for this room
|
|
room_puzzle_data[room] = {
|
|
"type": puzzle_type,
|
|
"doors": doors_in_room
|
|
}
|
|
LogManager.log("DungeonGenerator: Stored puzzle data for room (" + str(room.x) + ", " + str(room.y) + ") - type: " + str(puzzle_type) + ", doors: " + str(doors_in_room.size()), LogManager.CATEGORY_DUNGEON)
|
|
|
|
# Mark these doors as assigned
|
|
for door in doors_in_room:
|
|
assigned_doors.append(door)
|
|
|
|
LogManager.log("DungeonGenerator: Assigned puzzles to " + str(room_puzzle_data.size()) + " rooms", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# STEP 2: Create blocking doors for rooms with puzzles
|
|
# CRITICAL: Blocking doors should ONLY be placed ON THE DOORS IN THE PUZZLE ROOM
|
|
# NEVER create blocking doors for rooms that are NOT in room_puzzle_data!
|
|
# When you enter the puzzle room, these doors close, trapping you until you solve the puzzle
|
|
for room in room_puzzle_data.keys():
|
|
# CRITICAL SAFETY CHECK #1: Verify this room is actually in room_puzzle_data
|
|
if not room in room_puzzle_data:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Room (" + str(room.x) + ", " + str(room.y) + ") is NOT in room_puzzle_data! This should never happen!", LogManager.CATEGORY_DUNGEON)
|
|
continue
|
|
|
|
# CRITICAL SAFETY CHECK #2: Never create blocking doors for start or exit rooms
|
|
var room_index = -1
|
|
for j in range(all_rooms.size()):
|
|
var check_room = all_rooms[j]
|
|
if check_room.x == room.x and check_room.y == room.y and \
|
|
check_room.w == room.w and check_room.h == room.h:
|
|
room_index = j
|
|
break
|
|
|
|
if room_index == start_room_index or room_index == exit_room_index:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Attempted to create blocking doors for start/exit room! Skipping.", LogManager.CATEGORY_DUNGEON)
|
|
continue
|
|
|
|
# CRITICAL SAFETY CHECK #3: Verify this room is actually in all_rooms (sanity check)
|
|
if room_index == -1:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Room (" + str(room.x) + ", " + str(room.y) + ") not found in all_rooms! Skipping.", LogManager.CATEGORY_DUNGEON)
|
|
continue
|
|
|
|
var puzzle_info = room_puzzle_data[room]
|
|
var doors_in_room = puzzle_info.doors # Doors that are IN this puzzle room (lead OUT OF it)
|
|
var puzzle_type = puzzle_info.type
|
|
|
|
if doors_in_room.size() == 0:
|
|
LogManager.log("DungeonGenerator: WARNING - Room has puzzle but no doors! Skipping.", LogManager.CATEGORY_DUNGEON)
|
|
continue
|
|
|
|
# Randomly choose door type: 50% StoneDoor, 50% GateDoor
|
|
var door_type = "StoneDoor" if rng.randf() < 0.5 else "GateDoor"
|
|
|
|
# Create puzzle element first (switch or spawner) - ONCE per room, shared by all doors
|
|
var puzzle_element_created = false
|
|
var puzzle_element_data = {}
|
|
|
|
if puzzle_type == "switch_walk" or puzzle_type == "switch_pillar":
|
|
# Find a valid floor position for switch IN THE PUZZLE ROOM
|
|
var switch_type = "walk" if puzzle_type == "switch_walk" else "pillar"
|
|
var switch_weight = 1.0 if switch_type == "walk" else 5.0
|
|
|
|
var switch_data = _find_floor_switch_position(room, grid, map_size, rng, -1, -1)
|
|
if switch_data != null and not switch_data.is_empty() and switch_data.has("position"):
|
|
puzzle_element_created = true
|
|
puzzle_element_data = {
|
|
"type": "switch",
|
|
"switch_type": switch_type,
|
|
"switch_weight": switch_weight,
|
|
"switch_data": switch_data,
|
|
"switch_room": room
|
|
}
|
|
LogManager.log("DungeonGenerator: Created switch puzzle for room (" + str(room.x) + ", " + str(room.y) + ") - type: " + str(switch_type), LogManager.CATEGORY_DUNGEON)
|
|
else:
|
|
LogManager.log("DungeonGenerator: WARNING - Could not place floor switch in puzzle room (" + str(room.x) + ", " + str(room.y) + ")! Skipping puzzle.", LogManager.CATEGORY_DUNGEON)
|
|
elif puzzle_type == "enemy":
|
|
# Add enemy spawner IN THE PUZZLE ROOM
|
|
var spawner_positions = []
|
|
for x in range(room.x + 2, room.x + room.w - 2):
|
|
for y in range(room.y + 2, room.y + room.h - 2):
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
if grid[x][y] == 1: # Floor
|
|
var world_x = x * tile_size + tile_size / 2.0
|
|
var world_y = y * tile_size + tile_size / 2.0
|
|
spawner_positions.append({
|
|
"position": Vector2(world_x, world_y),
|
|
"tile_x": x,
|
|
"tile_y": y
|
|
})
|
|
|
|
if spawner_positions.size() > 0:
|
|
spawner_positions.shuffle()
|
|
var spawner_data = spawner_positions[0]
|
|
puzzle_element_created = true
|
|
puzzle_element_data = {
|
|
"type": "enemy",
|
|
"spawner_data": spawner_data,
|
|
"spawner_room": room
|
|
}
|
|
LogManager.log("DungeonGenerator: Created enemy spawner puzzle for room (" + str(room.x) + ", " + str(room.y) + ") - spawner at " + str(spawner_data.position), LogManager.CATEGORY_DUNGEON)
|
|
else:
|
|
LogManager.log("DungeonGenerator: WARNING - Could not place enemy spawner in puzzle room (" + str(room.x) + ", " + str(room.y) + ")! Skipping puzzle.", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# CRITICAL SAFETY CHECK: Only create blocking doors if puzzle element was successfully created
|
|
if not puzzle_element_created:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Puzzle element was NOT created for room (" + str(room.x) + ", " + str(room.y) + ") with puzzle_type: " + str(puzzle_type) + "! Skipping ALL doors in this room.", LogManager.CATEGORY_DUNGEON)
|
|
# Remove doors from assigned list since we're not creating the puzzle
|
|
for door in doors_in_room:
|
|
if door in assigned_doors:
|
|
assigned_doors.erase(door)
|
|
continue
|
|
|
|
# CRITICAL: Verify puzzle_element_data is valid before proceeding
|
|
if puzzle_element_data.is_empty() or not puzzle_element_data.has("type"):
|
|
LogManager.log_error("DungeonGenerator: ERROR - puzzle_element_data is invalid for room (" + str(room.x) + ", " + str(room.y) + ")! puzzle_element_created was true but data is empty!", LogManager.CATEGORY_DUNGEON)
|
|
continue
|
|
|
|
# Create blocking doors for at least 1 door (minimum), or all doors in the room
|
|
# For now, create blocking doors for ALL doors in the puzzle room
|
|
LogManager.log("DungeonGenerator: Creating blocking doors for room (" + str(room.x) + ", " + str(room.y) + ") with " + str(doors_in_room.size()) + " doors, puzzle type: " + str(puzzle_type) + ", puzzle_element type: " + str(puzzle_element_data.type), LogManager.CATEGORY_DUNGEON)
|
|
for door in doors_in_room:
|
|
# Determine direction based on which WALL of the PUZZLE ROOM the door is on
|
|
var direction = _determine_door_direction_for_puzzle_room(door, room, all_rooms)
|
|
|
|
# CRITICAL: door.x and door.y are the position in room1, not necessarily in puzzle room
|
|
# Need to calculate the correct position on the puzzle room's wall
|
|
var door_room2 = door.room2 if ("room2" in door and door.room2 and not door.room2.is_empty()) else null
|
|
|
|
# Determine if puzzle room is room2 (if so, door position needs adjustment)
|
|
var puzzle_is_room2 = false
|
|
if door_room2:
|
|
puzzle_is_room2 = (door_room2.x == room.x and door_room2.y == room.y and \
|
|
door_room2.w == room.w and door_room2.h == room.h)
|
|
|
|
# Calculate door position on the puzzle room's wall
|
|
var door_tile_x = door.x
|
|
var door_tile_y = door.y
|
|
var open_tile_x = door_tile_x
|
|
var open_tile_y = door_tile_y
|
|
|
|
# If puzzle room is room2, the door position needs to be moved to the puzzle room's wall
|
|
if puzzle_is_room2:
|
|
# Door is connecting from room1 to puzzle room (room2)
|
|
# We need to calculate the position on puzzle room's wall based on door direction
|
|
match direction:
|
|
"Up":
|
|
# Door on top wall of puzzle room - door.y should be at puzzle_room.y
|
|
open_tile_x = door_tile_x # Keep same X (horizontal position)
|
|
open_tile_y = room.y # Top wall of puzzle room
|
|
"Down":
|
|
# Door on bottom wall of puzzle room - door.y should be at puzzle_room.y + room.h - 1
|
|
open_tile_x = door_tile_x # Keep same X (horizontal position)
|
|
open_tile_y = room.y + room.h - 1 # Bottom wall of puzzle room
|
|
"Left":
|
|
# Door on left wall of puzzle room - door.x should be at puzzle_room.x
|
|
open_tile_x = room.x # Left wall of puzzle room
|
|
open_tile_y = door_tile_y # Keep same Y (vertical position)
|
|
"Right":
|
|
# Door on right wall of puzzle room - door.x should be at puzzle_room.x + room.w - 1
|
|
open_tile_x = room.x + room.w - 1 # Right wall of puzzle room
|
|
open_tile_y = door_tile_y # Keep same Y (vertical position)
|
|
# else: Puzzle room is room1 - door position is already in puzzle room, use as-is
|
|
|
|
# Adjust position based on door direction and offset from wall
|
|
# These offsets are relative to the door's position on the wall
|
|
match direction:
|
|
"Up":
|
|
# Door Up (3x2): Open at middle column, top row
|
|
# open_tile_x is already on the wall, adjust to middle column
|
|
open_tile_x = open_tile_x + 1 # Middle column (3 tiles wide, so +1 from left edge)
|
|
open_tile_y = open_tile_y + 0 # Already at top wall (row 0)
|
|
"Right":
|
|
# Door Right (2x3): Open at right column, middle row
|
|
# open_tile_x is already on the wall, adjust to right column
|
|
open_tile_x = open_tile_x + 1 # Right column (already at wall)
|
|
open_tile_y = open_tile_y + 1 # Middle row (3 tiles tall, so +1 from top)
|
|
"Down":
|
|
# Door Down (3x2): Open at middle column, bottom row
|
|
# open_tile_x is already on the wall, adjust to middle column
|
|
open_tile_x = open_tile_x + 1 # Middle column (3 tiles wide, so +1 from left edge)
|
|
open_tile_y = open_tile_y + 1 # Bottom row (2 tiles tall, so +1 from top edge)
|
|
"Left":
|
|
# Door Left (2x3): Open at left column, middle row
|
|
# open_tile_x is already on the wall, adjust to left column
|
|
open_tile_x = open_tile_x + 0 # Left column (already at wall)
|
|
open_tile_y = open_tile_y + 1 # Middle row (3 tiles tall, so +1 from top)
|
|
|
|
# Calculate world position from open tile (center of tile)
|
|
# This is the OPEN position - door will start here and move to CLOSED position when entering room
|
|
var door_world_x = open_tile_x * tile_size + tile_size / 2.0
|
|
var door_world_y = open_tile_y * tile_size + tile_size / 2.0
|
|
|
|
# Create door data
|
|
# Position is the OPEN state position (will move to CLOSED when entering room)
|
|
# CRITICAL: Verify room is still a valid puzzle room before creating door
|
|
if not room in room_puzzle_data:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Room (" + str(room.x) + ", " + str(room.y) + ") is no longer in room_puzzle_data! Cannot create door.", LogManager.CATEGORY_DUNGEON)
|
|
continue
|
|
|
|
# NOTE: door_room1 is already declared at line 1933 and verified to match puzzle room at line 1935-1940
|
|
# No need to re-declare or re-verify here - the door_in_puzzle_room check above already ensures room1 matches
|
|
|
|
var door_data = {
|
|
"type": door_type,
|
|
"direction": direction,
|
|
"position": Vector2(door_world_x, door_world_y), # OPEN position (tile center)
|
|
"tile_x": open_tile_x,
|
|
"tile_y": open_tile_y,
|
|
"door": door,
|
|
"blocking_room": room, # CRITICAL: This door is IN the puzzle room (the room that has the puzzle)
|
|
"is_closed": false, # Start open, close when entering puzzle room
|
|
"puzzle_type": puzzle_type # "switch_walk", "switch_pillar", or "enemy"
|
|
}
|
|
|
|
# Store puzzle room as room1 for blocking doors
|
|
door_data.original_room1 = room # Puzzle room is always room1 for blocking doors
|
|
|
|
LogManager.log("DungeonGenerator: Creating blocking door for puzzle room (" + str(room.x) + ", " + str(room.y) + ") - direction: " + str(direction) + ", open_tile: (" + str(open_tile_x) + "," + str(open_tile_y) + ")", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# CRITICAL: Add puzzle-specific data from the puzzle_element_data created above (shared across all doors in room)
|
|
# Only add door if puzzle element data is valid
|
|
var door_has_valid_puzzle = false
|
|
if puzzle_element_data.has("type") and puzzle_element_data.type == "switch":
|
|
if puzzle_element_data.has("switch_data") and puzzle_element_data.switch_data.has("position"):
|
|
door_data.floor_switch_position = puzzle_element_data.switch_data.position
|
|
door_data.switch_tile_x = puzzle_element_data.switch_data.tile_x
|
|
door_data.switch_tile_y = puzzle_element_data.switch_data.tile_y
|
|
door_data.switch_room = puzzle_element_data.switch_room
|
|
door_data.requires_switch = true
|
|
door_data.switch_type = puzzle_element_data.switch_type
|
|
door_data.switch_required_weight = puzzle_element_data.switch_weight
|
|
door_has_valid_puzzle = true
|
|
LogManager.log("DungeonGenerator: Added switch data to door - switch at (" + str(door_data.switch_tile_x) + ", " + str(door_data.switch_tile_y) + ")", LogManager.CATEGORY_DUNGEON)
|
|
elif puzzle_element_data.has("type") and puzzle_element_data.type == "enemy":
|
|
if puzzle_element_data.has("spawner_data") and puzzle_element_data.spawner_data.has("position"):
|
|
if not "enemy_spawners" in door_data:
|
|
door_data.enemy_spawners = []
|
|
door_data.enemy_spawners.append({
|
|
"position": puzzle_element_data.spawner_data.position,
|
|
"tile_x": puzzle_element_data.spawner_data.tile_x,
|
|
"tile_y": puzzle_element_data.spawner_data.tile_y,
|
|
"room": puzzle_element_data.spawner_room,
|
|
"spawn_once": true # Only spawn 1 enemy, then destroy spawner
|
|
})
|
|
door_data.requires_enemies = true
|
|
door_has_valid_puzzle = true
|
|
LogManager.log("DungeonGenerator: Added enemy spawner data to door - spawner at (" + str(puzzle_element_data.spawner_data.tile_x) + ", " + str(puzzle_element_data.spawner_data.tile_y) + ")", LogManager.CATEGORY_DUNGEON)
|
|
|
|
# CRITICAL SAFETY CHECK: Only add door to blocking doors if it has valid puzzle element
|
|
if not door_has_valid_puzzle:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Blocking door for room (" + str(room.x) + ", " + str(room.y) + ") has no valid puzzle element! Skipping door. puzzle_type: " + str(puzzle_type) + ", puzzle_element_data: " + str(puzzle_element_data), LogManager.CATEGORY_DUNGEON)
|
|
continue # Skip this door - don't add it to blocking_doors
|
|
|
|
# FINAL SAFETY CHECK: Verify door has either requires_switch or requires_enemies set
|
|
if door_data.type == "StoneDoor" or door_data.type == "GateDoor":
|
|
var has_switch = door_data.get("requires_switch", false) == true
|
|
var has_enemies = door_data.get("requires_enemies", false) == true
|
|
if not has_switch and not has_enemies:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Blocking door (StoneDoor/GateDoor) has neither requires_switch nor requires_enemies! Door data: " + str(door_data.keys()) + " - SKIPPING DOOR", LogManager.CATEGORY_DUNGEON)
|
|
continue # Skip this door - it's invalid
|
|
|
|
# FINAL CRITICAL SAFETY CHECK: Verify door's blocking_room matches the puzzle room exactly
|
|
if door_data.blocking_room.x != room.x or door_data.blocking_room.y != room.y or \
|
|
door_data.blocking_room.w != room.w or door_data.blocking_room.h != room.h:
|
|
LogManager.log_error("DungeonGenerator: ERROR - Door blocking_room (" + str(door_data.blocking_room.x) + "," + str(door_data.blocking_room.y) + ") doesn't match puzzle room (" + str(room.x) + "," + str(room.y) + ")! This door is for wrong room! SKIPPING DOOR", LogManager.CATEGORY_DUNGEON)
|
|
continue # Skip this door - it's for the wrong room
|
|
|
|
# Add door to blocking doors list ONLY if it has valid puzzle element
|
|
blocking_doors.append(door_data)
|
|
LogManager.log("DungeonGenerator: Created blocking door for puzzle room (" + str(room.x) + ", " + str(room.y) + ") - direction: " + str(direction) + ", open tile: (" + str(open_tile_x) + ", " + str(open_tile_y) + "), puzzle_type: " + str(puzzle_type) + ", has_switch: " + str(door_data.get("requires_switch", false)) + ", has_enemies: " + str(door_data.get("requires_enemies", false)), LogManager.CATEGORY_DUNGEON)
|
|
|
|
# STEP 3: Randomly assign some doors as KeyDoors (except start/exit room doors and already assigned doors)
|
|
var key_door_chance = 0.2 # 20% chance per door
|
|
var key_doors_to_create = []
|
|
|
|
for door in all_doors:
|
|
# Skip if already assigned to a room puzzle
|
|
if door in assigned_doors:
|
|
continue
|
|
|
|
# Skip doors connected to start or exit rooms
|
|
var door_room1 = door.room1 if "room1" in door else null
|
|
var door_room2 = door.room2 if "room2" in door else null
|
|
|
|
var is_start_or_exit_door = false
|
|
if door_room1:
|
|
var room1_index = all_rooms.find(door_room1)
|
|
if room1_index == start_room_index or room1_index == exit_room_index:
|
|
is_start_or_exit_door = true
|
|
if door_room2:
|
|
var room2_index = all_rooms.find(door_room2)
|
|
if room2_index == start_room_index or room2_index == exit_room_index:
|
|
is_start_or_exit_door = true
|
|
|
|
if is_start_or_exit_door:
|
|
continue
|
|
|
|
if rng.randf() < key_door_chance:
|
|
key_doors_to_create.append(door)
|
|
|
|
# STEP 4: Create KeyDoors with keys placed BEFORE the keydoor
|
|
for door in key_doors_to_create:
|
|
# Determine direction
|
|
var direction = ""
|
|
if "dir" in door:
|
|
match door.dir:
|
|
"E": direction = "Right"
|
|
"W": direction = "Left"
|
|
"N": direction = "Up"
|
|
"S": direction = "Down"
|
|
_: direction = _determine_door_direction(door, all_rooms)
|
|
else:
|
|
direction = _determine_door_direction(door, all_rooms)
|
|
|
|
# Calculate middle tile position
|
|
var door_tile_x = door.x
|
|
var door_tile_y = door.y
|
|
var middle_tile_x = door_tile_x
|
|
var middle_tile_y = door_tile_y
|
|
|
|
match direction:
|
|
"Down":
|
|
# Door Down (3x2): KeyDoors should be placed on row 0, col 1 (CLOSED state)
|
|
# Row 0 is the upper row (closer to room interior) - this is where KeyDoors start CLOSED
|
|
# When opened with key, they move to row 1 (col 1, row 1) - 16px down
|
|
# BUT: After 180° rotation, we need to adjust Y position UP by 8 pixels (half a tile)
|
|
# to account for sprite alignment - position will be adjusted in door.gd
|
|
middle_tile_x = door_tile_x + 1 # col 1 (middle column)
|
|
middle_tile_y = door_tile_y + 0 # row 0 (upper row - CLOSED state for KeyDoor)
|
|
"Up":
|
|
# Door Up (3x2): door spans 2 tiles tall, wall is at top edge
|
|
# Use the TOP tile (row 0) AT the wall boundary
|
|
middle_tile_x = door_tile_x + 1 # col 1 (middle column)
|
|
middle_tile_y = door_tile_y + 1 # row 0 (TOP tile, AT the wall boundary)
|
|
"Right":
|
|
# Door Right (2x3): door spans 2 tiles, wall is at right edge
|
|
# Use the RIGHT tile (col 1) at the wall boundary, not the left tile
|
|
middle_tile_x = door_tile_x + 0 # col 1 (right column, AT the wall boundary)
|
|
middle_tile_y = door_tile_y + 1 # row 1 (middle row)
|
|
"Left":
|
|
# Door Left (2x3): door spans 2 tiles, wall is at left edge
|
|
# Use the LEFT tile (col 0) at the wall boundary
|
|
middle_tile_x = door_tile_x + 1 # col 0 (left column, AT the wall boundary)
|
|
middle_tile_y = door_tile_y + 1 # row 1 (middle row)
|
|
|
|
var door_world_x = middle_tile_x * tile_size + tile_size / 2.0
|
|
var door_world_y = middle_tile_y * tile_size + tile_size / 2.0
|
|
|
|
# Determine which room this door blocks (the room you're entering into)
|
|
var door_room1 = door.room1 if "room1" in door else null
|
|
var door_room2 = door.room2 if "room2" in door else null
|
|
var blocking_room = door_room2 if door_room2 != null else door_room1
|
|
|
|
# Find rooms reachable BEFORE this door (for key placement)
|
|
var rooms_before_door = _find_rooms_before_door(door, start_room, all_rooms, all_doors)
|
|
|
|
# Pick a room for the key (must be reachable before the door)
|
|
var key_room = null
|
|
if rooms_before_door.size() > 0:
|
|
# Exclude start and exit rooms from key placement
|
|
var key_room_candidates = []
|
|
for room in rooms_before_door:
|
|
var room_index = all_rooms.find(room)
|
|
if room_index != start_room_index and room_index != exit_room_index:
|
|
key_room_candidates.append(room)
|
|
|
|
if key_room_candidates.size() > 0:
|
|
key_room = key_room_candidates[rng.randi() % key_room_candidates.size()]
|
|
else:
|
|
# Fallback: use start room
|
|
key_room = start_room
|
|
else:
|
|
# Fallback: use start room
|
|
key_room = start_room
|
|
|
|
var door_data = {
|
|
"type": "KeyDoor",
|
|
"direction": direction,
|
|
"position": Vector2(door_world_x, door_world_y),
|
|
"tile_x": middle_tile_x,
|
|
"tile_y": middle_tile_y,
|
|
"door": door,
|
|
"blocking_room": blocking_room,
|
|
"is_closed": true, # KeyDoors always closed
|
|
"key_room": key_room # Room where key is placed (before this door)
|
|
}
|
|
|
|
blocking_doors.append(door_data)
|
|
|
|
return {
|
|
"doors": blocking_doors,
|
|
"puzzle_data": room_puzzle_data
|
|
}
|
|
|
|
func _find_floor_switch_position(room: Dictionary, grid: Array, map_size: Vector2i, rng: RandomNumberGenerator, exclude_door_x: int = -1, exclude_door_y: int = -1) -> Dictionary:
|
|
# Find a valid floor position for a floor switch in the room
|
|
# exclude_door_x, exclude_door_y: Tile coordinates of door to avoid placing switch too close to
|
|
# Returns a dictionary with position (Vector2) and tile_x, tile_y (int) or empty dict if no position found
|
|
var tile_size = 16
|
|
var valid_positions = []
|
|
var min_distance_from_door = 3 # Minimum tiles away from door
|
|
|
|
# Room interior is from room.x + 2 to room.x + room.w - 2 (excluding 2-tile walls)
|
|
# Also exclude door tiles (grid value 2) to avoid placing switches in doorways
|
|
for x in range(room.x + 2, room.x + room.w - 2):
|
|
for y in range(room.y + 2, room.y + room.h - 2):
|
|
if x >= 0 and x < map_size.x and y >= 0 and y < map_size.y:
|
|
# Check if it's a floor tile (not a door tile)
|
|
if grid[x][y] == 1: # Floor (not door which is 2)
|
|
# Check if position is too close to door (if door position provided)
|
|
var too_close_to_door = false
|
|
if exclude_door_x >= 0 and exclude_door_y >= 0:
|
|
var distance_x = abs(x - exclude_door_x)
|
|
var distance_y = abs(y - exclude_door_y)
|
|
var distance = max(distance_x, distance_y) # Chebyshev distance (tiles)
|
|
if distance < min_distance_from_door:
|
|
too_close_to_door = true
|
|
|
|
if not too_close_to_door:
|
|
var world_x = x * tile_size + tile_size / 2.0
|
|
var world_y = y * tile_size + tile_size / 2.0
|
|
valid_positions.append({
|
|
"position": Vector2(world_x, world_y),
|
|
"tile_x": x,
|
|
"tile_y": y
|
|
})
|
|
|
|
if valid_positions.size() > 0:
|
|
# Pick a random position
|
|
return valid_positions[rng.randi() % valid_positions.size()]
|
|
|
|
return {}
|
|
|
|
func _determine_door_direction(door: Dictionary, _all_rooms: Array) -> String:
|
|
# Determine door direction based on door position and connected rooms
|
|
# Door on upper wall = "Up", left wall = "Left", etc.
|
|
# This returns direction relative to room1
|
|
if not "room1" in door or not "room2" in door:
|
|
return "Up" # Default
|
|
|
|
var room1 = door.room1
|
|
var room2 = door.room2
|
|
|
|
# Determine which wall the door is on by comparing room positions
|
|
# If room2 is above room1, door is on top wall of room1 (Up)
|
|
# If room2 is below room1, door is on bottom wall of room1 (Down)
|
|
# If room2 is left of room1, door is on left wall of room1 (Left)
|
|
# If room2 is right of room1, door is on right wall of room1 (Right)
|
|
|
|
var dx = room2.x - room1.x
|
|
var dy = room2.y - room1.y
|
|
|
|
# Check which direction has the larger difference
|
|
if abs(dy) > abs(dx):
|
|
# Vertical alignment
|
|
if dy < 0:
|
|
return "Up" # room2 is above room1 - door on top wall of room1
|
|
else:
|
|
return "Down" # room2 is below room1 - door on bottom wall of room1
|
|
else:
|
|
# Horizontal alignment
|
|
if dx < 0:
|
|
return "Left" # room2 is left of room1 - door on left wall of room1
|
|
else:
|
|
return "Right" # room2 is right of room1 - door on right wall of room1
|
|
|
|
func _determine_door_direction_for_puzzle_room(door: Dictionary, puzzle_room: Dictionary, _all_rooms: Array) -> String:
|
|
# Determine which WALL of the PUZZLE ROOM the door is on
|
|
# CRITICAL: door.x and door.y are the position in room1, not necessarily in the puzzle room
|
|
# Need to check which room is the puzzle room and determine the wall based on door direction
|
|
var door_room1 = door.room1 if ("room1" in door and door.room1 and not door.room1.is_empty()) else null
|
|
var door_room2 = door.room2 if ("room2" in door and door.room2 and not door.room2.is_empty()) else null
|
|
|
|
# Check which room is the puzzle room
|
|
var puzzle_is_room1 = false
|
|
var puzzle_is_room2 = false
|
|
|
|
if door_room1:
|
|
puzzle_is_room1 = (door_room1.x == puzzle_room.x and door_room1.y == puzzle_room.y and \
|
|
door_room1.w == puzzle_room.w and door_room1.h == puzzle_room.h)
|
|
|
|
if door_room2:
|
|
puzzle_is_room2 = (door_room2.x == puzzle_room.x and door_room2.y == puzzle_room.y and \
|
|
door_room2.w == puzzle_room.w and door_room2.h == puzzle_room.h)
|
|
|
|
# Get door direction from door.dir
|
|
if "dir" in door:
|
|
var door_dir = door.dir
|
|
|
|
if puzzle_is_room1:
|
|
# Puzzle room is room1 - door.dir represents the wall of puzzle room directly
|
|
match door_dir:
|
|
"E": return "Right" # Door on right wall of puzzle room
|
|
"W": return "Left" # Door on left wall of puzzle room
|
|
"N": return "Up" # Door on top wall of puzzle room
|
|
"S": return "Down" # Door on bottom wall of puzzle room
|
|
elif puzzle_is_room2:
|
|
# Puzzle room is room2 - door.dir is FROM room1, so flip it
|
|
match door_dir:
|
|
"E": return "Left" # Door on left wall of puzzle room (room2 is to the right of room1)
|
|
"W": return "Right" # Door on right wall of puzzle room (room2 is to the left of room1)
|
|
"N": return "Down" # Door on bottom wall of puzzle room (room2 is below room1)
|
|
"S": return "Up" # Door on top wall of puzzle room (room2 is above room1)
|
|
|
|
# Fallback: calculate based on door position relative to puzzle room center
|
|
var door_x = door.x
|
|
var door_y = door.y
|
|
var puzzle_center_x = puzzle_room.x + puzzle_room.w / 2.0
|
|
var puzzle_center_y = puzzle_room.y + puzzle_room.h / 2.0
|
|
|
|
var dx = door_x - puzzle_center_x
|
|
var dy = door_y - puzzle_center_y
|
|
|
|
# Determine which wall based on which direction from center
|
|
if abs(dy) > abs(dx):
|
|
# Vertical - door is more above/below than left/right
|
|
if dy < 0:
|
|
return "Up" # Door is above puzzle room center - door is on top wall
|
|
else:
|
|
return "Down" # Door is below puzzle room center - door is on bottom wall
|
|
else:
|
|
# Horizontal - door is more left/right than above/below
|
|
if dx < 0:
|
|
return "Left" # Door is left of puzzle room center - door is on left wall
|
|
else:
|
|
return "Right" # Door is right of puzzle room center - door is on right wall
|