fix(server): keep the rotation moving when a new lobby fills up early

Queued lobbies are joinable, and one that reaches maxPlayers starts on the
spot — hasReachedMaxPlayerCount flips the phase whether or not a countdown
is running. So a lobby can leave from anywhere in the queue, including
before the next scheduling tick sees it.

The next type came from the newest surviving lobby, which meant a lobby
that vanished that fast was never accounted for: the master handed out the
same type again, and again, and the other two were never created. The type
we last created is now remembered past its lobby's report, so the rotation
advances even when nothing survives to read it from.

Tests cover both that and the promotion order it doesn't change: the live
game is still the head of the queue, so a type whose lobbies keep filling
early is skipped every time rather than reordered.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ryanbarlow97

src/server/MasterLobbyService.ts

@@ -59,8 +59,9 @@ interface RotationEntry {
 }
 
 /**
- * The type to create next: successor of the newest lobby's type. Stateless on
- * purpose — no cursor to desynchronise on a restart or a failed create.
+ * The type to create next: successor of the newest entry's type. Takes the
+ * queue rather than a cursor, so a restart picks the rotation back up from
+ * whatever is already open.
  */
 export function nextRotationType(
   queue: readonly RotationEntry[],
@@ -120,6 +121,13 @@ export class MasterLobbyService {
   // gameID => when we told its worker to start counting down, until the worker
   // reports the lobby carrying a startsAt.
   private readonly pendingPromotions = new Map<string, number>();
+  // The last type we created, kept after its lobby is reported. Queued lobbies
+  // are joinable, so one can fill up and start before the next create; reading
+  // the rotation from survivors alone then hands out that same type forever and
+  // the other two are never created again.
+  private lastCreate:
+    | { publicGameType: ScheduledPublicGameType; createdAt: number }
+    | undefined;
   private started = false;
 
   constructor(
@@ -366,13 +374,16 @@ export class MasterLobbyService {
       return;
     }
 
-    const publicGameType = nextRotationType([...queue, ...pending]);
+    const publicGameType = nextRotationType([
+      ...queue,
+      ...pending,
+      ...(this.lastCreate ? [this.lastCreate] : []),
+    ]);
     const gameID = generateID();
-    this.pendingCreates.set(gameID, {
-      publicGameType,
-      // The worker stamps the real one; this only orders pending creates.
-      createdAt: Date.now(),
-    });
+    // The worker stamps the real one; this only orders pending creates.
+    const createdAt = Date.now();
+    this.pendingCreates.set(gameID, { publicGameType, createdAt });
+    this.lastCreate = { publicGameType, createdAt };
     this.sendMessageToWorker({
       type: "createGame",
       gameID,

tests/server/QueueRotation.test.ts

@@ -187,3 +187,93 @@ describe("promotion bookkeeping", () => {
     ).toHaveLength(1);
   });
 });
+
+/**
+ * Queued lobbies are joinable, and a lobby that reaches maxPlayers starts on
+ * the spot (hasReachedMaxPlayerCount flips the phase, startsAt or not). So a
+ * lobby can leave from the middle of the queue, and the rotation has to cope.
+ */
+describe("lobbies that fill up before their turn", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const queued = (entry: Entry) => ({ ...entry, numClients: 0 });
+  const creates = (sent: Record<string, string>[]) =>
+    sent.filter((m) => m.type === "createGame");
+
+  // One short of the target, so exactly one lobby is created per round and the
+  // rounds can be read off the create messages.
+  const ALMOST_FULL = 17;
+
+  it("keeps rotating when each new lobby fills up before the next round", async () => {
+    // 17 queued means the newest is a team lobby, so special is created next.
+    const queue = buildQueue(ALMOST_FULL).map(queued);
+    const { service, setLobbies, sent } = createScheduler(queue);
+    const created: string[] = [];
+
+    for (let round = 0; round < 3; round++) {
+      await service.maybeScheduleLobby();
+      const all = creates(sent());
+      const create = all[all.length - 1];
+      created.push(create.publicGameType);
+      // Its worker reports it, and then it fills up and starts, so the next
+      // round sees the same 17 lobbies it started with.
+      setLobbies([
+        ...queue,
+        queued({
+          gameID: create.gameID,
+          publicGameType: create.publicGameType as Entry["publicGameType"],
+          createdAt: 9000 + round,
+        }),
+      ]);
+      await service.maybeScheduleLobby();
+      setLobbies(queue);
+    }
+
+    expect(created).toEqual(["special", "ffa", "team"]);
+  });
+
+  /**
+   * Promotion takes the head of the queue, so the live game is the rotation
+   * with the early starters removed — types can be skipped, and a type whose
+   * lobbies keep filling early is skipped every time.
+   */
+  it("skips a type entirely when the lobby behind the head keeps filling up", async () => {
+    let open = buildQueue(18).map(queued);
+    const { service, setLobbies, sent } = createScheduler(open);
+    const live: Entry[] = [];
+
+    for (let round = 0; round < 9; round++) {
+      await service.maybeScheduleLobby();
+      const promotions = sent().filter((m) => m.type === "updateLobby");
+      const gameID = promotions[promotions.length - 1].gameID;
+      const head = open.find((l) => l.gameID === gameID)!;
+      live.push(head);
+      // The head's countdown runs out. On odd rounds the lobby behind it fills
+      // up and starts as well, leaving from the middle of the queue.
+      const alsoStarting = round % 2 === 1 ? open[1] : undefined;
+      open = open.filter((l) => l !== head && l !== alsoStarting);
+      setLobbies(open);
+    }
+
+    // Always the queue's own order, oldest first.
+    expect(live.map((l) => l.createdAt)).toEqual(
+      [...live]
+        .sort((a, b) => a.createdAt! - b.createdAt!)
+        .map((l) => l.createdAt),
+    );
+    // Every special sat behind a head that started early, so none ever went live.
+    expect(live.map((l) => l.publicGameType)).toEqual([
+      "ffa",
+      "team",
+      "ffa",
+      "team",
+      "ffa",
+      "team",
+      "ffa",
+      "team",
+      "ffa",
+    ]);
+  });
+});