917 lines
37 KiB
GDScript
917 lines
37 KiB
GDScript
extends CanvasLayer
|
|
|
|
# Game UI - Main menu and multiplayer lobby
|
|
|
|
@onready var main_menu = $Control/MainMenu
|
|
@onready var host_button = $Control/MainMenu/VBoxContainer/HostButton
|
|
@onready var join_button = $Control/MainMenu/VBoxContainer/JoinButton
|
|
@onready var select_race_button = $Control/MainMenu/VBoxContainer/SelectRaceButton
|
|
@onready var network_mode_option = $Control/MainMenu/VBoxContainer/NetworkModeContainer/NetworkModeOption
|
|
@onready var network_mode_container = $Control/MainMenu/VBoxContainer/NetworkModeContainer
|
|
@onready var local_players_spinbox = $Control/MainMenu/VBoxContainer/LocalPlayersContainer/SpinBox
|
|
@onready var address_input = $Control/MainMenu/VBoxContainer/AddressContainer/AddressInput
|
|
@onready var room_fetch_status_container = $Control/MainMenu/VBoxContainer/RoomFetchStatusContainer
|
|
@onready var loading_label = $Control/MainMenu/VBoxContainer/RoomFetchStatusContainer/RoomFetchLoadingContainer/LoadingLabel
|
|
@onready var loading_spinner = $Control/MainMenu/VBoxContainer/RoomFetchStatusContainer/RoomFetchLoadingContainer/LoadingSpinner
|
|
@onready var last_fetch_label = $Control/MainMenu/VBoxContainer/RoomFetchStatusContainer/LastFetchLabel
|
|
|
|
@onready var network_manager = $"/root/NetworkManager"
|
|
|
|
var select_class_scene: PackedScene = preload("res://scenes/select_class.tscn")
|
|
var select_class_instance: Node = null # Race select overlay (before dungeon)
|
|
var _race_select_standalone: bool = false # True when joiner picks race before Join (don't start game on confirm)
|
|
var pending_auto_join_after_race_select: bool = false # --join --webrtc with no --race=: show race select first, then auto-join
|
|
|
|
var connection_error_label: Label = null
|
|
var connection_error_shown: bool = false # Prevent spamming error messages
|
|
var is_joining_attempt: bool = false
|
|
var last_join_address: String = ""
|
|
var room_fetch_timer: Timer = null # Timer for retrying room fetches
|
|
var is_auto_joining: bool = false # Track if we're in auto-join mode
|
|
var is_hosting: bool = false # Track if we're hosting (don't fetch rooms when hosting)
|
|
var room_list_container: VBoxContainer = null # Container for displaying available rooms
|
|
var refresh_button: Button = null # Refresh button for manually reloading rooms
|
|
var refresh_cooldown_timer: Timer = null # Timer for refresh button cooldown
|
|
var active_room_join_button: Button = null # Join button we're currently using (reset on fail)
|
|
|
|
func _ready():
|
|
# Wait for nodes to be ready
|
|
await get_tree().process_frame
|
|
|
|
# Debug: Print node paths (UI category - disabled by default for network debugging)
|
|
LogManager.log("GameUI _ready() called", LogManager.CATEGORY_UI)
|
|
LogManager.log("Main menu node: " + str(main_menu), LogManager.CATEGORY_UI)
|
|
LogManager.log("Host button node: " + str(host_button), LogManager.CATEGORY_UI)
|
|
LogManager.log("Join button node: " + str(join_button), LogManager.CATEGORY_UI)
|
|
|
|
# Verify nodes exist
|
|
if not host_button:
|
|
push_error("host_button is null! Check node path: $Control/MainMenu/VBoxContainer/HostButton")
|
|
return
|
|
if not join_button:
|
|
push_error("join_button is null! Check node path: $Control/MainMenu/VBoxContainer/JoinButton")
|
|
return
|
|
|
|
# Connect buttons
|
|
host_button.pressed.connect(_on_host_pressed)
|
|
join_button.pressed.connect(_on_join_pressed)
|
|
if select_race_button:
|
|
select_race_button.pressed.connect(_on_select_race_pressed)
|
|
|
|
# Setup network mode dropdown
|
|
if network_mode_option:
|
|
network_mode_option.item_selected.connect(_on_network_mode_changed)
|
|
|
|
# On web builds, filter out ENet option (only WebRTC and WebSocket available)
|
|
if OS.get_name() == "Web":
|
|
LogManager.log("GameUI: Web platform detected, filtering network mode options", LogManager.CATEGORY_UI)
|
|
# Remove ENet option (index 0) for web builds
|
|
network_mode_option.remove_item(0)
|
|
# Adjust selected index (was 0 for ENet, now 0 is WebRTC)
|
|
network_mode_option.selected = 0
|
|
# Update network manager to use WebRTC by default
|
|
network_manager.set_network_mode(1)
|
|
else:
|
|
# On native builds, default to ENet (index 0)
|
|
network_mode_option.selected = 0
|
|
network_manager.set_network_mode(0)
|
|
|
|
# Update address input placeholder based on initial mode
|
|
_on_network_mode_changed(network_mode_option.selected)
|
|
|
|
# Connect network signals
|
|
if network_manager:
|
|
network_manager.connection_succeeded.connect(_on_connection_succeeded)
|
|
network_manager.connection_failed.connect(_on_connection_failed)
|
|
# Connect to rooms_fetched for displaying rooms (non-auto-join mode)
|
|
if not network_manager.rooms_fetched.is_connected(_on_rooms_fetched_display):
|
|
network_manager.rooms_fetched.connect(_on_rooms_fetched_display)
|
|
else:
|
|
push_error("NetworkManager not found!")
|
|
|
|
# Check for command-line arguments
|
|
_check_command_line_args()
|
|
|
|
# If WebRTC is selected at startup (not auto-joining and not hosting), fetch rooms
|
|
if not is_auto_joining and not is_hosting:
|
|
var current_mode = network_manager.network_mode
|
|
if current_mode == 1: # WebRTC
|
|
_start_room_fetch()
|
|
|
|
func _check_command_line_args():
|
|
var args = OS.get_cmdline_args()
|
|
LogManager.log("GameUI: Parsing command-line arguments: " + str(args), LogManager.CATEGORY_UI)
|
|
|
|
# Parse arguments
|
|
var should_host = false
|
|
var should_join = false
|
|
var should_debug = false
|
|
var force_webrtc = false
|
|
var join_address = "" # Empty by default - will fetch rooms if WebRTC/WebSocket
|
|
var local_count = 1
|
|
|
|
for arg in args:
|
|
if arg == "--host":
|
|
should_host = true
|
|
LogManager.log("GameUI: Found --host argument", LogManager.CATEGORY_UI)
|
|
elif arg == "--join":
|
|
should_join = true
|
|
LogManager.log("GameUI: Found --join argument", LogManager.CATEGORY_UI)
|
|
elif arg == "--websocket" or arg == "--webrtc":
|
|
force_webrtc = true
|
|
LogManager.log("GameUI: Found --websocket/--webrtc argument (forcing WebSocket mode)", LogManager.CATEGORY_UI)
|
|
elif arg == "--room-debug":
|
|
should_debug = true
|
|
LogManager.log("GameUI: Found --room-debug argument", LogManager.CATEGORY_UI)
|
|
elif arg.begins_with("--address="):
|
|
join_address = arg.split("=")[1]
|
|
elif arg.begins_with("--players="):
|
|
local_count = int(arg.split("=")[1])
|
|
elif arg.begins_with("--race="):
|
|
var race_arg = arg.split("=")[1].strip_edges().to_lower()
|
|
var gs = get_node_or_null("/root/GameState")
|
|
if gs:
|
|
if race_arg == "dwarf":
|
|
gs.selected_race = "Dwarf"
|
|
gs.skip_race_select = true
|
|
LogManager.log("GameUI: Race set from argument: Dwarf (skip race select)", LogManager.CATEGORY_UI)
|
|
elif race_arg == "elf":
|
|
gs.selected_race = "Elf"
|
|
gs.skip_race_select = true
|
|
LogManager.log("GameUI: Race set from argument: Elf (skip race select)", LogManager.CATEGORY_UI)
|
|
elif race_arg == "human":
|
|
gs.selected_race = "Human"
|
|
gs.skip_race_select = true
|
|
LogManager.log("GameUI: Race set from argument: Human (skip race select)", LogManager.CATEGORY_UI)
|
|
else:
|
|
LogManager.log("GameUI: Ignoring invalid --race=" + race_arg + " (use dwarf, elf, or human)", LogManager.CATEGORY_UI)
|
|
|
|
LogManager.log("GameUI: Parsed flags - should_host: " + str(should_host) + ", should_join: " + str(should_join) + ", force_webrtc: " + str(force_webrtc) + ", should_debug: " + str(should_debug), LogManager.CATEGORY_UI)
|
|
|
|
# Force WebRTC mode if --webrtc flag is present
|
|
if force_webrtc:
|
|
network_manager.set_network_mode(1) # WebRTC
|
|
if network_mode_option:
|
|
if OS.get_name() == "Web":
|
|
network_mode_option.selected = 0 # WebRTC is first option on web
|
|
else:
|
|
network_mode_option.selected = 1 # WebRTC is second option on native
|
|
_on_network_mode_changed(network_mode_option.selected)
|
|
LogManager.log("GameUI: WebRTC mode forced via --webrtc flag", LogManager.CATEGORY_UI)
|
|
|
|
# Set debug flag only if --room-debug is used with --host or --join
|
|
if should_debug and (should_host or should_join):
|
|
network_manager.show_room_labels = true
|
|
LogManager.log("Debug mode enabled: room labels will be shown", LogManager.CATEGORY_UI)
|
|
else:
|
|
LogManager.log("GameUI: Debug mode NOT enabled - should_debug: " + str(should_debug) + ", should_host: " + str(should_host) + ", should_join: " + str(should_join), LogManager.CATEGORY_UI)
|
|
|
|
# Auto-start based on arguments
|
|
if should_host:
|
|
is_hosting = true # Set flag so we don't fetch rooms
|
|
LogManager.log("Auto-hosting due to --host argument", LogManager.CATEGORY_UI)
|
|
network_manager.set_local_player_count(local_count)
|
|
if network_manager.host_game():
|
|
call_deferred("_show_race_select")
|
|
elif should_join:
|
|
# Check network mode after it's been set
|
|
var current_mode = network_manager.network_mode
|
|
if join_address.is_empty() and (current_mode == 1 or current_mode == 2):
|
|
# WebRTC/WebSocket with no address: auto-join first room. If no --race=, show race select first.
|
|
var gs = get_node_or_null("/root/GameState")
|
|
if gs and gs.skip_race_select:
|
|
# --race= was passed: skip race select and auto-join immediately
|
|
LogManager.log("Auto-joining: No address provided, fetching available rooms (mode: " + str(current_mode) + ", race: " + gs.selected_race + ")...", LogManager.CATEGORY_UI)
|
|
network_manager.set_local_player_count(local_count)
|
|
is_auto_joining = true
|
|
is_joining_attempt = true
|
|
room_fetch_timer = Timer.new()
|
|
room_fetch_timer.name = "RoomFetchTimer"
|
|
room_fetch_timer.wait_time = 2.0
|
|
room_fetch_timer.timeout.connect(_retry_room_fetch)
|
|
room_fetch_timer.autostart = false
|
|
add_child(room_fetch_timer)
|
|
if not network_manager.rooms_fetched.is_connected(_on_rooms_fetched_auto_join):
|
|
network_manager.rooms_fetched.connect(_on_rooms_fetched_auto_join)
|
|
_show_room_fetch_status()
|
|
_start_room_fetch()
|
|
else:
|
|
# No --race=: show race select first; after they confirm we start auto-join
|
|
LogManager.log("Auto-join with WebRTC/WebSocket: choose race first (no --race= passed)", LogManager.CATEGORY_UI)
|
|
pending_auto_join_after_race_select = true
|
|
_race_select_standalone = true
|
|
call_deferred("_show_race_select_ui")
|
|
elif not join_address.is_empty():
|
|
LogManager.log("Auto-joining to " + join_address + " due to --join argument", LogManager.CATEGORY_UI)
|
|
address_input.text = join_address
|
|
network_manager.set_local_player_count(local_count)
|
|
if network_manager.join_game(join_address):
|
|
# Connection callback will handle starting the game
|
|
pass
|
|
else:
|
|
# ENet mode without address - need a default address
|
|
var default_address = "127.0.0.1"
|
|
LogManager.log("Auto-joining to " + default_address + " due to --join argument (ENet mode, no address provided)", LogManager.CATEGORY_UI)
|
|
address_input.text = default_address
|
|
network_manager.set_local_player_count(local_count)
|
|
if network_manager.join_game(default_address):
|
|
# Connection callback will handle starting the game
|
|
pass
|
|
|
|
func _on_rooms_fetched_display(rooms: Array):
|
|
"""Display available rooms when fetched (non-auto-join mode)"""
|
|
# Only handle if not in auto-join mode (auto-join has its own handler)
|
|
if is_auto_joining:
|
|
LogManager.log("GameUI: Ignoring rooms_fetched_display - still in auto-join mode", LogManager.CATEGORY_UI)
|
|
return # Let auto-join handler take care of it
|
|
|
|
LogManager.log("GameUI: Received rooms for display: " + str(rooms.size()) + " rooms", LogManager.CATEGORY_UI)
|
|
|
|
# Hide loading indicator - request completed
|
|
_hide_loading_indicator()
|
|
|
|
# Update last fetch time
|
|
_update_last_fetch_time()
|
|
|
|
# Clear existing room list
|
|
_clear_room_list()
|
|
|
|
# Display rooms if any are found
|
|
if rooms.is_empty():
|
|
LogManager.log("GameUI: No available rooms found", LogManager.CATEGORY_UI)
|
|
# Keep room fetch status visible so user can see "Last fetched: ..." even with no rooms
|
|
# Add a "No rooms available" message
|
|
_add_room_list_header("No available rooms")
|
|
else:
|
|
LogManager.log("GameUI: Found " + str(rooms.size()) + " available room(s)", LogManager.CATEGORY_UI)
|
|
# Add header
|
|
_add_room_list_header("Available Rooms:")
|
|
# Add each room to the list
|
|
for room in rooms:
|
|
var room_code = room.get("room", "")
|
|
var players = room.get("players", 0)
|
|
var level = room.get("level", 1)
|
|
_add_room_item(room_code, players, level)
|
|
|
|
func _on_rooms_fetched_auto_join(rooms: Array):
|
|
"""Auto-join the first available room when --join --webrtc is used without address"""
|
|
if not is_auto_joining:
|
|
return # Not in auto-join mode, ignore
|
|
|
|
# Hide loading indicator - request completed
|
|
_hide_loading_indicator()
|
|
|
|
# Update last fetch time
|
|
_update_last_fetch_time()
|
|
|
|
if rooms.is_empty():
|
|
LogManager.log("No available rooms found, will retry in 2 seconds...", LogManager.CATEGORY_UI)
|
|
# Start timer to retry fetching
|
|
if room_fetch_timer:
|
|
room_fetch_timer.start()
|
|
return
|
|
|
|
# Stop retrying - we found rooms!
|
|
if room_fetch_timer:
|
|
room_fetch_timer.stop()
|
|
|
|
# DON'T set is_auto_joining = false yet - wait until connection succeeds or fails
|
|
# DON'T hide room fetch status UI yet - keep it visible in case join fails
|
|
|
|
# Disconnect from auto-join handler (we'll connect to display handler if join fails)
|
|
if network_manager.rooms_fetched.is_connected(_on_rooms_fetched_auto_join):
|
|
network_manager.rooms_fetched.disconnect(_on_rooms_fetched_auto_join)
|
|
|
|
# Sort rooms by player count (prefer rooms with more players, but not full)
|
|
rooms.sort_custom(func(a, b): return a.get("players", 0) < b.get("players", 0))
|
|
|
|
# Try to join the first room
|
|
var room = rooms[0]
|
|
var room_code = room.get("room", "")
|
|
if room_code.is_empty():
|
|
LogManager.log("Room code is empty, cannot join - will retry", LogManager.CATEGORY_UI)
|
|
# Restart timer to retry
|
|
if room_fetch_timer:
|
|
room_fetch_timer.start()
|
|
is_auto_joining = true
|
|
# Reconnect to auto-join handler
|
|
if not network_manager.rooms_fetched.is_connected(_on_rooms_fetched_auto_join):
|
|
network_manager.rooms_fetched.connect(_on_rooms_fetched_auto_join)
|
|
# Keep showing status UI
|
|
return
|
|
|
|
# Get local player count from spinbox (same as _on_join_pressed does)
|
|
var local_count = int(local_players_spinbox.value)
|
|
|
|
LogManager.log("Auto-joining room: " + room_code + " (players: " + str(room.get("players", 0)) + ", level: " + str(room.get("level", 1)) + ")", LogManager.CATEGORY_UI)
|
|
address_input.text = room_code
|
|
network_manager.set_local_player_count(local_count)
|
|
if network_manager.join_game(room_code):
|
|
# Connection callback will handle starting the game
|
|
# Note: We'll hide the UI and set is_auto_joining = false in _on_connection_succeeded
|
|
pass
|
|
else:
|
|
# Join failed immediately - switch to display mode
|
|
LogManager.log("Auto-join failed immediately, switching to room browser mode", LogManager.CATEGORY_UI)
|
|
is_auto_joining = false
|
|
# Connect to display handler
|
|
if not network_manager.rooms_fetched.is_connected(_on_rooms_fetched_display):
|
|
network_manager.rooms_fetched.connect(_on_rooms_fetched_display)
|
|
# Keep room fetch status UI visible (with refresh button)
|
|
_show_room_fetch_status()
|
|
# Fetch and display available rooms
|
|
_show_loading_indicator()
|
|
_start_room_fetch()
|
|
|
|
func _start_pending_auto_join():
|
|
"""Start auto-join flow after user chose race (--join --webrtc with no --race=)."""
|
|
if main_menu:
|
|
main_menu.visible = true # Room fetch status lives inside MainMenu
|
|
var local_count = int(local_players_spinbox.value) if local_players_spinbox else 1
|
|
network_manager.set_local_player_count(local_count)
|
|
is_auto_joining = true
|
|
is_joining_attempt = true
|
|
if not room_fetch_timer:
|
|
room_fetch_timer = Timer.new()
|
|
room_fetch_timer.name = "RoomFetchTimer"
|
|
room_fetch_timer.wait_time = 2.0
|
|
room_fetch_timer.timeout.connect(_retry_room_fetch)
|
|
room_fetch_timer.autostart = false
|
|
add_child(room_fetch_timer)
|
|
if not network_manager.rooms_fetched.is_connected(_on_rooms_fetched_auto_join):
|
|
network_manager.rooms_fetched.connect(_on_rooms_fetched_auto_join)
|
|
_show_room_fetch_status()
|
|
_start_room_fetch()
|
|
|
|
func _retry_room_fetch():
|
|
"""Retry fetching available rooms"""
|
|
if not is_auto_joining:
|
|
if room_fetch_timer:
|
|
room_fetch_timer.stop()
|
|
return
|
|
|
|
LogManager.log("Retrying room fetch...", LogManager.CATEGORY_UI)
|
|
_start_room_fetch()
|
|
|
|
func _start_room_fetch():
|
|
"""Start fetching rooms and show loading indicator"""
|
|
# Only fetch if WebRTC mode and not hosting
|
|
if network_manager.network_mode != 1: # Not WebRTC
|
|
return
|
|
|
|
if is_hosting or network_manager.is_hosting:
|
|
LogManager.log("GameUI: Skipping room fetch - we are hosting", LogManager.CATEGORY_UI)
|
|
return
|
|
|
|
# Show the status container and loading indicator
|
|
_show_room_fetch_status()
|
|
_show_loading_indicator()
|
|
|
|
# Check if a request is already in progress before starting a new one
|
|
var fetch_result = network_manager.fetch_available_rooms()
|
|
if not fetch_result:
|
|
# Request failed or is already in progress - hide loading indicator
|
|
_hide_loading_indicator()
|
|
# Start timer to retry (only in auto-join mode)
|
|
if is_auto_joining and room_fetch_timer:
|
|
room_fetch_timer.start()
|
|
|
|
func _show_room_fetch_status():
|
|
"""Show the room fetch status UI"""
|
|
if room_fetch_status_container:
|
|
room_fetch_status_container.visible = true
|
|
if last_fetch_label:
|
|
last_fetch_label.text = "Last fetched: Never"
|
|
# Create room list container if it doesn't exist
|
|
_create_room_list_container()
|
|
# Create refresh button if it doesn't exist
|
|
_create_refresh_button()
|
|
|
|
func _show_loading_indicator():
|
|
"""Show the loading indicator"""
|
|
if loading_label:
|
|
loading_label.text = "Loading rooms..."
|
|
if loading_spinner:
|
|
loading_spinner.text = "⏳"
|
|
|
|
func _hide_loading_indicator():
|
|
"""Hide the loading indicator"""
|
|
if loading_label:
|
|
loading_label.text = ""
|
|
if loading_spinner:
|
|
loading_spinner.text = ""
|
|
|
|
func _hide_room_fetch_status():
|
|
"""Hide the room fetch status UI"""
|
|
if room_fetch_status_container:
|
|
room_fetch_status_container.visible = false
|
|
|
|
func _create_refresh_button():
|
|
"""Create a refresh button for manually reloading the room list"""
|
|
if refresh_button:
|
|
return # Already exists
|
|
|
|
if not room_fetch_status_container:
|
|
return
|
|
|
|
# Create HBoxContainer for refresh button (below last fetch label)
|
|
var refresh_container = HBoxContainer.new()
|
|
refresh_container.name = "RefreshButtonContainer"
|
|
refresh_container.alignment = BoxContainer.ALIGNMENT_END
|
|
|
|
# Create refresh button
|
|
refresh_button = Button.new()
|
|
refresh_button.name = "RefreshButton"
|
|
refresh_button.text = "Refresh Rooms"
|
|
refresh_button.pressed.connect(_on_refresh_button_pressed)
|
|
|
|
refresh_container.add_child(refresh_button)
|
|
|
|
# Add refresh container after LastFetchLabel (or at the end if LastFetchLabel doesn't exist)
|
|
var last_fetch_node = room_fetch_status_container.get_node_or_null("LastFetchLabel")
|
|
if last_fetch_node:
|
|
var index = last_fetch_node.get_index() + 1
|
|
room_fetch_status_container.add_child(refresh_container)
|
|
room_fetch_status_container.move_child(refresh_container, index)
|
|
else:
|
|
room_fetch_status_container.add_child(refresh_container)
|
|
|
|
# Create cooldown timer
|
|
refresh_cooldown_timer = Timer.new()
|
|
refresh_cooldown_timer.name = "RefreshCooldownTimer"
|
|
refresh_cooldown_timer.wait_time = 5.0
|
|
refresh_cooldown_timer.one_shot = true
|
|
refresh_cooldown_timer.timeout.connect(_on_refresh_cooldown_finished)
|
|
refresh_cooldown_timer.autostart = false
|
|
add_child(refresh_cooldown_timer)
|
|
|
|
func _on_refresh_button_pressed():
|
|
"""Handle refresh button click"""
|
|
LogManager.log("GameUI: Refresh button pressed", LogManager.CATEGORY_UI)
|
|
|
|
# CRITICAL: Ensure we're not in auto-join mode when refreshing manually
|
|
# This prevents _on_rooms_fetched_display from ignoring the signal
|
|
if is_auto_joining:
|
|
LogManager.log("GameUI: Switching from auto-join to display mode for refresh", LogManager.CATEGORY_UI)
|
|
is_auto_joining = false
|
|
# Stop auto-join timer if it's running
|
|
if room_fetch_timer:
|
|
room_fetch_timer.stop()
|
|
# Disconnect auto-join handler
|
|
if network_manager and network_manager.rooms_fetched.is_connected(_on_rooms_fetched_auto_join):
|
|
network_manager.rooms_fetched.disconnect(_on_rooms_fetched_auto_join)
|
|
|
|
# Ensure display handler is connected (in case it was disconnected)
|
|
if network_manager and not network_manager.rooms_fetched.is_connected(_on_rooms_fetched_display):
|
|
LogManager.log("GameUI: Reconnecting rooms_fetched signal to display handler", LogManager.CATEGORY_UI)
|
|
network_manager.rooms_fetched.connect(_on_rooms_fetched_display)
|
|
|
|
# Disable button and start cooldown
|
|
if refresh_button:
|
|
refresh_button.disabled = true
|
|
refresh_button.text = "Refreshing..."
|
|
|
|
if refresh_cooldown_timer:
|
|
refresh_cooldown_timer.start()
|
|
|
|
# Fetch rooms
|
|
_start_room_fetch()
|
|
|
|
func _on_refresh_cooldown_finished():
|
|
"""Re-enable refresh button after cooldown"""
|
|
if refresh_button:
|
|
refresh_button.disabled = false
|
|
refresh_button.text = "Refresh Rooms"
|
|
|
|
func _update_last_fetch_time():
|
|
"""Update the last fetch time label with current datetime"""
|
|
# Try to find the label if it's null (might not be ready yet)
|
|
if not last_fetch_label:
|
|
last_fetch_label = get_node_or_null("Control/MainMenu/VBoxContainer/RoomFetchStatusContainer/LastFetchLabel")
|
|
|
|
if last_fetch_label:
|
|
var now = Time.get_datetime_dict_from_system()
|
|
var time_str = "%02d:%02d:%02d" % [now.hour, now.minute, now.second]
|
|
last_fetch_label.text = "Last fetched: " + time_str
|
|
LogManager.log("GameUI: Updated last fetch time to: " + time_str, LogManager.CATEGORY_UI)
|
|
else:
|
|
LogManager.log_error("GameUI: Cannot update last fetch time - last_fetch_label is null!")
|
|
|
|
func _create_room_list_container():
|
|
"""Create the container for displaying available rooms"""
|
|
if room_list_container:
|
|
return # Already exists
|
|
|
|
if not room_fetch_status_container:
|
|
return
|
|
|
|
# Create a ScrollContainer for the room list
|
|
var scroll_container = ScrollContainer.new()
|
|
scroll_container.name = "RoomListScrollContainer"
|
|
scroll_container.custom_minimum_size = Vector2(0, 150) # Set a reasonable height
|
|
scroll_container.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
|
|
# Create VBoxContainer inside scroll container
|
|
room_list_container = VBoxContainer.new()
|
|
room_list_container.name = "RoomListContainer"
|
|
room_list_container.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
|
|
scroll_container.add_child(room_list_container)
|
|
|
|
# Add scroll container to room_fetch_status_container (after LastFetchLabel)
|
|
room_fetch_status_container.add_child(scroll_container)
|
|
|
|
func _clear_room_list():
|
|
"""Clear all room items from the list"""
|
|
if room_list_container:
|
|
for child in room_list_container.get_children():
|
|
child.queue_free()
|
|
|
|
func _add_room_list_header(text: String):
|
|
"""Add a header label to the room list"""
|
|
if not room_list_container:
|
|
_create_room_list_container()
|
|
if not room_list_container:
|
|
return
|
|
|
|
var label = Label.new()
|
|
label.text = text
|
|
label.add_theme_font_size_override("font_size", 14)
|
|
room_list_container.add_child(label)
|
|
|
|
func _add_room_item(room_code: String, players: int, level: int):
|
|
"""Add a room item with join button to the list"""
|
|
if not room_list_container:
|
|
_create_room_list_container()
|
|
if not room_list_container:
|
|
return
|
|
|
|
# Create HBoxContainer for this room
|
|
var room_row = HBoxContainer.new()
|
|
room_row.name = "RoomRow_" + room_code
|
|
|
|
# Room code label
|
|
var code_label = Label.new()
|
|
code_label.text = room_code
|
|
code_label.custom_minimum_size = Vector2(100, 0)
|
|
code_label.add_theme_font_size_override("font_size", 12)
|
|
room_row.add_child(code_label)
|
|
|
|
# Info label (players, level)
|
|
var info_label = Label.new()
|
|
info_label.text = "Players: %d | Level: %d" % [players, level]
|
|
info_label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
info_label.add_theme_font_size_override("font_size", 12)
|
|
room_row.add_child(info_label)
|
|
|
|
# Join button
|
|
var room_join_button = Button.new()
|
|
room_join_button.name = "JoinButton"
|
|
room_join_button.text = "Join"
|
|
room_join_button.custom_minimum_size = Vector2(80, 0)
|
|
room_join_button.pressed.connect(func(): _join_room(room_code, room_join_button))
|
|
room_row.add_child(room_join_button)
|
|
|
|
room_list_container.add_child(room_row)
|
|
|
|
func _disable_all_room_join_buttons():
|
|
"""Disable all room Join buttons to prevent multiple clicks"""
|
|
if not room_list_container:
|
|
return
|
|
for row in room_list_container.get_children():
|
|
if row.name.begins_with("RoomRow_"):
|
|
var btn = row.get_node_or_null("JoinButton")
|
|
if btn and is_instance_valid(btn):
|
|
btn.disabled = true
|
|
|
|
func _reset_room_join_buttons():
|
|
"""Re-enable all room Join buttons and restore 'Join' text"""
|
|
if not room_list_container:
|
|
return
|
|
for row in room_list_container.get_children():
|
|
if row.name.begins_with("RoomRow_"):
|
|
var btn = row.get_node_or_null("JoinButton")
|
|
if btn and is_instance_valid(btn):
|
|
btn.disabled = false
|
|
btn.text = "Join"
|
|
active_room_join_button = null
|
|
|
|
func _join_room(room_code: String, room_join_button: Button = null):
|
|
"""Join a room by setting the address and clicking join"""
|
|
if room_code.is_empty():
|
|
return
|
|
|
|
# Prevent multiple clicks: disable all join buttons and show loader state
|
|
_disable_all_room_join_buttons()
|
|
if room_join_button and is_instance_valid(room_join_button):
|
|
room_join_button.text = "Joining..."
|
|
active_room_join_button = room_join_button
|
|
|
|
# Set the address input
|
|
if address_input:
|
|
address_input.text = room_code
|
|
|
|
# Get local player count
|
|
var local_count = int(local_players_spinbox.value)
|
|
network_manager.set_local_player_count(local_count)
|
|
|
|
is_joining_attempt = true
|
|
last_join_address = room_code
|
|
|
|
# Join the game
|
|
if not network_manager.join_game(room_code):
|
|
_reset_room_join_buttons()
|
|
is_joining_attempt = false
|
|
return
|
|
LogManager.log("Joining room: " + room_code, LogManager.CATEGORY_UI)
|
|
|
|
func _on_network_mode_changed(index: int):
|
|
# On web builds, index 0 = WebRTC, index 1 = WebSocket
|
|
# On native builds, index 0 = ENet, index 1 = WebRTC, index 2 = WebSocket
|
|
var actual_mode: int
|
|
if OS.get_name() == "Web":
|
|
# Web builds: 0 = WebRTC, 1 = WebSocket
|
|
actual_mode = index + 1 # Map 0->1 (WebRTC), 1->2 (WebSocket)
|
|
else:
|
|
# Native builds: 0 = ENet, 1 = WebRTC, 2 = WebSocket
|
|
actual_mode = index
|
|
|
|
network_manager.set_network_mode(actual_mode)
|
|
|
|
# Update address input placeholder based on mode
|
|
if address_input:
|
|
match actual_mode:
|
|
0: # ENet
|
|
address_input.placeholder_text = "Server IP or domain"
|
|
1: # WebRTC
|
|
address_input.placeholder_text = "Enter Room Code (e.g., ABC123)"
|
|
2: # WebSocket
|
|
address_input.placeholder_text = "Enter Room Code (e.g., ABC123)"
|
|
|
|
var mode_names = ["ENet", "WebRTC", "WebSocket"]
|
|
LogManager.log("GameUI: Network mode changed to: " + mode_names[actual_mode], LogManager.CATEGORY_UI)
|
|
|
|
# Handle room fetching based on mode
|
|
if actual_mode == 1: # WebRTC mode
|
|
# Only fetch if not auto-joining and not hosting
|
|
if not is_auto_joining and not is_hosting and not network_manager.is_hosting:
|
|
LogManager.log("GameUI: Switched to WebRTC mode, fetching rooms", LogManager.CATEGORY_UI)
|
|
# Ensure display handler is connected
|
|
if network_manager and not network_manager.rooms_fetched.is_connected(_on_rooms_fetched_display):
|
|
network_manager.rooms_fetched.connect(_on_rooms_fetched_display)
|
|
# Show room fetch status UI (with refresh button)
|
|
_show_room_fetch_status()
|
|
# Fetch rooms
|
|
_start_room_fetch()
|
|
else:
|
|
LogManager.log("GameUI: Switched to WebRTC mode but skipping room fetch (auto_joining: " + str(is_auto_joining) + ", hosting: " + str(is_hosting) + ")", LogManager.CATEGORY_UI)
|
|
else: # Not WebRTC mode (ENet or WebSocket)
|
|
# Hide room fetch status if switching away from WebRTC
|
|
LogManager.log("GameUI: Switched away from WebRTC mode, hiding room fetch UI", LogManager.CATEGORY_UI)
|
|
_hide_room_fetch_status()
|
|
|
|
func _on_host_pressed():
|
|
is_hosting = true # Set flag so we don't fetch rooms
|
|
var local_count = int(local_players_spinbox.value)
|
|
network_manager.set_local_player_count(local_count)
|
|
|
|
if network_manager.host_game():
|
|
var mode = network_manager.network_mode
|
|
if mode == 1 or mode == 2: # WebRTC or WebSocket
|
|
var room_id = network_manager.get_room_id()
|
|
var mode_name = "WebRTC" if mode == 1 else "WebSocket"
|
|
print("Hosting ", mode_name, " game - Room Code: ", room_id)
|
|
print("Share this code with players!")
|
|
else:
|
|
print("Hosting ENet game with ", local_count, " local players")
|
|
_show_race_select()
|
|
|
|
func _on_join_pressed():
|
|
# Reset error state when attempting new connection
|
|
connection_error_shown = false
|
|
_hide_connection_error()
|
|
is_joining_attempt = true
|
|
var address = address_input.text
|
|
if address.is_empty():
|
|
var mode = network_manager.network_mode
|
|
if mode == 1 or mode == 2: # WebRTC or WebSocket
|
|
LogManager.log("Error: Please enter a room code", LogManager.CATEGORY_UI)
|
|
return
|
|
else: # ENet mode without address - use default
|
|
address = "127.0.0.1"
|
|
|
|
var local_count = int(local_players_spinbox.value)
|
|
network_manager.set_local_player_count(local_count)
|
|
|
|
if network_manager.join_game(address):
|
|
last_join_address = address
|
|
var mode = network_manager.network_mode
|
|
if mode == 1: # WebRTC
|
|
LogManager.log("Joining WebRTC game with room code: " + address, LogManager.CATEGORY_UI)
|
|
elif mode == 2: # WebSocket
|
|
LogManager.log("Joining WebSocket game with room code: " + address, LogManager.CATEGORY_UI)
|
|
else: # ENet
|
|
LogManager.log("Joining ENet game at " + address + " with " + str(local_count) + " local players", LogManager.CATEGORY_UI)
|
|
|
|
func _on_connection_succeeded():
|
|
LogManager.log("GameUI: Connection succeeded signal received, starting game", LogManager.CATEGORY_UI)
|
|
is_joining_attempt = false
|
|
|
|
# If we were in auto-join mode, now we can safely exit it
|
|
if is_auto_joining:
|
|
is_auto_joining = false
|
|
# Hide room fetch status UI since we're connecting
|
|
_hide_room_fetch_status()
|
|
# Disconnect from auto-join handler if still connected
|
|
if network_manager.rooms_fetched.is_connected(_on_rooms_fetched_auto_join):
|
|
network_manager.rooms_fetched.disconnect(_on_rooms_fetched_auto_join)
|
|
|
|
# Check if node is still valid before starting game
|
|
if not is_inside_tree():
|
|
LogManager.log_error("GameUI: Cannot start game - node not in tree", LogManager.CATEGORY_UI)
|
|
return
|
|
# Joiner must load game_world immediately so host's spawn RPCs can be processed. Use race from
|
|
# GameState (set in _on_race_selected when they picked; do not overwrite). No race select after connect.
|
|
var gs = get_node_or_null("/root/GameState")
|
|
if gs:
|
|
gs.race_chosen_before_connect = false
|
|
# Only default to Dwarf if nothing was ever set (e.g. --join --webrtc --race=elf skips UI)
|
|
if gs.selected_race.is_empty():
|
|
gs.selected_race = "Dwarf"
|
|
print("GameUI: Connection succeeded, starting game - GameState.selected_race = '", gs.selected_race if gs else "Dwarf", "' (joiner will use this for their player)")
|
|
LogManager.log("GameUI: Connection succeeded, starting game (race: " + (gs.selected_race if gs else "Dwarf") + ")", LogManager.CATEGORY_UI)
|
|
call_deferred("_start_game")
|
|
|
|
func _on_connection_failed():
|
|
LogManager.log("Connection failed", LogManager.CATEGORY_UI)
|
|
# Always reset room Join buttons on failure (they may be stuck on "Joining...")
|
|
if is_joining_attempt:
|
|
_reset_room_join_buttons()
|
|
if connection_error_shown:
|
|
# Already shown, don't spam
|
|
return
|
|
|
|
connection_error_shown = true
|
|
var mode = network_manager.network_mode
|
|
var mode_name = "ENet"
|
|
if mode == 1:
|
|
mode_name = "WebRTC"
|
|
elif mode == 2:
|
|
mode_name = "WebSocket"
|
|
|
|
# If we were in auto-join mode, switch to display mode and show rooms
|
|
if is_auto_joining:
|
|
LogManager.log("Connection failed during auto-join, switching to room browser mode", LogManager.CATEGORY_UI)
|
|
is_auto_joining = false
|
|
# Stop auto-join timer
|
|
if room_fetch_timer:
|
|
room_fetch_timer.stop()
|
|
# Disconnect from auto-join handler
|
|
if network_manager.rooms_fetched.is_connected(_on_rooms_fetched_auto_join):
|
|
network_manager.rooms_fetched.disconnect(_on_rooms_fetched_auto_join)
|
|
# Connect to display handler instead
|
|
if not network_manager.rooms_fetched.is_connected(_on_rooms_fetched_display):
|
|
network_manager.rooms_fetched.connect(_on_rooms_fetched_display)
|
|
# Show room fetch status UI (refresh button and room list)
|
|
_show_room_fetch_status()
|
|
# Fetch and display available rooms
|
|
_show_loading_indicator()
|
|
_start_room_fetch()
|
|
# Show error message
|
|
_show_connection_error("Failed to auto-join room. Showing available rooms below.")
|
|
return
|
|
|
|
if is_joining_attempt:
|
|
var code_hint = (" (" + last_join_address + ")") if not last_join_address.is_empty() else ""
|
|
_show_connection_error("Failed to join room" + code_hint + ". Did you enter the correct code?")
|
|
# For WebRTC, refresh signaling connection after a failed join
|
|
if mode == 1 and network_manager and network_manager.has_method("refresh_webrtc_servers"):
|
|
network_manager.refresh_webrtc_servers(last_join_address)
|
|
# Show room list UI and refresh rooms after a failed WebRTC join
|
|
_show_room_fetch_status()
|
|
_show_loading_indicator()
|
|
_start_room_fetch()
|
|
# Also connect to display handler if not already connected
|
|
if not network_manager.rooms_fetched.is_connected(_on_rooms_fetched_display):
|
|
network_manager.rooms_fetched.connect(_on_rooms_fetched_display)
|
|
else:
|
|
_show_connection_error("Connection failed (" + mode_name + "). Please try again.")
|
|
|
|
func _show_connection_error(message: String):
|
|
"""Show a temporary error message in the UI"""
|
|
if not main_menu:
|
|
return
|
|
|
|
# Remove existing error label if any
|
|
_hide_connection_error()
|
|
|
|
# Create error label
|
|
connection_error_label = Label.new()
|
|
connection_error_label.name = "ConnectionErrorLabel"
|
|
connection_error_label.text = message
|
|
connection_error_label.modulate = Color.RED
|
|
connection_error_label.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
|
connection_error_label.add_theme_font_size_override("font_size", 14)
|
|
|
|
# Add to main menu VBoxContainer (after the title)
|
|
var vbox = main_menu.get_node_or_null("VBoxContainer")
|
|
if vbox:
|
|
# Insert after title (index 0) or at the beginning
|
|
vbox.add_child(connection_error_label)
|
|
vbox.move_child(connection_error_label, 1) # Move to position 1 (after title)
|
|
|
|
# Auto-hide after 5 seconds
|
|
await get_tree().create_timer(5.0).timeout
|
|
_hide_connection_error()
|
|
|
|
func _hide_connection_error():
|
|
"""Hide and remove the connection error label"""
|
|
if connection_error_label:
|
|
connection_error_label.queue_free()
|
|
connection_error_label = null
|
|
|
|
func _on_select_race_pressed():
|
|
"""Joiner picks race before connecting. Show race select; on confirm we just store choice and return to menu."""
|
|
_race_select_standalone = true
|
|
_show_race_select_ui()
|
|
|
|
func _show_race_select():
|
|
"""Show race select before dungeon (after Host or before Join). User picks race; on confirm we start game."""
|
|
if not is_inside_tree():
|
|
return
|
|
var gs = get_node_or_null("/root/GameState")
|
|
if gs and gs.skip_race_select:
|
|
LogManager.log("GameUI: Skipping race select (race from args: " + gs.selected_race + ")", LogManager.CATEGORY_UI)
|
|
_start_game()
|
|
return
|
|
_race_select_standalone = false
|
|
_show_race_select_ui()
|
|
|
|
func _show_race_select_ui():
|
|
"""Show race select overlay. _race_select_standalone: true = joiner picking before Join (don't start game)."""
|
|
if not is_inside_tree():
|
|
return
|
|
if select_class_instance and is_instance_valid(select_class_instance):
|
|
return
|
|
if main_menu:
|
|
main_menu.visible = false
|
|
var sel = select_class_scene.instantiate()
|
|
add_child(sel)
|
|
select_class_instance = sel
|
|
if sel.has_signal("race_selected"):
|
|
sel.race_selected.connect(_on_race_selected)
|
|
LogManager.log("GameUI: Race select shown" + (" (choose before Join)" if _race_select_standalone else ""), LogManager.CATEGORY_UI)
|
|
|
|
func _on_race_selected(race_name: String):
|
|
"""User confirmed race. Standalone = joiner chose before Join: store and return to menu. Else start game."""
|
|
if select_class_instance and is_instance_valid(select_class_instance):
|
|
select_class_instance.queue_free()
|
|
select_class_instance = null
|
|
# Always persist chosen race to GameState (select_class sets it too; this guarantees it from signal)
|
|
var gs = get_node_or_null("/root/GameState")
|
|
if gs and not race_name.is_empty():
|
|
gs.selected_race = race_name
|
|
LogManager.log("GameUI: JOINER PICKED race='" + race_name + "', GameState.selected_race set to '" + gs.selected_race + "'", LogManager.CATEGORY_UI)
|
|
if _race_select_standalone:
|
|
_race_select_standalone = false
|
|
if gs:
|
|
gs.race_chosen_before_connect = true
|
|
if pending_auto_join_after_race_select:
|
|
# --join --webrtc with no --race=: they just chose race, now start auto-join
|
|
pending_auto_join_after_race_select = false
|
|
_start_pending_auto_join()
|
|
LogManager.log("GameUI: Race chosen (" + race_name + "), fetching rooms to auto-join...", LogManager.CATEGORY_UI)
|
|
else:
|
|
if main_menu:
|
|
main_menu.visible = true
|
|
LogManager.log("GameUI: Race chosen for joining (" + race_name + "). Press Join when ready.", LogManager.CATEGORY_UI)
|
|
return
|
|
_start_game()
|
|
|
|
func _start_game():
|
|
# Check if node is still in the tree before trying to access get_tree()
|
|
if not is_inside_tree():
|
|
LogManager.log_error("GameUI: Cannot change scene - node is not in tree", LogManager.CATEGORY_UI)
|
|
return
|
|
|
|
# Disconnect network callbacks so we don't get signals on freed game_ui after scene change
|
|
if network_manager:
|
|
if network_manager.connection_succeeded.is_connected(_on_connection_succeeded):
|
|
network_manager.connection_succeeded.disconnect(_on_connection_succeeded)
|
|
if network_manager.connection_failed.is_connected(_on_connection_failed):
|
|
network_manager.connection_failed.disconnect(_on_connection_failed)
|
|
|
|
# Hide menu (and race select if still present)
|
|
if main_menu:
|
|
main_menu.visible = false
|
|
if select_class_instance and is_instance_valid(select_class_instance):
|
|
select_class_instance.queue_free()
|
|
select_class_instance = null
|
|
|
|
# Load the game scene
|
|
var tree = get_tree()
|
|
if tree:
|
|
tree.change_scene_to_file("res://scenes/game_world.tscn")
|
|
else:
|
|
LogManager.log_error("GameUI: Cannot change scene - get_tree() is null", LogManager.CATEGORY_UI)
|