Room System

export class Server {
  async onRoomCreate(roomId) {
    // Called once, when the first user joins.
    // Do NOT seed `players: []` here — a second player's onRoomJoin can land
    // before this hook runs, and the blind overwrite would erase them.
    await $room.updateRoomState({ createdAt: Date.now() });
  }
 
  async onRoomJoin(roomId, account) {
    // Room hooks are NOT serialized — two players joining at the same moment
    // run this concurrently, so the read-modify-write needs $lock or one of
    // the two appends is lost. (For a plain roster, prefer the built-in
    // $users array, which the runtime maintains for you.)
    await $lock(`room:${roomId}`, async () => {
      const state = (await $room.getRoomState()) || {};
      const players = state.players || [];
      players.push(account);
      await $room.updateRoomState({ players });
    });
  }
 
  async onRoomDisconnect(roomId, account) {
    // The user is still "in" the room during the grace period (below).
    await $room.broadcastToRoom('playerDisconnected', { account });
  }
 
  async onRoomLeave(roomId, account) {
    // Same lock key as onRoomJoin — a leave racing a join would otherwise
    // resurrect the leaver or drop the joiner.
    await $lock(`room:${roomId}`, async () => {
      const state = (await $room.getRoomState()) || {};
      const players = (state.players || []).filter(p => p !== account);
      await $room.updateRoomState({ players });
    });
  }
 
  async onRoomDestroy(roomId) {
    // The shared room state has ALREADY been deleted — $room.getRoomState()
    // returns no custom fields here; persist it from onRoomLeave instead.
    // Room user states and room collections are still readable, and are
    // deleted as soon as this hook returns.
  }
}

export class Server {
  ROOM_MAX_USERS = 4
 
  async findMatch() {
    const roomIds = await $global.getAllRoomIds();
    for (const roomId of roomIds) {
      const count = await $global.countRoomUsers(roomId);
      if (count < this.ROOM_MAX_USERS) {
        return roomId; // Found a room with space
      }
    }
    // No room available — a new id; the room is created when the first player joins it
    return 'Room' + Math.random().toString(16).substring(2, 10);
  }
}

import { useGameServer } from "@agent8/gameserver";
 
export default function JoinRoomExample() {
  const { connected, server, joinRoom, leaveRoom, currentRoomId, rsConnected } = useGameServer();
 
  const handleJoin = async () => {
    if (!connected) return;
    // 1. Ask server to find a room
    const roomId = await server.remoteFunction("findMatch", []);
    // 2. Join the room (SDK handles RS connection)
    await joinRoom(roomId);
  };
 
  const handleLeave = () => {
    leaveRoom();
  };
 
  return (
    <div>
      {rsConnected ? (
        <div>
          <p>In room: {currentRoomId}</p>
          <button onClick={handleLeave}>Leave Room</button>
        </div>
      ) : (
        <button onClick={handleJoin} disabled={!connected}>
          Find & Join Room
        </button>
      )}
    </div>
  );
}

import { useGameServer } from "@agent8/gameserver";
import { useEffect, useState } from "react";
 
export default function RoomUserEvents() {
  const { connected, server, joinRoom, currentRoomId, rsConnected } = useGameServer();
  const [events, setEvents] = useState([]);
 
  useEffect(() => {
    if (!rsConnected || !currentRoomId) return;
 
    const unsubJoin = server.onRoomUserJoin(currentRoomId, (account) => {
      setEvents((prev) => [...prev, { type: "join", account, time: new Date() }]);
    });
 
    const unsubLeave = server.onRoomUserLeave(currentRoomId, (account) => {
      setEvents((prev) => [...prev, { type: "leave", account, time: new Date() }]);
    });
 
    return () => {
      unsubJoin();
      unsubLeave();
    };
  }, [rsConnected, currentRoomId, server]);
 
  if (!rsConnected) return <p>Not in a room</p>;
 
  return (
    <div>
      <h3>Room Activity: {currentRoomId}</h3>
      <ul>
        {events.map((e, i) => (
          <li key={i}>
            {e.type === "join" ? "➡️" : "⬅️"} {e.account} — {e.time.toLocaleTimeString()}
          </li>
        ))}
      </ul>
    </div>
  );
}

import { useGameServer, useRoomState } from "@agent8/gameserver";
 
export default function RoomUsersList() {
  const { rsConnected, currentRoomId } = useGameServer();
  const roomState = useRoomState();
 
  if (!rsConnected) return <p>Not in a room</p>;
 
  return (
    <div>
      <h3>Users in Room: {currentRoomId}</h3>
      <p>Total: {roomState.$users?.length || 0}</p>
      <ul>
        {roomState.$users?.map((user) => (
          <li key={user}>{user}</li>
        ))}
      </ul>
    </div>
  );
}