fable/val Public Public: anyone can read this; nobody can change it.

/**

 * The shape of a served match, over a toy game: the rules every served game

 * needs and none should have to re-derive. These are the two holes that were

 * closed the hard way — a seat is rationed by address, and a client is sent

 * only what it can see — plus the idle gate and the reload race.

 */

import { expect, test } from "bun:test";

import { broadcastEvery, makeArena, TICK, type Command } from "./arena.ts";

type Toy = { id: string; name: string; bot: boolean; side: "a" | "b"; x: number; seen: boolean };

type World = { ticks: number; players: Toy[]; heard: Command[] };

/** Two sides of two; everybody on side "b" is out of side "a"'s sight unless marked seen. */

function toyGame(cadence?: (filled: number) => number) {

  const world: World = {

    ticks: 0,

    heard: [],

    players: [

      { id: "a1", name: "Ash", bot: true, side: "a", x: 10, seen: false },

      { id: "a2", name: "Bex", bot: true, side: "a", x: 20, seen: false },

      { id: "b1", name: "Cade", bot: true, side: "b", x: 30, seen: false },

      { id: "b2", name: "Dune", bot: true, side: "b", x: 40, seen: true },

    ],

  };

  return makeArena<World, Toy>({

    state: world,

    players: (s) => s.players,

    step: (s) => void (s.ticks += 1),

    sit: (s) => {

      const seat = s.players.find((p) => p.bot) ?? null;

      if (seat) seat.bot = false;

      return seat;

    },

    stand: (_s, p) => void (p.bot = true),

    visible: (_s, viewer, other) => viewer.side === other.side || other.seen,

    snapshot: (s, me, seen) => ({

      me: { id: me.id, x: me.x },

      players: seen.map((p) => ({ id: p.id, x: p.x })),

      board: s.players.map((p) => ({ id: p.id, name: p.name, bot: p.bot })),

    }),

    sticky: "board",

    cadence,

    spectatorSnapshot: (s) => ({ ticks: s.ticks, names: s.players.map((p) => p.name) }),

    command: (s, _p, message) => void s.heard.push(message),

  });

}

test("nobody watching, nothing happens; a watcher is somebody; a test drives it regardless", () => {

  const arena = toyGame();

  arena.beat();

  arena.beat();

  expect(arena.match().ticks).toBe(0);

  arena.watch("w", () => {});

  arena.beat();

  expect(arena.match().ticks).toBe(1);

  arena.unwatch("w");

  arena.beat();

  expect(arena.match().ticks).toBe(1);

  arena.advance(1);

  expect(arena.match().ticks).toBe(1 + Math.round(1 / TICK));

  expect(arena.attendance()).toBe(0);

});

test("a playing seat is rationed by address, and a session finds its own seat back", () => {

  const arena = toyGame();

  const first = arena.takeSeat("10.0.0.1", "session-1", "Kit");

  expect(first?.bot).toBe(false);

  expect(first?.name).toBe("Kit");

  // A second cookie from the same machine is not a second seat.

  expect(arena.addressCapped("10.0.0.1", "session-2")).toBe(true);

  expect(arena.takeSeat("10.0.0.1", "session-2", "Kit 2")).toBeNull();

  // The same session asking again is handed the seat it holds, renamed.

  const again = arena.takeSeat("10.0.0.1", "session-1", "Kat");

  expect(again?.id).toBe(first!.id);

  expect(again?.name).toBe("Kat");

  expect(arena.seatCount()).toBe(1);

  // Another machine sits down beside them.

  const other = arena.takeSeat("10.0.0.2", "session-3", "Kat");

  expect(other?.id).not.toBe(first!.id);

  // And two people may not share a name: the second gets a number.

  expect(other?.name).toBe("Kat 2");

});

test("a late close from a reload does not take the live seat with it", () => {

  const arena = toyGame();

  const seat = arena.takeSeat("10.0.0.1", "s", "Kit")!;

  arena.attach("s", seat.id, "10.0.0.1", "old-token", () => {});

  arena.attach("s", seat.id, "10.0.0.1", "new-token", () => {});

  arena.release("s", "old-token");

  expect(seat.bot).toBe(false);

  expect(arena.seatCount()).toBe(1);

  arena.release("s", "new-token");

  expect(seat.bot).toBe(true);

  expect(arena.seatCount()).toBe(0);

  expect(arena.addressCapped("10.0.0.1", "elsewhere")).toBe(false);

});

