NetCrafter Relay Tutorial: Turn-Based (Tile Claim)

namespace PivecLabs.NetCrafterRelay.Examples.TurnBasedDemo
{
    public static class TurnBasedRules
    {
        public const int GridSize = 6;
        public const int TileCount = GridSize * GridSize;

        public static int Index(int x, int y) => y * GridSize + x;

        public static bool InBounds(int x, int y) => x >= 0 && x < GridSize && y >= 0 && y < GridSize;

        public static int OwnerAt(int[] tileOwners, int x, int y) =>
            InBounds(x, y) ? tileOwners[Index(x, y)] : -1;

        // playerId doubles as this player's fixed turn-order position, starting corner, AND
        // color index -- RelayConnectionManager already hands out LocalUserId 0 (host) through
        // 3 (third joiner) in strict join order, so there's nothing left to separately assign.
        private static readonly (int x, int y)[] Corners =
        {
            (0, 0), (GridSize - 1, GridSize - 1), (GridSize - 1, 0), (0, GridSize - 1)
        };

        public static (int x, int y) CornerFor(int playerId) =>
            playerId >= 0 && playerId < Corners.Length ? Corners[playerId] : (0, 0);

        public static bool HasAdjacentOwnedTile(int[] tileOwners, int x, int y, int playerId) =>
            OwnerAt(tileOwners, x - 1, y) == playerId || OwnerAt(tileOwners, x + 1, y) == playerId ||
            OwnerAt(tileOwners, x, y - 1) == playerId || OwnerAt(tileOwners, x, y + 1) == playerId;

        // Every active player starts the game already owning their corner tile, so there is no
        // separate "first move" special case -- this one check covers every turn, including the
        // first.
        public static bool IsLegalMove(int[] tileOwners, int x, int y, int playerId) =>
            InBounds(x, y) && OwnerAt(tileOwners, x, y) == -1 &&
            HasAdjacentOwnedTile(tileOwners, x, y, playerId);

        public static bool HasAnyLegalMove(int[] tileOwners, int playerId)
        {
            for (int y = 0; y < GridSize; y++)
                for (int x = 0; x < GridSize; x++)
                    if (IsLegalMove(tileOwners, x, y, playerId))
                        return true;
            return false;
        }
    }
}

using System.Collections.Generic;

namespace PivecLabs.NetCrafterRelay.Examples.TurnBasedDemo
{
    // Returned by every TurnBasedGameState method that can change whose turn it is or end the
    // game, so both call sites that need this (HandleClaimTile's Custom Host Code, for a joiner's
    // move, and TurnBasedDemoController's own host-branch, for the host's own move) broadcast
    // and locally-apply the exact same way without duplicating any decision logic.
    public struct TileClaimResult
    {
        public bool claimed;
        public bool turnChanged;
        public int  nextTurnPlayerId;
        public bool gameOver;
        public bool endedEarly;
        public int  winnersMask;
    }

    public static class TurnBasedGameState
    {
        public static readonly Dictionary<int, string> PlayerNames = new();
        public static readonly HashSet<int> ConnectedPlayerIds = new();

        public static int ActivePlayersMask;
        public static int CurrentTurnPlayerId = -1;
        public static bool GameRunning;
        public static bool GameOver;
        public static bool EndedEarly;
        public static int WinnersMask;

        public static readonly int[] TileOwners = new int[TurnBasedRules.TileCount];

        public static void Reset()
        {
            PlayerNames.Clear();
            ConnectedPlayerIds.Clear();
            ActivePlayersMask = 0;
            CurrentTurnPlayerId = -1;
            GameRunning = false;
            GameOver = false;
            EndedEarly = false;
            WinnersMask = 0;
            for (int i = 0; i < TileOwners.Length; i++) TileOwners[i] = -1;
        }

        public static bool IsActivePlayer(int playerId) =>
            playerId >= 0 && playerId < 4 && (ActivePlayersMask & (1 << playerId)) != 0;

