benjivers/val Public Public: anyone can read this; the crew 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);

});

test("the snapshot carries the speed the server will move you at, not the reasons for it", () => {

  // The browser used to rebuild this rule from four fields and was right

  // only until a fifth was added. What it gets now is the answer: every

  // reason the match has to speed a body up, slow it down or hold it still,

  // resolved here, in units a second, to a tenth like every other number in

  // the snapshot.

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

  const state = match();

  const me = state.players[0]!;

  const was = { ...me };

  const phase = state.phase;

  const seen = () => JSON.parse(snapshot(me.id)).me as Record<string, unknown>;

  const speed = () => seen().speed;

  Object.assign(me, { alive: true, haste: 0, slow: 0, planting: 0, defusing: 0, weapon: "classic" });

  expect(speed()).toBe(250);

  me.weapon = "operator";

  expect(speed()).toBe(215);

  me.weapon = "classic";

  me.haste = 2;

  expect(speed()).toBe(337.5); // exactly what the tick will use

  me.haste = 0;

  me.slow = 2;

  expect(speed()).toBe(137.5);

  me.slow = 0;

  // Every way the match holds a body still arrives as a zero, and the client

  // is told none of them: a fifth one would need no change over there.

  me.planting = 1;

  expect(speed()).toBe(0);

  me.planting = 0;

  me.defusing = 1;

  expect(speed()).toBe(0);

  me.defusing = 0;

  me.alive = false;

  expect(speed()).toBe(0);

  me.alive = true;

  // Including the phases whose tick returns before it moves anybody.

  for (const stopped of ["end", "over"] as const) {

    state.phase = stopped;

    expect(speed()).toBe(0);

  }

  state.phase = phase;

  expect(speed()).toBe(250);

  // The three fields that existed only to be re-derived are gone with it.

  const me2 = seen();

  expect(me2).not.toHaveProperty("haste");

  expect(me2).not.toHaveProperty("slow");

  expect(me2).not.toHaveProperty("defusing");

  // What it costs the wire: a name and a number, once a seat a tick.

  const field = `"speed":${speed()},`;

  expect(snapshot(me.id)).toContain(field);

  expect(field.length).toBeLessThanOrEqual(16);

  Object.assign(me, was);

});