test("a viewer is sent only the bodies the game says they can see", () => {

  const arena = toyGame();

  const snap = JSON.parse(arena.snapshot("a1")) as { t: string; players: { id: string }[] };

  expect(snap.t).toBe("s");

  expect(snap.players.map((p) => p.id).sort()).toEqual(["a1", "a2", "b2"]);

  expect(JSON.stringify(snap.players)).not.toContain('"b1"');

});

test("an unknown viewer gets the spectator view, never another player's eyes", () => {

  const arena = toyGame();

  const snap = JSON.parse(arena.snapshot("nobody-here")) as Record<string, unknown>;

  expect(snap).toMatchObject({ t: "s", spectator: true });

  expect(snap.me).toBeUndefined();

  expect(snap.players).toBeUndefined();

  expect(JSON.stringify(snap)).not.toContain('"x"');

});

test("a spectator is sent the public state and never a position", () => {

  const arena = toyGame();

  const got: string[] = [];

  arena.watch("w", (data) => got.push(data), "cookie");

  expect(got.length).toBe(1);

  const snap = JSON.parse(got[0]!) as Record<string, unknown>;

  expect(snap).toMatchObject({ t: "s", spectator: true, why: "cookie", ticks: 0 });

  expect(snap.players).toBeUndefined();

  expect(snap.me).toBeUndefined();

  expect(got[0]).not.toContain('"x"');

  arena.unwatch("w");

});

test("the sticky field goes out once, then only when it changes", () => {

  const arena = toyGame();

  const seat = { playerId: "a1", token: "t", address: "10.0.0.1", send: () => {}, stickyCache: "" };

  const first = JSON.parse(arena.snapshotForSeat(seat)) as { board?: unknown[] };

  expect(first.board?.length).toBe(4);

  const second = JSON.parse(arena.snapshotForSeat(seat)) as { board?: unknown[] };

  expect(second.board).toBeUndefined();

  arena.match().players[3]!.name = "Eve";

  const third = JSON.parse(arena.snapshotForSeat(seat)) as { board?: { name: string }[] };

  expect(third.board?.[3]?.name).toBe("Eve");

  // The full snapshot is always the full snapshot.

  expect((JSON.parse(arena.snapshot("a1")) as { board: unknown[] }).board.length).toBe(4);

});

test("the loop sends at the cadence the room asks for, and a bot's commands are dropped", () => {

  const arena = toyGame();

  const got: string[] = [];

  const seat = arena.takeSeat("10.0.0.1", "s", "Kit")!;

  arena.attach("s", seat.id, "10.0.0.1", "t", (data) => got.push(data));

  arena.advance(1);

  expect(got.length).toBe(Math.round(1 / TICK) / broadcastEvery(1));

  arena.command(seat.id, { t: "i" });

  arena.command("b2", { t: "i" }); // a bot: nobody may drive it from outside

  expect(arena.match().heard.length).toBe(1);

});

test("a game that names its own cadence is sent at it, whatever the default says", () => {

  // Where the rate halves is a fact about one game's snapshot and one game's

  // room, so the game says; the engine's default is only for a game that has

  // not measured. Three ticks apart here, to be sure it is this and not the default.

  const arena = toyGame((filled) => (filled >= 2 ? 3 : 1));

  const got: string[] = [];

  const first = arena.takeSeat("10.0.0.1", "s1", "Kit")!;

  arena.attach("s1", first.id, "10.0.0.1", "t1", (data) => got.push(data));

  arena.advance(1);

  expect(got.length).toBe(Math.round(1 / TICK));

  const second = arena.takeSeat("10.0.0.2", "s2", "Kat")!;

  arena.attach("s2", second.id, "10.0.0.2", "t2", () => {});

  got.length = 0;

  arena.advance(1);

  expect(got.length).toBe(Math.round(1 / TICK) / 3);

});