940 lines
30 KiB
C#
940 lines
30 KiB
C#
using UnityEngine;
|
|
using UnityEngine.UIElements;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using MegaKoop.Steam;
|
|
|
|
namespace MegaKoop.UI
|
|
{
|
|
/// <summary>
|
|
/// Professional Multiplayer Lobby Controller with Steam API Integration
|
|
/// Senior-level implementation with proper state management
|
|
/// </summary>
|
|
public class MultiplayerLobbyController : MonoBehaviour
|
|
{
|
|
[Header("UI Document")]
|
|
[SerializeField] private UIDocument uiDocument;
|
|
|
|
[Header("Lobby Settings")]
|
|
[SerializeField] private int maxPlayers = 4;
|
|
[SerializeField] private string[] maxPlayersOptions = { "2", "3", "4", "8" };
|
|
|
|
// Root element
|
|
private VisualElement root;
|
|
|
|
// Panel
|
|
private VisualElement multiplayerPanel;
|
|
|
|
// Header Elements
|
|
private Label lobbyStatusLabel;
|
|
private VisualElement statusIndicator;
|
|
|
|
// Lobby Code Section
|
|
private VisualElement lobbyCodeSection;
|
|
private Label lobbyCodeDisplay;
|
|
private Button copyCodeButton;
|
|
|
|
// Connection Section
|
|
private VisualElement lobbyConnectionSection;
|
|
private Button hostLobbyButton;
|
|
private Button joinLobbyButton;
|
|
private VisualElement joinLobbyContent;
|
|
private VisualElement hostLobbyContent;
|
|
private TextField lobbyCodeInput;
|
|
private Button connectButton;
|
|
private Button createLobbyButton;
|
|
private DropdownField maxPlayersDropdown;
|
|
private Toggle publicLobbyToggle;
|
|
|
|
// Players Section
|
|
private VisualElement playersSection;
|
|
private Label playerCountLabel;
|
|
private ScrollView playersListScrollView;
|
|
private VisualElement playersList;
|
|
private VisualElement emptyPlayersState;
|
|
|
|
// Host Controls
|
|
private VisualElement hostControlsSection;
|
|
private Button inviteFriendsButton;
|
|
private Button kickPlayerButton;
|
|
|
|
// Player Ready Section
|
|
private VisualElement playerReadySection;
|
|
private Button toggleReadyButton;
|
|
private Label readyIcon;
|
|
private Label readyText;
|
|
|
|
// Footer
|
|
private Button startGameButton;
|
|
private Button leaveLobbyButton;
|
|
private Button backFromMultiplayerButton;
|
|
|
|
// Lobby State
|
|
private bool isHost = false;
|
|
private bool isInLobby = false;
|
|
private bool isPlayerReady = false;
|
|
private List<PlayerInfo> connectedPlayers = new List<PlayerInfo>();
|
|
private string currentLobbyCode = "";
|
|
private string selectedPlayerSteamId = "";
|
|
|
|
// Steam Integration
|
|
private SteamLobbyService steam;
|
|
|
|
private void Start()
|
|
{
|
|
if (uiDocument == null)
|
|
uiDocument = GetComponent<UIDocument>();
|
|
|
|
if (uiDocument != null)
|
|
{
|
|
root = uiDocument.rootVisualElement;
|
|
InitializeElements();
|
|
RegisterEvents();
|
|
EnsureSteamServices();
|
|
RegisterSteamEvents();
|
|
SetupInitialState();
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("UIDocument not found on MultiplayerLobbyController!");
|
|
}
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
UnregisterEvents();
|
|
UnregisterSteamEvents();
|
|
}
|
|
|
|
#region Initialization
|
|
|
|
private void InitializeElements()
|
|
{
|
|
// Panel
|
|
multiplayerPanel = root.Q<VisualElement>("MultiplayerPanel");
|
|
|
|
// Header
|
|
lobbyStatusLabel = root.Q<Label>("LobbyStatusLabel");
|
|
statusIndicator = root.Q<VisualElement>("StatusIndicator");
|
|
|
|
// Lobby Code Section
|
|
lobbyCodeSection = root.Q<VisualElement>("LobbyCodeSection");
|
|
lobbyCodeDisplay = root.Q<Label>("LobbyCodeDisplay");
|
|
copyCodeButton = root.Q<Button>("CopyCodeButton");
|
|
|
|
// Connection Section
|
|
lobbyConnectionSection = root.Q<VisualElement>("LobbyConnectionSection");
|
|
hostLobbyButton = root.Q<Button>("HostLobbyButton");
|
|
joinLobbyButton = root.Q<Button>("JoinLobbyButton");
|
|
joinLobbyContent = root.Q<VisualElement>("JoinLobbyContent");
|
|
hostLobbyContent = root.Q<VisualElement>("HostLobbyContent");
|
|
lobbyCodeInput = root.Q<TextField>("LobbyCodeInput");
|
|
connectButton = root.Q<Button>("ConnectButton");
|
|
createLobbyButton = root.Q<Button>("CreateLobbyButton");
|
|
maxPlayersDropdown = root.Q<DropdownField>("MaxPlayersDropdown");
|
|
publicLobbyToggle = root.Q<Toggle>("PublicLobbyToggle");
|
|
|
|
// Players Section
|
|
playersSection = root.Q<VisualElement>("PlayersSection");
|
|
playerCountLabel = root.Q<Label>("PlayerCountLabel");
|
|
playersListScrollView = root.Q<ScrollView>("PlayersListScrollView");
|
|
playersList = root.Q<VisualElement>("PlayersList");
|
|
emptyPlayersState = root.Q<VisualElement>("EmptyPlayersState");
|
|
|
|
// Host Controls
|
|
hostControlsSection = root.Q<VisualElement>("HostControlsSection");
|
|
inviteFriendsButton = root.Q<Button>("InviteFriendsButton");
|
|
kickPlayerButton = root.Q<Button>("KickPlayerButton");
|
|
|
|
// Player Ready Section
|
|
playerReadySection = root.Q<VisualElement>("PlayerReadySection");
|
|
toggleReadyButton = root.Q<Button>("ToggleReadyButton");
|
|
readyIcon = root.Q<Label>("ReadyIcon");
|
|
readyText = root.Q<Label>("ReadyText");
|
|
|
|
// Footer
|
|
startGameButton = root.Q<Button>("StartGameButton");
|
|
leaveLobbyButton = root.Q<Button>("LeaveLobbyButton");
|
|
backFromMultiplayerButton = root.Q<Button>("BackFromMultiplayerButton");
|
|
|
|
// Setup dropdowns
|
|
if (maxPlayersDropdown != null)
|
|
{
|
|
maxPlayersDropdown.choices = maxPlayersOptions.ToList();
|
|
maxPlayersDropdown.value = maxPlayers.ToString();
|
|
}
|
|
}
|
|
|
|
private void SetupInitialState()
|
|
{
|
|
// Show host content by default
|
|
ShowHostContent();
|
|
// Hide sections that require lobby
|
|
HideLobbyDependentSections();
|
|
|
|
UpdateUI();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Steam Integration
|
|
private void EnsureSteamServices()
|
|
{
|
|
if (steam == null)
|
|
{
|
|
steam = GetComponent<SteamLobbyService>();
|
|
if (steam == null)
|
|
{
|
|
var go = GameObject.Find("SteamServices") ?? new GameObject("SteamServices");
|
|
if (go.GetComponent<SteamManager>() == null) go.AddComponent<SteamManager>();
|
|
steam = go.GetComponent<SteamLobbyService>() ?? go.AddComponent<SteamLobbyService>();
|
|
DontDestroyOnLoad(go);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RegisterSteamEvents()
|
|
{
|
|
if (steam == null) return;
|
|
steam.OnLobbyCreated += OnSteamLobbyCreated;
|
|
steam.OnLobbyEntered += OnSteamLobbyEntered;
|
|
steam.OnLobbyLeft += OnSteamLobbyLeft;
|
|
steam.OnMembersChanged += OnSteamMembersChanged;
|
|
steam.OnLobbyDataUpdated += OnSteamLobbyDataUpdated;
|
|
steam.OnJoinFailed += OnSteamJoinFailed;
|
|
}
|
|
|
|
private void UnregisterSteamEvents()
|
|
{
|
|
if (steam == null) return;
|
|
steam.OnLobbyCreated -= OnSteamLobbyCreated;
|
|
steam.OnLobbyEntered -= OnSteamLobbyEntered;
|
|
steam.OnLobbyLeft -= OnSteamLobbyLeft;
|
|
steam.OnMembersChanged -= OnSteamMembersChanged;
|
|
steam.OnLobbyDataUpdated -= OnSteamLobbyDataUpdated;
|
|
steam.OnJoinFailed -= OnSteamJoinFailed;
|
|
}
|
|
|
|
private void OnSteamLobbyCreated()
|
|
{
|
|
if (steam == null) return;
|
|
isHost = steam.IsHost;
|
|
isInLobby = true;
|
|
currentLobbyCode = steam.LobbyCode;
|
|
RebuildPlayersFromSteam();
|
|
UpdateUI();
|
|
}
|
|
|
|
private void OnSteamLobbyEntered()
|
|
{
|
|
if (steam == null) return;
|
|
isHost = steam.IsHost;
|
|
isInLobby = true;
|
|
currentLobbyCode = steam.LobbyCode;
|
|
RebuildPlayersFromSteam();
|
|
UpdateUI();
|
|
}
|
|
|
|
private void OnSteamLobbyLeft()
|
|
{
|
|
isHost = false;
|
|
isInLobby = false;
|
|
isPlayerReady = false;
|
|
currentLobbyCode = string.Empty;
|
|
selectedPlayerSteamId = string.Empty;
|
|
connectedPlayers.Clear();
|
|
SetupInitialState();
|
|
UpdateUI();
|
|
}
|
|
|
|
private void OnSteamMembersChanged()
|
|
{
|
|
RebuildPlayersFromSteam();
|
|
UpdateUI();
|
|
}
|
|
|
|
private void OnSteamLobbyDataUpdated()
|
|
{
|
|
if (steam == null) return;
|
|
currentLobbyCode = steam.LobbyCode;
|
|
RebuildPlayersFromSteam();
|
|
UpdateUI();
|
|
}
|
|
|
|
private void OnSteamJoinFailed(string reason)
|
|
{
|
|
Debug.LogWarning($"Join failed: {reason}");
|
|
}
|
|
|
|
private void RebuildPlayersFromSteam()
|
|
{
|
|
if (steam == null || !steam.IsInLobby) return;
|
|
connectedPlayers.Clear();
|
|
var members = steam.GetMembers();
|
|
foreach (var m in members)
|
|
{
|
|
connectedPlayers.Add(new PlayerInfo
|
|
{
|
|
steamId = m.steamId,
|
|
playerName = string.IsNullOrEmpty(m.name) ? "Player" : m.name,
|
|
isHost = m.isHost,
|
|
isReady = m.isReady
|
|
});
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Event Registration
|
|
|
|
private void RegisterEvents()
|
|
{
|
|
if (hostLobbyButton != null)
|
|
hostLobbyButton.clicked += OnHostTabClicked;
|
|
|
|
if (joinLobbyButton != null)
|
|
joinLobbyButton.clicked += OnJoinTabClicked;
|
|
|
|
if (createLobbyButton != null)
|
|
createLobbyButton.clicked += OnCreateLobbyClicked;
|
|
|
|
if (connectButton != null)
|
|
connectButton.clicked += OnConnectClicked;
|
|
|
|
if (copyCodeButton != null)
|
|
copyCodeButton.clicked += OnCopyCodeClicked;
|
|
|
|
if (inviteFriendsButton != null)
|
|
inviteFriendsButton.clicked += OnInviteFriendsClicked;
|
|
|
|
if (kickPlayerButton != null)
|
|
kickPlayerButton.clicked += OnKickPlayerClicked;
|
|
|
|
if (toggleReadyButton != null)
|
|
toggleReadyButton.clicked += OnToggleReadyClicked;
|
|
|
|
if (startGameButton != null)
|
|
startGameButton.clicked += OnStartGameClicked;
|
|
|
|
if (leaveLobbyButton != null)
|
|
leaveLobbyButton.clicked += OnLeaveLobbyClicked;
|
|
|
|
if (backFromMultiplayerButton != null)
|
|
backFromMultiplayerButton.clicked += OnBackClicked;
|
|
}
|
|
|
|
private void UnregisterEvents()
|
|
{
|
|
if (hostLobbyButton != null)
|
|
hostLobbyButton.clicked -= OnHostTabClicked;
|
|
|
|
if (joinLobbyButton != null)
|
|
joinLobbyButton.clicked -= OnJoinTabClicked;
|
|
|
|
if (createLobbyButton != null)
|
|
createLobbyButton.clicked -= OnCreateLobbyClicked;
|
|
|
|
if (connectButton != null)
|
|
connectButton.clicked -= OnConnectClicked;
|
|
|
|
if (copyCodeButton != null)
|
|
copyCodeButton.clicked -= OnCopyCodeClicked;
|
|
|
|
if (inviteFriendsButton != null)
|
|
inviteFriendsButton.clicked -= OnInviteFriendsClicked;
|
|
|
|
if (kickPlayerButton != null)
|
|
kickPlayerButton.clicked -= OnKickPlayerClicked;
|
|
|
|
if (toggleReadyButton != null)
|
|
toggleReadyButton.clicked -= OnToggleReadyClicked;
|
|
|
|
if (startGameButton != null)
|
|
startGameButton.clicked -= OnStartGameClicked;
|
|
|
|
if (leaveLobbyButton != null)
|
|
leaveLobbyButton.clicked -= OnLeaveLobbyClicked;
|
|
|
|
if (backFromMultiplayerButton != null)
|
|
backFromMultiplayerButton.clicked -= OnBackClicked;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Button Callbacks
|
|
|
|
private void OnHostTabClicked()
|
|
{
|
|
ShowHostContent();
|
|
}
|
|
|
|
private void OnJoinTabClicked()
|
|
{
|
|
ShowJoinContent();
|
|
}
|
|
|
|
private void OnCreateLobbyClicked()
|
|
{
|
|
CreateLobby();
|
|
}
|
|
|
|
private void OnConnectClicked()
|
|
{
|
|
string code = lobbyCodeInput?.value ?? "";
|
|
if (!string.IsNullOrEmpty(code) && code.Length == 6)
|
|
{
|
|
JoinLobby(code);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("Invalid lobby code! Must be 6 characters.");
|
|
}
|
|
}
|
|
|
|
private void OnCopyCodeClicked()
|
|
{
|
|
if (!string.IsNullOrEmpty(currentLobbyCode))
|
|
{
|
|
GUIUtility.systemCopyBuffer = currentLobbyCode;
|
|
Debug.Log($"Lobby code copied: {currentLobbyCode}");
|
|
|
|
// Visual feedback
|
|
if (copyCodeButton != null)
|
|
{
|
|
string originalText = copyCodeButton.text;
|
|
copyCodeButton.text = "COPIED!";
|
|
copyCodeButton.schedule.Execute(() => copyCodeButton.text = originalText).StartingIn(1500);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnInviteFriendsClicked()
|
|
{
|
|
if (steam != null && isInLobby)
|
|
{
|
|
steam.InviteFriends();
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("Invite: not in lobby or steam service missing");
|
|
}
|
|
}
|
|
|
|
private void OnKickPlayerClicked()
|
|
{
|
|
if (!string.IsNullOrEmpty(selectedPlayerSteamId) && isHost)
|
|
{
|
|
KickPlayer(selectedPlayerSteamId);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("No player selected to kick!");
|
|
}
|
|
}
|
|
|
|
private void OnToggleReadyClicked()
|
|
{
|
|
TogglePlayerReady();
|
|
}
|
|
|
|
private void OnStartGameClicked()
|
|
{
|
|
if (isHost && isInLobby)
|
|
{
|
|
StartGame();
|
|
}
|
|
}
|
|
|
|
private void OnLeaveLobbyClicked()
|
|
{
|
|
LeaveLobby();
|
|
}
|
|
|
|
private void OnBackClicked()
|
|
{
|
|
HideMultiplayerPanel();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Lobby Management
|
|
|
|
public void ShowMultiplayerPanel()
|
|
{
|
|
multiplayerPanel?.RemoveFromClassList("hidden");
|
|
}
|
|
|
|
public void HideMultiplayerPanel()
|
|
{
|
|
multiplayerPanel?.AddToClassList("hidden");
|
|
}
|
|
|
|
private void CreateLobby()
|
|
{
|
|
// Parse max players
|
|
if (maxPlayersDropdown != null && int.TryParse(maxPlayersDropdown.value, out int maxP))
|
|
maxPlayers = maxP;
|
|
|
|
if (steam != null)
|
|
{
|
|
bool isPublic = publicLobbyToggle == null || publicLobbyToggle.value;
|
|
steam.CreateLobby(maxPlayers, isPublic);
|
|
}
|
|
else
|
|
{
|
|
// Fallback mock
|
|
isHost = true; isInLobby = true; currentLobbyCode = GenerateLobbyCode();
|
|
connectedPlayers.Clear();
|
|
connectedPlayers.Add(new PlayerInfo { steamId = "HOST_ID", playerName = "Host Player", isHost = true, isReady = true });
|
|
UpdateUI();
|
|
}
|
|
}
|
|
|
|
private void JoinLobby(string lobbyCode)
|
|
{
|
|
if (steam != null)
|
|
{
|
|
steam.JoinLobbyByCode(lobbyCode);
|
|
}
|
|
else
|
|
{
|
|
// Fallback mock
|
|
isHost = false; isInLobby = true; isPlayerReady = false; currentLobbyCode = lobbyCode;
|
|
connectedPlayers.Clear();
|
|
connectedPlayers.Add(new PlayerInfo { steamId = "HOST_ID", playerName = "Host Player", isHost = true, isReady = true });
|
|
connectedPlayers.Add(new PlayerInfo { steamId = "MY_ID", playerName = "My Player", isHost = false, isReady = false });
|
|
UpdateUI();
|
|
}
|
|
}
|
|
|
|
private void LeaveLobby()
|
|
{
|
|
if (steam != null && steam.IsInLobby)
|
|
{
|
|
steam.LeaveLobby();
|
|
}
|
|
else
|
|
{
|
|
isHost = false; isInLobby = false; isPlayerReady = false; currentLobbyCode = ""; selectedPlayerSteamId = ""; connectedPlayers.Clear();
|
|
SetupInitialState(); UpdateUI();
|
|
}
|
|
}
|
|
|
|
private void StartGame()
|
|
{
|
|
if (!isHost)
|
|
{
|
|
Debug.LogWarning("Only host can start the game!");
|
|
return;
|
|
}
|
|
|
|
// Check if all players are ready
|
|
bool allReady = connectedPlayers.All(p => p.isReady);
|
|
if (!allReady)
|
|
{
|
|
Debug.LogWarning("Not all players are ready!");
|
|
return;
|
|
}
|
|
|
|
// Signal via Steam lobby data (host)
|
|
if (steam != null && steam.IsInLobby)
|
|
{
|
|
steam.StartGameSignal();
|
|
}
|
|
Debug.Log("Starting game...");
|
|
|
|
// Load game scene
|
|
// UnityEngine.SceneManagement.SceneManager.LoadScene("GameScene");
|
|
}
|
|
|
|
private void TogglePlayerReady()
|
|
{
|
|
if (isHost) return; // Host is always ready
|
|
|
|
isPlayerReady = !isPlayerReady;
|
|
// Steam ready flag
|
|
if (steam != null && steam.IsInLobby)
|
|
{
|
|
steam.SetReady(isPlayerReady);
|
|
}
|
|
// Update local player ready state
|
|
var myPlayer = connectedPlayers.Find(p => p.steamId == "MY_ID");
|
|
if (myPlayer != null)
|
|
{
|
|
myPlayer.isReady = isPlayerReady;
|
|
}
|
|
|
|
Debug.Log($"Player ready status: {isPlayerReady}");
|
|
|
|
UpdateUI();
|
|
}
|
|
|
|
private void KickPlayer(string steamId)
|
|
{
|
|
if (!isHost || steamId == "HOST_ID") return;
|
|
|
|
if (steam != null && steam.IsInLobby)
|
|
{
|
|
steam.Kick(steamId);
|
|
}
|
|
connectedPlayers.RemoveAll(p => p.steamId == steamId);
|
|
selectedPlayerSteamId = "";
|
|
|
|
Debug.Log($"Kicked player: {steamId}");
|
|
|
|
UpdateUI();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UI Updates
|
|
|
|
private void UpdateUI()
|
|
{
|
|
UpdateStatusBadge();
|
|
UpdateLobbyCodeSection();
|
|
UpdateConnectionSection();
|
|
UpdatePlayersList();
|
|
UpdateHostControls();
|
|
UpdatePlayerReadySection();
|
|
UpdateFooterButtons();
|
|
}
|
|
|
|
private void UpdateStatusBadge()
|
|
{
|
|
if (lobbyStatusLabel != null)
|
|
{
|
|
if (isInLobby)
|
|
{
|
|
lobbyStatusLabel.text = isHost ? "HOSTING" : "CONNECTED";
|
|
lobbyStatusLabel.AddToClassList("connected");
|
|
statusIndicator?.AddToClassList("connected");
|
|
}
|
|
else
|
|
{
|
|
lobbyStatusLabel.text = "OFFLINE";
|
|
lobbyStatusLabel.RemoveFromClassList("connected");
|
|
statusIndicator?.RemoveFromClassList("connected");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateLobbyCodeSection()
|
|
{
|
|
if (lobbyCodeSection != null)
|
|
{
|
|
if (isInLobby && !string.IsNullOrEmpty(currentLobbyCode))
|
|
{
|
|
lobbyCodeSection.RemoveFromClassList("hidden");
|
|
if (lobbyCodeDisplay != null)
|
|
lobbyCodeDisplay.text = currentLobbyCode;
|
|
}
|
|
else
|
|
{
|
|
lobbyCodeSection.AddToClassList("hidden");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateConnectionSection()
|
|
{
|
|
if (lobbyConnectionSection != null)
|
|
{
|
|
if (isInLobby)
|
|
{
|
|
lobbyConnectionSection.AddToClassList("hidden");
|
|
}
|
|
else
|
|
{
|
|
lobbyConnectionSection.RemoveFromClassList("hidden");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdatePlayersList()
|
|
{
|
|
if (playersList == null) return;
|
|
|
|
// Update count
|
|
if (playerCountLabel != null)
|
|
{
|
|
playerCountLabel.text = $"{connectedPlayers.Count}/{maxPlayers}";
|
|
}
|
|
|
|
// Clear list
|
|
playersList.Clear();
|
|
|
|
// Show/hide empty state
|
|
if (emptyPlayersState != null)
|
|
{
|
|
if (connectedPlayers.Count == 0)
|
|
{
|
|
emptyPlayersState.RemoveFromClassList("hidden");
|
|
}
|
|
else
|
|
{
|
|
emptyPlayersState.AddToClassList("hidden");
|
|
}
|
|
}
|
|
|
|
// Add players
|
|
foreach (var player in connectedPlayers)
|
|
{
|
|
var playerItem = CreatePlayerItem(player);
|
|
playersList.Add(playerItem);
|
|
}
|
|
}
|
|
|
|
private VisualElement CreatePlayerItem(PlayerInfo player)
|
|
{
|
|
var item = new VisualElement();
|
|
item.AddToClassList("player-item");
|
|
|
|
if (player.isHost)
|
|
item.AddToClassList("host");
|
|
|
|
if (player.steamId == selectedPlayerSteamId)
|
|
item.AddToClassList("selected");
|
|
|
|
// Player info container
|
|
var playerInfo = new VisualElement();
|
|
playerInfo.AddToClassList("player-info");
|
|
|
|
// Avatar
|
|
var avatar = new VisualElement();
|
|
avatar.AddToClassList("player-avatar");
|
|
playerInfo.Add(avatar);
|
|
|
|
// Name and badge
|
|
var nameContainer = new VisualElement();
|
|
nameContainer.style.flexDirection = FlexDirection.Row;
|
|
nameContainer.style.alignItems = Align.Center;
|
|
|
|
var nameLabel = new Label(player.playerName);
|
|
nameLabel.AddToClassList("player-name");
|
|
nameContainer.Add(nameLabel);
|
|
|
|
if (player.isHost)
|
|
{
|
|
var hostBadge = new Label("HOST");
|
|
hostBadge.AddToClassList("player-host-badge");
|
|
nameContainer.Add(hostBadge);
|
|
}
|
|
|
|
playerInfo.Add(nameContainer);
|
|
item.Add(playerInfo);
|
|
|
|
// Status container
|
|
var statusContainer = new VisualElement();
|
|
statusContainer.AddToClassList("player-status");
|
|
|
|
var readyIndicator = new VisualElement();
|
|
readyIndicator.AddToClassList("player-ready-indicator");
|
|
if (player.isReady)
|
|
readyIndicator.AddToClassList("ready");
|
|
statusContainer.Add(readyIndicator);
|
|
|
|
var readyLabel = new Label(player.isReady ? "READY" : "NOT READY");
|
|
readyLabel.AddToClassList("player-ready-text");
|
|
if (player.isReady)
|
|
readyLabel.AddToClassList("ready");
|
|
statusContainer.Add(readyLabel);
|
|
|
|
item.Add(statusContainer);
|
|
|
|
// Click event for selection (host only)
|
|
if (isHost && !player.isHost)
|
|
{
|
|
item.RegisterCallback<ClickEvent>(evt =>
|
|
{
|
|
selectedPlayerSteamId = player.steamId;
|
|
UpdatePlayersList();
|
|
});
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
private void UpdateHostControls()
|
|
{
|
|
if (hostControlsSection != null)
|
|
{
|
|
if (isHost && isInLobby)
|
|
{
|
|
hostControlsSection.RemoveFromClassList("hidden");
|
|
}
|
|
else
|
|
{
|
|
hostControlsSection.AddToClassList("hidden");
|
|
}
|
|
}
|
|
|
|
// Enable/disable kick button
|
|
if (kickPlayerButton != null)
|
|
{
|
|
kickPlayerButton.SetEnabled(!string.IsNullOrEmpty(selectedPlayerSteamId));
|
|
}
|
|
}
|
|
|
|
private void UpdatePlayerReadySection()
|
|
{
|
|
if (playerReadySection != null)
|
|
{
|
|
if (!isHost && isInLobby)
|
|
{
|
|
playerReadySection.RemoveFromClassList("hidden");
|
|
|
|
// Update ready button appearance
|
|
if (toggleReadyButton != null)
|
|
{
|
|
if (isPlayerReady)
|
|
{
|
|
toggleReadyButton.AddToClassList("ready");
|
|
if (readyText != null) readyText.text = "READY";
|
|
}
|
|
else
|
|
{
|
|
toggleReadyButton.RemoveFromClassList("ready");
|
|
if (readyText != null) readyText.text = "NOT READY";
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
playerReadySection.AddToClassList("hidden");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateFooterButtons()
|
|
{
|
|
// Start game button (host only, in lobby)
|
|
if (startGameButton != null)
|
|
{
|
|
if (isHost && isInLobby)
|
|
{
|
|
startGameButton.RemoveFromClassList("hidden");
|
|
|
|
// Enable only if all players ready
|
|
bool allReady = connectedPlayers.All(p => p.isReady);
|
|
startGameButton.SetEnabled(allReady && connectedPlayers.Count >= 2);
|
|
}
|
|
else
|
|
{
|
|
startGameButton.AddToClassList("hidden");
|
|
}
|
|
}
|
|
|
|
// Leave lobby button
|
|
if (leaveLobbyButton != null)
|
|
{
|
|
if (isInLobby)
|
|
{
|
|
leaveLobbyButton.RemoveFromClassList("hidden");
|
|
}
|
|
else
|
|
{
|
|
leaveLobbyButton.AddToClassList("hidden");
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UI State Management
|
|
|
|
private void ShowHostContent()
|
|
{
|
|
hostLobbyButton?.AddToClassList("primary-button");
|
|
joinLobbyButton?.RemoveFromClassList("primary-button");
|
|
|
|
hostLobbyContent?.RemoveFromClassList("hidden");
|
|
joinLobbyContent?.AddToClassList("hidden");
|
|
}
|
|
|
|
private void ShowJoinContent()
|
|
{
|
|
joinLobbyButton?.AddToClassList("primary-button");
|
|
hostLobbyButton?.RemoveFromClassList("primary-button");
|
|
|
|
joinLobbyContent?.RemoveFromClassList("hidden");
|
|
hostLobbyContent?.AddToClassList("hidden");
|
|
}
|
|
|
|
private void HideLobbyDependentSections()
|
|
{
|
|
lobbyCodeSection?.AddToClassList("hidden");
|
|
hostControlsSection?.AddToClassList("hidden");
|
|
playerReadySection?.AddToClassList("hidden");
|
|
startGameButton?.AddToClassList("hidden");
|
|
leaveLobbyButton?.AddToClassList("hidden");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helper Methods
|
|
|
|
private string GenerateLobbyCode()
|
|
{
|
|
const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
|
|
var code = "";
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
code += chars[Random.Range(0, chars.Length)];
|
|
}
|
|
return code;
|
|
}
|
|
|
|
// Public methods for Steam API callbacks
|
|
public void OnPlayerJoinedLobby(string steamId, string playerName)
|
|
{
|
|
var player = new PlayerInfo
|
|
{
|
|
steamId = steamId,
|
|
playerName = playerName,
|
|
isHost = false,
|
|
isReady = false
|
|
};
|
|
|
|
connectedPlayers.Add(player);
|
|
UpdateUI();
|
|
|
|
Debug.Log($"Player joined: {playerName}");
|
|
}
|
|
|
|
public void OnPlayerLeftLobby(string steamId)
|
|
{
|
|
connectedPlayers.RemoveAll(p => p.steamId == steamId);
|
|
if (selectedPlayerSteamId == steamId)
|
|
selectedPlayerSteamId = "";
|
|
|
|
UpdateUI();
|
|
|
|
Debug.Log($"Player left: {steamId}");
|
|
}
|
|
|
|
public void OnPlayerReadyChanged(string steamId, bool isReady)
|
|
{
|
|
var player = connectedPlayers.Find(p => p.steamId == steamId);
|
|
if (player != null)
|
|
{
|
|
player.isReady = isReady;
|
|
UpdateUI();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// Player information in lobby
|
|
/// </summary>
|
|
[System.Serializable]
|
|
public class PlayerInfo
|
|
{
|
|
public string steamId;
|
|
public string playerName;
|
|
public bool isHost;
|
|
public bool isReady;
|
|
}
|
|
}
|