Lobbies

Genre-neutral lobby directory: browsable, joinable game sessions with metadata + a host who can start the match. A session may be in at most one lobby at a time. Roster/state changes are pushed to members through the Core IRoomRegistry. Depends only on Core primitives (sessions + identity + rooms). Crossplay never inspects what a "match" means to the game.

• IReadOnlyList<LobbyInfo> Browse()

  Snapshot of the browsable lobbies (open, public lobbies only), ordered by id.

• bool TryCastVote(ISession session, byte optionIndex, out ushort reason)

  Casts (or changes) the caller's pick for the lobby's active vote.

• bool TryCreate(ISession session, string name, string mode, int maxPlayers, bool isPrivate, string password, out long lobbyId, out ushort reason)

  Creates a lobby owned by session and adds it as the host. On success the new id is returned and the host is sent the initial roster. Returns false with reason set to a notification code.

• bool TryJoin(ISession session, long lobbyId, string password, out ushort reason)

  Adds session to lobbyId (checking password/capacity/state). On success every member is sent the updated roster. Returns false with reason.

• bool TryLeave(ISession session, out ushort reason)

  Removes session from whatever lobby it is in, reassigning the host or closing the lobby when it empties, and broadcasting the updated roster. Returns false with reason when the session is in no lobby.

• bool TryStartMatch(ISession session, out ushort reason)

  Host-only: moves the caller's lobby to InProgress and broadcasts MatchStarting + the updated roster. Returns false with reason (not in a lobby / not host / already in progress).

• bool TryStartVote(ISession session, string[] options, out ushort reason)

  Host opens a vote among opaque options — map names, mode keys, anything (a new vote replaces a stale one). Default: unsupported — the single-node service implements it; cross-node lobby votes are a future Redis-twin addition.

Configurable lobby rules (defaults live here, never inline in the service/handlers).

• int DefaultMaxPlayers { get; set; }

  Max-players used when a create request does not specify one (0 or less).

• int MaxModeLength { get; set; }

  Maximum length of the game-defined mode tag.

• int MaxNameLength { get; set; }

  Maximum lobby name length.

• int MaxPasswordLength { get; set; }

  Maximum password length.

• int MaxPlayersCap { get; set; }

  Largest max-players any lobby may be created with (requests are clamped down to this).

• int MaxVoteOptionLength { get; set; }

  Longest allowed vote-option text.

• int MaxVoteOptions { get; set; }

  Most options a single vote may offer.

• int MinMaxPlayers { get; set; }

  Smallest max-players a lobby may be created with.

• int MinNameLength { get; set; }

  Minimum lobby name length.

Data-layer lobby service (no UI): async create/list/join/leave/start RPCs plus events for the server-pushed roster/state and match-starting broadcasts. Self-registers under the Crossplay client context. Depends only on Crossplay Core.

• event Action<LobbyRoster> RosterChanged

  Raised whenever the server pushes the roster/state of the lobby this client is in.

• event Action<MatchStarting> MatchStarting

  Raised when the host starts the match for the lobby this client is in.

• UniTask<LobbyCreateResponse> CreateAsync(string name, string mode, int maxPlayers, bool isPrivate, string password, CancellationToken ct = default)

  Creates a lobby owned by this client (public unless isPrivate).

• UniTask<LobbyListResponse> ListAsync(CancellationToken ct = default)

  Requests the browsable list of open, public lobbies.

• UniTask<LobbyJoinResponse> JoinAsync(long lobbyId, string password, CancellationToken ct = default)

  Joins a lobby by id (with an optional password).

• UniTask<LobbyLeaveResponse> LeaveAsync(CancellationToken ct = default)

  Leaves the current lobby.

• UniTask<LobbyStartMatchResponse> StartMatchAsync(CancellationToken ct = default)

  Host-only: starts the match for the current lobby.

• UniTask<LobbyVoteStartResponse> StartVoteAsync(string[] options, CancellationToken ct = default)

  Host opens a vote among opaque options (map names, mode keys, anything).

• void CastVote(byte optionIndex)

  Casts (or changes) my pick. Fire-and-forget — the broadcast state is the feedback.

• event Action<LobbyVote> VoteStarted

  Raised when a vote begins.

• event Action<LobbyVoteState> VoteStateChanged

  Raised after every cast (Complete carries the winner).

Narrow contract the presenter drives. UI-only: render calls in, user intents out.