        // Host-only. Snapshots whichever players are connected RIGHT NOW as this round's fixed
        // roster -- up to 4, ascending by id. Re-reads ConnectedPlayerIds fresh every call (not a
        // remembered original lineup), so Play Again naturally picks up whoever is still around.
        public static List<int> StartGame()
        {
            for (int i = 0; i < TileOwners.Length; i++) TileOwners[i] = -1;

            var active = new List<int>();
            foreach (var id in ConnectedPlayerIds)
            {
                if (active.Count >= 4) break;
                active.Add(id);
            }
            active.Sort();

            ActivePlayersMask = 0;
            foreach (var id in active)
            {
                ActivePlayersMask |= 1 << id;
                var (x, y) = TurnBasedRules.CornerFor(id);
                TileOwners[TurnBasedRules.Index(x, y)] = id;
            }

            CurrentTurnPlayerId = active.Count > 0 ? active[0] : -1;
            GameRunning = active.Count >= 2;
            GameOver = false;
            EndedEarly = false;
            WinnersMask = 0;
            return active;
        }

        public static TileClaimResult TryClaimTileAndAdvance(int x, int y, int playerId)
        {
            var result = new TileClaimResult();
            if (!GameRunning || GameOver) return result;
            if (playerId != CurrentTurnPlayerId || !IsActivePlayer(playerId)) return result;
            if (!TurnBasedRules.IsLegalMove(TileOwners, x, y, playerId)) return result;

            TileOwners[TurnBasedRules.Index(x, y)] = playerId;
            result.claimed = true;
            ApplyTurnAdvance(playerId, ref result);
            return result;
        }

        // Host-only -- called when the turn timer elapses with no claim made. An idle player is
        // treated exactly like a player with no legal move.
        public static TileClaimResult SkipIdlePlayer(int playerId)
        {
            var result = new TileClaimResult();
            if (!GameRunning || GameOver || playerId != CurrentTurnPlayerId) return result;
            ApplyTurnAdvance(playerId, ref result);
            return result;
        }

        // Host-only. A disconnected player's tiles stay exactly as they are (frozen) -- see
        // Part 7's Departure Handling section for why. If it was their turn, the turn moves on
        // immediately rather than waiting for the turn timer. If fewer than 2 of the active
        // roster are still connected afterward, the round ends with no winner computed.
        public static TileClaimResult HandlePlayerDisconnected(int playerId)
        {
            ConnectedPlayerIds.Remove(playerId);
            var result = new TileClaimResult();
            if (!GameRunning) return result;

            int remainingActiveConnected = 0;
            for (int id = 0; id < 4; id++)
                if (IsActivePlayer(id) && ConnectedPlayerIds.Contains(id)) remainingActiveConnected++;

            if (remainingActiveConnected < 2)
            {
                GameRunning = false;
                GameOver = true;
                EndedEarly = true;
                WinnersMask = 0;
                result.gameOver = true;
                result.endedEarly = true;
                return result;
            }

            if (IsActivePlayer(playerId) && playerId == CurrentTurnPlayerId)
                ApplyTurnAdvance(playerId, ref result);

            return result;
        }

        private static void ApplyTurnAdvance(int afterPlayerId, ref TileClaimResult result)
        {
            int next = FindNextTurnPlayerOrNegativeOne(afterPlayerId);
            if (next < 0)
            {
                GameRunning = false;
                GameOver = true;
                WinnersMask = ComputeWinnersMask();
                result.gameOver = true;
                result.winnersMask = WinnersMask;
            }
            else
            {
                CurrentTurnPlayerId = next;
                result.turnChanged = true;
                result.nextTurnPlayerId = next;
            }
        }

        // Walks the 4 possible ids starting right after afterPlayerId, wrapping around, picking
        // the first CONNECTED active player who still has a legal move. A disconnected active
        // player's slot is skipped unconditionally; a connected one with no legal move is skipped
        // the same way an idle timeout is. Returns -1 if nobody qualifies -- the round is over.
        public static int FindNextTurnPlayerOrNegativeOne(int afterPlayerId)
        {
            for (int step = 1; step <= 4; step++)
            {
                int candidate = (afterPlayerId + step) % 4;
                if (!IsActivePlayer(candidate)) continue;
                if (!ConnectedPlayerIds.Contains(candidate)) continue;
                if (TurnBasedRules.HasAnyLegalMove(TileOwners, candidate)) return candidate;
            }
            return -1;
        }

