Elrinth/DungeonsOfKharadum
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix alot of shit for webrtc to work

Browse Source
This commit is contained in:
Elrinth
2026-01-17 10:19:51 +01:00
parent f71b510cfc
commit eb718fa990
68 changed files with 6616 additions and 917 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
src/scripts/door.gd
View File

@@ -101,6 +101,12 @@ func _ready() -> void:
# Call setup after a frame to ensure everything is ready
call_deferred("_ready_after_setup")
# Ensure door_index meta is set if name follows BlockingDoor_<index>
if name.begins_with("BlockingDoor_") and not has_meta("door_index"):
var index_str = name.substr(13)
if index_str.is_valid_int():
set_meta("door_index", index_str.to_int())
func _update_door_texture():
# Update door texture based on door type
@@ -113,24 +119,24 @@ func _update_door_texture():
var locked_texture = load("res://assets/gfx/door_locked.png")
if locked_texture:
sprite.texture = locked_texture
print("Door: Set KeyDoor texture to door_locked.png")
LogManager.log("Door: Set KeyDoor texture to door_locked.png", LogManager.CATEGORY_DOOR)
else:
push_error("Door: Could not load door_locked.png texture!")
LogManager.log_error("Door: Could not load door_locked.png texture!", LogManager.CATEGORY_DOOR)
"GateDoor":
var gate_texture = load("res://assets/gfx/door_gate.png")
if gate_texture:
sprite.texture = gate_texture
print("Door: Set GateDoor texture to door_gate.png")
LogManager.log("Door: Set GateDoor texture to door_gate.png", LogManager.CATEGORY_DOOR)
else:
push_error("Door: Could not load door_gate.png texture!")
LogManager.log_error("Door: Could not load door_gate.png texture!", LogManager.CATEGORY_DOOR)
"StoneDoor":
# Use door_barred.png for stone doors
var barred_texture = load("res://assets/gfx/door_barred.png")
if barred_texture:
sprite.texture = barred_texture
print("Door: Set StoneDoor texture to door_barred.png")
LogManager.log("Door: Set StoneDoor texture to door_barred.png", LogManager.CATEGORY_DOOR)
else:
push_error("Door: Could not load door_barred.png texture!")
LogManager.log_error("Door: Could not load door_barred.png texture!", LogManager.CATEGORY_DOOR)
# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
@@ -138,7 +144,7 @@ func _process(delta: float) -> void:
if is_opening or is_closing:
# Safety check: ensure closed_position is valid before animating
if closed_position == Vector2.ZERO:
print("Door: ERROR - closed_position is zero during animation! Resetting...")
LogManager.log_error("Door: ERROR - closed_position is zero during animation! Resetting...", LogManager.CATEGORY_DOOR)
closed_position = position - open_offset if is_opening else position
is_opening = false
is_closing = false
@@ -160,7 +166,7 @@ func _process(delta: float) -> void:
global_position = position # Also update global position during animation
# Debug: log for KeyDoors to verify movement
if type == "KeyDoor" and move_timer < 0.1: # Only log once at start of animation
print("Door: KeyDoor opening animation - start: ", start_pos, ", target: ", target_pos, ", offset: ", open_offset, ", direction: ", direction)
LogManager.log("Door: KeyDoor opening animation - start: " + str(start_pos) + ", target: " + str(target_pos) + ", offset: " + str(open_offset) + ", direction: " + str(direction), LogManager.CATEGORY_DOOR)
# For KeyDoors: disable collision as soon as opening starts (allow passage immediately)
# For StoneDoor/GateDoor: update collision based on position
@@ -211,7 +217,8 @@ func _process(delta: float) -> void:
global_position = open_position # Also set global position
# When moved from closed position (open), collision should be DISABLED
set_collision_layer_value(7, false)
print("Door: Opening animation complete - moved to open position: ", open_position, " (closed: ", closed_position, ", offset: ", open_offset, ") - collision DISABLED", " (key_used=", key_used, ")" if type == "KeyDoor" else "")
var key_used_str = " (key_used=" + str(key_used) + ")" if type == "KeyDoor" else ""
LogManager.log("Door: Opening animation complete - moved to open position: " + str(open_position) + " (closed: " + str(closed_position) + ", offset: " + str(open_offset) + ") - collision DISABLED" + key_used_str, LogManager.CATEGORY_DOOR)
# CRITICAL: For KeyDoors, ensure key_used is true after animation completes
# This prevents the door from being reset to closed in _process()
@@ -234,7 +241,7 @@ func _process(delta: float) -> void:
global_position = closed_position # Also set global position
# When at closed position, collision should be ENABLED
set_collision_layer_value(7, true)
print("Door: Closing animation complete - moved to closed position: ", closed_position, " - collision ENABLED")
LogManager.log("Door: Closing animation complete - moved to closed position: " + str(closed_position) + " - collision ENABLED", LogManager.CATEGORY_DOOR)
# Spawn smoke puffs when StoneDoor finishes closing (1-3 puffs)
if type == "StoneDoor":
@@ -285,7 +292,7 @@ func _process(delta: float) -> void:
# Snap to closed position if somehow moved (shouldn't happen, but safety check)
var distance_to_closed = position.distance_to(closed_position)
if distance_to_closed > 1.0:
print("Door: KeyDoor was moved incorrectly! Resetting to closed position.")
LogManager.log("Door: KeyDoor was moved incorrectly! Resetting to closed position.", LogManager.CATEGORY_DOOR)
position = closed_position
is_closed = true
set_collision_layer_value(7, true)
@@ -329,9 +336,9 @@ func _open():
global_position = closed_position
is_closed = true
set_collision_layer_value(7, true) # Collision enabled at closed position
print("Door: KeyDoor _open() called - reset to closed position ", closed_position, " before opening")
LogManager.log("Door: KeyDoor _open() called - reset to closed position " + str(closed_position) + " before opening", LogManager.CATEGORY_DOOR)
else:
push_error("Door: KeyDoor _open() called but closed_position is zero!")
LogManager.log_error("Door: KeyDoor _open() called but closed_position is zero!", LogManager.CATEGORY_DOOR)
return
$SfxOpenKeyDoor.play()
else:
@@ -341,7 +348,7 @@ func _open():
if is_actually_open:
# Door is already open - don't do anything
print("Door: _open() called but door is already open! Position: ", position, ", closed: ", closed_position, ", distance: ", distance_to_closed)
LogManager.log("Door: _open() called but door is already open! Position: " + str(position) + ", closed: " + str(closed_position) + ", distance: " + str(distance_to_closed), LogManager.CATEGORY_DOOR)
# Ensure door is at open position and collision is disabled
var open_pos = closed_position + open_offset
position = open_pos
@@ -356,9 +363,9 @@ func _open():
global_position = closed_position
is_closed = true
set_collision_layer_value(7, true)
print("Door: StoneDoor/GateDoor _open() called - ensuring door is at closed position ", closed_position, " before opening")
LogManager.log("Door: StoneDoor/GateDoor _open() called - ensuring door is at closed position " + str(closed_position) + " before opening", LogManager.CATEGORY_DOOR)
else:
push_error("Door: StoneDoor/GateDoor _open() called but closed_position is zero!")
LogManager.log_error("Door: StoneDoor/GateDoor _open() called but closed_position is zero!", LogManager.CATEGORY_DOOR)
return
if type == "GateDoor":
$SfxOpenGateDoor.play()
@@ -367,16 +374,29 @@ func _open():
# CRITICAL: Store starting position for animation (should be closed_position)
animation_start_position = position
print("Door: Starting open animation from ", animation_start_position, " to ", closed_position + open_offset, " (offset: ", open_offset, ")")
LogManager.log("Door: Starting open animation from " + str(animation_start_position) + " to " + str(closed_position + open_offset) + " (offset: " + str(open_offset) + ")", LogManager.CATEGORY_DOOR)
is_opening = true
is_closing = false
move_timer = 0.0
# Sync door opening to clients in multiplayer
if multiplayer.has_multiplayer_peer() and multiplayer.is_server() and is_inside_tree():
_sync_door_open.rpc()
# Also sync puzzle_solved state
_sync_puzzle_solved.rpc(puzzle_solved)
var game_world = get_tree().get_first_node_in_group("game_world")
if game_world and game_world.has_method("_rpc_to_ready_peers"):
game_world._rpc_to_ready_peers("_sync_door_open_by_name", [name])
# Also sync puzzle_solved state
game_world._rpc_to_ready_peers("_sync_door_puzzle_solved_by_name", [name, puzzle_solved])
# Track door state for syncing to new clients
if game_world:
game_world.door_states[name] = {
"is_closed": false,
"puzzle_solved": puzzle_solved,
"key_used": key_used if "key_used" in self else false,
"position": position,
"closed_position": closed_position,
"open_offset": open_offset
}
func _close():
# Only close on server/authority in multiplayer, then sync to clients
@@ -385,30 +405,30 @@ func _close():
# CRITICAL: KeyDoors should NEVER be closed (they only open with a key and stay open)
if type == "KeyDoor":
print("Door: ERROR - _close() called on KeyDoor! KeyDoors should never be closed!")
LogManager.log_error("Door: ERROR - _close() called on KeyDoor! KeyDoors should never be closed!", LogManager.CATEGORY_DOOR)
return
# Ensure closed_position is valid before closing
if closed_position == Vector2.ZERO:
# If closed_position wasn't set correctly, use current position
closed_position = position
print("Door: WARNING - closed_position was zero, using current position: ", closed_position)
LogManager.log("Door: WARNING - closed_position was zero, using current position: " + str(closed_position), LogManager.CATEGORY_DOOR)
# Check both flag and actual position to determine door state
var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
var is_actually_at_closed = distance_to_closed < 5.0 # Within 5 pixels of closed position
print("Door: _close() called - is_closed: ", is_closed, ", is_actually_at_closed: ", is_actually_at_closed, ", position: ", position, ", closed: ", closed_position, ", distance: ", distance_to_closed)
LogManager.log("Door: _close() called - is_closed: " + str(is_closed) + ", is_actually_at_closed: " + str(is_actually_at_closed) + ", position: " + str(position) + ", closed: " + str(closed_position) + ", distance: " + str(distance_to_closed), LogManager.CATEGORY_DOOR)
# If door is already at closed position (both visually and by flag), don't do anything
if is_closed and is_actually_at_closed and not is_opening and not is_closing:
print("Door: Already closed (both flag and position match), not closing again")
LogManager.log("Door: Already closed (both flag and position match), not closing again", LogManager.CATEGORY_DOOR)
return # Already closed, don't do anything
# CRITICAL: If door is at closed position but flag says open, just fix the state - don't animate
if is_actually_at_closed and not is_closed:
# Door is visually at closed position but flag says open - fix state only
print("Door: Door is at closed position but flag says open! Fixing state only (no animation)")
LogManager.log("Door: Door is at closed position but flag says open! Fixing state only (no animation)", LogManager.CATEGORY_DOOR)
position = closed_position # Ensure exact position
is_closed = true
set_collision_layer_value(7, true)
@@ -424,7 +444,7 @@ func _close():
# If door is significantly away from expected open position, snap to open position first
if distance_to_open > 10.0:
# Door is very far from expected open position - reset to open position first
print("Door: WARNING - Door is far from expected open position! Resetting to open: ", expected_open_pos, " (was at: ", position, ", distance: ", distance_to_open, ")")
LogManager.log("Door: WARNING - Door is far from expected open position! Resetting to open: " + str(expected_open_pos) + " (was at: " + str(position) + ", distance: " + str(distance_to_open) + ")", LogManager.CATEGORY_DOOR)
animation_start_position = expected_open_pos
position = expected_open_pos
global_position = expected_open_pos
@@ -434,7 +454,7 @@ func _close():
# Door is at or near open position - use current position as start
animation_start_position = position
print("Door: Starting close animation from ", animation_start_position, " to ", closed_position, " (offset: ", open_offset, ")")
LogManager.log("Door: Starting close animation from " + str(animation_start_position) + " to " + str(closed_position) + " (offset: " + str(open_offset) + ")", LogManager.CATEGORY_DOOR)
if type == "GateDoor":
$SfxCloseGateDoor.play()
else:
@@ -446,7 +466,20 @@ func _close():
# Sync door closing to clients in multiplayer
if multiplayer.has_multiplayer_peer() and multiplayer.is_server() and is_inside_tree():
_sync_door_close.rpc()
var game_world = get_tree().get_first_node_in_group("game_world")
if game_world and game_world.has_method("_rpc_to_ready_peers"):
game_world._rpc_to_ready_peers("_sync_door_close_by_name", [name])
# Track door state for syncing to new clients
if game_world:
game_world.door_states[name] = {
"is_closed": true,
"puzzle_solved": puzzle_solved,
"key_used": key_used if "key_used" in self else false,
"position": position,
"closed_position": closed_position,
"open_offset": open_offset
}
func _ready_after_setup():
# Called after door is fully set up with room references and positioned
@@ -454,7 +487,7 @@ func _ready_after_setup():
# The position set by game_world is the OPEN position (initial state for blocking doors)
var open_position = position # Current position is the OPEN position (from tile coordinates)
print("Door: _ready_after_setup() called - type: ", type, ", direction: ", direction, ", is_closed: ", is_closed, ", open_position: ", open_position)
LogManager.log("Door: _ready_after_setup() called - type: " + str(type) + ", direction: " + str(direction) + ", is_closed: " + str(is_closed) + ", open_position: " + str(open_position), LogManager.CATEGORY_DOOR)
# CRITICAL: Calculate closed position based on direction
# For StoneDoor/GateDoor: They start OPEN, then CLOSE when entering room
@@ -491,7 +524,7 @@ func _ready_after_setup():
# This is used when opening from closed position
open_offset = -closed_offset # open_offset = (0, -16) means open is 16px up from closed
print("Door: Calculated positions - open: ", open_position, ", closed: ", closed_position, ", closed_offset: ", closed_offset, ", open_offset: ", open_offset)
LogManager.log("Door: Calculated positions - open: " + str(open_position) + ", closed: " + str(closed_position) + ", closed_offset: " + str(closed_offset) + ", open_offset: " + str(open_offset), LogManager.CATEGORY_DOOR)
# CRITICAL: KeyDoors should ALWAYS start closed, regardless of is_closed value
# KeyDoors should NEVER be moved until opened with a key
@@ -523,7 +556,7 @@ func _ready_after_setup():
position = closed_position
global_position = closed_position
set_collision_layer_value(7, true) # Collision enabled when closed
print("Door: KeyDoor starting CLOSED at position ", position, " (direction: ", direction, "), will open to ", closed_position + open_offset, " - collision ENABLED")
LogManager.log("Door: KeyDoor starting CLOSED at position " + str(position) + " (direction: " + str(direction) + "), will open to " + str(closed_position + open_offset) + " - collision ENABLED", LogManager.CATEGORY_DOOR)
# Create key indicator sprite for KeyDoor
_create_key_indicator()
return # Exit early for KeyDoors
@@ -533,46 +566,46 @@ func _ready_after_setup():
global_position = closed_position
is_closed = true # Ensure state matches position
set_collision_layer_value(7, true)
print("Door: Starting CLOSED at position ", position, " (type: ", type, ", direction: ", direction, ") - collision ENABLED")
LogManager.log("Door: Starting CLOSED at position " + str(position) + " (type: " + str(type) + ", direction: " + str(direction) + ") - collision ENABLED", LogManager.CATEGORY_DOOR)
else:
# StoneDoor/GateDoor starting OPEN (default for blocking doors)
# CRITICAL: Door MUST start at open position (which is where game_world placed it)
# Ensure position is EXACTLY at open_position (don't assume game_world set it correctly)
if position.distance_to(open_position) > 1.0:
# Position doesn't match open_position - force it to open position
print("Door: WARNING - Position doesn't match open_position! Forcing to open: ", open_position, " (was: ", position, ")")
LogManager.log("Door: WARNING - Position doesn't match open_position! Forcing to open: " + str(open_position) + " (was: " + str(position) + ")", LogManager.CATEGORY_DOOR)
position = open_position
global_position = position # Ensure global_position matches position
is_closed = false # CRITICAL: State MUST be false (open) when at open position
set_collision_layer_value(7, false) # CRITICAL: Collision MUST be DISABLED when open
print("Door: Starting OPEN at position ", position, " (closed: ", closed_position, ", open: ", open_position, ", open_offset: ", open_offset, ", type: ", type, ", direction: ", direction, ") - collision DISABLED, is_closed: ", is_closed)
LogManager.log("Door: Starting OPEN at position " + str(position) + " (closed: " + str(closed_position) + ", open: " + str(open_position) + ", open_offset: " + str(open_offset) + ", type: " + str(type) + ", direction: " + str(direction) + ") - collision DISABLED, is_closed: " + str(is_closed), LogManager.CATEGORY_DOOR)
# CRITICAL: Verify the door is actually at open position after setting it
var actual_distance = position.distance_to(closed_position)
var expected_distance = 16.0 # Should be 16 pixels away
if abs(actual_distance - expected_distance) > 2.0:
push_error("Door: ERROR - Door open/closed distance is wrong! Position: ", position, ", closed: ", closed_position, ", distance: ", actual_distance, " (expected: ", expected_distance, ")")
LogManager.log_error("Door: ERROR - Door open/closed distance is wrong! Position: " + str(position) + ", closed: " + str(closed_position) + ", distance: " + str(actual_distance) + " (expected: " + str(expected_distance) + ")", LogManager.CATEGORY_DOOR)
# Force it to correct open position
position = open_position
global_position = open_position
is_closed = false # CRITICAL: Ensure state is false when at open position
set_collision_layer_value(7, false)
print("Door: FORCED door to open position: ", position, " (distance to closed: ", position.distance_to(closed_position), ", is_closed: ", is_closed, ")")
LogManager.log("Door: FORCED door to open position: " + str(position) + " (distance to closed: " + str(position.distance_to(closed_position)) + ", is_closed: " + str(is_closed) + ")", LogManager.CATEGORY_DOOR)
# FINAL VERIFICATION: Double-check state matches position
var distance_to_closed = position.distance_to(closed_position)
var should_be_open = distance_to_closed > 8.0 # If more than 8px from closed, should be open
if should_be_open and is_closed:
push_error("Door: ERROR - Door is at open position but is_closed is true! Fixing state...")
LogManager.log_error("Door: ERROR - Door is at open position but is_closed is true! Fixing state...", LogManager.CATEGORY_DOOR)
is_closed = false
set_collision_layer_value(7, false)
print("Door: Fixed state - door is now OPEN (is_closed: ", is_closed, ", collision: ", get_collision_layer_value(7), ")")
LogManager.log("Door: Fixed state - door is now OPEN (is_closed: " + str(is_closed) + ", collision: " + str(get_collision_layer_value(7)) + ")", LogManager.CATEGORY_DOOR)
elif not should_be_open and not is_closed:
push_error("Door: ERROR - Door is at closed position but is_closed is false! Fixing state...")
LogManager.log_error("Door: ERROR - Door is at closed position but is_closed is false! Fixing state...", LogManager.CATEGORY_DOOR)
is_closed = true
set_collision_layer_value(7, true)
print("Door: Fixed state - door is now CLOSED (is_closed: ", is_closed, ", collision: ", get_collision_layer_value(7), ")")
LogManager.log("Door: Fixed state - door is now CLOSED (is_closed: " + str(is_closed) + ", collision: " + str(get_collision_layer_value(7)) + ")", LogManager.CATEGORY_DOOR)
# NOTE: Doors are NOT connected via signals to room triggers
# Instead, room triggers call door._on_room_entered() directly
@@ -634,20 +667,20 @@ func _on_room_entered(body):
var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
var is_actually_open = distance_to_closed > 5.0 # If door is more than 5 pixels away from closed_position, it's open
print("Door: _on_room_entered() - type: ", type, ", is_closed: ", is_closed, ", is_actually_open: ", is_actually_open, ", position: ", position, ", closed: ", closed_position, ", distance: ", distance_to_closed)
LogManager.log("Door: _on_room_entered() - type: " + str(type) + ", is_closed: " + str(is_closed) + ", is_actually_open: " + str(is_actually_open) + ", position: " + str(position) + ", closed: " + str(closed_position) + ", distance: " + str(distance_to_closed), LogManager.CATEGORY_DOOR)
# CRITICAL: Only close if door is actually open (both flag and position must indicate open)
# If door is already closed, don't do anything
if is_actually_open and not is_closing and not is_opening:
# Door is actually open (position is away from closed position) - close it
print("Door: Closing door on room entry - was at position ", position, " (closed: ", closed_position, ", is_closed: ", is_closed, ", distance: ", distance_to_closed, ")")
LogManager.log("Door: Closing door on room entry - was at position " + str(position) + " (closed: " + str(closed_position) + ", is_closed: " + str(is_closed) + ", distance: " + str(distance_to_closed) + ")", LogManager.CATEGORY_DOOR)
# Ensure door is at open position before closing
var expected_open_pos = closed_position + open_offset
var dist_to_open = position.distance_to(expected_open_pos)
if dist_to_open > 5.0:
# Door is not at expected open position - reset to open position first
print("Door: WARNING - Door is not at expected open position! Resetting to open: ", expected_open_pos, " (was at: ", position, ")")
LogManager.log("Door: WARNING - Door is not at expected open position! Resetting to open: " + str(expected_open_pos) + " (was at: " + str(position) + ")", LogManager.CATEGORY_DOOR)
position = expected_open_pos
global_position = expected_open_pos
is_closed = false
@@ -659,20 +692,20 @@ func _on_room_entered(body):
return # Exit early, don't check puzzle state yet
elif is_actually_open:
# Door is open but animation already in progress - don't interfere
print("Door: Door is open but animation in progress, not closing")
LogManager.log("Door: Door is open but animation in progress, not closing", LogManager.CATEGORY_DOOR)
return
elif not is_actually_open:
# Door is already at closed position - but for StoneDoor/GateDoor, this shouldn't happen on room entry
# They should start OPEN and then CLOSE when entering room
# If door is at closed position, it might have been closed already - don't do anything
print("Door: WARNING - Door is already at closed position when entering room! This shouldn't happen for StoneDoor/GateDoor that start open.")
LogManager.log("Door: WARNING - Door is already at closed position when entering room! This shouldn't happen for StoneDoor/GateDoor that start open.", LogManager.CATEGORY_DOOR)
if closed_position != Vector2.ZERO:
# Ensure exact position and state match
position = closed_position
global_position = closed_position
is_closed = true
set_collision_layer_value(7, true) # Collision ENABLED when closed
print("Door: Door was already closed - ensuring state is correct, position: ", position, ", closed: ", closed_position)
LogManager.log("Door: Door was already closed - ensuring state is correct, position: " + str(position) + ", closed: " + str(closed_position), LogManager.CATEGORY_DOOR)
# Now that door is confirmed closed, check if puzzle is already solved
# CRITICAL: Only check puzzle state if door is closed - don't check if puzzle is already solved
if not puzzle_solved:
@@ -694,7 +727,7 @@ func _check_puzzle_state():
# CRITICAL: Don't check puzzle state while door is animating (closing or opening)
# This prevents race conditions where switch triggers before door finishes closing
if is_closing or is_opening:
print("Door: Skipping puzzle check - door is animating (is_closing: ", is_closing, ", is_opening: ", is_opening, ")")
LogManager.log("Door: Skipping puzzle check - door is animating (is_closing: " + str(is_closing) + ", is_opening: " + str(is_opening) + ")", LogManager.CATEGORY_DOOR)
return
# Check door's actual state (position-based check is more reliable than flags)
@@ -708,13 +741,15 @@ func _check_puzzle_state():
# This handles race conditions where switch triggers while door is still closing
if puzzle_solved and (not is_actually_open or collision_enabled):
# Door should be open but isn't (position or collision) - reset puzzle_solved to allow switch to trigger again
print("Door: puzzle_solved is true but door is not actually open (position: ", is_actually_open, ", collision: ", collision_enabled, ") - resetting to allow switch to trigger again")
LogManager.log("Door: puzzle_solved is true but door is not actually open (position: " + str(is_actually_open) + ", collision: " + str(collision_enabled) + ") - resetting to allow switch to trigger again", LogManager.CATEGORY_DOOR)
puzzle_solved = false
switches_activated = false
# Check if all enemies are defeated (enemies in blocking room)
if requires_enemies and _are_all_enemies_defeated():
print("Door: All enemies defeated! Opening door ", name, " (type: ", type, ", room: ", blocking_room.get("x", "?") if blocking_room and not blocking_room.is_empty() else "?", ",", blocking_room.get("y", "?") if blocking_room and not blocking_room.is_empty() else "?", ")")
var room_x_str = str(blocking_room.get("x", "?")) if blocking_room and not blocking_room.is_empty() else "?"
var room_y_str = str(blocking_room.get("y", "?")) if blocking_room and not blocking_room.is_empty() else "?"
LogManager.log("Door: All enemies defeated! Opening door " + str(name) + " (type: " + str(type) + ", room: " + room_x_str + "," + room_y_str + ")", LogManager.CATEGORY_DOOR)
enemies_defeated = true
puzzle_solved = true
if is_actually_closed:
@@ -744,7 +779,7 @@ func _check_puzzle_state():
# Not all switches are active
if puzzle_solved and has_pillar_switch:
# Pillar switch became inactive and door was open - close it and reset puzzle
print("Door: Pillar switch deactivated - closing door ", name)
LogManager.log("Door: Pillar switch deactivated - closing door " + str(name), LogManager.CATEGORY_DOOR)
switches_activated = false
puzzle_solved = false
if not is_actually_closed:
@@ -768,9 +803,13 @@ func _are_all_enemies_defeated() -> bool:
return false
# Find all enemies in the room that were spawned from spawners
var entities_node = get_tree().get_first_node_in_group("game_world")
var game_world = get_tree().get_first_node_in_group("game_world")
var entities_node = null
if game_world:
entities_node = game_world.get_node_or_null("Entities")
if not entities_node:
entities_node = get_node("/root/GameWorld/Entities")
# Fallback without throwing if GameWorld isn't ready yet
entities_node = get_node_or_null("/root/GameWorld/Entities")
if not entities_node:
return false
@@ -804,10 +843,14 @@ func _are_all_enemies_defeated() -> bool:
if enemy_in_room:
room_spawned_enemies.append(child)
print("Door: Found spawned enemy in room: ", child.name, " (spawner: ", child.get_meta("spawner_name") if child.has_meta("spawner_name") else "unknown", ", is_dead: ", child.is_dead if "is_dead" in child else "unknown", ")")
var spawner_name = str(child.get_meta("spawner_name")) if child.has_meta("spawner_name") else "unknown"
var is_dead_str = str(child.is_dead) if "is_dead" in child else "unknown"
LogManager.log("Door: Found spawned enemy in room: " + str(child.name) + " (spawner: " + spawner_name + ", is_dead: " + is_dead_str + ")", LogManager.CATEGORY_DOOR)
# Check if all spawned enemies are dead
print("Door: _are_all_enemies_defeated() - Found ", room_spawned_enemies.size(), " spawned enemies in room (", target_room.get("x", "?") if target_room and not target_room.is_empty() else "?", ",", target_room.get("y", "?") if target_room and not target_room.is_empty() else "?", ")")
var target_room_x_str = str(target_room.get("x", "?")) if target_room and not target_room.is_empty() else "?"
var target_room_y_str = str(target_room.get("y", "?")) if target_room and not target_room.is_empty() else "?"
LogManager.log("Door: _are_all_enemies_defeated() - Found " + str(room_spawned_enemies.size()) + " spawned enemies in room (" + target_room_x_str + "," + target_room_y_str + ")", LogManager.CATEGORY_DOOR)
# First, check if any enemies in room_spawned_enemies are still alive
# If any are alive, puzzle is not solved
@@ -820,12 +863,12 @@ func _are_all_enemies_defeated() -> bool:
enemy_is_dead = enemy.is_queued_for_deletion() or not enemy.is_inside_tree()
if not enemy_is_dead:
print("Door: Enemy ", enemy.name, " is still alive - puzzle not solved yet")
LogManager.log("Door: Enemy " + str(enemy.name) + " is still alive - puzzle not solved yet", LogManager.CATEGORY_DOOR)
return false # Enemy is still alive, puzzle not solved
# If we have enemies and all are dead, puzzle is solved
if room_spawned_enemies.size() > 0:
print("Door: All ", room_spawned_enemies.size(), " spawned enemies are dead! Puzzle solved!")
LogManager.log("Door: All " + str(room_spawned_enemies.size()) + " spawned enemies are dead! Puzzle solved!", LogManager.CATEGORY_DOOR)
return true # All enemies found are dead
# No spawned enemies found - check if spawners have actually spawned enemies before
@@ -836,9 +879,9 @@ func _are_all_enemies_defeated() -> bool:
# This catches cases where enemies weren't added to room_spawned_enemies due to position check issues
var entities_child = entities_node.get_node_or_null("Entities") if entities_node else null
if not entities_child and entities_node:
var game_world = get_tree().get_first_node_in_group("game_world")
if game_world:
entities_child = game_world.get_node_or_null("Entities")
var fallback_game_world = get_tree().get_first_node_in_group("game_world")
if fallback_game_world:
entities_child = fallback_game_world.get_node_or_null("Entities")
var tile_size = 16
var room_min_x = target_room.x + 2
@@ -871,7 +914,7 @@ func _are_all_enemies_defeated() -> bool:
if enemy_is_alive:
# Found an ALIVE enemy in this room - puzzle not solved!
print("Door: Found ALIVE enemy ", child.name, " in room - puzzle not solved yet (enemy still alive)")
LogManager.log("Door: Found ALIVE enemy " + str(child.name) + " in room - puzzle not solved yet (enemy still alive)", LogManager.CATEGORY_DOOR)
return false
# No alive enemies found in room - now check if spawners have spawned
@@ -907,9 +950,9 @@ func _are_all_enemies_defeated() -> bool:
if not has_spawned:
var entities_child_for_spawner = entities_node.get_node_or_null("Entities") if entities_node else null
if not entities_child_for_spawner and entities_node:
var game_world = get_tree().get_first_node_in_group("game_world")
if game_world:
entities_child_for_spawner = game_world.get_node_or_null("Entities")
var fallback_game_world = get_tree().get_first_node_in_group("game_world")
if fallback_game_world:
entities_child_for_spawner = fallback_game_world.get_node_or_null("Entities")
if entities_child_for_spawner:
for child in entities_child_for_spawner.get_children():
@@ -1002,7 +1045,7 @@ func _are_all_enemies_defeated() -> bool:
for spawner_name in unique_spawner_names_that_spawned.keys():
spawners_in_room.append(null) # Placeholder for destroyed spawner
spawners_that_have_spawned.append(null) # Count as spawned
print("Door: Spawner ", spawner_name, " was destroyed but spawned enemies that are now all dead - counting as spawned")
LogManager.log("Door: Spawner " + str(spawner_name) + " was destroyed but spawned enemies that are now all dead - counting as spawned", LogManager.CATEGORY_DOOR)
else:
# Spawners exist - check if any weren't counted as spawned yet
for spawner_name in unique_spawner_names_that_spawned.keys():
@@ -1017,7 +1060,7 @@ func _are_all_enemies_defeated() -> bool:
var spawner = spawners_in_room[i]
if is_instance_valid(spawner) and spawner.name == spawner_name:
spawners_that_have_spawned.append(spawner)
print("Door: Found dead enemy from spawner ", spawner_name, " - marking as spawned")
LogManager.log("Door: Found dead enemy from spawner " + str(spawner_name) + " - marking as spawned", LogManager.CATEGORY_DOOR)
break
@@ -1034,7 +1077,7 @@ func _are_all_enemies_defeated() -> bool:
if valid_spawners_count > 0 and valid_spawned_count >= valid_spawners_count:
# All spawners in room have spawned at least once, and no enemies found in room
# This means all spawned enemies are dead - puzzle solved!
print("Door: No spawned enemies found, but all ", valid_spawners_count, " spawners in room have spawned enemies that are all dead - puzzle solved!")
LogManager.log("Door: No spawned enemies found, but all " + str(valid_spawners_count) + " spawners in room have spawned enemies that are all dead - puzzle solved!", LogManager.CATEGORY_DOOR)
return true
# Also check: if no spawners found (they were destroyed), but this is a puzzle room (has blocking doors),
@@ -1043,13 +1086,13 @@ func _are_all_enemies_defeated() -> bool:
if valid_spawners_count == 0 and valid_spawned_count > 0:
# Spawners were destroyed, but we found evidence they spawned
# Since no enemies found, they must all be dead - puzzle solved!
print("Door: No spawners or enemies found, but found evidence of spawned enemies that are now all dead - puzzle solved!")
LogManager.log("Door: No spawners or enemies found, but found evidence of spawned enemies that are now all dead - puzzle solved!", LogManager.CATEGORY_DOOR)
return true
if valid_spawners_count > 0:
print("Door: Spawners in room (", valid_spawners_count, ") but only ", valid_spawned_count, " have spawned - puzzle not solved yet")
LogManager.log("Door: Spawners in room (" + str(valid_spawners_count) + ") but only " + str(valid_spawned_count) + " have spawned - puzzle not solved yet", LogManager.CATEGORY_DOOR)
else:
print("Door: No spawned enemies found in room - puzzle not solved yet (enemies may not have spawned or already removed)")
LogManager.log("Door: No spawned enemies found in room - puzzle not solved yet (enemies may not have spawned or already removed)", LogManager.CATEGORY_DOOR)
return false
for enemy in room_spawned_enemies:
@@ -1062,13 +1105,13 @@ func _are_all_enemies_defeated() -> bool:
enemy_is_dead = enemy.is_queued_for_deletion() or not enemy.is_inside_tree()
if not enemy_is_dead:
print("Door: Enemy ", enemy.name, " is still alive (is_dead: ", enemy_is_dead, ", is_queued: ", enemy.is_queued_for_deletion(), ", in_tree: ", enemy.is_inside_tree(), ")")
LogManager.log("Door: Enemy " + str(enemy.name) + " is still alive (is_dead: " + str(enemy_is_dead) + ", is_queued: " + str(enemy.is_queued_for_deletion()) + ", in_tree: " + str(enemy.is_inside_tree()) + ")", LogManager.CATEGORY_DOOR)
return false
else:
# Enemy is no longer valid (removed from scene) - consider it dead
print("Door: Enemy is no longer valid (removed from scene) - counting as dead")
LogManager.log("Door: Enemy is no longer valid (removed from scene) - counting as dead", LogManager.CATEGORY_DOOR)
print("Door: All ", room_spawned_enemies.size(), " spawned enemies are dead! Puzzle solved!")
LogManager.log("Door: All " + str(room_spawned_enemies.size()) + " spawned enemies are dead! Puzzle solved!", LogManager.CATEGORY_DOOR)
return true # All enemies are dead
func _spawn_smoke_puffs_on_close():
@@ -1135,20 +1178,22 @@ func _are_all_switches_activated() -> bool:
# Do NOT use position-based fallback checks - they cause cross-room door triggering!
if connected_switches.size() > 0:
# Check all connected switches (these are the switches in THIS door's puzzle room)
print("Door: _are_all_switches_activated() - Checking ", connected_switches.size(), " connected switches for door ", name, " (room: ", blocking_room.get("x", "?"), ",", blocking_room.get("y", "?"), ")")
var switch_room_x = str(blocking_room.get("x", "?")) if blocking_room and not blocking_room.is_empty() else "?"
var switch_room_y = str(blocking_room.get("y", "?")) if blocking_room and not blocking_room.is_empty() else "?"
LogManager.log("Door: _are_all_switches_activated() - Checking " + str(connected_switches.size()) + " connected switches for door " + str(name) + " (room: " + switch_room_x + "," + switch_room_y + ")", LogManager.CATEGORY_DOOR)
for switch in connected_switches:
if not is_instance_valid(switch):
continue
# is_activated is a variable, not a method
if not switch.is_activated:
print("Door: Switch ", switch.name, " is NOT activated")
LogManager.log("Door: Switch " + str(switch.name) + " is NOT activated", LogManager.CATEGORY_DOOR)
return false
print("Door: All connected switches are activated!")
LogManager.log("Door: All connected switches are activated!", LogManager.CATEGORY_DOOR)
return true # All connected switches are activated
# CRITICAL: If no switches are connected, the puzzle is NOT solved!
# Switches should ALWAYS be connected when spawned - if they're not, it's an error
print("Door: WARNING - Door ", name, " has no connected switches! Puzzle cannot be solved!")
LogManager.log("Door: WARNING - Door " + str(name) + " has no connected switches! Puzzle cannot be solved!", LogManager.CATEGORY_DOOR)
return false # No connected switches means puzzle is NOT solved
func _on_key_interaction_area_body_entered(body):
@@ -1165,7 +1210,7 @@ func _on_key_interaction_area_body_entered(body):
key_used = true
_show_key_indicator()
_open()
print("KeyDoor opened with key!")
LogManager.log("KeyDoor opened with key!", LogManager.CATEGORY_DOOR)
func _show_key_indicator():
# Show key indicator above door
@@ -1253,7 +1298,8 @@ func _sync_door_open():
else:
$SfxOpenStoneDoor.play()
print("Door: Client received door open RPC for ", name, " - starting open animation", " (key_used=", key_used, ")" if type == "KeyDoor" else "")
var key_used_str = " (key_used=" + str(key_used) + ")" if type == "KeyDoor" else ""
LogManager.log("Door: Client received door open RPC for " + str(name) + " - starting open animation" + key_used_str, LogManager.CATEGORY_DOOR)
@rpc("authority", "reliable")
func _sync_puzzle_solved(is_solved: bool):
@@ -1263,7 +1309,7 @@ func _sync_puzzle_solved(is_solved: bool):
if is_solved:
enemies_defeated = true
switches_activated = true
print("Door: Client received puzzle_solved sync for ", name, " - puzzle_solved: ", is_solved)
LogManager.log("Door: Client received puzzle_solved sync for " + str(name) + " - puzzle_solved: " + str(is_solved), LogManager.CATEGORY_DOOR)
@rpc("authority", "reliable")
func _sync_door_close():
@@ -1289,4 +1335,4 @@ func _sync_door_close():
is_closing = true
move_timer = 0.0
print("Door: Client received door close RPC for ", name, " - starting close animation")
LogManager.log("Door: Client received door close RPC for " + str(name) + " - starting close animation", LogManager.CATEGORY_DOOR)