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

/**

 * How often the arena speaks.

 *

 * The simulation is 30Hz either way; what is decided here is how much of it

 * the browser is told about, which is the difference between a body drawn

 * from fifteen samples a second and one drawn from thirty.

 */

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

import { mkdtempSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

process.env.FORGE_APP_DATA ??= mkdtempSync(join(tmpdir(), "app-"));

const { advance, attach, broadcastEvery, match, release, seatCount, snapshot } = await import("./arena.ts");

test("a small room hears every tick, a full one every other", () => {

  expect(broadcastEvery(0)).toBe(1);

  expect(broadcastEvery(1)).toBe(1);

  expect(broadcastEvery(2)).toBe(1);

  expect(broadcastEvery(3)).toBe(2);

  expect(broadcastEvery(10)).toBe(2);

});

/** A seat that only counts what it was sent. */

function listen(session: string) {

  const got: string[] = [];

  attach(session, match().players[0]!.id, `test-${session}`, session, (data) => got.push(data));

  return got;

}

// The arena is one match shared by the whole test run, and another file may

// be holding a seat of its own while this one runs; what is checked is that

// the loop broadcasts at exactly the cadence the room it is in asks for.

test("the loop sends at the cadence the seat count asks for", () => {

  const one = listen("rate-a");

  const two = listen("rate-b");

  const every = broadcastEvery(seatCount());

  advance(1);

  // Thirty ticks to the second, one snapshot every `every` of them.

  expect(one.length).toBe(30 / every);

  expect(two.length).toBe(one.length);

  release("rate-a", "rate-a");

  release("rate-b", "rate-b");

});

test("a full room halves the cadence rather than multiplying the traffic", () => {

  const seats = ["rate-c", "rate-d", "rate-e"].map(listen);

  expect(seatCount()).toBeGreaterThan(2);

  advance(1);

  for (const got of seats) expect(got.length).toBe(15);

  for (const session of ["rate-c", "rate-d", "rate-e"]) release(session, session);

});

test("a snapshot stays small enough to send thirty times a second", () => {

  // The trade is only worth making if the payload is small. Measured over a

  // live round it is 3.2-4.5 KiB a seat, mean 3.4 — a hundred KiB a second

  // at 30Hz, and at most two seats are sent that much. This is the number

  // the pull quotes, so it is checked here rather than assumed; the ceiling

  // is loose enough not to fail on a busy tick and tight enough that a

  // snapshot which doubled in size would say so.

  for (let i = 0; i < 40 && match().phase !== "live"; i++) advance(1);

  const bytes = Buffer.byteLength(snapshot(match().players[0]!.id));

  expect(bytes).toBeGreaterThan(200);

  expect(bytes).toBeLessThan(8000);

});