        public static int ComputeWinnersMask()
        {
            var counts = new Dictionary<int, int>();
            for (int i = 0; i < TileOwners.Length; i++)
            {
                int owner = TileOwners[i];
                if (owner < 0) continue;
                counts.TryGetValue(owner, out var c);
                counts[owner] = c + 1;
            }

            int best = -1;
            foreach (var kv in counts)
                if (kv.Value > best) best = kv.Value;

            int mask = 0;
            foreach (var kv in counts)
                if (kv.Value == best) mask |= 1 << kv.Key;
            return mask;
        }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace PivecLabs.NetCrafterRelay.Examples.TurnBasedDemo
{
    public class TurnBasedTile : MonoBehaviour
    {
        public int x;
        public int y;

        public Button button;
        public Image background;

        // -1 = unclaimed. Purely a rendering concern -- this is this CLIENT's own mirror of what
        // the host has broadcast so far, rebuilt from TileClaimed events, never written to from
        // a local click.
        public int ownerPlayerId = -1;

        public static readonly Color UnclaimedColor = new Color(0.82f, 0.82f, 0.82f, 1f);
        public static readonly Color[] PlayerColors =
        {
            new Color(0.85f, 0.25f, 0.25f, 1f), // player 0 (host) -- red
            new Color(0.25f, 0.45f, 0.85f, 1f), // player 1 -- blue
            new Color(0.30f, 0.70f, 0.35f, 1f), // player 2 -- green
            new Color(0.90f, 0.75f, 0.20f, 1f), // player 3 -- yellow
        };

        public static Color ColorForPlayer(int playerId) =>
            playerId >= 0 && playerId < PlayerColors.Length ? PlayerColors[playerId] : UnclaimedColor;

        public void SetOwner(int playerId)
        {
            ownerPlayerId = playerId;
            if (background != null)
                background.color = playerId < 0 ? UnclaimedColor : ColorForPlayer(playerId);
        }

        // Advisory only -- the host re-validates this exact same check independently
        // (TurnBasedRules.IsLegalMove) and silently ignores anything illegal, so a stale value
        // here can only make a legal tile look unclickable or waste a click, never let an
        // illegal claim through.
        public void SetInteractable(bool interactable)
        {
            if (button != null) button.interactable = interactable;
        }

        // Wired to this prefab's own Button -> On Click () -- see Part 6.3.
        public void OnClicked()
        {
            TurnBasedDemoController.Instance?.RequestClaimTile(x, y);
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using PivecLabs.Generated.TurnBased;
using PivecLabs.NetCrafterRelay;

namespace PivecLabs.NetCrafterRelay.Examples.TurnBasedDemo
{
    public class TurnBasedDemoController : MonoBehaviour
    {
        public static TurnBasedDemoController Instance { get; private set; }

        public GameObject relayConnectionManagerObject;

        public GameObject loginPanel;
        public TMP_InputField displayNameInput;

        public GameObject lobbyPanel;
        public TMP_InputField joinCodeInput;
        public TMP_Text joinCodeDisplay;
        public TMP_Text statusText;
        public TMP_Text lobbyRosterText;
        public GameObject startGameButtonObject;
        public Button startGameButton;

        public GameObject gameplayPanel;
        public TMP_Text turnText;
        public TMP_Text rosterScoreText;
        public TurnBasedTile[] tiles;

        public GameObject gameOverPanel;
        public TMP_Text gameOverText;
        public GameObject playAgainButtonObject;
        public Button playAgainButton;

        private RelayConnectionManager relay;
        private string displayName = "Player";

        // Bumped on every real turn change so the turn-timer coroutine can tell "a move already
        // happened" apart from "the turn landed back on the same player after a full lap" --
        // comparing CurrentTurnPlayerId alone can't distinguish those in a 2-player game.
        private int _turnVersion;
        private Coroutine _turnTimerCoroutine;
        private const float TurnTimeoutSeconds = 30f;

        private static readonly string[] ColorNames = { "Red", "Blue", "Green", "Yellow" };

        private void Awake()
        {
            Instance = this;
            TurnBasedGameState.Reset();

            relay = relayConnectionManagerObject.GetComponent<RelayConnectionManager>();
            if (relay == null)
            {
                Debug.LogError($"[TurnBasedDemo] '{relayConnectionManagerObject.name}' has no " +
                    $"{typeof(RelayConnectionManager).FullName} component attached.");
            }

            relayConnectionManagerObject.SetActive(false);
            ShowLogin();
        }

        private void Start()
        {
            if (NetCrafterEventDispatcher.Instance == null)
            {
                Debug.LogError("[TurnBasedDemo] No NetCrafterEventDispatcher in the scene.");
                return;
            }
            NetCrafterEventDispatcher.Instance.Subscribe("RelayHosting", OnRelayHosting);
            NetCrafterEventDispatcher.Instance.Subscribe("ConnectionLost", OnConnectionLost);
            NetCrafterEventDispatcher.Instance.Subscribe("RelayStatus", OnRelayStatus);
        }

        private void ShowLogin()
        {
            loginPanel.SetActive(true);
            lobbyPanel.SetActive(false);
            gameplayPanel.SetActive(false);
            if (gameOverPanel != null) gameOverPanel.SetActive(false);
        }

        private void ShowLobby()
        {
            loginPanel.SetActive(false);
            lobbyPanel.SetActive(true);
            gameplayPanel.SetActive(false);
            if (gameOverPanel != null) gameOverPanel.SetActive(false);
        }

        private void ShowGameplay()
        {
            loginPanel.SetActive(false);
            lobbyPanel.SetActive(false);
            gameplayPanel.SetActive(true);
            if (gameOverPanel != null) gameOverPanel.SetActive(false);
        }

        public void OnLoginClicked()
        {
            displayName = string.IsNullOrEmpty(displayNameInput.text) ? "Player" : displayNameInput.text;
            ShowLobby();
        }

        public void OnHostClicked()
        {
            if (relay == null) return;
            if (statusText != null) statusText.text = "";
            relayConnectionManagerObject.SetActive(true);
        }

        public void OnJoinClicked()
        {
            if (relay == null) return;
            string code = joinCodeInput.text.Trim();
            if (string.IsNullOrEmpty(code)) return;
            if (statusText != null) statusText.text = "";
            relay.UpdateHost(code);
            relayConnectionManagerObject.SetActive(true);
            StartCoroutine(SendLoginWhenConnected());
        }

        private void OnRelayHosting(object joinCodeObj)
        {
            joinCodeDisplay.text = "Join code: " + (string)joinCodeObj;
            StartCoroutine(SendLoginWhenConnected());
        }

        private void OnConnectionLost(object reason)
        {
            if (statusText != null) statusText.text = NetCrafterConnectionStatus.ToPlayerMessage((string)reason);
        }

        private void OnRelayStatus(object message)
        {
            if (statusText != null) statusText.text = (string)message;
        }

        private const float HostLobbyDisplaySeconds = 4f;
        private const float ConnectTimeoutSeconds = 60f;

        private IEnumerator SendLoginWhenConnected()
        {
            float deadline = Time.realtimeSinceStartup + ConnectTimeoutSeconds;
            while (!relay.IsConnected && Time.realtimeSinceStartup < deadline) yield return null;
            if (!relay.IsConnected)
            {
                Debug.LogError($"[TurnBasedDemo] Failed to connect within {ConnectTimeoutSeconds}s.");
                yield break;
            }

            if (relay.IsHost)
            {
                TurnBasedGameState.PlayerNames[relay.LocalUserId] = displayName;
                TurnBasedGameState.ConnectedPlayerIds.Add(relay.LocalUserId);
                relay.OnPeerDisconnected += OnHostDetectedPeerDisconnected;
                yield return new WaitForSeconds(HostLobbyDisplaySeconds);
            }
            else
            {
                relay.OnPeerDisconnected += OnJoinerDetectedHostDisconnected;
                new LoginRequest { displayName = displayName }.Send(relay);
            }

            RefreshLobbyRoster();
            RefreshStartButtonState();
            ShowLobby();
        }

        public void OnStartGameClicked()
        {
            if (relay == null || !relay.IsHost) return;
            if (TurnBasedGameState.ConnectedPlayerIds.Count < 2) return;

            var active = TurnBasedGameState.StartGame();

            // GameStarted broadcasts BEFORE the corner TileClaimed events, not after -- see
            // OnGameStartedReceived's own comment: GameStarted is this schema's single
            // authoritative board-clear point on every peer, so anything it's meant to clear
            // must still be clearable when it arrives, not already overwritten by claims that
            // got there first.
            var started = new GameStartedEvent
            {
                activePlayersMask = TurnBasedGameState.ActivePlayersMask,
                currentTurnPlayerId = TurnBasedGameState.CurrentTurnPlayerId
            };
            relay.BroadcastToAll("GameStarted", started.Serialize(), true);
            OnGameStartedReceived(started.activePlayersMask, started.currentTurnPlayerId);

            foreach (var id in active)
            {
                var (x, y) = TurnBasedRules.CornerFor(id);
                var claimed = new TileClaimedEvent { x = x, y = y, playerId = id };
                relay.BroadcastToAll("TileClaimed", claimed.Serialize(), true);
                OnTileClaimedReceived(x, y, id);
            }
        }

        public void OnPlayAgainClicked() => OnStartGameClicked();

        public void RequestClaimTile(int x, int y)
        {
            if (relay == null) return;

            if (relay.IsHost)
            {
                var result = TurnBasedGameState.TryClaimTileAndAdvance(x, y, relay.LocalUserId);
                if (!result.claimed) return;

                var claimed = new TileClaimedEvent { x = x, y = y, playerId = relay.LocalUserId };
                relay.BroadcastToAll("TileClaimed", claimed.Serialize(), true);
                OnTileClaimedReceived(x, y, relay.LocalUserId);

                if (result.gameOver)
                {
                    var over = new GameOverEvent { winnersMask = result.winnersMask, endedEarly = false };
                    relay.BroadcastToAll("GameOver", over.Serialize(), true);
                    OnGameOverReceived(result.winnersMask, false);
                }
                else if (result.turnChanged)
                {
                    var turn = new TurnChangedEvent { currentTurnPlayerId = result.nextTurnPlayerId };
                    relay.BroadcastToAll("TurnChanged", turn.Serialize(), true);
                    OnTurnChangedReceived(result.nextTurnPlayerId);
                }
            }
            else
            {
                new ClaimTileRequest { x = x, y = y }.Send(relay);
            }
        }

        private void StartTurnTimerIfHost()
        {
            if (relay == null || !relay.IsHost) return;
            if (_turnTimerCoroutine != null) StopCoroutine(_turnTimerCoroutine);
            _turnTimerCoroutine = StartCoroutine(TurnTimerCoroutine(_turnVersion, TurnBasedGameState.CurrentTurnPlayerId));
        }

        private IEnumerator TurnTimerCoroutine(int versionAtStart, int playerIdAtStart)
        {
            yield return new WaitForSeconds(TurnTimeoutSeconds);
            if (versionAtStart != _turnVersion) yield break;
            if (!TurnBasedGameState.GameRunning || TurnBasedGameState.GameOver) yield break;

            var result = TurnBasedGameState.SkipIdlePlayer(playerIdAtStart);
            if (result.gameOver)
            {
                var over = new GameOverEvent { winnersMask = result.winnersMask, endedEarly = false };
                relay.BroadcastToAll("GameOver", over.Serialize(), true);
                OnGameOverReceived(result.winnersMask, false);
            }
            else if (result.turnChanged)
            {
                var turn = new TurnChangedEvent { currentTurnPlayerId = result.nextTurnPlayerId };
                relay.BroadcastToAll("TurnChanged", turn.Serialize(), true);
                OnTurnChangedReceived(result.nextTurnPlayerId);
            }
        }

        private void OnHostDetectedPeerDisconnected(int peerId)
        {
            var left = new PlayerLeftEvent { playerId = peerId };
            relay.BroadcastToAll("PlayerLeft", left.Serialize(), true);
            OnPlayerLeftReceived(peerId);

            var result = TurnBasedGameState.HandlePlayerDisconnected(peerId);
            if (result.gameOver)
            {
                var over = new GameOverEvent { winnersMask = result.winnersMask, endedEarly = result.endedEarly };
                relay.BroadcastToAll("GameOver", over.Serialize(), true);
                OnGameOverReceived(result.winnersMask, result.endedEarly);
            }
            else if (result.turnChanged)
            {
                var turn = new TurnChangedEvent { currentTurnPlayerId = result.nextTurnPlayerId };
                relay.BroadcastToAll("TurnChanged", turn.Serialize(), true);
                OnTurnChangedReceived(result.nextTurnPlayerId);
            }
        }

        private void OnJoinerDetectedHostDisconnected(int peerId)
        {
            OnPlayerLeftReceived(peerId);
            if (statusText != null) statusText.text = "Host disconnected — connection lost.";
        }

        public void OnPlayerJoinedReceived(int playerId, string joinedDisplayName)
        {
            TurnBasedGameState.PlayerNames[playerId] = joinedDisplayName;
            RefreshLobbyRoster();
            RefreshRosterScoreText();
            RefreshStartButtonState();
        }

        public void OnPlayerJoinedBroadcastReceived()
        {
            var ev = (PlayerJoinedEvent)NetCrafterSceneEventRouter.Instance.GetLastPayload("PlayerJoined");
            OnPlayerJoinedReceived(ev.playerId, ev.displayName);
        }

        public void OnPlayerLeftReceived(int playerId)
        {
            TurnBasedGameState.PlayerNames.Remove(playerId);
            TurnBasedGameState.ConnectedPlayerIds.Remove(playerId);
            RefreshLobbyRoster();
            RefreshRosterScoreText();
            RefreshStartButtonState();
        }

        public void OnPlayerLeftBroadcastReceived()
        {
            var ev = (PlayerLeftEvent)NetCrafterSceneEventRouter.Instance.GetLastPayload("PlayerLeft");
            OnPlayerLeftReceived(ev.playerId);
        }

        public void OnTileClaimedReceived(int x, int y, int playerId)
        {
            TurnBasedGameState.TileOwners[TurnBasedRules.Index(x, y)] = playerId;
            int idx = TurnBasedRules.Index(x, y);
            if (tiles != null && idx >= 0 && idx < tiles.Length && tiles[idx] != null)
                tiles[idx].SetOwner(playerId);
            RefreshRosterScoreText();
            RefreshBoardInteractable();
        }

        public void OnTileClaimedBroadcastReceived()
        {
            var ev = (TileClaimedEvent)NetCrafterSceneEventRouter.Instance.GetLastPayload("TileClaimed");
            OnTileClaimedReceived(ev.x, ev.y, ev.playerId);
        }

        public void OnTurnChangedReceived(int currentTurnPlayerId)
        {
            TurnBasedGameState.CurrentTurnPlayerId = currentTurnPlayerId;
            _turnVersion++;
            StartTurnTimerIfHost();
            RefreshTurnText();
            RefreshBoardInteractable();
        }

        public void OnTurnChangedBroadcastReceived()
        {
            var ev = (TurnChangedEvent)NetCrafterSceneEventRouter.Instance.GetLastPayload("TurnChanged");
            OnTurnChangedReceived(ev.currentTurnPlayerId);
        }

        // Fires both for a genuine "the host just started the round" broadcast AND for the
        // snapshot HandleLogin re-sends to a player who joined mid-round -- either way, the only
        // correct reaction is the same, so no special-casing is needed here for which case it is.
        //
        // This is also this schema's single authoritative board-clear point, on every peer
        // (host included): without it, a new round only ever overwrote the 2-4 starting
        // corners, leaving every tile claimed during a PREVIOUS round still showing its old
        // owner. Both OnStartGameClicked and HandleLogin send GameStarted before any
        // TileClaimed for the new/current round specifically so this reset can never wipe out
        // a claim that already arrived.
        public void OnGameStartedReceived(int activePlayersMask, int currentTurnPlayerId)
        {
            for (int i = 0; i < TurnBasedGameState.TileOwners.Length; i++)
                TurnBasedGameState.TileOwners[i] = -1;
            if (tiles != null)
                foreach (var tile in tiles)
                    if (tile != null) tile.SetOwner(-1);

            TurnBasedGameState.ActivePlayersMask = activePlayersMask;
            TurnBasedGameState.CurrentTurnPlayerId = currentTurnPlayerId;
            TurnBasedGameState.GameRunning = true;
            TurnBasedGameState.GameOver = false;
            _turnVersion++;
            StartTurnTimerIfHost();

            ShowGameplay();
            RefreshTurnText();
            RefreshRosterScoreText();
            RefreshBoardInteractable();
        }

        public void OnGameStartedBroadcastReceived()
        {
            var ev = (GameStartedEvent)NetCrafterSceneEventRouter.Instance.GetLastPayload("GameStarted");
            OnGameStartedReceived(ev.activePlayersMask, ev.currentTurnPlayerId);
        }

        public void OnGameOverReceived(int winnersMask, bool endedEarly)
        {
            TurnBasedGameState.GameRunning = false;
            TurnBasedGameState.GameOver = true;
            TurnBasedGameState.WinnersMask = winnersMask;
            TurnBasedGameState.EndedEarly = endedEarly;
            _turnVersion++;

            if (gameOverPanel != null) gameOverPanel.SetActive(true);
            if (playAgainButtonObject != null)
                playAgainButtonObject.SetActive(relay != null && relay.IsHost);

            RefreshGameOverText();
            RefreshBoardInteractable();
        }

        public void OnGameOverBroadcastReceived()
        {
            var ev = (GameOverEvent)NetCrafterSceneEventRouter.Instance.GetLastPayload("GameOver");
            OnGameOverReceived(ev.winnersMask, ev.endedEarly);
        }

        private void RefreshLobbyRoster()
        {
            if (lobbyRosterText == null) return;
            var sb = new StringBuilder();
            foreach (var kv in TurnBasedGameState.PlayerNames) sb.AppendLine(kv.Value);
            lobbyRosterText.text = sb.ToString();
        }

        private void RefreshStartButtonState()
        {
            bool isHost = relay != null && relay.IsHost;
            if (startGameButtonObject != null) startGameButtonObject.SetActive(isHost);
            if (startGameButton != null) startGameButton.interactable = TurnBasedGameState.ConnectedPlayerIds.Count >= 2;
        }

        private void RefreshTurnText()
        {
            if (turnText == null) return;
            int current = TurnBasedGameState.CurrentTurnPlayerId;
            string name = TurnBasedGameState.PlayerNames.TryGetValue(current, out var n) ? n : $"Player {current}";
            string color = current >= 0 && current < ColorNames.Length ? ColorNames[current] : "?";
            bool isMe = relay != null && current == relay.LocalUserId;
            bool spectating = relay != null && TurnBasedGameState.GameRunning &&
                               !TurnBasedGameState.IsActivePlayer(relay.LocalUserId);

            string whoseTurn = isMe ? "Your turn" : $"{name}'s turn ({color})";
            turnText.text = spectating ? $"Spectating — {whoseTurn}" : whoseTurn;
        }

        private void RefreshRosterScoreText()
        {
            if (rosterScoreText == null) return;
            var counts = new int[4];
            foreach (var owner in TurnBasedGameState.TileOwners)
                if (owner >= 0 && owner < 4) counts[owner]++;

            var sb = new StringBuilder();
            foreach (var kv in TurnBasedGameState.PlayerNames)
            {
                int id = kv.Key;
                string suffix = id >= 0 && id < 4 ? $" ({ColorNames[id]}): {counts[id]}" : "";
                sb.AppendLine($"{kv.Value}{suffix}");
            }
            rosterScoreText.text = sb.ToString();
        }

        private void RefreshGameOverText()
        {
            if (gameOverText == null) return;
            if (TurnBasedGameState.EndedEarly)
            {
                gameOverText.text = "Game ended — not enough players remaining.";
                return;
            }

            var winners = new List<string>();
            for (int id = 0; id < 4; id++)
            {
                if ((TurnBasedGameState.WinnersMask & (1 << id)) == 0) continue;
                string name = TurnBasedGameState.PlayerNames.TryGetValue(id, out var n) ? n : $"Player {id}";
                winners.Add(name);
            }

            if (winners.Count == 0) gameOverText.text = "Game over.";
            else if (winners.Count == 1) gameOverText.text = $"{winners[0]} wins!";
            else gameOverText.text = "Tie between " + string.Join(" and ", winners) + "!";
        }

        private void RefreshBoardInteractable()
        {
            if (tiles == null || relay == null) return;
            bool myTurn = TurnBasedGameState.GameRunning && !TurnBasedGameState.GameOver &&
                          TurnBasedGameState.CurrentTurnPlayerId == relay.LocalUserId;

            foreach (var tile in tiles)
            {
                if (tile == null) continue;
                bool legal = myTurn && TurnBasedRules.IsLegalMove(TurnBasedGameState.TileOwners, tile.x, tile.y, relay.LocalUserId);
                tile.SetInteractable(legal);
            }
        }

        public bool IsConnectedForAutomation => relay != null && relay.IsConnected;
    }
}