53c9cd7
@@ -51,7 +51,7 @@
server:
  with hands: 200–350ms to react to a target they have just seen, an aim
  cone that opens several degrees on the swing and only settles while they
  hold the same target, and more of both when you are crossing their view
  (`src/aim.ts`). Every roll of it comes from the match's seeded random, so
  (`src/engine/aim.ts`). Every roll of it comes from the match's seeded random, so
  a seed replays the same round.
Agents: Ember, Veil, Sable, Mender, Rook — two basics bought with credits
@@ -64,12 +64,12 @@
Guns: Classic, Ghost, Sheriff, Spectre, Phantom, Vandal, Operator.
- Your own body is *drawn* from a guess — the browser runs your own movement
  forward from your own keys between snapshots, through the same
  step-and-slide the server uses (`src/glide.ts`), and carries the last
  step-and-slide the server uses (`src/engine/glide.ts`), and carries the last
  snapshot forward by up to a quarter second of held input. It is a drawing
  optimisation only: nothing is sent, every snapshot leans the drawn body
  back onto the server's answer, and a real disagreement is taken outright.
  The lag your own keys take to reach the server (a send every 50ms, a hop,
  a tick — `LEAD_SLACK` in `static/predict.js`) is not a disagreement: the
  a tick — `LEAD_SLACK` in `static/engine/predict.js`) is not a disagreement: the
  drawn body may lead the answer by that much along the way it is going and
  is left alone there, so a start is not yanked back and a stop is not
  dragged on. Anywhere the server would refuse — a wall, the spawn pen in
@@ -79,8 +79,8 @@
Guns: Classic, Ghost, Sheriff, Spectre, Phantom, Vandal, Operator.
  second kick; whether it landed is still only the server's to say.
  Where you are *looking* is the browser's too: the mouse moves it at frame
  rate, and the server's angle is taken back only when it is telling you
  something you did not say (`static/yaw.js`).
- Everybody else is drawn by entity interpolation (`static/interp.js`): each
  something you did not say (`static/engine/yaw.js`).
- Everybody else is drawn by entity interpolation (`static/engine/interp.js`): each
  body keeps the last few snapshots, and the frame is drawn about one
  snapshot interval in the past, between the two that bracket that moment.
  So they move at the speed the server moved them and arrive where it put
@@ -101,19 +101,19 @@
Guns: Classic, Ghost, Sheriff, Spectre, Phantom, Vandal, Operator.
  no looking up or down, and everything that is not a wall — bodies, the
  spike, ability zones — is a flat billboard scaled by distance and clipped
  against the walls. It is drawn into an offscreen canvas 960 columns wide
  (`static/resolution.js`, never more than the canvas has pixels), one ray
  (`static/engine/resolution.js`, never more than the canvas has pixels), one ray
  every other column, and scaled onto the visible one, so the frame costs the
  same on a retina screen as on any other; the crosshair, the HUD and the
  minimap are drawn on top at full device resolution. Columns that would draw
  the same rectangle are batched into one fill (`static/slices.js`), the
  the same rectangle are batched into one fill (`static/engine/slices.js`), the
  map's tiles are drawn once a size and blitted after that, and if the frame
  still runs over 20ms the render width drops a rung until it fits
  (`static/budget.js`). Fidelity is cheap here and frame rate is not.
  (`static/engine/budget.js`). Fidelity is cheap here and frame rate is not.
  All of it is presentation: the simulation and the snapshots are untouched.
- A body you have only just been shown is faded and grown into sight over a
  tenth of a second, and slid in from the direction it came if it was seen
  near there before; where somebody was last seen alive leaves an outline
  that dims away over a second (`static/presence.js`). The server still sends
  that dims away over a second (`static/engine/presence.js`). The server still sends
  only what you can see — that is the rule, and nothing here bends it. This
  is a drawing about information you already had: an enemy who steps into a
  sightline has no history, and without it they appear mid-stride rather than
@@ -177,7 +177,7 @@
says how.
## Shape
`src/map.ts` the grid and its geometry · `src/weapons.ts` the damage table ·
`src/engine/` the machinery any game on this server stands on — the grid and its collision (`grid.ts`, `glide.ts`), the bot aim model (`aim.ts`) and the served match with its idle gate, per-address seats, positionless spectator view and per-viewer vision filter (`arena.ts`); nothing in it imports the game, and `src/engine/boundary.test.ts` keeps it that way · `static/engine/` the client feel stack and renderer — interpolation, prediction, presence, yaw, steer, raycast, scene, slices, resolution, budget, topdown, gun · `src/map.ts` this map's rows and what its letters mean · `src/weapons.ts` the damage table ·
`src/economy.ts` credits · `src/abilities.ts` the agent kits ·
`src/match.ts` the round loop (`tick(state, dt)` is the whole game and takes
no clock) · `src/bots.ts` the seats nobody is in · `src/arena.ts` the one
@@ -18,7 +18,7 @@
import {
import { HEIGHT, WIDTH } from "./map.ts";
import { newMatch, startRound, tick } from "./match.ts";
import type { MatchState, Player, Zone } from "./state.ts";
import { FOV } from "../static/raycast.js";
import { FOV } from "../static/engine/raycast.js";
const flashes = (): Ability[] => AGENTS.flatMap((a) => SLOTS.map((s) => a.abilities[s])).filter((a) => a.kind === "flash");
@@ -143,7 +143,7 @@
export const buyableSlots: Slot[] = ["c", "q"];
 * of the flash you get flashed, and if you are not, you do not. Facing is
 * the gate. Distance only decides how long.
 *
 * The browser draws a 75° field of view (`FOV` in `static/raycast.js`), so
 * The browser draws a 75° field of view (`FOV` in `static/engine/raycast.js`), so
 * anything inside half of that was on your screen: you looked at it, you
 * pay the whole duration. Past the edge of the screen there is a little
 * grace for the fact that you were probably turning, falling away quickly
@@ -1,24 +1,10 @@
/**
 * How a bot points a gun, tested as the pure maths it is, and then once
 * through a whole bot to prove the gate is actually wired to the trigger.
 * The bot's aim (`engine/aim.ts`), once through a whole bot to prove the
 * reaction gate is actually wired to the trigger and the cone to the barrel.
 */
import { expect, test } from "bun:test";
import {
  acquire,
  aimCone,
  canFire,
  CONE_FLOOR,
  crossRate,
  drift,
  emptyTrack,
  FORGET,
  heldFor,
  lose,
  REACTION_MAX,
  REACTION_MIN,
  reactionTime,
} from "./aim.ts";
import { acquire, crossRate, emptyTrack, REACTION_MAX, REACTION_MIN } from "./engine/aim.ts";
import { botThink } from "./bots.ts";
import { newMatch, RUN_SPEED } from "./match.ts";
import type { MatchState, Player } from "./state.ts";
@@ -28,106 +14,6 @@
const rolls = (...values: number[]) => {
  return () => values[at++ % values.length]!;
};
test("the reaction a bot draws is between 200 and 350ms, whatever the roll", () => {
  expect(reactionTime(0)).toBeCloseTo(REACTION_MIN, 9);
  expect(reactionTime(1)).toBeCloseTo(REACTION_MAX, 9);
  expect(reactionTime(0.5)).toBeCloseTo((REACTION_MIN + REACTION_MAX) / 2, 9);
  // A roll out of range is still a reaction, not a bot that never shoots.
  expect(reactionTime(-3)).toBe(REACTION_MIN);
  expect(reactionTime(9)).toBe(REACTION_MAX);
});
test("the trigger gate is a pure function of when acquisition happened", () => {
  const track = emptyTrack();
  // Nothing in sight is never a shot, however long the round has run.
  expect(canFire(track, 100)).toBe(false);
  acquire(track, "bot-red-1", 10, { x: 0, y: 0 }, rolls(0, 0.5));
  expect(track.reaction).toBeCloseTo(REACTION_MIN, 9);
  expect(canFire(track, 10)).toBe(false);
  expect(canFire(track, 10.19)).toBe(false);
  expect(canFire(track, 10.21)).toBe(true);
  expect(canFire(track, 12)).toBe(true);
  expect(heldFor(track, 12)).toBeCloseTo(2, 9);
});
test("a new target starts the reaction again; the same one does not", () => {
  const track = emptyTrack();
  acquire(track, "one", 5, { x: 100, y: 100 }, rolls(1, 0.5));
  expect(track.since).toBe(5);
  acquire(track, "one", 5.3, { x: 180, y: 100 }, rolls(0, 0.5));
  expect(track.since).toBe(5); // the hold carries on
  expect(canFire(track, 5.4)).toBe(true);
  acquire(track, "two", 5.4, { x: 0, y: 0 }, rolls(0, 0.5));
  expect(track.since).toBe(5.4); // swinging onto somebody else costs again
  expect(canFire(track, 5.5)).toBe(false);
});
test("a hold survives a blink out of sight, and no longer", () => {
  const track = emptyTrack();
  acquire(track, "one", 1, { x: 0, y: 0 }, rolls(0, 0.5));
  lose(track, 1 + FORGET / 2);
  expect(track.id).toBe("one");
  // Back a moment later: the same hold, already through its reaction.
  acquire(track, "one", 1 + FORGET / 2, { x: 0, y: 0 }, rolls(0, 0.5));
  expect(track.since).toBe(1);
  // Gone for longer than that and it is a fresh acquisition.
  lose(track, 3);
  expect(track.id).toBe(null);
  acquire(track, "one", 3, { x: 0, y: 0 }, rolls(0, 0.5));
  expect(track.since).toBe(3);
  expect(canFire(track, 3.1)).toBe(false);
});
test("the cone starts wide, settles the longer one target is held, and never closes", () => {
  const swing = aimCone(0, 0);
  const second = aimCone(1, 0);
  const settled = aimCone(3, 0);
  expect(swing).toBeGreaterThan(0.08); // several degrees on the swing
  expect(second).toBeLessThan(swing / 2);
  expect(settled).toBeLessThan(second);
  expect(settled).toBeGreaterThanOrEqual(CONE_FLOOR);
  expect(aimCone(99, 0)).toBeCloseTo(CONE_FLOOR, 6);
});
test("a target crossing the view costs the bot accuracy", () => {
  expect(aimCone(3, 1)).toBeGreaterThan(aimCone(3, 0) * 3);
  expect(aimCone(3, 0.5)).toBeGreaterThan(aimCone(3, 0));
  expect(aimCone(3, 0.5)).toBeLessThan(aimCone(3, 1));
  // Nonsense from the caller is clamped, not multiplied out.
  expect(aimCone(3, 50)).toBeCloseTo(aimCone(3, 1), 9);
});
test("crossing is measured across the sight line, not along it", () => {
  const bot = { x: 0, y: 0 };
  const walking = emptyTrack();
  acquire(walking, "t", 0, { x: 300, y: 0 }, rolls(0, 0.5));
  // Straight down the barrel: nothing to track.
  expect(crossRate(walking, bot, { x: 260, y: 0 }, 0.1)).toBeCloseTo(0, 6);
  const strafing = emptyTrack();
  acquire(strafing, "t", 0, { x: 300, y: 0 }, rolls(0, 0.5));
  // Straight across it at a run: all of it but the turn of the sight line.
  expect(crossRate(strafing, bot, { x: 300, y: 25 }, 0.1)).toBeCloseTo(250, -1);
  // And it remembers where the target went, so the next tick measures again.
  expect(crossRate(strafing, bot, { x: 300, y: 25 }, 0.1)).toBeCloseTo(0, 6);
});
test("the error wanders inside the cone instead of being redrawn every tick", () => {
  const track = emptyTrack();
  acquire(track, "one", 0, { x: 0, y: 0 }, rolls(0, 1));
  // Drawn at the edge of the swing cone on acquisition.
  expect(Math.abs(track.error)).toBeCloseTo(aimCone(0, 0), 9);
  // One tick moves it a little, not to somewhere unrelated.
  const before = track.error;
  const after = drift(track, aimCone(0, 0), 1 / 30, rolls(0.9));
  expect(Math.abs(after - before)).toBeLessThan(aimCone(0, 0) / 4);
  // And it is squeezed toward the barrel as the cone closes around it.
  for (let i = 0; i < 90; i++) drift(track, aimCone(3, 0), 1 / 30, rolls(0.5, 1, 0));
  expect(Math.abs(track.error)).toBeLessThanOrEqual(aimCone(3, 0) + 1e-12);
});
// ------------------------------------------------------------- through a bot
const facing = (state: MatchState): { bot: Player; prey: Player } => {
  const bot = state.players.find((p) => p.side === "def")!;
  const prey = state.players.find((p) => p.side === "atk")!;
@@ -1,240 +1,63 @@
/**
 * The arena: one match, always running, and the seats people sit in.
 * The arena: this game's one live match, served the way `engine/arena.ts`
 * serves any match — ticking only while somebody is connected, one playing
 * seat an address, a positionless view for whoever has no seat, and every
 * snapshot built for one viewer from what they can see.
 *
 * The match ticks whether anybody is watching or not, so a visitor never
 * arrives at a frozen board — they get the round that is happening. Taking a
 * seat replaces a bot in place: same body, same credits, same position, so
 * joining mid-round hands you a live player rather than a lobby.
 *
 * Every snapshot is built for one viewer: enemies they cannot see are not in
 * it. The client never learns a position it has no line of sight to.
 * What is this game's own is here: taking a seat replaces a bot in the
 * emptiest team (same body, same credits, same position, so joining
 * mid-round hands you a live player rather than a lobby), the commands a
 * client may send, the shape of the snapshot, and the kill feed read off the
 * match a tick at a time.
 */
import { agentById, sightBlocked } from "./abilities.ts";
import { runBots } from "./bots.ts";
import { recordResult } from "./db.ts";
import { makeArena, type Command, type Why } from "./engine/arena.ts";
import { fallsBetween, marksOf, trimFeed, type Fall, type Mark } from "./killfeed.ts";
import type { Point } from "./map.ts";
import {
  buyAbility,
  buyShield,
  buyWeapon,
  newMatch,
  pickAgent,
  setInput,
  tick,
  visible,
} from "./match.ts";
import { buyAbility, buyShield, buyWeapon, newMatch, pickAgent, setInput, tick, visible } from "./match.ts";
import type { MatchState, Player } from "./state.ts";
import { isWeaponId, WEAPONS } from "./weapons.ts";
export const TICK = 1 / 30;
export { broadcastEvery, TICK, type Command, type Seat, type Why } from "./engine/arena.ts";
/**
 * How many ticks apart the snapshots go out.
 *
 * The simulation runs at 30Hz and used to broadcast every other tick, which
 * gave the browser fifteen positions a second to draw sixty frames from —
 * not many, and with interpolation it also doubles the delay the drawing has
 * to sit behind the present. A small room gets every tick: it is the case
 * that matters (one or two people playing each other), the payload is a
 * couple of kilobytes of JSON a seat, and the arena only runs at all while
 * somebody is connected. Above that the cost multiplies by seats and the
 * older cadence comes back.
 */
export const broadcastEvery = (filled: number): number => (filled <= 2 ? 1 : 2);
export type Seat = {
  playerId: string;
  token: string;
  address: string;
  send: (data: string) => void;
  /** The scoreboard as this seat last received it, so it is only resent when it changes. */
  board: string;
};
let state: MatchState = newMatch();
const seats = new Map<string, Seat>();
// A session is a cookie, and a cookie costs one HTTP request — free for
// anyone to mint as many of as they like. The address is the one thing here
// a single machine cannot hand itself two of, so it is what a playing seat
// is actually rationed by; the session on top of it is only what lets a
// reload find its way back to the same seat rather than a fresh one.
const addressSeats = new Map<string, string>();
let ticks = 0;
const state: MatchState = newMatch();
let lastResult: string | null = null;
// The kill feed is read off the match a tick at a time; the rules keep no
// list of their own, and this is a view, not a rule.
let marks: Mark[] = marksOf(state.players);
let feed: Fall[] = [];
export const match = (): MatchState => state;
const round2 = (n: number): number => Math.round(n * 10) / 10;
export const findPlayer = (id: string): Player | undefined => state.players.find((p) => p.id === id);
/**
 * A name nobody else in this match is using.
 *
 * The kill feed, the round log and the scoreboard all address people by
 * name: two players called Kit make a line that reads as a team kill this
 * game cannot have. The bots are dealt distinct names; a person who picks
 * one that is taken gets a number after it, inside the sixteen characters a
 * name is allowed.
 */
function freeName(want: string, exceptId: string): string {
  const taken = new Set(state.players.filter((p) => p.id !== exceptId).map((p) => p.name));
  if (!taken.has(want)) return want;
  for (let n = 2; n < 100; n++) {
    const tried = `${want.slice(0, 13)} ${n}`;
    if (!taken.has(tried)) return tried;
  }
  return want;
}
/**
 * Whether this address already plays under a different session. Checked
 * before a socket is even offered a seat, so the caller can hand it a
 * spectator view instead of upgrading it into a second side's vision.
 */
export function addressCapped(address: string, session: string): boolean {
  const holder = addressSeats.get(address);
  return holder !== undefined && holder !== session;
}
/**
 * Sit somebody down in the emptiest team, replacing a bot where it stands.
 *
 * Both claims go in right here, synchronously, before the caller ever opens
 * a socket. A websocket upgrade completes on a later tick, so two requests
 * arriving close together both used to read the maps before either had
 * written to them — one client, two seats, opposite sides, the vision of
 * both. Claiming inline closes that window regardless of how the two
 * requests were related.
 */
export function takeSeat(address: string, session: string, name: string): Player | null {
  const existing = seats.get(session);
  const held = existing ? findPlayer(existing.playerId) : undefined;
  if (held) {
    held.name = freeName(name, held.id);
    return held;
  }
  if (addressCapped(address, session)) return null;
/** Sit in the emptiest team, on a bot's seat, keeping its body as it stands. */
function sit(state: MatchState): Player | null {
  const humans = { red: 0, blue: 0 };
  for (const player of state.players) if (!player.bot) humans[player.team] += 1;
  const wanted = humans.red <= humans.blue ? "red" : "blue";
  const seat =
    state.players.find((p) => p.bot && p.team === wanted) ?? state.players.find((p) => p.bot);
  const seat = state.players.find((p) => p.bot && p.team === wanted) ?? state.players.find((p) => p.bot);
  if (!seat) return null;
  seat.bot = false;
  seat.name = freeName(name, seat.id);
  seat.think = 0;
  seat.input = { mx: 0, my: 0, angle: seat.angle, fire: false, use: false, reload: false, cast: null };
  addressSeats.set(address, session);
  seats.set(session, { playerId: seat.id, token: "", address, send: () => {}, board: "" });
  return seat;
}
/** The socket that actually opened fills in how to reach it and its token. */
export function attach(session: string, playerId: string, address: string, token: string, send: (data: string) => void): void {
  seats.set(session, { playerId, token, address, send, board: "" });
/** The seat goes back to a bot, mid-round and all. */
function stand(_state: MatchState, player: Player): void {
  player.bot = true;
  player.think = 0;
  player.input.fire = false;
  player.input.use = false;
}
/**
 * A person leaving gives the seat back to a bot, mid-round and all — but only
 * if this is still the socket the session is on. A reload opens the new
 * socket before the old one's close event arrives; without the token, that
 * late close would delete the reconnect's seat entry and hand a live human's
 * seat to a bot mid-round.
 */
export function release(session: string, token: string): void {
  const seat = seats.get(session);
  if (!seat || seat.token !== token) return;
  seats.delete(session);
  if (addressSeats.get(seat.address) === session) addressSeats.delete(seat.address);
  const player = findPlayer(seat.playerId);
  if (player && !stillHeld(seat.playerId)) {
    player.bot = true;
    player.think = 0;
    player.input.fire = false;
    player.input.use = false;
  }
}
/**
 * Test-only hygiene: give back whatever this address currently holds. The
 * arena is one match shared by the whole test run, over real HTTP, from one
 * loopback address — this is how a test that needs that address free gets it
 * free, rather than depending on every other test in the file to clean up
 * after itself.
 */
export function releaseAddress(address: string): void {
  const session = addressSeats.get(address);
  if (session !== undefined) release(session, seats.get(session)?.token ?? "");
}
const stillHeld = (playerId: string): boolean =>
  [...seats.values()].some((s) => s.playerId === playerId);
export const seatCount = (): number => seats.size;
// -------------------------------------------------------------- spectators
// A connection that never carried a session the page minted gets no side and
// no seat: only the public state everyone already sees on the page itself.
const spectators = new Map<string, { send: (data: string) => void; why: Why }>();
/**
 * Why this connection is watching. The client says so in words, and the two
 * have different answers — open the tab that is playing, or let the page keep
 * its cookie — so which one it is travels with the snapshot.
 */
export type Why = "address" | "cookie" | "unsaid";
export function spectatorSnapshot(why: Why = "unsaid"): string {
  return JSON.stringify({
    t: "s",
    spectator: true,
    why,
    phase: state.phase,
    clock: round2(Math.max(0, state.clock)),
    round: state.round,
    score: state.score,
    attackers: state.attackers,
    result: state.result,
    last: state.last,
    events: state.events.slice(0, 5).map((e) => e.text),
    // Names and a gun, the same as a seat is sent, and for the same reason it
    // is safe there: the feed says what happened, never where.
    feed: feed.map((f) => ({
      k: f.killer,
      v: f.victim,
      w: f.weapon ? WEAPONS[f.weapon].name : null,
      h: f.headshot,
      t: round2(Math.max(0, state.now - f.at)),
    })),
  });
}
export function watch(token: string, send: (data: string) => void, why: Why = "unsaid"): void {
  spectators.set(token, { send, why });
  send(spectatorSnapshot(why));
}
export function unwatch(token: string): void {
  spectators.delete(token);
}
// ------------------------------------------------------------- the commands
export type Command = { t: string; [key: string]: unknown };
const num = (value: unknown): number | undefined =>
  typeof value === "number" && Number.isFinite(value) ? value : undefined;
/** Everything a client may ask for, validated here and nowhere else. */
export function command(playerId: string, message: Command): void {
  const player = findPlayer(playerId);
  if (!player || player.bot) return;
function runCommand(state: MatchState, player: Player, message: Command): void {
  switch (message.t) {
    case "i":
      setInput(player, {
@@ -260,36 +83,38 @@
export function command(playerId: string, message: Command): void {
  }
}
// ------------------------------------------------------------- the snapshot
// Names and a gun, never a position: the feed says what happened, not
// where, so it can never be read as a call-out.
const feedFor = (state: MatchState) =>
  feed.map((f) => ({
    k: f.killer,
    v: f.victim,
    w: f.weapon ? WEAPONS[f.weapon].name : null,
    h: f.headshot,
    t: round2(Math.max(0, state.now - f.at)),
  }));
const round2 = (n: number): number => Math.round(n * 10) / 10;
/** The full snapshot for one viewer, as one string. */
export const snapshot = (viewerId: string): string => JSON.stringify(snapshotFor(viewerId));
/**
 * The snapshot a seat is actually sent on this tick. The scoreboard — ten
 * names, agents and tallies — was almost half of every snapshot and changes
 * a few times a round, so it goes out only when it differs from what this
 * seat last received; the client keeps the one it has. Everything else is
 * the full snapshot, every time.
 */
export function snapshotForSeat(seat: Seat): string {
  const full = snapshotFor(seat.playerId);
  const board = JSON.stringify(full.board);
  if (board === seat.board) delete (full as { board?: unknown }).board;
  else seat.board = board;
  return JSON.stringify(full);
/** The public state everyone already sees on the page itself. */
function spectatorShape(state: MatchState, _why: Why) {
  return {
    phase: state.phase,
    clock: round2(Math.max(0, state.clock)),
    round: state.round,
    score: state.score,
    attackers: state.attackers,
    result: state.result,
    last: state.last,
    events: state.events.slice(0, 5).map((e) => e.text),
    feed: feedFor(state),
  };
}
function snapshotFor(viewerId: string) {
  const me = findPlayer(viewerId) ?? state.players[0]!;
/** The snapshot for one seat: `seen` is exactly who the arena says they may see. */
function snapshotShape(state: MatchState, me: Player, seen: Player[]) {
  const agent = agentById(me.agent);
  const seen = state.players.filter((p) => visible(state, me, p));
  const canSee = (point: Point): boolean => !sightBlocked(me, point, state.zones);
  return {
    t: "s",
    phase: state.phase,
    clock: round2(Math.max(0, state.clock)),
    round: state.round,
@@ -356,6 +181,9 @@
function snapshotFor(viewerId: string) {
    },
    orbs: state.orbs.filter((o) => !o.taken).map((o) => ({ x: o.x, y: o.y })),
    shots: state.shots.filter((s) => canSee({ x: s.x1, y: s.y1 }) || canSee({ x: s.x2, y: s.y2 })),
    // The scoreboard — ten names, agents and tallies — was almost half of
    // every snapshot and changes a few times a round, so the arena sends it
    // only when it differs from what the seat last received.
    board: state.players.map((p) => ({
      id: p.id,
      name: p.name,
@@ -372,15 +200,7 @@
function snapshotFor(viewerId: string) {
      ultNeeds: agentById(p.agent).abilities.x.points,
    })),
    events: state.events.slice(0, 5).map((e) => e.text),
    // Names and a gun, never a position: the feed says what happened, not
    // where, so it can never be read as a call-out.
    feed: feed.map((f) => ({
      k: f.killer,
      v: f.victim,
      w: f.weapon ? WEAPONS[f.weapon].name : null,
      h: f.headshot,
      t: round2(Math.max(0, state.now - f.at)),
    })),
    feed: feedFor(state),
  };
}
@@ -389,7 +209,7 @@
function snapshotFor(viewerId: string) {
 * killer stands is what tells a gun kill from an ability kill — the position
 * is used here and goes no further.
 */
function readFalls(): void {
function readFalls(state: MatchState): void {
  const after = marksOf(state.players);
  const shooters = new Set<string>();
  for (const shot of state.shots) {
@@ -407,77 +227,49 @@
function readFalls(): void {
  feed = trimFeed(feed, state.now);
}
// ----------------------------------------------------------------- the loop
/**
 * Nobody watching, nothing happens.
 *
 * The arena used to tick around the clock, so bots played out rounds for an
 * empty room — burning a share of a small box's CPU and filling the record
 * with matches no one saw. The world now freezes when the last connection
 * goes and carries on from exactly where it stopped when someone arrives, so
 * a visitor never finds a score that ran up while they were away.
 *
 * A spectator counts as somebody: watching is watching.
 */
const attended = (): boolean => seats.size > 0 || spectators.size > 0;
/** How many connections the arena is playing for: seats plus watchers. */
export const attendance = (): number => seats.size + spectators.size;
function step(): void {
  runBots(state, TICK);
  tick(state, TICK);
  readFalls();
/** One tick of this game: the bots, the rules, the feed, and the record. */
function step(state: MatchState, dt: number): void {
  runBots(state, dt);
  tick(state, dt);
  readFalls(state);
  if (state.result && state.result !== lastResult) {
    lastResult = state.result;
    recordResult(state.result, state.score.red, state.score.blue, state.round);
  }
  if (state.result === null) lastResult = null;
  ticks += 1;
  if (ticks % broadcastEvery(seats.size) !== 0) return;
  for (const seat of seats.values()) {
    try {
      seat.send(snapshotForSeat(seat));
    } catch {
      // A socket that will not take a frame is closed already; the close
      // handler gives the seat back.
    }
  }
  for (const spectator of spectators.values()) {
    try {
      spectator.send(spectatorSnapshot(spectator.why));
    } catch {
      // Same story: the close handler drops it from the set.
    }
  }
}
let timer: ReturnType<typeof setInterval> | null = null;
const arena = makeArena<MatchState, Player>({
  state,
  players: (s) => s.players,
  step,
  sit,
  stand,
  visible,
  snapshot: snapshotShape,
  sticky: "board",
  spectatorSnapshot: spectatorShape,
  command: runCommand,
});
/**
 * One beat of real time. The gate lives here rather than inside `step` so the
 * tests can still drive the simulation directly with `advance` — a test is an
 * attendance of its own, and making it prove otherwise would only teach the
 * suite to work around the rule.
 */
export function beat(): void {
  if (attended()) step();
}
export function startArena(): void {
  if (timer) return;
  timer = setInterval(beat, TICK * 1000);
  // The clock must never hold the process open on its own.
  (timer as unknown as { unref?: () => void }).unref?.();
}
export function stopArena(): void {
  if (timer) clearInterval(timer);
  timer = null;
}
/** Used by the tests: run the arena forward without waiting for real time. */
export function advance(seconds: number): void {
  for (let i = 0; i < Math.round(seconds / TICK); i++) step();
}
export const {
  match,
  findPlayer,
  addressCapped,
  takeSeat,
  attach,
  release,
  releaseAddress,
  seatCount,
  watch,
  unwatch,
  spectatorSnapshot,
  command,
  snapshot,
  snapshotForSeat,
  attendance,
  beat,
  advance,
} = arena;
export const startArena = arena.start;
export const stopArena = arena.stop;
@@ -8,7 +8,7 @@
 */
import { agentById, castable, flashDuration, sightBlocked, type Ability } from "./abilities.ts";
import { acquire, aimCone, canFire, crossRate, drift, heldFor, lose } from "./aim.ts";
import { acquire, aimCone, canFire, crossRate, drift, heldFor, lose } from "./engine/aim.ts";
import { pathStep, rayHitWall, siteAt, siteCentre, walkDistance, type Point, type Site } from "./map.ts";
import { buyAbility, buyShield, buyWeapon, random, RUN_SPEED, SPIKE_REACH, visible } from "./match.ts";
import type { MatchState, Player, Slot } from "./state.ts";
@@ -400,8 +400,8 @@
test("the bundled client connects, paints the HUD and draws a frame", async () =
  // the rule.
  // The lead is the cap plus the slack the guess is allowed over the answer
  // (predict.js LEAD_SLACK: the lag your own keys take to reach the server).
  const { moveSpeed } = await import("./glide.ts");
  const { LEAD_MAX, LEAD_SLACK } = await import("../static/predict.js");
  const { moveSpeed } = await import("./engine/glide.ts");
  const { LEAD_MAX, LEAD_SLACK } = await import("../static/engine/predict.js");
  expect(lead).toBeLessThan((LEAD_MAX + LEAD_SLACK) * moveSpeed(seat) + 10);
  expect(Math.abs(sideways)).toBeLessThan(6);
  // Nothing on the server moved: this is a drawing, and the match is still
@@ -0,0 +1,124 @@
/**
 * How a bot points a gun, tested as the pure maths it is. That the gate is
 * actually wired to a trigger is the game's to prove: `src/aim.test.ts`.
 */
import { expect, test } from "bun:test";
import {
  acquire,
  aimCone,
  canFire,
  CONE_FLOOR,
  crossRate,
  drift,
  emptyTrack,
  FORGET,
  heldFor,
  lose,
  REACTION_MAX,
  REACTION_MIN,
  reactionTime,
} from "./aim.ts";
const rolls = (...values: number[]) => {
  let at = 0;
  return () => values[at++ % values.length]!;
};
test("the reaction a bot draws is between 200 and 350ms, whatever the roll", () => {
  expect(reactionTime(0)).toBeCloseTo(REACTION_MIN, 9);
  expect(reactionTime(1)).toBeCloseTo(REACTION_MAX, 9);
  expect(reactionTime(0.5)).toBeCloseTo((REACTION_MIN + REACTION_MAX) / 2, 9);
  // A roll out of range is still a reaction, not a bot that never shoots.
  expect(reactionTime(-3)).toBe(REACTION_MIN);
  expect(reactionTime(9)).toBe(REACTION_MAX);
});
test("the trigger gate is a pure function of when acquisition happened", () => {
  const track = emptyTrack();
  // Nothing in sight is never a shot, however long the round has run.
  expect(canFire(track, 100)).toBe(false);
  acquire(track, "bot-red-1", 10, { x: 0, y: 0 }, rolls(0, 0.5));
  expect(track.reaction).toBeCloseTo(REACTION_MIN, 9);
  expect(canFire(track, 10)).toBe(false);
  expect(canFire(track, 10.19)).toBe(false);
  expect(canFire(track, 10.21)).toBe(true);
  expect(canFire(track, 12)).toBe(true);
  expect(heldFor(track, 12)).toBeCloseTo(2, 9);
});
test("a new target starts the reaction again; the same one does not", () => {
  const track = emptyTrack();
  acquire(track, "one", 5, { x: 100, y: 100 }, rolls(1, 0.5));
  expect(track.since).toBe(5);
  acquire(track, "one", 5.3, { x: 180, y: 100 }, rolls(0, 0.5));
  expect(track.since).toBe(5); // the hold carries on
  expect(canFire(track, 5.4)).toBe(true);
  acquire(track, "two", 5.4, { x: 0, y: 0 }, rolls(0, 0.5));
  expect(track.since).toBe(5.4); // swinging onto somebody else costs again
  expect(canFire(track, 5.5)).toBe(false);
});
test("a hold survives a blink out of sight, and no longer", () => {
  const track = emptyTrack();
  acquire(track, "one", 1, { x: 0, y: 0 }, rolls(0, 0.5));
  lose(track, 1 + FORGET / 2);
  expect(track.id).toBe("one");
  // Back a moment later: the same hold, already through its reaction.
  acquire(track, "one", 1 + FORGET / 2, { x: 0, y: 0 }, rolls(0, 0.5));
  expect(track.since).toBe(1);
  // Gone for longer than that and it is a fresh acquisition.
  lose(track, 3);
  expect(track.id).toBe(null);
  acquire(track, "one", 3, { x: 0, y: 0 }, rolls(0, 0.5));
  expect(track.since).toBe(3);
  expect(canFire(track, 3.1)).toBe(false);
});
test("the cone starts wide, settles the longer one target is held, and never closes", () => {
  const swing = aimCone(0, 0);
  const second = aimCone(1, 0);
  const settled = aimCone(3, 0);
  expect(swing).toBeGreaterThan(0.08); // several degrees on the swing
  expect(second).toBeLessThan(swing / 2);
  expect(settled).toBeLessThan(second);
  expect(settled).toBeGreaterThanOrEqual(CONE_FLOOR);
  expect(aimCone(99, 0)).toBeCloseTo(CONE_FLOOR, 6);
});
test("a target crossing the view costs the bot accuracy", () => {
  expect(aimCone(3, 1)).toBeGreaterThan(aimCone(3, 0) * 3);
  expect(aimCone(3, 0.5)).toBeGreaterThan(aimCone(3, 0));
  expect(aimCone(3, 0.5)).toBeLessThan(aimCone(3, 1));
  // Nonsense from the caller is clamped, not multiplied out.
  expect(aimCone(3, 50)).toBeCloseTo(aimCone(3, 1), 9);
});
test("crossing is measured across the sight line, not along it", () => {
  const bot = { x: 0, y: 0 };
  const walking = emptyTrack();
  acquire(walking, "t", 0, { x: 300, y: 0 }, rolls(0, 0.5));
  // Straight down the barrel: nothing to track.
  expect(crossRate(walking, bot, { x: 260, y: 0 }, 0.1)).toBeCloseTo(0, 6);
  const strafing = emptyTrack();
  acquire(strafing, "t", 0, { x: 300, y: 0 }, rolls(0, 0.5));
  // Straight across it at a run: all of it but the turn of the sight line.
  expect(crossRate(strafing, bot, { x: 300, y: 25 }, 0.1)).toBeCloseTo(250, -1);
  // And it remembers where the target went, so the next tick measures again.
  expect(crossRate(strafing, bot, { x: 300, y: 25 }, 0.1)).toBeCloseTo(0, 6);
});
test("the error wanders inside the cone instead of being redrawn every tick", () => {
  const track = emptyTrack();
  acquire(track, "one", 0, { x: 0, y: 0 }, rolls(0, 1));
  // Drawn at the edge of the swing cone on acquisition.
  expect(Math.abs(track.error)).toBeCloseTo(aimCone(0, 0), 9);
  // One tick moves it a little, not to somewhere unrelated.
  const before = track.error;
  const after = drift(track, aimCone(0, 0), 1 / 30, rolls(0.9));
  expect(Math.abs(after - before)).toBeLessThan(aimCone(0, 0) / 4);
  // And it is squeezed toward the barrel as the cone closes around it.
  for (let i = 0; i < 90; i++) drift(track, aimCone(3, 0), 1 / 30, rolls(0.5, 1, 0));
  expect(Math.abs(track.error)).toBeLessThanOrEqual(aimCone(3, 0) + 1e-12);
});
@@ -0,0 +1,143 @@
/**
 * 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() {
  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",
    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("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: () => {}, board: "" };
  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);
});
@@ -0,0 +1,332 @@
/**
 * The shape of a served match: one world, always running while somebody is
 * connected, and the seats people sit in.
 *
 * Nothing here knows what the game is. The game hands over its state and a
 * handful of answers — how to step it, who is in it, what one viewer may see
 * and what a snapshot looks like — and this module keeps the rules every
 * served game needs and none should re-derive:
 *
 * - The idle gate: nobody watching, nothing happens. The world freezes when
 *   the last connection goes and carries on when someone arrives.
 * - A playing seat is rationed by address, not by cookie: a cookie costs one
 *   HTTP request, an address is the one thing a machine cannot mint two of.
 *   Both claims go in synchronously, before a socket is ever offered a seat.
 * - A connection with no seat watches: it is sent the public state and no
 *   position in it.
 * - Every snapshot is built for one viewer, from the bodies the game says
 *   that viewer can see. The client never learns a position it has no line
 *   of sight to.
 */
export const TICK = 1 / 30;
/**
 * How many ticks apart the snapshots go out.
 *
 * The simulation runs at 30Hz. A small room gets every tick: it is the case
 * that matters (one or two people playing each other), the payload is a
 * couple of kilobytes of JSON a seat, and the arena only runs at all while
 * somebody is connected. Above that the cost multiplies by seats and the
 * older cadence — every other tick — comes back.
 */
export const broadcastEvery = (filled: number): number => (filled <= 2 ? 1 : 2);
export type Seat = {
  playerId: string;
  token: string;
  address: string;
  send: (data: string) => void;
  /** The sticky part of the snapshot as this seat last received it, so it is only resent when it changes. */
  board: string;
};
/**
 * Why this connection is watching. The client says so in words, and the two
 * have different answers — open the tab that is playing, or let the page keep
 * its cookie — so which one it is travels with the snapshot.
 */
export type Why = "address" | "cookie" | "unsaid";
export type Command = { t: string; [key: string]: unknown };
/** What the arena needs of a body: a way to find it, address it, and tell a bot from a person. */
export type Body = { id: string; name: string; bot: boolean };
/** The game, as the arena sees it. */
export type Game<S, P extends Body> = {
  /** The one world. Mutated in place; the arena never replaces it. */
  state: S;
  players: (state: S) => P[];
  /** One fixed step of the world, bots and rules and all. */
  step: (state: S, dt: number) => void;
  /** Hand a bot's seat to a person: the same body, made human. Null when there is none. */
  sit: (state: S) => P | null;
  /** Give a seat back to a bot. */
  stand: (state: S, player: P) => void;
  /** May this viewer be sent this body? The server's answer, never the client's. */
  visible: (state: S, viewer: P, other: P) => boolean;
  /** The snapshot for one viewer, given exactly the bodies they may see. */
  snapshot: (state: S, viewer: P, seen: P[]) => Record<string, unknown>;
  /**
   * A field of the snapshot resent only when it differs from what the seat
   * last received; the client keeps the one it has. Null sends everything.
   */
  sticky: string | null;
  /** The public view for a connection with no seat. Must carry no position. */
  spectatorSnapshot: (state: S, why: Why) => Record<string, unknown>;
  /** Everything a client may ask for, validated by the game and nowhere else. */
  command: (state: S, player: P, message: Command) => void;
};
export function makeArena<S, P extends Body>(game: Game<S, P>) {
  const state = game.state;
  const seats = new Map<string, Seat>();
  // A session is a cookie, and a cookie costs one HTTP request — free for
  // anyone to mint as many of as they like. The address is the one thing here
  // a single machine cannot hand itself two of, so it is what a playing seat
  // is actually rationed by; the session on top of it is only what lets a
  // reload find its way back to the same seat rather than a fresh one.
  const addressSeats = new Map<string, string>();
  let ticks = 0;
  const match = (): S => state;
  const findPlayer = (id: string): P | undefined => game.players(state).find((p) => p.id === id);
  /**
   * A name nobody else in this match is using. Two players under one name
   * make a feed line that reads as a team kill; a person who picks a taken
   * name gets a number after it, inside the sixteen characters a name is
   * allowed.
   */
  function freeName(want: string, exceptId: string): string {
    const taken = new Set(
      game
        .players(state)
        .filter((p) => p.id !== exceptId)
        .map((p) => p.name),
    );
    if (!taken.has(want)) return want;
    for (let n = 2; n < 100; n++) {
      const tried = `${want.slice(0, 13)} ${n}`;
      if (!taken.has(tried)) return tried;
    }
    return want;
  }
  /**
   * Whether this address already plays under a different session. Checked
   * before a socket is even offered a seat, so the caller can hand it a
   * spectator view instead of upgrading it into a second side's vision.
   */
  function addressCapped(address: string, session: string): boolean {
    const holder = addressSeats.get(address);
    return holder !== undefined && holder !== session;
  }
  /**
   * Sit somebody down, replacing a bot where it stands.
   *
   * Both claims go in right here, synchronously, before the caller ever opens
   * a socket. A websocket upgrade completes on a later tick, so two requests
   * arriving close together both used to read the maps before either had
   * written to them — one client, two seats, opposite sides, the vision of
   * both. Claiming inline closes that window regardless of how the two
   * requests were related.
   */
  function takeSeat(address: string, session: string, name: string): P | null {
    const existing = seats.get(session);
    const held = existing ? findPlayer(existing.playerId) : undefined;
    if (held) {
      held.name = freeName(name, held.id);
      return held;
    }
    if (addressCapped(address, session)) return null;
    const seat = game.sit(state);
    if (!seat) return null;
    seat.name = freeName(name, seat.id);
    addressSeats.set(address, session);
    seats.set(session, { playerId: seat.id, token: "", address, send: () => {}, board: "" });
    return seat;
  }
  /** The socket that actually opened fills in how to reach it and its token. */
  function attach(session: string, playerId: string, address: string, token: string, send: (data: string) => void): void {
    seats.set(session, { playerId, token, address, send, board: "" });
  }
  const stillHeld = (playerId: string): boolean => [...seats.values()].some((s) => s.playerId === playerId);
  /**
   * A person leaving gives the seat back to a bot, mid-round and all — but only
   * if this is still the socket the session is on. A reload opens the new
   * socket before the old one's close event arrives; without the token, that
   * late close would delete the reconnect's seat entry and hand a live human's
   * seat to a bot mid-round.
   */
  function release(session: string, token: string): void {
    const seat = seats.get(session);
    if (!seat || seat.token !== token) return;
    seats.delete(session);
    if (addressSeats.get(seat.address) === session) addressSeats.delete(seat.address);
    const player = findPlayer(seat.playerId);
    if (player && !stillHeld(seat.playerId)) game.stand(state, player);
  }
  /**
   * Test-only hygiene: give back whatever this address currently holds. The
   * arena is one match shared by the whole test run, over real HTTP, from one
   * loopback address — this is how a test that needs that address free gets it
   * free, rather than depending on every other test in the file to clean up
   * after itself.
   */
  function releaseAddress(address: string): void {
    const session = addressSeats.get(address);
    if (session !== undefined) release(session, seats.get(session)?.token ?? "");
  }
  const seatCount = (): number => seats.size;
  // ------------------------------------------------------------ spectators
  // A connection that never carried a session the page minted gets no side and
  // no seat: only the public state everyone already sees on the page itself.
  const spectators = new Map<string, { send: (data: string) => void; why: Why }>();
  const spectatorSnapshot = (why: Why = "unsaid"): string =>
    JSON.stringify({ t: "s", spectator: true, why, ...game.spectatorSnapshot(state, why) });
  function watch(token: string, send: (data: string) => void, why: Why = "unsaid"): void {
    spectators.set(token, { send, why });
    send(spectatorSnapshot(why));
  }
  function unwatch(token: string): void {
    spectators.delete(token);
  }
  // ----------------------------------------------------------- the commands
  function command(playerId: string, message: Command): void {
    const player = findPlayer(playerId);
    if (!player || player.bot) return;
    game.command(state, player, message);
  }
  // ----------------------------------------------------------- the snapshot
  function snapshotFor(viewerId: string): Record<string, unknown> {
    const players = game.players(state);
    const me = findPlayer(viewerId) ?? players[0]!;
    const seen = players.filter((p) => game.visible(state, me, p));
    return { t: "s", ...game.snapshot(state, me, seen) };
  }
  /** The full snapshot for one viewer, as one string. */
  const snapshot = (viewerId: string): string => JSON.stringify(snapshotFor(viewerId));
  /**
   * The snapshot a seat is actually sent on this tick: everything, every time,
   * except the sticky field, which goes out only when it differs from what
   * this seat last received.
   */
  function snapshotForSeat(seat: Seat): string {
    const full = snapshotFor(seat.playerId);
    if (game.sticky !== null) {
      const part = JSON.stringify(full[game.sticky]);
      if (part === seat.board) delete full[game.sticky];
      else seat.board = part;
    }
    return JSON.stringify(full);
  }
  // --------------------------------------------------------------- the loop
  /**
   * Nobody watching, nothing happens.
   *
   * An arena that ticks around the clock plays out rounds for an empty room —
   * burning a share of a small box's CPU and filling the record with matches
   * no one saw. The world freezes when the last connection goes and carries on
   * from exactly where it stopped when someone arrives, so a visitor never
   * finds a score that ran up while they were away.
   *
   * A spectator counts as somebody: watching is watching.
   */
  const attended = (): boolean => seats.size > 0 || spectators.size > 0;
  /** How many connections the arena is playing for: seats plus watchers. */
  const attendance = (): number => seats.size + spectators.size;
  function step(): void {
    game.step(state, TICK);
    ticks += 1;
    if (ticks % broadcastEvery(seats.size) !== 0) return;
    for (const seat of seats.values()) {
      try {
        seat.send(snapshotForSeat(seat));
      } catch {
        // A socket that will not take a frame is closed already; the close
        // handler gives the seat back.
      }
    }
    for (const spectator of spectators.values()) {
      try {
        spectator.send(spectatorSnapshot(spectator.why));
      } catch {
        // Same story: the close handler drops it from the set.
      }
    }
  }
  let timer: ReturnType<typeof setInterval> | null = null;
  /**
   * One beat of real time. The gate lives here rather than inside `step` so the
   * tests can still drive the simulation directly with `advance` — a test is an
   * attendance of its own, and making it prove otherwise would only teach the
   * suite to work around the rule.
   */
  function beat(): void {
    if (attended()) step();
  }
  function start(): void {
    if (timer) return;
    timer = setInterval(beat, TICK * 1000);
    // The clock must never hold the process open on its own.
    (timer as unknown as { unref?: () => void }).unref?.();
  }
  function stop(): void {
    if (timer) clearInterval(timer);
    timer = null;
  }
  /** Used by the tests: run the arena forward without waiting for real time. */
  function advance(seconds: number): void {
    for (let i = 0; i < Math.round(seconds / TICK); i++) step();
  }
  return {
    match,
    findPlayer,
    addressCapped,
    takeSeat,
    attach,
    release,
    releaseAddress,
    seatCount,
    watch,
    unwatch,
    spectatorSnapshot,
    command,
    snapshot,
    snapshotForSeat,
    attendance,
    beat,
    start,
    stop,
    advance,
  };
}
@@ -0,0 +1,88 @@
/**
 * The property that makes the engine folders copyable at all: nothing under
 * `src/engine/` or `static/engine/` imports anything outside them. A module
 * that reached for the game's map, agents or match would come along with the
 * copy and bring the whole game with it.
 *
 * Tests count: an engine test that needs the game to run is a test the next
 * game cannot take with it.
 */
import { expect, test } from "bun:test";
import { readdirSync, readFileSync } from "node:fs";
import { dirname, join, resolve } from "node:path";
const ROOT = resolve(import.meta.dir, "..", "..");
const ENGINE = [join(ROOT, "src", "engine"), join(ROOT, "static", "engine")];
const inEngine = (path: string): boolean => ENGINE.some((dir) => resolve(path).startsWith(dir + "/"));
/** Every import specifier in a file: static, re-exported, or dynamic. */
function importsOf(source: string): string[] {
  const out: string[] = [];
  for (const match of source.matchAll(/^\s*(?:import|export)\b[^;]*?\bfrom\s+["']([^"']+)["']/gm)) out.push(match[1]!);
  for (const match of source.matchAll(/\bimport\(\s*["']([^"']+)["']\s*\)/g)) out.push(match[1]!);
  return out;
}
const files = ENGINE.flatMap((dir) =>
  readdirSync(dir)
    .filter((name) => /\.(ts|js)$/.test(name))
    .map((name) => join(dir, name)),
);
test("the engine folders exist and hold the pieces a game stands on", () => {
  const names = files.map((f) => f.split("/").slice(-2).join("/"));
  for (const need of [
    "engine/glide.ts",
    "engine/aim.ts",
    "engine/grid.ts",
    "engine/arena.ts",
    "engine/interp.js",
    "engine/predict.js",
    "engine/presence.js",
    "engine/yaw.js",
    "engine/steer.js",
    "engine/raycast.js",
    "engine/scene.js",
    "engine/slices.js",
    "engine/resolution.js",
    "engine/budget.js",
    "engine/topdown.js",
    "engine/gun.js",
  ])
    expect(names).toContain(need);
});
test("no engine module, and no engine test, imports a game module", () => {
  const crossings: string[] = [];
  for (const file of files) {
    for (const spec of importsOf(readFileSync(file, "utf8"))) {
      if (/^(bun|node):/.test(spec)) continue;
      if (!spec.startsWith(".")) {
        crossings.push(`${file}: ${spec} (a package)`);
        continue;
      }
      const target = resolve(dirname(file), spec);
      if (!inEngine(target)) crossings.push(`${file.slice(ROOT.length + 1)} -> ${spec}`);
    }
  }
  expect(crossings).toEqual([]);
});
test("the engine does not know what a spike is", () => {
  // The words of this game. An engine file that says one of them has a hole
  // that should have been a parameter.
  const words = /\b(spike|agent|credits|molly|defus\w*|plant\w*|orb|valorant)\b/i;
  const said: string[] = [];
  for (const file of files) {
    if (file.endsWith(".test.ts")) continue;
    const source = readFileSync(file, "utf8")
      // Comments may explain things by example; the code may not.
      .replace(/\/\*[\s\S]*?\*\//g, "")
      .replace(/\/\/.*$/gm, "");
    const hit = source.match(words);
    if (hit) said.push(`${file.slice(ROOT.length + 1)}: ${hit[0]}`);
  }
  expect(said).toEqual([]);
});
@@ -5,7 +5,7 @@
 */
import { expect, test } from "bun:test";
import { FAST, makeBudget, measure, PATIENCE, SLOW, WINDOW } from "../static/budget.js";
import { FAST, makeBudget, measure, PATIENCE, SLOW, WINDOW } from "../../static/engine/budget.js";
/** `seconds` of frames, each `ms` long, and how many times the level moved. */
function run(budget: ReturnType<typeof makeBudget>, ms: number, seconds: number, from = 0) {
@@ -6,7 +6,6 @@
import { expect, test } from "bun:test";
import { BODY_R, circleBlocked, moveSpeed, RUN, slideCircle } from "./glide.ts";
import { moveCircle } from "./map.ts";
const TILE = 80;
// A room with solid walls, open from (1,1) to (3,3).
@@ -93,14 +92,6 @@
test("a step never ends inside a wall, from anywhere in the room", () => {
      }
});
test("the real map moves by the same maths", () => {
  // Mid, walking east into whatever is there: the map's own binding.
  const to = moveCircle(1200, 640, 9, 0, BODY_R);
  expect(to.x).toBeGreaterThanOrEqual(1200);
  expect(to.x).toBeLessThanOrEqual(1209);
  expect(to.y).toBe(640);
});
test("speed is the one table both sides read", () => {
  expect(moveSpeed({})).toBe(RUN);
  expect(moveSpeed({ haste: true })).toBeCloseTo(RUN * 1.35, 9);
@@ -0,0 +1,224 @@
/**
 * A tile grid and the questions everything else asks of it: which tiles are
 * solid, where a circle slides to, whether a wall stands between two points,
 * where a ray stops, and how far a walk is.
 *
 * The grid is rows of letters. `#` is a wall; every other letter is floor,
 * and what a letter means beyond that is the game's business — this module
 * hands back the cells of a letter and never asks what they are for.
 *
 * `makeGrid` binds the maths to one set of rows and one tile size. The
 * collision itself is `glide.ts`, which the browser runs too; the walk
 * distances are cached per goal for the round and cleared by the caller.
 */
import { circleBlocked, slideCircle } from "./glide.ts";
export type Point = { x: number; y: number };
export type Grid = {
  lines: string[];
  cols: number;
  rows: number;
  tile: number;
  width: number;
  height: number;
  /** The letter at a tile; anything off the grid is a wall. */
  at: (col: number, row: number) => string;
  solidTile: (col: number, row: number) => boolean;
  tileOf: (x: number, y: number) => { col: number; row: number };
  centreOf: (col: number, row: number) => Point;
  solidAt: (x: number, y: number) => boolean;
  /** The letter under a point. */
  cellAt: (x: number, y: number) => string;
  /** The centres of every tile carrying this letter, row by row. */
  cellsOf: (mark: string) => Point[];
  /** Slide a circle through this grid. */
  moveCircle: (x: number, y: number, dx: number, dy: number, r: number) => Point;
  /** True when a circle at (x,y) overlaps any solid tile. */
  blockedCircle: (x: number, y: number, r: number) => boolean;
  wallBetween: (a: Point, b: Point) => boolean;
  rayHitWall: (from: Point, angle: number, range: number) => Point;
  walkDistance: (from: Point, to: Point) => number;
  pathStep: (from: Point, to: Point) => Point;
  clearPaths: () => void;
};
/** Closest approach of a segment to a point, as distance and travel along it. */
export function segmentPoint(a: Point, b: Point, p: Point): { dist: number; travel: number } {
  const dx = b.x - a.x;
  const dy = b.y - a.y;
  const len2 = dx * dx + dy * dy;
  const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2));
  const cx = a.x + dx * t;
  const cy = a.y + dy * t;
  return { dist: Math.hypot(p.x - cx, p.y - cy), travel: t * Math.sqrt(len2) };
}
export const segmentHitsCircle = (a: Point, b: Point, c: Point, r: number): boolean =>
  segmentPoint(a, b, c).dist <= r;
const STEPS = [
  [1, 0],
  [-1, 0],
  [0, 1],
  [0, -1],
] as const;
export function makeGrid(lines: string[], tile: number): Grid {
  const cols = lines[0]!.length;
  const rows = lines.length;
  const at = (col: number, row: number): string =>
    row < 0 || row >= rows || col < 0 || col >= cols ? "#" : lines[row]![col]!;
  const solidTile = (col: number, row: number): boolean => at(col, row) === "#";
  const tileOf = (x: number, y: number): { col: number; row: number } => ({
    col: Math.floor(x / tile),
    row: Math.floor(y / tile),
  });
  const centreOf = (col: number, row: number): Point => ({
    x: col * tile + tile / 2,
    y: row * tile + tile / 2,
  });
  const solidAt = (x: number, y: number): boolean => {
    const t = tileOf(x, y);
    return solidTile(t.col, t.row);
  };
  const cellAt = (x: number, y: number): string => {
    const t = tileOf(x, y);
    return at(t.col, t.row);
  };
  const cellsOf = (mark: string): Point[] => {
    const out: Point[] = [];
    for (let row = 0; row < rows; row++)
      for (let col = 0; col < cols; col++) if (at(col, row) === mark) out.push(centreOf(col, row));
    return out;
  };
  const moveCircle = (x: number, y: number, dx: number, dy: number, r: number): Point =>
    slideCircle(x, y, dx, dy, r, solidTile, tile);
  const blockedCircle = (x: number, y: number, r: number): boolean => circleBlocked(x, y, r, solidTile, tile);
  /**
   * Does a wall stand between two points? Sampled every third of a tile: a
   * wall is a whole tile thick, so nothing is ever stepped over.
   */
  function wallBetween(a: Point, b: Point): boolean {
    const dx = b.x - a.x;
    const dy = b.y - a.y;
    const dist = Math.hypot(dx, dy);
    const steps = Math.ceil(dist / (tile / 3));
    for (let i = 1; i < steps; i++) {
      const t = i / steps;
      if (solidAt(a.x + dx * t, a.y + dy * t)) return true;
    }
    return false;
  }
  /** Where a shot stops: the first wall along the ray, or its full range. */
  function rayHitWall(from: Point, angle: number, range: number): Point {
    const dx = Math.cos(angle);
    const dy = Math.sin(angle);
    const step = tile / 4;
    for (let d = step; d <= range; d += step) {
      const x = from.x + dx * d;
      const y = from.y + dy * d;
      if (solidAt(x, y)) return { x: from.x + dx * (d - step), y: from.y + dy * (d - step) };
    }
    return { x: from.x + dx * range, y: from.y + dy * range };
  }
  // Walk distance from a goal tile, breadth-first over floor. Bots ask for it
  // every few ticks; the field for a goal is built once and kept for the round.
  const fields = new Map<number, Int32Array>();
  const clearPaths = (): void => void fields.clear();
  function field(goalCol: number, goalRow: number): Int32Array {
    const key = goalRow * cols + goalCol;
    const cached = fields.get(key);
    if (cached) return cached;
    const dist = new Int32Array(cols * rows).fill(-1);
    if (!solidTile(goalCol, goalRow)) {
      dist[key] = 0;
      const queue: number[] = [key];
      for (let head = 0; head < queue.length; head++) {
        const here = queue[head]!;
        const col = here % cols;
        const row = (here - col) / cols;
        const d = dist[here]!;
        for (const [dc, dr] of STEPS) {
          const nc = col + dc;
          const nr = row + dr;
          if (nc < 0 || nc >= cols || nr < 0 || nr >= rows) continue;
          const nk = nr * cols + nc;
          if (dist[nk] !== -1 || solidTile(nc, nr)) continue;
          dist[nk] = d + 1;
          queue.push(nk);
        }
      }
    }
    if (fields.size > 64) fields.clear();
    fields.set(key, dist);
    return dist;
  }
  /** Walk distance in tiles between two points, or -1 when unreachable. */
  function walkDistance(from: Point, to: Point): number {
    const f = tileOf(from.x, from.y);
    const g = tileOf(to.x, to.y);
    return field(g.col, g.row)[f.row * cols + f.col] ?? -1;
  }
  /**
   * The next point to walk toward on the way to a goal: the centre of the
   * neighbouring tile that is one step closer, so a walker rounds corners
   * instead of grinding into them.
   */
  function pathStep(from: Point, to: Point): Point {
    const f = tileOf(from.x, from.y);
    const g = tileOf(to.x, to.y);
    if (f.col === g.col && f.row === g.row) return to;
    const dist = field(g.col, g.row);
    const here = dist[f.row * cols + f.col] ?? -1;
    if (here <= 0) return to;
    let best: Point | null = null;
    let bestD = here;
    for (const [dc, dr] of STEPS) {
      const nc = f.col + dc;
      const nr = f.row + dr;
      if (nc < 0 || nc >= cols || nr < 0 || nr >= rows) continue;
      const d = dist[nr * cols + nc] ?? -1;
      if (d !== -1 && d < bestD) {
        bestD = d;
        best = centreOf(nc, nr);
      }
    }
    // Straight to the goal when nothing stands in the way — smoother than
    // walking tile centre to tile centre down an open corridor.
    if (best && !wallBetween(from, to) && (walkDistance(from, to) ?? 99) < 6) return to;
    return best ?? to;
  }
  return {
    lines,
    cols,
    rows,
    tile,
    width: cols * tile,
    height: rows * tile,
    at,
    solidTile,
    tileOf,
    centreOf,
    solidAt,
    cellAt,
    cellsOf,
    moveCircle,
    blockedCircle,
    wallBetween,
    rayHitWall,
    walkDistance,
    pathStep,
    clearPaths,
  };
}
@@ -1,5 +1,5 @@
import { expect, test } from "bun:test";
import { fade, firedNow, gunFire, gunSnapshot, gunTick, hitMarked, makeGun } from "../static/gun.js";
import { fade, firedNow, gunFire, gunSnapshot, gunTick, hitMarked, makeGun } from "../../static/engine/gun.js";
const snap = (over: Record<string, unknown> = {}, shots: unknown[] = []) => ({
  me: { x: 100, y: 100, ammo: 25, reloading: false, alive: true, ...over },
@@ -9,7 +9,7 @@
 */
import { expect, test } from "bun:test";
import { arrive, bodyAt, delay, feed, GONE, LAG, LAG_MAX, LAG_MIN, makeTimeline, sample } from "../static/interp.js";
import { arrive, bodyAt, delay, feed, GONE, LAG, LAG_MAX, LAG_MIN, makeTimeline, sample } from "../../static/engine/interp.js";
type Mark = { t: number; x: number; y: number; angle: number };
const pair = (a: Mark, b: Mark) => [a, b];
@@ -165,66 +165,3 @@
test("the moment being drawn is always bracketed by samples on hand", () => {
});
// --------------------------------------------- against the real simulation
/**
 * The match's own motion, sampled at the rate the server broadcasts it and
 * drawn at the rate a browser draws: what a bot walking across the map
 * actually looks like. The samples carry exactly what a snapshot carries —
 * a position rounded to a tenth, thirty times a second.
 *
 * The measure is the spread of the per-frame steps. A body drawn at the
 * server's speed takes even steps; the exponential chase this replaced took
 * a long step just after each snapshot and shorter ones after it, which is
 * choppiness with a number on it — twice this spread, measured the same way.
 */
test("the simulation's own motion is drawn at an even speed", async () => {
  const { runBots } = await import("./bots.ts");
  const { newMatch, tick } = await import("./match.ts");
  const round2 = (n: number) => Math.round(n * 10) / 10;
  // A match of its own: nothing here touches the arena everybody shares.
  const state = newMatch();
  const step = () => {
    runBots(state, 1 / 30);
    tick(state, 1 / 30);
  };
  for (let i = 0; i < 30 * 40 && state.phase !== "live"; i++) step();
  const stream: { t: number; bodies: { id: string; x: number; y: number; angle: number }[] }[] = [];
  for (let i = 0; i < 60; i++) {
    step();
    stream.push({
      t: i / 30,
      bodies: state.players.map((p) => ({ id: p.id, x: round2(p.x), y: round2(p.y), angle: round2(p.angle) })),
    });
  }
  const timeline = makeTimeline();
  const paths = new Map<string, { x: number; y: number }[]>();
  let next = 0;
  for (let f = 0; f / 60 < 1.8; f++) {
    const now = f / 60;
    while (next < stream.length && stream[next]!.t <= now) {
      arrive(timeline, stream[next]!.t);
      for (const p of stream[next]!.bodies) feed(timeline, p.id, p, stream[next]!.t);
      next += 1;
    }
    for (const p of stream[Math.max(0, next - 1)]!.bodies) {
      const at = bodyAt(timeline, p, now - delay(timeline));
      paths.set(p.id, [...(paths.get(p.id) ?? []), { x: at.x, y: at.y }]);
    }
  }
  // Whoever walked furthest in that second and a half.
  const walked = [...paths.values()]
    .filter((path) => path.length > 80)
    .map((path) => path.slice(1).map((at, i) => Math.hypot(at.x - path[i]!.x, at.y - path[i]!.y)))
    .map((steps) => steps.filter((step) => step > 0.001))
    .sort((a, b) => b.reduce((s, x) => s + x, 0) - a.reduce((s, x) => s + x, 0))[0]!;
  expect(walked.length).toBeGreaterThan(30);
  const mean = walked.reduce((s, x) => s + x, 0) / walked.length;
  const spread = Math.sqrt(walked.reduce((s, x) => s + (x - mean) ** 2, 0) / walked.length) / mean;
  // A body moving at the server's own speed: about four units every sixtieth
  // of a second, which is the run speed.
  expect(mean * 60).toBeGreaterThan(150);
  expect(spread).toBeLessThan(0.15);
});
@@ -5,11 +5,36 @@
import { expect, test } from "bun:test";
import { BODY_R, moveSpeed } from "./glide.ts";
import { moveCircle, solidTile, TILE } from "./map.ts";
import { advance, anchor, holdBack, insideWall, LEAD_MAX, makeLocal, project, reconcile, SNAP } from "../static/predict.js";
import { makeGrid } from "./grid.ts";
import { advance, anchor, holdBack, insideWall, LEAD_MAX, makeLocal, project, reconcile, SNAP } from "../../static/engine/predict.js";
// The world the browser builds out of map.json, which is the map the server
// plays on: the same rows, the same tile, the same body.
// A map of the shape a served one has: an outer wall, rooms, pillars and a
// corridor, bound to the same grid the server plays on. The browser builds
// the same world out of map.json: the same rows, the same tile, the same body.
const TILE = 80;
const ROWS = [
  "##############################",
  "#........###......###........#",
  "#........###......###........#",
  "#........##........##........#",
  "#........##.#....#.##........#",
  "#........##........##........#",
  "#...##......#....#......##...#",
  "#..####....#......#....####..#",
  "#..####..###......###..####..#",
  "#..####..####....####..####..#",
  "#..####..####.##.####..####..#",
  "#........####.##.####........#",
  "#..####..####....####..####..#",
  "#..####..#####..#####..####..#",
  "#..####..#####..#####..####..#",
  "#..####..###......###..####..#",
  "#........##........##........#",
  "#............................#",
  "##############################",
];
const grid = makeGrid(ROWS, TILE);
const { moveCircle, solidTile } = grid;
const world = { solid: solidTile, tile: TILE, r: BODY_R };
test("nothing is drawn until the server has said where you are", () => {
@@ -38,11 +63,11 @@
test("a frame of movement is the speed it was given, in the direction it was giv
});
test("the guess resolves a wall exactly the way the server does", () => {
  // Every open tile of the real map, walked into from eight directions: the
  // Every open tile of the map, walked into from eight directions: the
  // browser's step and the server's land in the same place, or the camera
  // spends the round being dragged off whatever it guessed.
  const rows = 19;
  const cols = 30;
  const rows = grid.rows;
  const cols = grid.cols;
  let tried = 0;
  for (let row = 1; row < rows - 1; row++)
    for (let col = 1; col < cols - 1; col++) {
@@ -18,7 +18,7 @@
import {
  slide,
  SMALL,
  swell,
} from "../static/presence.js";
} from "../../static/engine/presence.js";
const body = (over: Record<string, unknown> = {}) => ({
  id: "them",
@@ -27,7 +27,6 @@
const body = (over: Record<string, unknown> = {}) => ({
  angle: 0,
  alive: true,
  mate: false,
  agent: "sable",
  ...over,
});
@@ -103,13 +102,13 @@
test("a body that has not moved since has no direction to come from", () => {
test("where somebody was last seen is marked, and the mark dims away", () => {
  const p = makePresence();
  sighted(p, [body({ x: 640, y: 480, agent: "veil" })], 10);
  sighted(p, [body({ x: 640, y: 480 })], 10);
  expect(ghosts(p, 10)).toEqual([]);
  sighted(p, [], 10.5);
  const fresh = ghosts(p, 10.5);
  expect(fresh.length).toBe(1);
  expect(fresh[0]).toMatchObject({ id: "them", x: 640, y: 480, agent: "veil", fade: 1 });
  expect(fresh[0]).toMatchObject({ id: "them", x: 640, y: 480, mate: false, fade: 1 });
  expect(ghosts(p, 10.5 + GHOST / 2)[0]!.fade).toBeCloseTo(0.5, 5);
  expect(ghosts(p, 10.5 + GHOST)).toEqual([]);
  // And it is forgotten, not kept for ever.
@@ -14,7 +14,7 @@
import {
  smokeAlong,
  spriteColumnVisible,
  wallLight,
} from "../static/raycast.js";
} from "../../static/engine/raycast.js";
const W = 900;
@@ -5,7 +5,7 @@
 */
import { expect, test } from "bun:test";
import { renderSize, WIDTHS } from "../static/resolution.js";
import { renderSize, WIDTHS } from "../../static/engine/resolution.js";
test("a retina window draws the world at a fixed width, not at its pixels", () => {
  const size = renderSize(3024, 1915, 0);
@@ -0,0 +1,236 @@
/**
 * The renderer, run for real against a canvas that writes down what it was
 * asked to draw. No browser, but every line of the draw path is executed —
 * which is what catches a typo in a frame nobody can see from a unit test.
 *
 * This is the engine's half: walls, bodies, marks, arrivals. What a game puts
 * on the floor besides is drawn through hooks and tested with the game.
 */
import { expect, test } from "bun:test";
import { GHOST, ghosts, makePresence, shown, sighted } from "../../static/engine/presence.js";
import { drawScene, makeScene } from "../../static/engine/scene.js";
type Op = { op: string; args: unknown[]; alpha: number };
/** A canvas that records. Every call the renderer makes has to exist here. */
function fakeContext() {
  const ops: Op[] = [];
  const note =
    (op: string) =>
    (...args: unknown[]) => {
      // The opacity in force when the call was made: how faded a body
      // arriving into sight is, and how far a last-seen mark has dimmed.
      ops.push({ op, args, alpha: ctx.globalAlpha });
    };
  const ctx = {
    ops,
    fillStyle: "",
    strokeStyle: "",
    lineWidth: 1,
    font: "",
    textAlign: "left",
    globalAlpha: 1,
    clearRect: note("clearRect"),
    fillRect: note("fillRect"),
    strokeRect: note("strokeRect"),
    beginPath: note("beginPath"),
    closePath: note("closePath"),
    moveTo: note("moveTo"),
    lineTo: note("lineTo"),
    arc: note("arc"),
    ellipse: note("ellipse"),
    fill: note("fill"),
    stroke: note("stroke"),
    clip: note("clip"),
    rect: note("rect"),
    save: note("save"),
    restore: note("restore"),
    translate: note("translate"),
    rotate: note("rotate"),
    fillText: note("fillText"),
    measureText: (text: string) => ({ width: text.length * 6 }),
    createLinearGradient: () => ({ addColorStop() {} }),
  };
  return ctx;
}
// A room three tiles deep running east, with a pillar standing in it at
// column 5 — enough geometry for a body to hide behind.
const room = (col: number, row: number): boolean =>
  col < 1 || col > 12 || row < 1 || row > 3 || col === 5;
const TILE = 80;
const world = { solid: room, tile: TILE };
// What the engine's renderer needs of a snapshot: you, who you can see,
// and the shots you were let see. Nothing of the game.
const snapshot = (players: unknown[]) => ({
  me: { id: "me", x: 120, y: 200, angle: 0, alive: true, hp: 100 },
  players,
  shots: [],
});
const body = (over: Record<string, unknown> = {}) => ({
  id: "them",
  name: "Sable",
  x: 280,
  y: 200,
  angle: 3.1,
  hp: 100,
  alive: true,
  mate: false,
  ...over,
});
const view = { width: 900, height: 570, look: (p: { x: number; y: number; angle: number }) => p };
const eye = { x: 120, y: 200, angle: 0 };
test("a frame draws walls in runs: the whole width covered, far fewer fills", () => {
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([]), view);
  const rects = ctx.ops.filter((o) => o.op === "fillRect");
  // The bands are the full width; the rest are wall runs.
  const walls = rects
    .map((o) => ({ x: Number(o.args[0]), w: Number(o.args[2]) }))
    .filter((r) => r.w < view.width)
    .sort((a, b) => a.x - b.x);
  // This room is closed, so every column of the picture is wall: the runs
  // start at the left edge, meet end to end and reach the right one. That is
  // the same picture the old one-fill-a-column loop drew.
  expect(walls[0]!.x).toBe(0);
  let reach = 0;
  for (const rect of walls) {
    expect(rect.x).toBeLessThanOrEqual(reach);
    reach = Math.max(reach, rect.x + rect.w);
  }
  expect(reach).toBeGreaterThanOrEqual(view.width);
  // And it costs a fraction of the fills: one a column would be 900.
  expect(walls.length).toBeLessThan(view.width / 2);
});
test("a body in the open is drawn; the same body behind the pillar is not", () => {
  const open = fakeContext();
  drawScene(open as never, makeScene(), world, eye, snapshot([body()]), view);
  // The head is the only arc in this scene, so it stands for the body.
  expect(open.ops.some((o) => o.op === "arc")).toBe(true);
  const hidden = fakeContext();
  drawScene(hidden as never, makeScene(), world, eye, snapshot([body({ x: 700 })]), view);
  expect(hidden.ops.some((o) => o.op === "arc")).toBe(false);
});
test("a team mate gets a name tag and an enemy never does", () => {
  const mate = fakeContext();
  drawScene(mate as never, makeScene(), world, eye, snapshot([body({ mate: true })]), view);
  expect(mate.ops.some((o) => o.op === "fillText" && o.args[0] === "Sable")).toBe(true);
  const enemy = fakeContext();
  drawScene(enemy as never, makeScene(), world, eye, snapshot([body()]), view);
  expect(enemy.ops.some((o) => o.op === "fillText")).toBe(false);
});
test("the dead lie on the floor and wear no markers at all", () => {
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([body({ mate: true, alive: false, hp: 0 })]), view);
  // Flat on the ground: an ellipse, not an upright body with a head.
  expect(ctx.ops.some((o) => o.op === "ellipse")).toBe(true);
  // No name tag, and no chevron — the chevron is the only closed path here.
  expect(ctx.ops.some((o) => o.op === "fillText")).toBe(false);
  expect(ctx.ops.some((o) => o.op === "closePath")).toBe(false);
});
test("an enemy wears a chevron and a team mate does not", () => {
  const enemy = fakeContext();
  drawScene(enemy as never, makeScene(), world, eye, snapshot([body()]), view);
  expect(enemy.ops.some((o) => o.op === "closePath")).toBe(true);
  const mate = fakeContext();
  drawScene(mate as never, makeScene(), world, eye, snapshot([body({ mate: true })]), view);
  expect(mate.ops.some((o) => o.op === "closePath")).toBe(false);
  expect(mate.ops.some((o) => o.op === "fillText")).toBe(true);
});
test("a body has a hard dark edge, whichever side it is on", () => {
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([body()]), view);
  expect(ctx.ops.some((o) => o.op === "strokeRect")).toBe(true);
});
// ------------------------------------------- coming into sight, and leaving
test("a body arriving is drawn faded and small, and solid once it is in", () => {
  const edgeOf = (ctx: ReturnType<typeof fakeContext>) => ctx.ops.find((o) => o.op === "strokeRect")!;
  const arriving = fakeContext();
  drawScene(arriving as never, makeScene(), world, eye, snapshot([body()]), { ...view, shown: () => 0.4 });
  const solid = fakeContext();
  drawScene(solid as never, makeScene(), world, eye, snapshot([body()]), { ...view, shown: () => 1 });
  expect(edgeOf(arriving).alpha).toBeCloseTo(0.4, 5);
  expect(edgeOf(solid).alpha).toBe(1);
  // And smaller: it grows from its feet as it comes in.
  expect(Number(edgeOf(arriving).args[2])).toBeLessThan(Number(edgeOf(solid).args[2]));
  expect(Number(edgeOf(arriving).args[2])).toBeGreaterThan(Number(edgeOf(solid).args[2]) * 0.7);
});
test("a body the presence store has only just seen is the one being faded", () => {
  const seen = makePresence();
  const them = body();
  sighted(seen, [them], 100);
  const draw = (at: number) => {
    const ctx = fakeContext();
    drawScene(ctx as never, makeScene(), world, eye, snapshot([them]), {
      ...view,
      shown: (p: { id: string }) => shown(seen, p.id, at),
    });
    return ctx.ops.find((o) => o.op === "strokeRect")!;
  };
  expect(draw(100.03).alpha).toBeGreaterThan(0);
  expect(draw(100.03).alpha).toBeLessThan(1);
  expect(draw(100.5).alpha).toBe(1);
});
test("a last-seen mark is an outline, dimming, and never a body", () => {
  const marks = [{ id: "them", x: 280, y: 200, angle: 0, mate: false, fade: 0.6 }];
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([]), { ...view, marks });
  const edge = ctx.ops.find((o) => o.op === "strokeRect");
  expect(edge).toBeDefined();
  expect(edge!.alpha).toBeCloseTo(0.6, 5);
  // No head, no chevron, no name: a memory of a sighting, not a sighting.
  expect(ctx.ops.some((o) => o.op === "arc")).toBe(false);
  expect(ctx.ops.some((o) => o.op === "closePath")).toBe(false);
  expect(ctx.ops.some((o) => o.op === "fillText")).toBe(false);
  expect(GHOST).toBeGreaterThan(0);
});
test("a body that steps out of sight leaves the outline the store hands over", () => {
  const seen = makePresence();
  const them = body();
  sighted(seen, [them], 100); // in sight, in the open
  sighted(seen, [], 100.1); // and gone behind the corner
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([]), {
    ...view,
    marks: ghosts(seen, 100.1),
  });
  // Nobody is in the snapshot at all, and there is still something there.
  const edge = ctx.ops.find((o) => o.op === "strokeRect");
  expect(edge).toBeDefined();
  expect(edge!.alpha).toBeCloseTo(1, 2);
  // A second later the store hands over nothing, and nothing is drawn.
  const after = fakeContext();
  drawScene(after as never, makeScene(), world, eye, snapshot([]), {
    ...view,
    marks: ghosts(seen, 100.1 + GHOST),
  });
  expect(after.ops.some((o) => o.op === "strokeRect")).toBe(false);
});
test("a mark where the wall now stands between you and it is not drawn", () => {
  const marks = [{ id: "them", x: 700, y: 200, angle: 0, mate: false, fade: 1 }];
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([]), { ...view, marks });
  expect(ctx.ops.some((o) => o.op === "strokeRect")).toBe(false);
});
@@ -5,7 +5,7 @@
 */
import { expect, test } from "bun:test";
import { covered, GEOM, hazeStep, makeColumns, SKY, wallRuns } from "../static/slices.js";
import { covered, GEOM, hazeStep, makeColumns, SKY, wallRuns } from "../../static/engine/slices.js";
type Col = { level: number; side?: number; top?: number; high?: number; haze?: number };
@@ -1,5 +1,5 @@
import { expect, test } from "bun:test";
import { moveVector } from "../static/steer.js";
import { moveVector } from "../../static/engine/steer.js";
test("W walks the way you are looking, whichever way that is", () => {
  const east = moveVector(0, -1, 0);
@@ -4,7 +4,7 @@
 */
import { expect, test } from "bun:test";
import { makeYaw, settle, shortWay, told, turn, SENT_TOLERANCE } from "../static/yaw.js";
import { makeYaw, settle, shortWay, told, turn, SENT_TOLERANCE } from "../../static/engine/yaw.js";
const me = (angle: number, extra: Partial<{ id: string; alive: boolean }> = {}) => ({
  id: "p1",
@@ -11,13 +11,13 @@
 */
import { expect, test } from "bun:test";
import { BODY_R, moveSpeed, RUN } from "./glide.ts";
import { BODY_R, moveSpeed, RUN } from "./engine/glide.ts";
import { solidTile, TILE } from "./map.ts";
import { newMatch, setInput, startRound, tick } from "./match.ts";
import { runBots } from "./bots.ts";
import { arrive, bodyAt, delay, feed, makeTimeline, renderTime } from "../static/interp.js";
import { makeLocal, stepLocal } from "../static/predict.js";
import { makeYaw, settle, told } from "../static/yaw.js";
import { arrive, bodyAt, delay, feed, makeTimeline, renderTime } from "../static/engine/interp.js";
import { makeLocal, stepLocal } from "../static/engine/predict.js";
import { makeYaw, settle, told } from "../static/engine/yaw.js";
const round2 = (n: number) => Math.round(n * 10) / 10;
const world = { solid: solidTile, tile: TILE, r: BODY_R };
@@ -361,3 +361,66 @@
test("a round start points you at the site once, and nothing stomps it a tick la
  // At most one a round — the spawn — and never a second one to angle zero.
  expect(worstRound).toBeLessThanOrEqual(1);
});
/**
 * The match's own motion, sampled at the rate the server broadcasts it and
 * drawn at the rate a browser draws: what a bot walking across the map
 * actually looks like. The samples carry exactly what a snapshot carries —
 * a position rounded to a tenth, thirty times a second.
 *
 * The measure is the spread of the per-frame steps. A body drawn at the
 * server's speed takes even steps; the exponential chase this replaced took
 * a long step just after each snapshot and shorter ones after it, which is
 * choppiness with a number on it — twice this spread, measured the same way.
 */
test("the simulation's own motion is drawn at an even speed", async () => {
  const { runBots } = await import("./bots.ts");
  const { newMatch, tick } = await import("./match.ts");
  const round2 = (n: number) => Math.round(n * 10) / 10;
  // A match of its own: nothing here touches the arena everybody shares.
  const state = newMatch();
  const step = () => {
    runBots(state, 1 / 30);
    tick(state, 1 / 30);
  };
  for (let i = 0; i < 30 * 40 && state.phase !== "live"; i++) step();
  const stream: { t: number; bodies: { id: string; x: number; y: number; angle: number }[] }[] = [];
  for (let i = 0; i < 60; i++) {
    step();
    stream.push({
      t: i / 30,
      bodies: state.players.map((p) => ({ id: p.id, x: round2(p.x), y: round2(p.y), angle: round2(p.angle) })),
    });
  }
  const timeline = makeTimeline();
  const paths = new Map<string, { x: number; y: number }[]>();
  let next = 0;
  for (let f = 0; f / 60 < 1.8; f++) {
    const now = f / 60;
    while (next < stream.length && stream[next]!.t <= now) {
      arrive(timeline, stream[next]!.t);
      for (const p of stream[next]!.bodies) feed(timeline, p.id, p, stream[next]!.t);
      next += 1;
    }
    for (const p of stream[Math.max(0, next - 1)]!.bodies) {
      const at = bodyAt(timeline, p, now - delay(timeline));
      paths.set(p.id, [...(paths.get(p.id) ?? []), { x: at.x, y: at.y }]);
    }
  }
  // Whoever walked furthest in that second and a half.
  const walked = [...paths.values()]
    .filter((path) => path.length > 80)
    .map((path) => path.slice(1).map((at, i) => Math.hypot(at.x - path[i]!.x, at.y - path[i]!.y)))
    .map((steps) => steps.filter((step) => step > 0.001))
    .sort((a, b) => b.reduce((s, x) => s + x, 0) - a.reduce((s, x) => s + x, 0))[0]!;
  expect(walked.length).toBeGreaterThan(30);
  const mean = walked.reduce((s, x) => s + x, 0) / walked.length;
  const spread = Math.sqrt(walked.reduce((s, x) => s + (x - mean) ** 2, 0) / walked.length) / mean;
  // A body moving at the server's own speed: about four units every sixtieth
  // of a second, which is the run speed.
  expect(mean * 60).toBeGreaterThan(150);
  expect(spread).toBeLessThan(0.15);
});
@@ -0,0 +1,16 @@
/**
 * This map, bound to the engine's grid: the rows are the game's, the maths is
 * shared with the browser, and the binding has to hand one to the other.
 */
import { expect, test } from "bun:test";
import { BODY_R } from "./engine/glide.ts";
import { moveCircle } from "./map.ts";
test("the real map moves by the same maths", () => {
  // Mid, walking east into whatever is there: the map's own binding.
  const to = moveCircle(1200, 640, 9, 0, BODY_R);
  expect(to.x).toBeGreaterThanOrEqual(1200);
  expect(to.x).toBeLessThanOrEqual(1209);
  expect(to.y).toBe(640);
});
@@ -1,5 +1,5 @@
/**
 * The map: one grid, and the geometry everything else asks questions of.
 * The map: this game's one grid, and what its letters mean.
 *
 * Two sites (A left, B right), a mid corridor between the spawns, and a back
 * corridor along the bottom that links A main, spawn and B main — the flank.
@@ -7,11 +7,15 @@
 * corridor is comfortably wide and a wall is never thin enough for a ray to
 * step over.
 *
 * Everything here is a pure function of the grid: collision, line of sight
 * and the walk distance a bot uses to path. No state.
 * The mechanics — collision, line of sight, the walk distance a bot uses to
 * path — are `engine/grid.ts`, bound here to these rows. What is this
 * game's own is the rows themselves and the reading of their letters: a
 * plant site, a spawn, where the orbs sit.
 */
import { circleBlocked, slideCircle } from "./glide.ts";
import { makeGrid, segmentHitsCircle, segmentPoint, type Point } from "./engine/grid.ts";
export { segmentHitsCircle, segmentPoint, type Point };
export const TILE = 80;
@@ -38,53 +42,38 @@
const ROWS_SRC = [
  "##############################",
];
export const COLS = ROWS_SRC[0]!.length;
export const ROWS = ROWS_SRC.length;
export const WIDTH = COLS * TILE;
export const HEIGHT = ROWS * TILE;
const board = makeGrid(ROWS_SRC, TILE);
export const COLS = board.cols;
export const ROWS = board.rows;
export const WIDTH = board.width;
export const HEIGHT = board.height;
export const grid: string[] = ROWS_SRC;
export const gridRows = (): string[] => ROWS_SRC.slice();
export type Site = "A" | "B";
export type Point = { x: number; y: number };
const at = (col: number, row: number): string =>
  row < 0 || row >= ROWS || col < 0 || col >= COLS ? "#" : ROWS_SRC[row]![col]!;
export const solidTile = (col: number, row: number): boolean => at(col, row) === "#";
export const tileOf = (x: number, y: number): { col: number; row: number } => ({
  col: Math.floor(x / TILE),
  row: Math.floor(y / TILE),
});
export const centreOf = (col: number, row: number): Point => ({
  x: col * TILE + TILE / 2,
  y: row * TILE + TILE / 2,
});
export const solidAt = (x: number, y: number): boolean => {
  const t = tileOf(x, y);
  return solidTile(t.col, t.row);
};
export const solidTile = board.solidTile;
export const tileOf = board.tileOf;
export const centreOf = board.centreOf;
export const solidAt = board.solidAt;
export const moveCircle = board.moveCircle;
export const blockedCircle = board.blockedCircle;
export const wallBetween = board.wallBetween;
export const rayHitWall = board.rayHitWall;
export const walkDistance = board.walkDistance;
export const pathStep = board.pathStep;
export const clearPaths = board.clearPaths;
/** The site a point plants on, or null: the spike only arms inside a site. */
export const siteAt = (x: number, y: number): Site | null => {
  const t = tileOf(x, y);
  const c = at(t.col, t.row);
  const c = board.cellAt(x, y);
  return c === "A" || c === "B" ? c : null;
};
const cellsOf = (mark: string): Point[] => {
  const out: Point[] = [];
  for (let row = 0; row < ROWS; row++)
    for (let col = 0; col < COLS; col++) if (at(col, row) === mark) out.push(centreOf(col, row));
  return out;
};
export const spawnCells = (side: "atk" | "def"): Point[] => cellsOf(side === "atk" ? "a" : "d");
export const siteCells = (site: Site): Point[] => cellsOf(site);
export const spawnCells = (side: "atk" | "def"): Point[] => board.cellsOf(side === "atk" ? "a" : "d");
export const siteCells = (site: Site): Point[] => board.cellsOf(site);
export const siteCentre = (site: Site): Point => {
  const cells = siteCells(site);
@@ -94,139 +83,3 @@
export const siteCentre = (site: Site): Point => {
/** Ult orbs: one on each half of mid, free for whoever walks over them. */
export const orbSpots = (): Point[] => [centreOf(4, 11), centreOf(25, 11)];
/**
 * Slide a circle through this grid. The maths is in `glide.ts`, which the
 * browser runs too; here it is bound to this map's tiles.
 */
export const moveCircle = (x: number, y: number, dx: number, dy: number, r: number): Point =>
  slideCircle(x, y, dx, dy, r, solidTile, TILE);
/** True when a circle at (x,y) overlaps any solid tile. */
export const blockedCircle = (x: number, y: number, r: number): boolean =>
  circleBlocked(x, y, r, solidTile, TILE);
/**
 * Does a wall stand between two points? Sampled every third of a tile: a
 * wall is a whole tile thick, so nothing is ever stepped over.
 */
export function wallBetween(a: Point, b: Point): boolean {
  const dx = b.x - a.x;
  const dy = b.y - a.y;
  const dist = Math.hypot(dx, dy);
  const steps = Math.ceil(dist / (TILE / 3));
  for (let i = 1; i < steps; i++) {
    const t = i / steps;
    if (solidAt(a.x + dx * t, a.y + dy * t)) return true;
  }
  return false;
}
/** Where a shot stops: the first wall along the ray, or its full range. */
export function rayHitWall(from: Point, angle: number, range: number): Point {
  const dx = Math.cos(angle);
  const dy = Math.sin(angle);
  const step = TILE / 4;
  for (let d = step; d <= range; d += step) {
    const x = from.x + dx * d;
    const y = from.y + dy * d;
    if (solidAt(x, y)) return { x: from.x + dx * (d - step), y: from.y + dy * (d - step) };
  }
  return { x: from.x + dx * range, y: from.y + dy * range };
}
/** Closest approach of a segment to a point, as distance and travel along it. */
export function segmentPoint(a: Point, b: Point, p: Point): { dist: number; travel: number } {
  const dx = b.x - a.x;
  const dy = b.y - a.y;
  const len2 = dx * dx + dy * dy;
  const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2));
  const cx = a.x + dx * t;
  const cy = a.y + dy * t;
  return { dist: Math.hypot(p.x - cx, p.y - cy), travel: t * Math.sqrt(len2) };
}
export const segmentHitsCircle = (a: Point, b: Point, c: Point, r: number): boolean =>
  segmentPoint(a, b, c).dist <= r;
// Walk distance from a goal tile, breadth-first over floor. Bots ask for it
// every few ticks; the field for a goal is built once and kept for the round.
const fields = new Map<number, Int32Array>();
export const clearPaths = (): void => void fields.clear();
function field(goalCol: number, goalRow: number): Int32Array {
  const key = goalRow * COLS + goalCol;
  const cached = fields.get(key);
  if (cached) return cached;
  const dist = new Int32Array(COLS * ROWS).fill(-1);
  if (!solidTile(goalCol, goalRow)) {
    dist[key] = 0;
    const queue: number[] = [key];
    for (let head = 0; head < queue.length; head++) {
      const here = queue[head]!;
      const col = here % COLS;
      const row = (here - col) / COLS;
      const d = dist[here]!;
      for (const [dc, dr] of [
        [1, 0],
        [-1, 0],
        [0, 1],
        [0, -1],
      ] as const) {
        const nc = col + dc;
        const nr = row + dr;
        if (nc < 0 || nc >= COLS || nr < 0 || nr >= ROWS) continue;
        const nk = nr * COLS + nc;
        if (dist[nk] !== -1 || solidTile(nc, nr)) continue;
        dist[nk] = d + 1;
        queue.push(nk);
      }
    }
  }
  if (fields.size > 64) fields.clear();
  fields.set(key, dist);
  return dist;
}
/** Walk distance in tiles between two points, or -1 when unreachable. */
export function walkDistance(from: Point, to: Point): number {
  const f = tileOf(from.x, from.y);
  const g = tileOf(to.x, to.y);
  return field(g.col, g.row)[f.row * COLS + f.col] ?? -1;
}
/**
 * The next point to walk toward on the way to a goal: the centre of the
 * neighbouring tile that is one step closer, so bots round corners instead
 * of grinding into them.
 */
export function pathStep(from: Point, to: Point): Point {
  const f = tileOf(from.x, from.y);
  const g = tileOf(to.x, to.y);
  if (f.col === g.col && f.row === g.row) return to;
  const dist = field(g.col, g.row);
  const here = dist[f.row * COLS + f.col] ?? -1;
  if (here <= 0) return to;
  let best: Point | null = null;
  let bestD = here;
  for (const [dc, dr] of [
    [1, 0],
    [-1, 0],
    [0, 1],
    [0, -1],
  ] as const) {
    const nc = f.col + dc;
    const nr = f.row + dr;
    if (nc < 0 || nc >= COLS || nr < 0 || nr >= ROWS) continue;
    const d = dist[nr * COLS + nc] ?? -1;
    if (d !== -1 && d < bestD) {
      bestD = d;
      best = centreOf(nc, nr);
    }
  }
  // Straight to the goal when nothing stands in the way — smoother than
  // walking tile centre to tile centre down an open corridor.
  if (best && !wallBetween(from, to) && (walkDistance(from, to) ?? 99) < 6) return to;
  return best ?? to;
}
@@ -9,8 +9,8 @@
 */
import { cast, castable, agentById, buyableSlots, flashDuration, sightBlocked, SLOTS } from "./abilities.ts";
import { emptyTrack } from "./aim.ts";
import { BODY_R, moveSpeed, RUN } from "./glide.ts";
import { emptyTrack } from "./engine/aim.ts";
import { BODY_R, moveSpeed, RUN } from "./engine/glide.ts";
import { award, clampCredits, roundReward, spend, START_CREDITS } from "./economy.ts";
import {
  blockedCircle,
@@ -27,7 +27,7 @@
import { emptyInput, type Input, type MatchState, type Player, type Side, type S
import { applyDamage, damage, shotSpread, SHIELD, WEAPONS, zoneFromMiss, type WeaponId } from "./weapons.ts";
// A body's size and its speed are shared with the browser, which predicts
// your own movement between snapshots: `src/glide.ts` is the one copy.
// your own movement between snapshots: `src/engine/glide.ts` is the one copy.
export const PLAYER_R = BODY_R;
export const RUN_SPEED = RUN;
export const BUY_TIME = 14;
@@ -2,11 +2,13 @@
 * The renderer, run for real against a canvas that writes down what it was
 * asked to draw. No browser, but every line of the draw path is executed —
 * which is what catches a typo in a frame nobody can see from a unit test.
 *
 * This is the game's half: the spike, the orbs, the zones, the real map and
 * the gun. The walls and the bodies are proved in `engine/scene.test.ts`.
 */
import { expect, test } from "bun:test";
import { drawGun, makeGun } from "../static/gun.js";
import { GHOST, ghosts, makePresence, shown, sighted } from "../static/presence.js";
import { drawGun, makeGun } from "../static/engine/gun.js";
import { drawScene, makeScene } from "../static/scene.js";
import { drawTopdown } from "../static/topdown.js";
import { gridRows, TILE } from "./map.ts";
@@ -91,77 +93,6 @@
const body = (over: Record<string, unknown> = {}) => ({
const view = { width: 900, height: 570, look: (p: { x: number; y: number; angle: number }) => p };
const eye = { x: 120, y: 200, angle: 0 };
test("a frame draws walls in runs: the whole width covered, far fewer fills", () => {
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([]), view);
  const rects = ctx.ops.filter((o) => o.op === "fillRect");
  // The bands are the full width; the rest are wall runs.
  const walls = rects
    .map((o) => ({ x: Number(o.args[0]), w: Number(o.args[2]) }))
    .filter((r) => r.w < view.width)
    .sort((a, b) => a.x - b.x);
  // This room is closed, so every column of the picture is wall: the runs
  // start at the left edge, meet end to end and reach the right one. That is
  // the same picture the old one-fill-a-column loop drew.
  expect(walls[0]!.x).toBe(0);
  let reach = 0;
  for (const rect of walls) {
    expect(rect.x).toBeLessThanOrEqual(reach);
    reach = Math.max(reach, rect.x + rect.w);
  }
  expect(reach).toBeGreaterThanOrEqual(view.width);
  // And it costs a fraction of the fills: one a column would be 900.
  expect(walls.length).toBeLessThan(view.width / 2);
});
test("a body in the open is drawn; the same body behind the pillar is not", () => {
  const open = fakeContext();
  drawScene(open as never, makeScene(), world, eye, snapshot([body()]), view);
  // The head is the only arc in this scene, so it stands for the body.
  expect(open.ops.some((o) => o.op === "arc")).toBe(true);
  const hidden = fakeContext();
  drawScene(hidden as never, makeScene(), world, eye, snapshot([body({ x: 700 })]), view);
  expect(hidden.ops.some((o) => o.op === "arc")).toBe(false);
});
test("a team mate gets a name tag and an enemy never does", () => {
  const mate = fakeContext();
  drawScene(mate as never, makeScene(), world, eye, snapshot([body({ mate: true })]), view);
  expect(mate.ops.some((o) => o.op === "fillText" && o.args[0] === "Sable")).toBe(true);
  const enemy = fakeContext();
  drawScene(enemy as never, makeScene(), world, eye, snapshot([body()]), view);
  expect(enemy.ops.some((o) => o.op === "fillText")).toBe(false);
});
test("the dead lie on the floor and wear no markers at all", () => {
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([body({ mate: true, alive: false, hp: 0 })]), view);
  // Flat on the ground: an ellipse, not an upright body with a head.
  expect(ctx.ops.some((o) => o.op === "ellipse")).toBe(true);
  // No name tag, and no chevron — the chevron is the only closed path here.
  expect(ctx.ops.some((o) => o.op === "fillText")).toBe(false);
  expect(ctx.ops.some((o) => o.op === "closePath")).toBe(false);
});
test("an enemy wears a chevron and a team mate does not", () => {
  const enemy = fakeContext();
  drawScene(enemy as never, makeScene(), world, eye, snapshot([body()]), view);
  expect(enemy.ops.some((o) => o.op === "closePath")).toBe(true);
  const mate = fakeContext();
  drawScene(mate as never, makeScene(), world, eye, snapshot([body({ mate: true })]), view);
  expect(mate.ops.some((o) => o.op === "closePath")).toBe(false);
  expect(mate.ops.some((o) => o.op === "fillText")).toBe(true);
});
test("a body has a hard dark edge, whichever side it is on", () => {
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([body()]), view);
  expect(ctx.ops.some((o) => o.op === "strokeRect")).toBe(true);
});
test("a smoke between the eye and a body hides it", () => {
  const smoke = [{ k: "smoke", x: 200, y: 200, r: 90, f: 0, l: 8 }];
  const ctx = fakeContext();
@@ -248,85 +179,6 @@
test("the gun and the crosshair draw, and the hit marker only when there is one"
  expect(loud.ops.length).toBeGreaterThan(quiet);
});
// ------------------------------------------- coming into sight, and leaving
test("a body arriving is drawn faded and small, and solid once it is in", () => {
  const edgeOf = (ctx: ReturnType<typeof fakeContext>) => ctx.ops.find((o) => o.op === "strokeRect")!;
  const arriving = fakeContext();
  drawScene(arriving as never, makeScene(), world, eye, snapshot([body()]), { ...view, shown: () => 0.4 });
  const solid = fakeContext();
  drawScene(solid as never, makeScene(), world, eye, snapshot([body()]), { ...view, shown: () => 1 });
  expect(edgeOf(arriving).alpha).toBeCloseTo(0.4, 5);
  expect(edgeOf(solid).alpha).toBe(1);
  // And smaller: it grows from its feet as it comes in.
  expect(Number(edgeOf(arriving).args[2])).toBeLessThan(Number(edgeOf(solid).args[2]));
  expect(Number(edgeOf(arriving).args[2])).toBeGreaterThan(Number(edgeOf(solid).args[2]) * 0.7);
});
test("a body the presence store has only just seen is the one being faded", () => {
  const seen = makePresence();
  const them = body();
  sighted(seen, [them], 100);
  const draw = (at: number) => {
    const ctx = fakeContext();
    drawScene(ctx as never, makeScene(), world, eye, snapshot([them]), {
      ...view,
      shown: (p: { id: string }) => shown(seen, p.id, at),
    });
    return ctx.ops.find((o) => o.op === "strokeRect")!;
  };
  expect(draw(100.03).alpha).toBeGreaterThan(0);
  expect(draw(100.03).alpha).toBeLessThan(1);
  expect(draw(100.5).alpha).toBe(1);
});
test("a last-seen mark is an outline, dimming, and never a body", () => {
  const marks = [{ id: "them", x: 280, y: 200, angle: 0, mate: false, fade: 0.6 }];
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([]), { ...view, marks });
  const edge = ctx.ops.find((o) => o.op === "strokeRect");
  expect(edge).toBeDefined();
  expect(edge!.alpha).toBeCloseTo(0.6, 5);
  // No head, no chevron, no name: a memory of a sighting, not a sighting.
  expect(ctx.ops.some((o) => o.op === "arc")).toBe(false);
  expect(ctx.ops.some((o) => o.op === "closePath")).toBe(false);
  expect(ctx.ops.some((o) => o.op === "fillText")).toBe(false);
  expect(GHOST).toBeGreaterThan(0);
});
test("a body that steps out of sight leaves the outline the store hands over", () => {
  const seen = makePresence();
  const them = body();
  sighted(seen, [them], 100); // in sight, in the open
  sighted(seen, [], 100.1); // and gone behind the corner
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([]), {
    ...view,
    marks: ghosts(seen, 100.1),
  });
  // Nobody is in the snapshot at all, and there is still something there.
  const edge = ctx.ops.find((o) => o.op === "strokeRect");
  expect(edge).toBeDefined();
  expect(edge!.alpha).toBeCloseTo(1, 2);
  // A second later the store hands over nothing, and nothing is drawn.
  const after = fakeContext();
  drawScene(after as never, makeScene(), world, eye, snapshot([]), {
    ...view,
    marks: ghosts(seen, 100.1 + GHOST),
  });
  expect(after.ops.some((o) => o.op === "strokeRect")).toBe(false);
});
test("a mark where the wall now stands between you and it is not drawn", () => {
  const marks = [{ id: "them", x: 700, y: 200, angle: 0, mate: false, fade: 1 }];
  const ctx = fakeContext();
  drawScene(ctx as never, makeScene(), world, eye, snapshot([]), { ...view, marks });
  expect(ctx.ops.some((o) => o.op === "strokeRect")).toBe(false);
});
test("on the map a last-seen ring is hollow, and dims with the mark", () => {
  const map = { rows: gridRows(), tile: TILE };
  const box = { x: 0, y: 0, w: 900, h: 570 };
@@ -1,6 +1,7 @@
/**
 * val — the door. Routing, sessions, sockets and the security floor; the
 * game itself is in src/match.ts and the live one in src/arena.ts.
 * game itself is in src/match.ts, the live one in src/arena.ts, and the
 * machinery that serves any game in src/engine/.
 *
 * A seat belongs to a session cookie, so the same browser gets the same
 * player back across a reload, and a socket is only ever given a seat the
@@ -3,7 +3,7 @@
 * can both speak about a player without importing each other.
 */
import type { Track } from "./aim.ts";
import type { Track } from "./engine/aim.ts";
import type { Point, Site } from "./map.ts";
import type { WeaponId } from "./weapons.ts";
@@ -15,7 +15,7 @@
 * drawing optimisation and nothing here is ever sent anywhere.
 */
import { circleBlocked, slideCircle } from "../src/glide.ts";
import { circleBlocked, slideCircle } from "../../src/engine/glide.ts";
/** Past this much disagreement the server simply wins: a spawn, a teleport. */
export const SNAP = 40;
@@ -74,7 +74,6 @@
function remember(it, body, seq) {
  it.angle = body.angle;
  it.alive = body.alive;
  it.mate = body.mate;
  it.agent = body.agent;
}
/**
@@ -125,7 +124,7 @@
export function ghosts(presence, now) {
      presence.last.delete(id);
      continue;
    }
    out.push({ id, x: it.x, y: it.y, angle: it.angle, agent: it.agent, mate: it.mate, fade: left });
    out.push({ id, x: it.x, y: it.y, angle: it.angle, mate: it.mate, fade: left });
  }
  return out;
}
@@ -0,0 +1,424 @@
/**
 * The world, drawn from inside the player's head.
 *
 * One pass of rays across the screen builds the walls and a depth buffer;
 * everything else — bodies, the game's own props, tracers — is a billboard
 * tested against that buffer, so a body behind a corner is not drawn at all.
 * Fog is measured along each ray, not painted as a disc: cross one and
 * everything past it fogs.
 *
 * The ray loop allocates nothing and draws nothing: it writes a shade level,
 * a face and a slice into the column arrays, and `slices.js` collapses those
 * into runs so a flat wall costs one `fillRect` and not one a column.
 * Colours come out of a table built once, the depth and column buffers are
 * kept between frames, and the sprite list is sorted in a buffer the scene
 * owns.
 *
 * Nothing here knows what the game is. What a body is and how it hides is
 * generic; what stands on the floor besides bodies, and what fogs a ray, the
 * game says through `view` — see `drawScene`.
 */
import { swell } from "./presence.js";
import { makeColumns, SKY, wallRuns } from "./slices.js";
import {
  castRay,
  columnOffset,
  hitResult,
  project,
  projection,
  projectResult,
  sliceHeight,
  smokeAlong,
  spriteColumnVisible,
  wallLight,
} from "./raycast.js";
export const EYE = 40; // half a tile up: the horizon sits on the middle of the wall
export const WALL = 80; // walls are one tile tall
const BODY = 58; // a person, in world units
const MAX_SIGHT = 1800;
const LEVELS = 48;
// Wall colours, quantised into levels and built once, so the ray loop never
// builds a string. How dark a slice is comes from `wallLight`, which already
// knows about distance and which face was struck.
const SHADES = (() => {
  const out = [];
  for (let i = 0; i < LEVELS; i++) {
    const k = (i + 0.5) / LEVELS;
    out.push(`rgb(${Math.round(150 * k)},${Math.round(158 * k)},${Math.round(178 * k)})`);
  }
  return out;
})();
const FOG = "rgb(198,203,212)";
const NO_FOG = () => {};
const NO_PROPS = () => {};
const PLAIN = () => "#999";
const NO_BADGE = () => null;
export function makeScene() {
  return {
    depth: new Float32Array(0),
    cols: makeColumns(0),
    runs: [],
    hit: hitResult(),
    proj: projectResult(),
    order: [],
    smokes: [],
    sky: null,
    skyKey: "",
  };
}
const levelOf = (light) => Math.min(LEVELS - 1, Math.max(0, (light * LEVELS) | 0));
/**
 * The walls, a rectangle a run rather than a rectangle a column. The runs
 * are stretches where the shade level, the face, the fog and the geometry
 * all agree — see `slices.js` — so this is the same picture the per-column
 * loop drew, in a fraction of the calls.
 */
function drawWalls(ctx, scene, step) {
  const runs = scene.runs;
  const used = wallRuns(scene.cols, runs);
  for (let r = 0; r < used; r++) {
    const run = runs[r];
    const x = run.from * step;
    const wide = (run.to - run.from + 1) * step + 1;
    ctx.fillStyle = SHADES[run.level];
    ctx.fillRect(x, run.top, wide, run.high);
    if (run.haze > 0.01) {
      ctx.globalAlpha = run.haze;
      ctx.fillStyle = FOG;
      ctx.fillRect(x, run.top, wide, run.high);
      ctx.globalAlpha = 1;
    }
  }
}
/**
 * Draw one frame.
 *
 * `world` carries the map (`solid`, `tile`), `eye` is where the camera
 * stands and looks, `snap` is the last snapshot the server sent — it must
 * carry `me`, `players` and `shots` — and `view` is the frame: its pixel
 * size, `look(player)` for the smoothed position to draw somebody at, and
 * the game's own holes in the picture, each optional:
 *
 * - `fog(snap, out)` pushes the discs `{x, y, r}` a ray fogs through.
 * - `props(snap, out)` pushes what stands on the floor besides bodies, each
 *   `{x, y, draw}`; `draw(ctx, thing, floorY, proj, clip)` is handed the
 *   projected thing (`column`, `perp`, `size`) and a `clip(thing, left,
 *   right, fn)` that runs `fn` only where the thing beats the wall.
 * - `trim(player)` is the colour of the stripe across a body.
 * - `badge(player)` is a colour to mark a body with, or null.
 */
export function drawScene(ctx, scene, world, eye, snap, view) {
  const W = view.width;
  const H = view.height;
  // One ray every other column of the buffer, and the wall slice two columns
  // wide: flat shading does not reward a ray a pixel, and the sprites are
  // still drawn at the buffer's own resolution. Below that width a picture
  // this coarse stops being one.
  const step = W >= 640 ? 2 : 1;
  const columns = Math.ceil(W / step);
  if (scene.depth.length !== columns) {
    scene.depth = new Float32Array(columns);
    scene.cols = makeColumns(columns);
  }
  const proj = projection(W);
  const horizon = H / 2;
  drawSky(ctx, scene, W, H, horizon);
  const smokes = scene.smokes;
  smokes.length = 0;
  (view.fog || NO_FOG)(snap, smokes);
  const depth = scene.depth;
  const cols = scene.cols;
  const fog = cols.haze;
  const hit = scene.hit;
  for (let i = 0; i < columns; i++) {
    const offset = columnOffset(i * step + step / 2, W);
    const angle = eye.angle + offset;
    castRay(world.solid, eye.x, eye.y, angle, world.tile, MAX_SIGHT, hit);
    const perp = Math.max(1, hit.dist * Math.cos(offset));
    depth[i] = perp;
    let haze = 0;
    if (smokes.length) {
      const dx = Math.cos(angle);
      const dy = Math.sin(angle);
      for (let s = 0; s < smokes.length; s++) {
        const z = smokes[s];
        haze += smokeAlong(eye.x, eye.y, dx, dy, z.x, z.y, z.r, hit.dist);
        if (haze >= 1) break;
      }
      haze = Math.min(1, haze);
    }
    fog[i] = haze;
    if (!hit.wall) {
      cols.level[i] = SKY;
      continue;
    }
    const h = Math.min(H * 6, sliceHeight(perp, proj, WALL));
    cols.level[i] = levelOf(wallLight(perp, hit.side, world.tile));
    cols.side[i] = hit.side;
    cols.top[i] = horizon - h / 2;
    cols.high[i] = h;
  }
  drawWalls(ctx, scene, step);
  drawThings(ctx, scene, eye, snap, view, proj, horizon, step, columns);
}
/** The two bands: a dark ceiling above the horizon, a warmer floor below. */
function drawSky(ctx, scene, W, H, horizon) {
  const key = `${W}x${H}`;
  if (scene.skyKey !== key || !scene.sky) {
    const sky = ctx.createLinearGradient(0, 0, 0, H);
    sky.addColorStop(0, "#0a0c11");
    sky.addColorStop(0.49, "#23262f");
    sky.addColorStop(0.5, "#3a3026");
    sky.addColorStop(1, "#15120e");
    scene.sky = sky;
    scene.skyKey = key;
  }
  ctx.fillStyle = scene.sky;
  ctx.fillRect(0, 0, W, H);
  ctx.fillStyle = "rgba(255,255,255,0.09)";
  ctx.fillRect(0, horizon - 1, W, 2);
}
/**
 * Everything that is not a wall, far to near, each one clipped to the screen
 * columns where it beats the wall behind it. The game's props go in first,
 * then bodies, then marks: a tie in depth keeps that order.
 */
function drawThings(ctx, scene, eye, snap, view, proj, horizon, step, columns) {
  const W = view.width;
  const things = scene.order;
  things.length = 0;
  (view.props || NO_PROPS)(snap, things);
  const trim = view.trim || PLAIN;
  const badge = view.badge || NO_BADGE;
  for (const player of snap.players) {
    if (player.id === snap.me.id) continue;
    const at = view.look(player);
    // How far into sight this body is: 0 the moment it appears, 1 solid.
    // See presence.js — a body that pops into existence reads as a bug.
    const shown = view.shown ? view.shown(player) : 1;
    things.push({ kind: "body", player, shown, x: at.x, y: at.y, angle: at.angle });
  }
  // Where somebody was last seen, dimming away. It stands where they were,
  // so a wall between you and that spot hides it like anything else.
  if (view.marks) for (const mark of view.marks) things.push({ kind: "mark", mark, x: mark.x, y: mark.y });
  const p = scene.proj;
  for (const thing of things) {
    project(eye.x, eye.y, eye.angle, thing.x, thing.y, W, proj, BODY, p);
    thing.perp = p.perp;
    thing.column = p.column;
    thing.size = p.size;
    thing.behind = p.behind;
  }
  things.sort((a, b) => b.perp - a.perp);
  const clip = (thing, left, right, fn) => withRuns(ctx, scene, left, right, thing.perp, step, columns, fn);
  for (const thing of things) {
    if (thing.behind) continue;
    const floorY = horizon + (EYE * proj) / thing.perp;
    const haze = hazeAt(scene, thing.column, step, columns);
    const arriving = thing.kind === "body" ? thing.shown : thing.kind === "mark" ? thing.mark.fade : 1;
    ctx.globalAlpha = Math.max(0, 1 - haze) * arriving;
    if (ctx.globalAlpha < 0.05) continue;
    if (thing.kind === "body") drawBody(ctx, thing, floorY, clip, trim, badge);
    else if (thing.kind === "mark") drawMark(ctx, thing, floorY, clip);
    else thing.draw(ctx, thing, floorY, proj, clip);
    ctx.globalAlpha = 1;
  }
  ctx.globalAlpha = 1;
  drawTracers(ctx, scene, eye, snap, W, proj, horizon);
}
const hazeAt = (scene, column, step, columns) => {
  const i = Math.max(0, Math.min(columns - 1, Math.round(column / step)));
  return scene.cols.haze[i] ?? 0;
};
/**
 * The visible runs of a sprite: the stretches of screen column where it is
 * nearer than the wall. Two rectangles at most in practice, and the caller
 * clips its drawing to each.
 */
function withRuns(ctx, scene, left, right, perp, step, columns, draw) {
  let runStart = -1;
  const from = Math.max(0, Math.floor(left / step));
  const to = Math.min(columns - 1, Math.ceil(right / step));
  for (let i = from; i <= to + 1; i++) {
    const shown = i <= to && spriteColumnVisible(perp, scene.depth[i]);
    if (shown && runStart < 0) runStart = i;
    if (!shown && runStart >= 0) {
      ctx.save();
      ctx.beginPath();
      ctx.rect(runStart * step - 0.5, 0, (i - runStart) * step + 1, 1e5);
      ctx.clip();
      draw();
      ctx.restore();
      runStart = -1;
    }
  }
}
function drawBody(ctx, thing, floorY, clip, trim, badge) {
  const p = thing.player;
  // A body arriving grows from its feet as it fades in, so it reads as
  // somebody coming round the corner rather than one appearing there.
  const h = thing.size * swell(thing.shown ?? 1);
  const w = h * 0.46;
  const cx = thing.column;
  const top = floorY - h;
  const mate = p.mate;
  // The dead lie down. No tag, no chevron, no trim colour: if something is
  // upright with a marker over it, it is alive and it can shoot you.
  if (!p.alive) {
    const lie = h * 0.16;
    clip(thing, cx - w * 1.1, cx + w * 1.1, () => {
      ctx.fillStyle = "#4a4e57";
      ctx.beginPath();
      ctx.ellipse(cx, floorY - lie * 0.4, w * 1.05, lie, 0, 0, 7);
      ctx.fill();
      ctx.strokeStyle = "#23262d";
      ctx.lineWidth = Math.max(1, h * 0.02);
      ctx.stroke();
    });
    return;
  }
  const skin = mate ? "#3f9fd6" : "#d8483f";
  const stripe = trim(p);
  const mark = badge(p);
  const edge = Math.max(1.2, h * 0.05);
  clip(thing, cx - w * 1.2, cx + w * 1.5, () => {
    // Body and head, each with a hard dark edge: the silhouette is what
    // carries across a dim room, where the colour does not.
    ctx.fillStyle = skin;
    ctx.fillRect(cx - w / 2, top + h * 0.28, w, h * 0.72);
    ctx.strokeStyle = "#0b0d11";
    ctx.lineWidth = edge;
    ctx.strokeRect(cx - w / 2, top + h * 0.28, w, h * 0.72);
    ctx.fillStyle = stripe;
    ctx.fillRect(cx - w / 2, top + h * 0.34, w, h * 0.1);
    ctx.beginPath();
    ctx.arc(cx, top + h * 0.17, h * 0.15, 0, 7);
    ctx.fillStyle = skin;
    ctx.fill();
    ctx.strokeStyle = "#0b0d11";
    ctx.stroke();
    if (mark) {
      ctx.fillStyle = mark;
      ctx.fillRect(cx + w * 0.5, top + h * 0.4, w * 0.3, h * 0.3);
    }
    if (p.hp < 100) {
      ctx.fillStyle = "#000a";
      ctx.fillRect(cx - w / 2, top - h * 0.1, w, h * 0.06);
      ctx.fillStyle = mate ? "#6fcf6f" : "#e8b04a";
      ctx.fillRect(cx - w / 2, top - h * 0.1, w * (p.hp / 100), h * 0.06);
    }
    if (mate) tag(ctx, p, cx, top, h);
    else chevron(ctx, cx, top, h);
  });
}
/**
 * A mark where somebody was last seen: an empty outline and a scuff on the
 * floor, dimming away over a second. Deliberately not a body — nothing is
 * filled, there is no head and no chevron — because it is a memory of a
 * sighting and must never be mistaken for one.
 */
function drawMark(ctx, thing, floorY, clip) {
  const h = thing.size * 0.9;
  const w = h * 0.46;
  const cx = thing.column;
  const top = floorY - h;
  clip(thing, cx - w * 1.2, cx + w * 1.2, () => {
    ctx.strokeStyle = thing.mark.mate ? "rgba(120,180,230,0.85)" : "rgba(235,150,120,0.9)";
    ctx.lineWidth = Math.max(1, h * 0.035);
    ctx.strokeRect(cx - w / 2, top + h * 0.28, w, h * 0.72);
    ctx.fillStyle = "rgba(10,12,16,0.45)";
    ctx.fillRect(cx - w * 0.7, floorY - h * 0.04, w * 1.4, h * 0.05);
  });
}
/** An enemy wears a chevron: a shape, not a hue, for anyone whose eyes read
 * red and blue the same way. */
function chevron(ctx, cx, top, h) {
  const size = Math.max(4, h * 0.16);
  const y = top - h * 0.16;
  ctx.beginPath();
  ctx.moveTo(cx - size, y - size);
  ctx.lineTo(cx + size, y - size);
  ctx.lineTo(cx, y);
  ctx.closePath();
  ctx.fillStyle = "#ff6f5e";
  ctx.fill();
  ctx.lineWidth = Math.max(1, h * 0.02);
  ctx.strokeStyle = "#140a08";
  ctx.stroke();
}
/** A team mate wears their name and a pip of their health — never an enemy. */
function tag(ctx, p, cx, top, h) {
  const size = Math.max(9, Math.min(18, h * 0.16));
  const y = top - h * 0.34;
  ctx.font = `${size}px system-ui, sans-serif`;
  ctx.textAlign = "center";
  const width = ctx.measureText(p.name).width + size * 1.4;
  ctx.fillStyle = "rgba(10,12,16,0.65)";
  ctx.fillRect(cx - width / 2, y, width, size * 1.4);
  ctx.fillStyle = p.hp > 60 ? "#6fcf6f" : p.hp > 25 ? "#e0a040" : "#e05a4a";
  ctx.fillRect(cx - width / 2 + size * 0.25, y + size * 0.35, size * 0.45, size * 0.7);
  ctx.fillStyle = "#cfe8ff";
  ctx.fillText(p.name, cx + size * 0.4, y + size * 1.05);
  ctx.textAlign = "left";
}
/** A round thing on the floor, for a game to draw its pickups with. */
export function drawBlob(ctx, thing, floorY, colour, scale, clip) {
  const r = thing.size * scale;
  const cx = thing.column;
  clip(thing, cx - r, cx + r, () => {
    ctx.fillStyle = colour;
    ctx.beginPath();
    ctx.arc(cx, floorY - r, r, 0, 7);
    ctx.fill();
  });
}
/** Shots the server let us see, as a line through the world. */
function drawTracers(ctx, scene, eye, snap, W, proj, horizon) {
  if (!snap.shots.length) return;
  const p = scene.proj;
  ctx.lineWidth = 2;
  for (const shot of snap.shots) {
    project(eye.x, eye.y, eye.angle, shot.x1, shot.y1, W, proj, BODY, p);
    if (p.behind) continue;
    const x1 = p.column;
    const y1 = horizon + (EYE * proj) / p.perp - p.size * 0.6;
    project(eye.x, eye.y, eye.angle, shot.x2, shot.y2, W, proj, BODY, p);
    if (p.behind) continue;
    ctx.strokeStyle = shot.hit ? "rgba(255,140,120,0.5)" : "rgba(255,240,190,0.35)";
    ctx.beginPath();
    ctx.moveTo(x1, y1);
    ctx.lineTo(p.column, horizon + (EYE * proj) / p.perp - p.size * 0.6);
    ctx.stroke();
  }
}
@@ -0,0 +1,206 @@
/**
 * The board from above.
 *
 * It is three things: the minimap in the corner, the full-screen map Tab
 * holds open, and the view a phone plays in, where a raycaster with touch
 * look would be miserable. One function, drawn into whatever box it is given.
 *
 * Nothing here knows what the game is. The tiles, the shots the server let
 * us see, the last-seen marks and the bodies are generic; what a letter on
 * the grid is coloured, what else lies on the floor and what a body wears
 * for a badge, the game says through `opts` — see `drawTopdown`.
 */
const WALL_COLOUR = "#20242d";
const FLOOR_COLOUR = "#171a21";
const plainTile = (cell) => (cell === "#" ? WALL_COLOUR : FLOOR_COLOUR);
const never = () => false;
const nothing = () => {};
const grey = () => "#888";
/**
 * Draw the whole map into `box` (canvas pixels). `look(player)` gives the
 * smoothed position; `opts.labels` draws the grid's letters and names, which
 * only fit on the big version; `opts.marks` are the last-seen rings from
 * `presence.js`, which answer "where did they go" without claiming anybody
 * is there now; `opts.tiles: false` leaves out the map itself, for a caller
 * that has already drawn it once and kept it.
 *
 * The game's holes, each optional: `opts.tile(cell)` colours a letter,
 * `opts.label(cell)` says whether the letter is written on the big map,
 * `opts.under(ctx, snap, s)` draws what lies on the floor beneath the bodies,
 * `opts.over(ctx, snap, s)` what hides them from above, `opts.trim(player)`
 * is the ring round a body and `opts.badges(ctx, player, x, y, r)` whatever it
 * wears. `s` is world units to canvas pixels.
 *
 * Called with no snapshot it draws the tiles and stops, which is exactly
 * that layer.
 */
export function drawTopdown(ctx, map, snap, look, box, opts = {}) {
  const cols = map.rows[0].length;
  const s = box.w / (cols * map.tile);
  const labels = opts.labels !== false;
  const tiles = opts.tiles !== false;
  const tileColour = opts.tile || plainTile;
  const label = opts.label || never;
  ctx.save();
  ctx.beginPath();
  ctx.rect(box.x, box.y, box.w, box.h);
  ctx.clip();
  ctx.translate(box.x, box.y);
  const t = map.tile * s;
  if (tiles)
    for (let row = 0; row < map.rows.length; row++)
      for (let col = 0; col < map.rows[row].length; col++) {
        const cell = map.rows[row][col];
        ctx.fillStyle = tileColour(cell);
        ctx.fillRect(col * t, row * t, t + 0.6, t + 0.6);
        if (labels && label(cell)) {
          ctx.fillStyle = "#6b5f3a";
          ctx.font = `${Math.round(t * 0.5)}px system-ui, sans-serif`;
          ctx.fillText(cell, col * t + t * 0.3, row * t + t * 0.68);
        }
      }
  if (!snap) {
    ctx.restore();
    return;
  }
  (opts.under || nothing)(ctx, snap, s);
  for (const shot of snap.shots) {
    ctx.strokeStyle = shot.hit ? "rgba(255,120,110,0.85)" : "rgba(255,240,180,0.5)";
    ctx.lineWidth = Math.max(1, 2 * s);
    ctx.beginPath();
    ctx.moveTo(shot.x1 * s, shot.y1 * s);
    ctx.lineTo(shot.x2 * s, shot.y2 * s);
    ctx.stroke();
  }
  // Under the living: a ring where somebody was last seen is never allowed
  // to sit on top of a body that is actually in sight.
  if (opts.marks) for (const mark of opts.marks) drawMark(ctx, mark, s);
  const trim = opts.trim || grey;
  const badges = opts.badges || nothing;
  for (const player of snap.players) drawPlayer(ctx, player, look(player), s, snap.me, labels, trim, badges);
  (opts.over || nothing)(ctx, snap, s);
  ctx.restore();
}
/**
 * Where somebody was last seen: a hollow ring and the way they were facing,
 * dimming away. Hollow because a filled dot on this map means a body, and
 * this is a memory of one.
 */
function drawMark(ctx, m, s) {
  const x = m.x * s;
  const y = m.y * s;
  const r = Math.max(2.5, 16 * s);
  ctx.save();
  ctx.globalAlpha = 0.8 * m.fade;
  ctx.strokeStyle = m.mate ? "#4fb3d9" : "#e35d5b";
  ctx.lineWidth = Math.max(1, 2 * s);
  disc(ctx, x, y, r, false, true);
  ctx.beginPath();
  ctx.moveTo(x, y);
  ctx.lineTo(x + Math.cos(m.angle) * r * 1.7, y + Math.sin(m.angle) * r * 1.7);
  ctx.stroke();
  ctx.restore();
}
export function disc(ctx, x, y, r, fill, stroke) {
  ctx.beginPath();
  ctx.arc(x, y, r, 0, 7);
  if (fill) ctx.fill();
  if (stroke) ctx.stroke();
}
/**
 * Everybody is a dot and you are an arrow — but a team mate is on the map
 * whether you can see them or not, with their initial in the dot and a cross
 * when they are down, and an enemy is only ever drawn while they are alive
 * and in sight. The map stays honest about vision and legible about your own.
 */
function drawPlayer(ctx, p, pos, s, me, labels, trim, badges) {
  const mine = p.id === me.id;
  if (!p.alive && !p.mate) return; // a corpse is not a threat and not a call-out
  const x = pos.x * s;
  const y = pos.y * s;
  const r = Math.max(2.5, 16 * s);
  const body = !p.alive ? "#555a63" : p.mate ? (mine ? "#eaeaea" : "#4fb3d9") : "#e35d5b";
  if (mine && p.alive) {
    ctx.save();
    ctx.translate(x, y);
    ctx.rotate(pos.angle);
    ctx.fillStyle = body;
    ctx.beginPath();
    ctx.moveTo(r * 1.5, 0);
    ctx.lineTo(-r, r * 0.9);
    ctx.lineTo(-r * 0.4, 0);
    ctx.lineTo(-r, -r * 0.9);
    ctx.closePath();
    ctx.fill();
    ctx.restore();
    return;
  }
  // The dead of your own team keep their place on the map, crossed out.
  if (!p.alive) {
    ctx.strokeStyle = "#6a707c";
    ctx.lineWidth = Math.max(1, 2 * s);
    ctx.beginPath();
    ctx.moveTo(x - r * 0.8, y - r * 0.8);
    ctx.lineTo(x + r * 0.8, y + r * 0.8);
    ctx.moveTo(x + r * 0.8, y - r * 0.8);
    ctx.lineTo(x - r * 0.8, y + r * 0.8);
    ctx.stroke();
    if (labels) {
      ctx.fillStyle = "rgba(180,185,195,0.6)";
      ctx.font = `${Math.round(11 * Math.max(1, s * 2))}px system-ui, sans-serif`;
      ctx.textAlign = "center";
      ctx.fillText(p.name, x, y - r * 1.9);
      ctx.textAlign = "left";
    }
    return;
  }
  ctx.fillStyle = body;
  ctx.beginPath();
  ctx.arc(x, y, r, 0, 7);
  ctx.fill();
  ctx.strokeStyle = trim(p);
  ctx.lineWidth = Math.max(1, 3 * s);
  ctx.stroke();
  ctx.strokeStyle = body;
  ctx.beginPath();
  ctx.moveTo(x, y);
  ctx.lineTo(x + Math.cos(pos.angle) * r * 2, y + Math.sin(pos.angle) * r * 2);
  ctx.stroke();
  // The initial inside the dot, when the dot is big enough to hold one.
  if (p.mate && r >= 6) {
    ctx.fillStyle = "#0c1016";
    ctx.font = `${Math.round(r * 1.2)}px system-ui, sans-serif`;
    ctx.textAlign = "center";
    ctx.fillText((p.name[0] || "?").toUpperCase(), x, y + r * 0.45);
    ctx.textAlign = "left";
  }
  badges(ctx, p, x, y, r);
  if (labels) {
    ctx.fillStyle = "rgba(235,235,235,0.75)";
    ctx.font = `${Math.round(11 * Math.max(1, s * 2))}px system-ui, sans-serif`;
    ctx.textAlign = "center";
    ctx.fillText(p.name, x, y - r * 1.9);
    ctx.textAlign = "left";
  }
  if (p.hp < 100) {
    ctx.fillStyle = "#0008";
    ctx.fillRect(x - r, y + r * 1.2, r * 2, 3);
    ctx.fillStyle = "#6fcf6f";
    ctx.fillRect(x - r, y + r * 1.2, r * 2 * (p.hp / 100), 3);
  }
}
@@ -1,40 +1,13 @@
/**
 * The world, drawn from inside the player's head.
 *
 * One pass of rays across the screen builds the walls and a depth buffer;
 * everything else — bodies, the spike, ability zones, tracers — is a
 * billboard tested against that buffer, so a body behind a corner is not
 * drawn at all. Smoke is measured along each ray, not painted as a disc:
 * cross one and everything past it fogs.
 *
 * The ray loop allocates nothing and draws nothing: it writes a shade level,
 * a face and a slice into the column arrays, and `slices.js` collapses those
 * into runs so a flat wall costs one `fillRect` and not one a column.
 * Colours come out of a table built once, the depth and column buffers are
 * kept between frames, and the sprite list is sorted in a buffer the scene
 * owns.
 * This game's first-person picture: the engine's renderer (`engine/scene.js`)
 * with the Valorant things in it — the spike, the ult orbs, the ability
 * zones, an agent's colour on a body and the spike on the carrier's back.
 * Smoke and a wall fog the rays; nothing else does.
 */
import { swell } from "./presence.js";
import { makeColumns, SKY, wallRuns } from "./slices.js";
import {
  castRay,
  columnOffset,
  hitResult,
  project,
  projection,
  projectResult,
  sliceHeight,
  smokeAlong,
  spriteColumnVisible,
  wallLight,
} from "./raycast.js";
import { drawBlob, drawScene as drawWorld, makeScene, WALL } from "./engine/scene.js";
const EYE = 40; // half a tile up: the horizon sits on the middle of the wall
const WALL = 80; // walls are one tile tall
const BODY = 58; // a person, in world units
const MAX_SIGHT = 1800;
const LEVELS = 48;
export { makeScene };
export const AGENT_COLOUR = {
  ember: "#f08a4b",
@@ -44,352 +17,35 @@
export const AGENT_COLOUR = {
  rook: "#d96a8f",
};
// Wall colours, quantised into levels and built once, so the ray loop never
// builds a string. How dark a slice is comes from `wallLight`, which already
// knows about distance and which face was struck.
const SHADES = (() => {
  const out = [];
  for (let i = 0; i < LEVELS; i++) {
    const k = (i + 0.5) / LEVELS;
    out.push(`rgb(${Math.round(150 * k)},${Math.round(158 * k)},${Math.round(178 * k)})`);
  }
  return out;
})();
const FOG = "rgb(198,203,212)";
export function makeScene() {
  return {
    depth: new Float32Array(0),
    cols: makeColumns(0),
    runs: [],
    hit: hitResult(),
    proj: projectResult(),
    order: [],
    smokes: [],
    sky: null,
    skyKey: "",
  };
/** What a ray fogs through: a smoke, or a wall an ability put up, once it has landed. */
function fog(snap, out) {
  for (const zone of snap.zones) if ((zone.k === "smoke" || zone.k === "wall") && zone.f <= 0) out.push(zone);
}
const levelOf = (light) => Math.min(LEVELS - 1, Math.max(0, (light * LEVELS) | 0));
/**
 * The walls, a rectangle a run rather than a rectangle a column. The runs
 * are stretches where the shade level, the face, the fog and the geometry
 * all agree — see `slices.js` — so this is the same picture the per-column
 * loop drew, in a fraction of the calls.
 */
function drawWalls(ctx, scene, step) {
  const runs = scene.runs;
  const used = wallRuns(scene.cols, runs);
  for (let r = 0; r < used; r++) {
    const run = runs[r];
    const x = run.from * step;
    const wide = (run.to - run.from + 1) * step + 1;
    ctx.fillStyle = SHADES[run.level];
    ctx.fillRect(x, run.top, wide, run.high);
    if (run.haze > 0.01) {
      ctx.globalAlpha = run.haze;
      ctx.fillStyle = FOG;
      ctx.fillRect(x, run.top, wide, run.high);
      ctx.globalAlpha = 1;
    }
  }
}
/**
 * Draw one frame.
 *
 * `world` carries the map (`solid`, `tile`), `eye` is where the camera
 * stands and looks, `snap` is the last snapshot the server sent, and `view`
 * is the frame: its pixel size, and `look(player)` for the smoothed position
 * to draw somebody at.
 */
export function drawScene(ctx, scene, world, eye, snap, view) {
  const W = view.width;
  const H = view.height;
  // One ray every other column of the buffer, and the wall slice two columns
  // wide: flat shading does not reward a ray a pixel, and the sprites are
  // still drawn at the buffer's own resolution. Below that width a picture
  // this coarse stops being one.
  const step = W >= 640 ? 2 : 1;
  const columns = Math.ceil(W / step);
  if (scene.depth.length !== columns) {
    scene.depth = new Float32Array(columns);
    scene.cols = makeColumns(columns);
  }
  const proj = projection(W);
  const horizon = H / 2;
  drawSky(ctx, scene, W, H, horizon);
  const smokes = scene.smokes;
  smokes.length = 0;
  for (const zone of snap.zones) if ((zone.k === "smoke" || zone.k === "wall") && zone.f <= 0) smokes.push(zone);
  const depth = scene.depth;
  const cols = scene.cols;
  const fog = cols.haze;
  const hit = scene.hit;
  for (let i = 0; i < columns; i++) {
    const offset = columnOffset(i * step + step / 2, W);
    const angle = eye.angle + offset;
    castRay(world.solid, eye.x, eye.y, angle, world.tile, MAX_SIGHT, hit);
    const perp = Math.max(1, hit.dist * Math.cos(offset));
    depth[i] = perp;
    let haze = 0;
    if (smokes.length) {
      const dx = Math.cos(angle);
      const dy = Math.sin(angle);
      for (let s = 0; s < smokes.length; s++) {
        const z = smokes[s];
        haze += smokeAlong(eye.x, eye.y, dx, dy, z.x, z.y, z.r, hit.dist);
        if (haze >= 1) break;
      }
      haze = Math.min(1, haze);
    }
    fog[i] = haze;
    if (!hit.wall) {
      cols.level[i] = SKY;
      continue;
    }
    const h = Math.min(H * 6, sliceHeight(perp, proj, WALL));
    cols.level[i] = levelOf(wallLight(perp, hit.side, world.tile));
    cols.side[i] = hit.side;
    cols.top[i] = horizon - h / 2;
    cols.high[i] = h;
  }
  drawWalls(ctx, scene, step);
  drawThings(ctx, scene, world, eye, snap, view, proj, horizon, step, columns);
}
/** The two bands: a dark ceiling above the horizon, a warmer floor below. */
function drawSky(ctx, scene, W, H, horizon) {
  const key = `${W}x${H}`;
  if (scene.skyKey !== key || !scene.sky) {
    const sky = ctx.createLinearGradient(0, 0, 0, H);
    sky.addColorStop(0, "#0a0c11");
    sky.addColorStop(0.49, "#23262f");
    sky.addColorStop(0.5, "#3a3026");
    sky.addColorStop(1, "#15120e");
    scene.sky = sky;
    scene.skyKey = key;
  }
  ctx.fillStyle = scene.sky;
  ctx.fillRect(0, 0, W, H);
  ctx.fillStyle = "rgba(255,255,255,0.09)";
  ctx.fillRect(0, horizon - 1, W, 2);
}
/**
 * Everything that is not a wall, far to near, each one clipped to the screen
 * columns where it beats the wall behind it.
 */
function drawThings(ctx, scene, world, eye, snap, view, proj, horizon, step, columns) {
  const W = view.width;
  const things = scene.order;
  things.length = 0;
/** Everything on the floor that is not a body: zones, orbs, the spike. */
function props(snap, out) {
  for (const zone of snap.zones) {
    if (zone.k === "smoke") continue;
    things.push({ kind: "zone", zone, x: zone.x, y: zone.y });
    out.push({ kind: "zone", zone, x: zone.x, y: zone.y, draw: drawZone });
  }
  for (const orb of snap.orbs) things.push({ kind: "orb", x: orb.x, y: orb.y });
  for (const orb of snap.orbs) out.push({ kind: "orb", x: orb.x, y: orb.y, draw: drawOrb });
  if (snap.spike.x !== null && !snap.spike.carried)
    things.push({ kind: "spike", x: snap.spike.x, y: snap.spike.y });
  for (const player of snap.players) {
    if (player.id === snap.me.id) continue;
    const at = view.look(player);
    // How far into sight this body is: 0 the moment it appears, 1 solid.
    // See presence.js — a body that pops into existence reads as a bug.
    const shown = view.shown ? view.shown(player) : 1;
    things.push({ kind: "body", player, shown, x: at.x, y: at.y, angle: at.angle });
  }
  // Where somebody was last seen, dimming away. It stands where they were,
  // so a wall between you and that spot hides it like anything else.
  if (view.marks) for (const mark of view.marks) things.push({ kind: "mark", mark, x: mark.x, y: mark.y });
  const p = scene.proj;
  for (const thing of things) {
    project(eye.x, eye.y, eye.angle, thing.x, thing.y, W, proj, BODY, p);
    thing.perp = p.perp;
    thing.column = p.column;
    thing.size = p.size;
    thing.behind = p.behind;
  }
  things.sort((a, b) => b.perp - a.perp);
  for (const thing of things) {
    if (thing.behind) continue;
    const floorY = horizon + (EYE * proj) / thing.perp;
    const haze = hazeAt(scene, thing.column, step, columns);
    const arriving = thing.kind === "body" ? thing.shown : thing.kind === "mark" ? thing.mark.fade : 1;
    ctx.globalAlpha = Math.max(0, 1 - haze) * arriving;
    if (ctx.globalAlpha < 0.05) continue;
    if (thing.kind === "body") drawBody(ctx, scene, thing, floorY, step, columns);
    else if (thing.kind === "mark") drawMark(ctx, scene, thing, floorY, step, columns);
    else if (thing.kind === "spike") drawSpike(ctx, scene, thing, floorY, snap, step, columns);
    else if (thing.kind === "orb") drawBlob(ctx, scene, thing, floorY, "#c9a0ff", 0.35, step, columns);
    else drawZone(ctx, scene, thing, floorY, proj, step, columns);
    ctx.globalAlpha = 1;
  }
  ctx.globalAlpha = 1;
  drawTracers(ctx, scene, eye, snap, W, proj, horizon);
    out.push({ kind: "spike", x: snap.spike.x, y: snap.spike.y, planted: snap.spike.planted, draw: drawSpike });
}
const hazeAt = (scene, column, step, columns) => {
  const i = Math.max(0, Math.min(columns - 1, Math.round(column / step)));
  return scene.cols.haze[i] ?? 0;
};
const trim = (p) => AGENT_COLOUR[p.agent] || "#999";
const badge = (p) => (p.spike ? "#f0d060" : null);
/**
 * The visible runs of a sprite: the stretches of screen column where it is
 * nearer than the wall. Two rectangles at most in practice, and the caller
 * clips its drawing to each.
 */
function withRuns(ctx, scene, left, right, perp, step, columns, draw) {
  let runStart = -1;
  const from = Math.max(0, Math.floor(left / step));
  const to = Math.min(columns - 1, Math.ceil(right / step));
  for (let i = from; i <= to + 1; i++) {
    const shown = i <= to && spriteColumnVisible(perp, scene.depth[i]);
    if (shown && runStart < 0) runStart = i;
    if (!shown && runStart >= 0) {
      ctx.save();
      ctx.beginPath();
      ctx.rect(runStart * step - 0.5, 0, (i - runStart) * step + 1, 1e5);
      ctx.clip();
      draw();
      ctx.restore();
      runStart = -1;
    }
  }
export function drawScene(ctx, scene, world, eye, snap, view) {
  drawWorld(ctx, scene, world, eye, snap, { ...view, fog, props, trim, badge });
}
function drawBody(ctx, scene, thing, floorY, step, columns) {
  const p = thing.player;
  // A body arriving grows from its feet as it fades in, so it reads as
  // somebody coming round the corner rather than one appearing there.
  const h = thing.size * swell(thing.shown ?? 1);
  const w = h * 0.46;
  const cx = thing.column;
  const top = floorY - h;
  const mate = p.mate;
  // The dead lie down. No tag, no chevron, no agent colour: if something is
  // upright with a marker over it, it is alive and it can shoot you.
  if (!p.alive) {
    const lie = h * 0.16;
    withRuns(ctx, scene, cx - w * 1.1, cx + w * 1.1, thing.perp, step, columns, () => {
      ctx.fillStyle = "#4a4e57";
      ctx.beginPath();
      ctx.ellipse(cx, floorY - lie * 0.4, w * 1.05, lie, 0, 0, 7);
      ctx.fill();
      ctx.strokeStyle = "#23262d";
      ctx.lineWidth = Math.max(1, h * 0.02);
      ctx.stroke();
    });
    return;
  }
  const skin = mate ? "#3f9fd6" : "#d8483f";
  const trim = AGENT_COLOUR[p.agent] || "#999";
  const edge = Math.max(1.2, h * 0.05);
  withRuns(ctx, scene, cx - w * 1.2, cx + w * 1.5, thing.perp, step, columns, () => {
    // Body and head, each with a hard dark edge: the silhouette is what
    // carries across a dim room, where the colour does not.
    ctx.fillStyle = skin;
    ctx.fillRect(cx - w / 2, top + h * 0.28, w, h * 0.72);
    ctx.strokeStyle = "#0b0d11";
    ctx.lineWidth = edge;
    ctx.strokeRect(cx - w / 2, top + h * 0.28, w, h * 0.72);
    ctx.fillStyle = trim;
    ctx.fillRect(cx - w / 2, top + h * 0.34, w, h * 0.1);
    ctx.beginPath();
    ctx.arc(cx, top + h * 0.17, h * 0.15, 0, 7);
    ctx.fillStyle = skin;
    ctx.fill();
    ctx.strokeStyle = "#0b0d11";
    ctx.stroke();
    if (p.spike) {
      ctx.fillStyle = "#f0d060";
      ctx.fillRect(cx + w * 0.5, top + h * 0.4, w * 0.3, h * 0.3);
    }
    if (p.hp < 100) {
      ctx.fillStyle = "#000a";
      ctx.fillRect(cx - w / 2, top - h * 0.1, w, h * 0.06);
      ctx.fillStyle = mate ? "#6fcf6f" : "#e8b04a";
      ctx.fillRect(cx - w / 2, top - h * 0.1, w * (p.hp / 100), h * 0.06);
    }
    if (mate) tag(ctx, p, cx, top, h);
    else chevron(ctx, cx, top, h);
  });
}
/**
 * A mark where somebody was last seen: an empty outline and a scuff on the
 * floor, dimming away over a second. Deliberately not a body — nothing is
 * filled, there is no head and no chevron — because it is a memory of a
 * sighting and must never be mistaken for one.
 */
function drawMark(ctx, scene, thing, floorY, step, columns) {
  const h = thing.size * 0.9;
  const w = h * 0.46;
  const cx = thing.column;
  const top = floorY - h;
  withRuns(ctx, scene, cx - w * 1.2, cx + w * 1.2, thing.perp, step, columns, () => {
    ctx.strokeStyle = thing.mark.mate ? "rgba(120,180,230,0.85)" : "rgba(235,150,120,0.9)";
    ctx.lineWidth = Math.max(1, h * 0.035);
    ctx.strokeRect(cx - w / 2, top + h * 0.28, w, h * 0.72);
    ctx.fillStyle = "rgba(10,12,16,0.45)";
    ctx.fillRect(cx - w * 0.7, floorY - h * 0.04, w * 1.4, h * 0.05);
  });
}
/** An enemy wears a chevron: a shape, not a hue, for anyone whose eyes read
 * red and blue the same way. */
function chevron(ctx, cx, top, h) {
  const size = Math.max(4, h * 0.16);
  const y = top - h * 0.16;
  ctx.beginPath();
  ctx.moveTo(cx - size, y - size);
  ctx.lineTo(cx + size, y - size);
  ctx.lineTo(cx, y);
  ctx.closePath();
  ctx.fillStyle = "#ff6f5e";
  ctx.fill();
  ctx.lineWidth = Math.max(1, h * 0.02);
  ctx.strokeStyle = "#140a08";
  ctx.stroke();
}
/** A team mate wears their name and a pip of their health — never an enemy. */
function tag(ctx, p, cx, top, h) {
  const size = Math.max(9, Math.min(18, h * 0.16));
  const y = top - h * 0.34;
  ctx.font = `${size}px system-ui, sans-serif`;
  ctx.textAlign = "center";
  const width = ctx.measureText(p.name).width + size * 1.4;
  ctx.fillStyle = "rgba(10,12,16,0.65)";
  ctx.fillRect(cx - width / 2, y, width, size * 1.4);
  ctx.fillStyle = p.hp > 60 ? "#6fcf6f" : p.hp > 25 ? "#e0a040" : "#e05a4a";
  ctx.fillRect(cx - width / 2 + size * 0.25, y + size * 0.35, size * 0.45, size * 0.7);
  ctx.fillStyle = "#cfe8ff";
  ctx.fillText(p.name, cx + size * 0.4, y + size * 1.05);
  ctx.textAlign = "left";
}
function drawSpike(ctx, scene, thing, floorY, snap, step, columns) {
function drawSpike(ctx, thing, floorY, proj, clip) {
  const h = thing.size * 0.42;
  const cx = thing.column;
  const planted = snap.spike.planted;
  const planted = thing.planted;
  const blink = planted && Math.floor(Date.now() / 220) % 2 === 0;
  withRuns(ctx, scene, cx - h, cx + h, thing.perp, step, columns, () => {
  clip(thing, cx - h, cx + h, () => {
    ctx.fillStyle = planted ? (blink ? "#ff5b4a" : "#7d2a22") : "#c8b45c";
    ctx.fillRect(cx - h * 0.28, floorY - h, h * 0.56, h);
    ctx.fillStyle = planted && blink ? "#ffd7a0" : "#2a2418";
@@ -397,24 +53,15 @@
function drawSpike(ctx, scene, thing, floorY, snap, step, columns) {
  });
}
function drawBlob(ctx, scene, thing, floorY, colour, scale, step, columns) {
  const r = thing.size * scale;
  const cx = thing.column;
  withRuns(ctx, scene, cx - r, cx + r, thing.perp, step, columns, () => {
    ctx.fillStyle = colour;
    ctx.beginPath();
    ctx.arc(cx, floorY - r, r, 0, 7);
    ctx.fill();
  });
}
const drawOrb = (ctx, thing, floorY, proj, clip) => drawBlob(ctx, thing, floorY, "#c9a0ff", 0.35, clip);
function drawZone(ctx, scene, thing, floorY, proj, step, columns) {
function drawZone(ctx, thing, floorY, proj, clip) {
  const z = thing.zone;
  const wide = (z.r * proj) / thing.perp;
  const cx = thing.column;
  if (z.k === "wall") {
    const h = (WALL * proj) / thing.perp;
    withRuns(ctx, scene, cx - wide, cx + wide, thing.perp, step, columns, () => {
    clip(thing, cx - wide, cx + wide, () => {
      ctx.fillStyle = "rgba(120,200,255,0.45)";
      ctx.fillRect(cx - wide, floorY - h, wide * 2, h);
      ctx.strokeStyle = "rgba(180,225,255,0.8)";
@@ -424,30 +71,10 @@
function drawZone(ctx, scene, thing, floorY, proj, step, columns) {
  }
  const colour =
    z.k === "molly" ? "rgba(235,120,50,0.6)" : z.k === "flash" ? "rgba(255,235,170,0.9)" : z.k === "heal" ? "rgba(120,230,140,0.55)" : z.k === "trip" ? "rgba(230,200,90,0.75)" : "rgba(90,220,170,0.5)";
  withRuns(ctx, scene, cx - wide, cx + wide, thing.perp, step, columns, () => {
  clip(thing, cx - wide, cx + wide, () => {
    ctx.fillStyle = colour;
    ctx.beginPath();
    ctx.ellipse(cx, floorY, wide, Math.max(2, wide * 0.3), 0, 0, 7);
    ctx.fill();
  });
}
/** Shots the server let us see, as a line through the world. */
function drawTracers(ctx, scene, eye, snap, W, proj, horizon) {
  if (!snap.shots.length) return;
  const p = scene.proj;
  ctx.lineWidth = 2;
  for (const shot of snap.shots) {
    project(eye.x, eye.y, eye.angle, shot.x1, shot.y1, W, proj, BODY, p);
    if (p.behind) continue;
    const x1 = p.column;
    const y1 = horizon + (EYE * proj) / p.perp - p.size * 0.6;
    project(eye.x, eye.y, eye.angle, shot.x2, shot.y2, W, proj, BODY, p);
    if (p.behind) continue;
    ctx.strokeStyle = shot.hit ? "rgba(255,140,120,0.5)" : "rgba(255,240,190,0.35)";
    ctx.beginPath();
    ctx.moveTo(x1, y1);
    ctx.lineTo(p.column, horizon + (EYE * proj) / p.perp - p.size * 0.6);
    ctx.stroke();
  }
}
@@ -1,11 +1,11 @@
/**
 * The board from above — the drawing this game started as.
 *
 * It is three things now: the minimap in the corner, the full-screen map Tab
 * holds open, and the view a phone plays in, where a raycaster with touch
 * look would be miserable. One function, drawn into whatever box it is given.
 * This game's map from above: the engine's board (`engine/topdown.js`) with
 * the Valorant things on it — site letters, spawn tints, the orbs, the ability
 * zones, the spike and its defuse bar, an agent's colour round a dot, the
 * spike on the carrier and a blinded player's white eye.
 */
import { disc, drawTopdown as drawBoard } from "./engine/topdown.js";
import { AGENT_COLOUR } from "./scene.js";
const TILE_COLOUR = {
@@ -17,48 +17,12 @@
const TILE_COLOUR = {
  ".": "#171a21",
};
/**
 * Draw the whole map into `box` (canvas pixels). `look(player)` gives the
 * smoothed position; `opts.labels` draws site letters and names, which only
 * fit on the big version; `opts.marks` are the last-seen rings from
 * `presence.js`, which answer "where did they go" without claiming anybody
 * is there now; `opts.tiles: false` leaves out the map itself, for a caller
 * that has already drawn it once and kept it — it is 570 rectangles of a
 * map that never changes.
 *
 * Called with no snapshot it draws the tiles and stops, which is exactly
 * that layer.
 */
export function drawTopdown(ctx, map, snap, look, box, opts = {}) {
  const cols = map.rows[0].length;
  const s = box.w / (cols * map.tile);
  const labels = opts.labels !== false;
  const tiles = opts.tiles !== false;
  ctx.save();
  ctx.beginPath();
  ctx.rect(box.x, box.y, box.w, box.h);
  ctx.clip();
  ctx.translate(box.x, box.y);
  const t = map.tile * s;
  if (tiles)
    for (let row = 0; row < map.rows.length; row++)
      for (let col = 0; col < map.rows[row].length; col++) {
        const cell = map.rows[row][col];
        ctx.fillStyle = TILE_COLOUR[cell] ?? "#171a21";
        ctx.fillRect(col * t, row * t, t + 0.6, t + 0.6);
        if (labels && (cell === "A" || cell === "B")) {
          ctx.fillStyle = "#6b5f3a";
          ctx.font = `${Math.round(t * 0.5)}px system-ui, sans-serif`;
          ctx.fillText(cell, col * t + t * 0.3, row * t + t * 0.68);
        }
      }
  if (!snap) {
    ctx.restore();
    return;
  }
const tile = (cell) => TILE_COLOUR[cell] ?? "#171a21";
const label = (cell) => cell === "A" || cell === "B";
const trim = (p) => AGENT_COLOUR[p.agent] || "#888";
/** Orbs, then every zone but smoke, then the spike: what lies under the bodies. */
function under(ctx, snap, s) {
  for (const orb of snap.orbs) {
    ctx.fillStyle = "#c9a0ff";
    ctx.beginPath();
@@ -78,23 +42,27 @@
export function drawTopdown(ctx, map, snap, look, box, opts = {}) {
      ctx.fillRect(x - 20 * s, y + 12 * s, 40 * s * (snap.spike.defuse / 7), 3);
    }
  }
}
  for (const shot of snap.shots) {
    ctx.strokeStyle = shot.hit ? "rgba(255,120,110,0.85)" : "rgba(255,240,180,0.5)";
    ctx.lineWidth = Math.max(1, 2 * s);
    ctx.beginPath();
    ctx.moveTo(shot.x1 * s, shot.y1 * s);
    ctx.lineTo(shot.x2 * s, shot.y2 * s);
    ctx.stroke();
  }
  // Under the living: a ring where somebody was last seen is never allowed
  // to sit on top of a body that is actually in sight.
  if (opts.marks) for (const mark of opts.marks) drawMark(ctx, mark, s);
  for (const player of snap.players) drawPlayer(ctx, player, look(player), s, snap.me, labels);
  // Smoke last: on this view it hides what is under it, as it should.
/** Smoke last: on this view it hides what is under it, as it should. */
function over(ctx, snap, s) {
  for (const zone of snap.zones) if (zone.k === "smoke" && zone.f <= 0) drawZone(ctx, zone, s);
  ctx.restore();
}
/** The spike on a carrier's back, and the white eye of somebody blinded. */
function badges(ctx, p, x, y, r) {
  if (p.spike) {
    ctx.fillStyle = "#f0d060";
    ctx.fillRect(x - r * 0.4, y - r * 1.8, r * 0.8, r * 0.8);
  }
  if (p.blind) {
    ctx.fillStyle = "rgba(255,255,255,0.8)";
    disc(ctx, x, y - r * 1.6, r * 0.35, true);
  }
}
export function drawTopdown(ctx, map, snap, look, box, opts = {}) {
  drawBoard(ctx, map, snap, look, box, { ...opts, tile, label, under, over, trim, badges });
}
function drawZone(ctx, z, s) {
@@ -126,125 +94,3 @@
function drawZone(ctx, z, s) {
    disc(ctx, x, y, 14 * s, true);
  }
}
/**
 * Where somebody was last seen: a hollow ring and the way they were facing,
 * dimming away. Hollow because a filled dot on this map means a body, and
 * this is a memory of one.
 */
function drawMark(ctx, m, s) {
  const x = m.x * s;
  const y = m.y * s;
  const r = Math.max(2.5, 16 * s);
  ctx.save();
  ctx.globalAlpha = 0.8 * m.fade;
  ctx.strokeStyle = m.mate ? "#4fb3d9" : "#e35d5b";
  ctx.lineWidth = Math.max(1, 2 * s);
  disc(ctx, x, y, r, false, true);
  ctx.beginPath();
  ctx.moveTo(x, y);
  ctx.lineTo(x + Math.cos(m.angle) * r * 1.7, y + Math.sin(m.angle) * r * 1.7);
  ctx.stroke();
  ctx.restore();
}
function disc(ctx, x, y, r, fill, stroke) {
  ctx.beginPath();
  ctx.arc(x, y, r, 0, 7);
  if (fill) ctx.fill();
  if (stroke) ctx.stroke();
}
/**
 * Everybody is a dot and you are an arrow — but a team mate is on the map
 * whether you can see them or not, with their initial in the dot and a cross
 * when they are down, and an enemy is only ever drawn while they are alive
 * and in sight. The map stays honest about vision and legible about your own.
 */
function drawPlayer(ctx, p, pos, s, me, labels) {
  const mine = p.id === me.id;
  if (!p.alive && !p.mate) return; // a corpse is not a threat and not a call-out
  const x = pos.x * s;
  const y = pos.y * s;
  const r = Math.max(2.5, 16 * s);
  const body = !p.alive ? "#555a63" : p.mate ? (mine ? "#eaeaea" : "#4fb3d9") : "#e35d5b";
  if (mine && p.alive) {
    ctx.save();
    ctx.translate(x, y);
    ctx.rotate(pos.angle);
    ctx.fillStyle = body;
    ctx.beginPath();
    ctx.moveTo(r * 1.5, 0);
    ctx.lineTo(-r, r * 0.9);
    ctx.lineTo(-r * 0.4, 0);
    ctx.lineTo(-r, -r * 0.9);
    ctx.closePath();
    ctx.fill();
    ctx.restore();
    return;
  }
  // The dead of your own team keep their place on the map, crossed out.
  if (!p.alive) {
    ctx.strokeStyle = "#6a707c";
    ctx.lineWidth = Math.max(1, 2 * s);
    ctx.beginPath();
    ctx.moveTo(x - r * 0.8, y - r * 0.8);
    ctx.lineTo(x + r * 0.8, y + r * 0.8);
    ctx.moveTo(x + r * 0.8, y - r * 0.8);
    ctx.lineTo(x - r * 0.8, y + r * 0.8);
    ctx.stroke();
    if (labels) {
      ctx.fillStyle = "rgba(180,185,195,0.6)";
      ctx.font = `${Math.round(11 * Math.max(1, s * 2))}px system-ui, sans-serif`;
      ctx.textAlign = "center";
      ctx.fillText(p.name, x, y - r * 1.9);
      ctx.textAlign = "left";
    }
    return;
  }
  ctx.fillStyle = body;
  ctx.beginPath();
  ctx.arc(x, y, r, 0, 7);
  ctx.fill();
  ctx.strokeStyle = AGENT_COLOUR[p.agent] || "#888";
  ctx.lineWidth = Math.max(1, 3 * s);
  ctx.stroke();
  ctx.strokeStyle = body;
  ctx.beginPath();
  ctx.moveTo(x, y);
  ctx.lineTo(x + Math.cos(pos.angle) * r * 2, y + Math.sin(pos.angle) * r * 2);
  ctx.stroke();
  // The initial inside the dot, when the dot is big enough to hold one.
  if (p.mate && r >= 6) {
    ctx.fillStyle = "#0c1016";
    ctx.font = `${Math.round(r * 1.2)}px system-ui, sans-serif`;
    ctx.textAlign = "center";
    ctx.fillText((p.name[0] || "?").toUpperCase(), x, y + r * 0.45);
    ctx.textAlign = "left";
  }
  if (p.spike) {
    ctx.fillStyle = "#f0d060";
    ctx.fillRect(x - r * 0.4, y - r * 1.8, r * 0.8, r * 0.8);
  }
  if (p.blind) {
    ctx.fillStyle = "rgba(255,255,255,0.8)";
    disc(ctx, x, y - r * 1.6, r * 0.35, true);
  }
  if (labels) {
    ctx.fillStyle = "rgba(235,235,235,0.75)";
    ctx.font = `${Math.round(11 * Math.max(1, s * 2))}px system-ui, sans-serif`;
    ctx.textAlign = "center";
    ctx.fillText(p.name, x, y - r * 1.9);
    ctx.textAlign = "left";
  }
  if (p.hp < 100) {
    ctx.fillStyle = "#0008";
    ctx.fillRect(x - r, y + r * 1.2, r * 2, 3);
    ctx.fillStyle = "#6fcf6f";
    ctx.fillRect(x - r, y + r * 1.2, r * 2 * (p.hp / 100), 3);
  }
}
@@ -6,27 +6,27 @@
 *
 * This file is the wiring: the socket, the keys and the pointer, the HUD.
 * The drawing lives beside it — `scene.js` for the first-person view,
 * `topdown.js` for the map, `gun.js` for the crosshair, `prompt.js` for the
 * line of advice and `raycast.js` for the maths all of it stands on.
 * `topdown.js` for the map, `prompt.js` for the line of advice — and the
 * machinery under `engine/`: the renderer, the feel stack, the gun.
 */
"use strict";
import { banner, drawBanner } from "./banner.js";
import { makeBeeper } from "./beep.js";
import { makeBudget, measure } from "./budget.js";
import { arrive, bodyAt, delay, feed, makeTimeline, renderTime } from "./interp.js";
import { BODY_R, moveSpeed } from "../src/glide.ts";
import { drawGun, gunFire, gunSnapshot, gunTick, makeGun } from "./gun.js";
import { makeLocal, stepLocal } from "./predict.js";
import { forget, ghosts, makePresence, shown, sighted, slide } from "./presence.js";
import { makeBudget, measure } from "./engine/budget.js";
import { arrive, bodyAt, delay, feed, makeTimeline, renderTime } from "./engine/interp.js";
import { BODY_R, moveSpeed } from "../src/engine/glide.ts";
import { drawGun, gunFire, gunSnapshot, gunTick, makeGun } from "./engine/gun.js";
import { makeLocal, stepLocal } from "./engine/predict.js";
import { forget, ghosts, makePresence, shown, sighted, slide } from "./engine/presence.js";
import { choosePrompt, REACH } from "./prompt.js";
import { renderSize, WIDTHS } from "./resolution.js";
import { renderSize, WIDTHS } from "./engine/resolution.js";
import { roster, rosterKey } from "./roster.js";
import { AGENT_COLOUR, drawScene, makeScene } from "./scene.js";
import { moveVector } from "./steer.js";
import { moveVector } from "./engine/steer.js";
import { drawTopdown } from "./topdown.js";
import { drawWatching, watching, watchLines } from "./watch.js";
import { aim as aimAt, makeYaw, settle, told, turn } from "./yaw.js";
import { aim as aimAt, makeYaw, settle, told, turn } from "./engine/yaw.js";
const $ = (id) => document.getElementById(id);
const view = $("view");
		@@ -51,7 +51,7 @@ server:
51	51	with hands: 200–350ms to react to a target they have just seen, an aim
52	52	cone that opens several degrees on the swing and only settles while they
53	53	hold the same target, and more of both when you are crossing their view
54		(`src/aim.ts`). Every roll of it comes from the match's seeded random, so
	54	(`src/engine/aim.ts`). Every roll of it comes from the match's seeded random, so
55	55	a seed replays the same round.
56	56
57	57	Agents: Ember, Veil, Sable, Mender, Rook — two basics bought with credits
		@@ -64,12 +64,12 @@ Guns: Classic, Ghost, Sheriff, Spectre, Phantom, Vandal, Operator.
64	64
65	65	- Your own body is drawn from a guess — the browser runs your own movement
66	66	forward from your own keys between snapshots, through the same
67		step-and-slide the server uses (`src/glide.ts`), and carries the last
	67	step-and-slide the server uses (`src/engine/glide.ts`), and carries the last
68	68	snapshot forward by up to a quarter second of held input. It is a drawing
69	69	optimisation only: nothing is sent, every snapshot leans the drawn body
70	70	back onto the server's answer, and a real disagreement is taken outright.
71	71	The lag your own keys take to reach the server (a send every 50ms, a hop,
72		a tick — `LEAD_SLACK` in `static/predict.js`) is not a disagreement: the
	72	a tick — `LEAD_SLACK` in `static/engine/predict.js`) is not a disagreement: the
73	73	drawn body may lead the answer by that much along the way it is going and
74	74	is left alone there, so a start is not yanked back and a stop is not
75	75	dragged on. Anywhere the server would refuse — a wall, the spawn pen in
		@@ -79,8 +79,8 @@ Guns: Classic, Ghost, Sheriff, Spectre, Phantom, Vandal, Operator.
79	79	second kick; whether it landed is still only the server's to say.
80	80	Where you are looking is the browser's too: the mouse moves it at frame
81	81	rate, and the server's angle is taken back only when it is telling you
82		something you did not say (`static/yaw.js`).
83		- Everybody else is drawn by entity interpolation (`static/interp.js`): each
	82	something you did not say (`static/engine/yaw.js`).
	83	- Everybody else is drawn by entity interpolation (`static/engine/interp.js`): each
84	84	body keeps the last few snapshots, and the frame is drawn about one
85	85	snapshot interval in the past, between the two that bracket that moment.
86	86	So they move at the speed the server moved them and arrive where it put
		@@ -101,19 +101,19 @@ Guns: Classic, Ghost, Sheriff, Spectre, Phantom, Vandal, Operator.
101	101	no looking up or down, and everything that is not a wall — bodies, the
102	102	spike, ability zones — is a flat billboard scaled by distance and clipped
103	103	against the walls. It is drawn into an offscreen canvas 960 columns wide
104		(`static/resolution.js`, never more than the canvas has pixels), one ray
	104	(`static/engine/resolution.js`, never more than the canvas has pixels), one ray
105	105	every other column, and scaled onto the visible one, so the frame costs the
106	106	same on a retina screen as on any other; the crosshair, the HUD and the
107	107	minimap are drawn on top at full device resolution. Columns that would draw
108		the same rectangle are batched into one fill (`static/slices.js`), the
	108	the same rectangle are batched into one fill (`static/engine/slices.js`), the
109	109	map's tiles are drawn once a size and blitted after that, and if the frame
110	110	still runs over 20ms the render width drops a rung until it fits
111		(`static/budget.js`). Fidelity is cheap here and frame rate is not.
	111	(`static/engine/budget.js`). Fidelity is cheap here and frame rate is not.
112	112	All of it is presentation: the simulation and the snapshots are untouched.
113	113	- A body you have only just been shown is faded and grown into sight over a
114	114	tenth of a second, and slid in from the direction it came if it was seen
115	115	near there before; where somebody was last seen alive leaves an outline
116		that dims away over a second (`static/presence.js`). The server still sends
	116	that dims away over a second (`static/engine/presence.js`). The server still sends
117	117	only what you can see — that is the rule, and nothing here bends it. This
118	118	is a drawing about information you already had: an enemy who steps into a
119	119	sightline has no history, and without it they appear mid-stride rather than
		@@ -177,7 +177,7 @@ says how.
177	177
178	178	## Shape
179	179
180		`src/map.ts` the grid and its geometry · `src/weapons.ts` the damage table ·
	180	`src/engine/` the machinery any game on this server stands on — the grid and its collision (`grid.ts`, `glide.ts`), the bot aim model (`aim.ts`) and the served match with its idle gate, per-address seats, positionless spectator view and per-viewer vision filter (`arena.ts`); nothing in it imports the game, and `src/engine/boundary.test.ts` keeps it that way · `static/engine/` the client feel stack and renderer — interpolation, prediction, presence, yaw, steer, raycast, scene, slices, resolution, budget, topdown, gun · `src/map.ts` this map's rows and what its letters mean · `src/weapons.ts` the damage table ·
181	181	`src/economy.ts` credits · `src/abilities.ts` the agent kits ·
182	182	`src/match.ts` the round loop (`tick(state, dt)` is the whole game and takes
183	183	no clock) · `src/bots.ts` the seats nobody is in · `src/arena.ts` the one
		@@ -18,7 +18,7 @@ import {
18	18	import { HEIGHT, WIDTH } from "./map.ts";
19	19	import { newMatch, startRound, tick } from "./match.ts";
20	20	import type { MatchState, Player, Zone } from "./state.ts";
21		import { FOV } from "../static/raycast.js";
	21	import { FOV } from "../static/engine/raycast.js";
22	22
23	23	const flashes = (): Ability[] => AGENTS.flatMap((a) => SLOTS.map((s) => a.abilities[s])).filter((a) => a.kind === "flash");
24	24
		@@ -143,7 +143,7 @@ export const buyableSlots: Slot[] = ["c", "q"];
143	143	* of the flash you get flashed, and if you are not, you do not. Facing is
144	144	* the gate. Distance only decides how long.
145	145	*
146		* The browser draws a 75° field of view (`FOV` in `static/raycast.js`), so
	146	* The browser draws a 75° field of view (`FOV` in `static/engine/raycast.js`), so
147	147	* anything inside half of that was on your screen: you looked at it, you
148	148	* pay the whole duration. Past the edge of the screen there is a little
149	149	* grace for the fact that you were probably turning, falling away quickly
		@@ -1,24 +1,10 @@
1	1	/**
2		* How a bot points a gun, tested as the pure maths it is, and then once
3		* through a whole bot to prove the gate is actually wired to the trigger.
	2	* The bot's aim (`engine/aim.ts`), once through a whole bot to prove the
	3	* reaction gate is actually wired to the trigger and the cone to the barrel.
4	4	*/
5	5
6	6	import { expect, test } from "bun:test";
7		import {
8		acquire,
9		aimCone,
10		canFire,
11		CONE_FLOOR,
12		crossRate,
13		drift,
14		emptyTrack,
15		FORGET,
16		heldFor,
17		lose,
18		REACTION_MAX,
19		REACTION_MIN,
20		reactionTime,
21		} from "./aim.ts";
	7	import { acquire, crossRate, emptyTrack, REACTION_MAX, REACTION_MIN } from "./engine/aim.ts";
22	8	import { botThink } from "./bots.ts";
23	9	import { newMatch, RUN_SPEED } from "./match.ts";
24	10	import type { MatchState, Player } from "./state.ts";
		@@ -28,106 +14,6 @@ const rolls = (...values: number[]) => {
28	14	return () => values[at++ % values.length]!;
29	15	};
30	16
31		test("the reaction a bot draws is between 200 and 350ms, whatever the roll", () => {
32		expect(reactionTime(0)).toBeCloseTo(REACTION_MIN, 9);
33		expect(reactionTime(1)).toBeCloseTo(REACTION_MAX, 9);
34		expect(reactionTime(0.5)).toBeCloseTo((REACTION_MIN + REACTION_MAX) / 2, 9);
35		// A roll out of range is still a reaction, not a bot that never shoots.
36		expect(reactionTime(-3)).toBe(REACTION_MIN);
37		expect(reactionTime(9)).toBe(REACTION_MAX);
38		});
39
40		test("the trigger gate is a pure function of when acquisition happened", () => {
41		const track = emptyTrack();
42		// Nothing in sight is never a shot, however long the round has run.
43		expect(canFire(track, 100)).toBe(false);
44
45		acquire(track, "bot-red-1", 10, { x: 0, y: 0 }, rolls(0, 0.5));
46		expect(track.reaction).toBeCloseTo(REACTION_MIN, 9);
47		expect(canFire(track, 10)).toBe(false);
48		expect(canFire(track, 10.19)).toBe(false);
49		expect(canFire(track, 10.21)).toBe(true);
50		expect(canFire(track, 12)).toBe(true);
51		expect(heldFor(track, 12)).toBeCloseTo(2, 9);
52		});
53
54		test("a new target starts the reaction again; the same one does not", () => {
55		const track = emptyTrack();
56		acquire(track, "one", 5, { x: 100, y: 100 }, rolls(1, 0.5));
57		expect(track.since).toBe(5);
58		acquire(track, "one", 5.3, { x: 180, y: 100 }, rolls(0, 0.5));
59		expect(track.since).toBe(5); // the hold carries on
60		expect(canFire(track, 5.4)).toBe(true);
61		acquire(track, "two", 5.4, { x: 0, y: 0 }, rolls(0, 0.5));
62		expect(track.since).toBe(5.4); // swinging onto somebody else costs again
63		expect(canFire(track, 5.5)).toBe(false);
64		});
65
66		test("a hold survives a blink out of sight, and no longer", () => {
67		const track = emptyTrack();
68		acquire(track, "one", 1, { x: 0, y: 0 }, rolls(0, 0.5));
69		lose(track, 1 + FORGET / 2);
70		expect(track.id).toBe("one");
71		// Back a moment later: the same hold, already through its reaction.
72		acquire(track, "one", 1 + FORGET / 2, { x: 0, y: 0 }, rolls(0, 0.5));
73		expect(track.since).toBe(1);
74		// Gone for longer than that and it is a fresh acquisition.
75		lose(track, 3);
76		expect(track.id).toBe(null);
77		acquire(track, "one", 3, { x: 0, y: 0 }, rolls(0, 0.5));
78		expect(track.since).toBe(3);
79		expect(canFire(track, 3.1)).toBe(false);
80		});
81
82		test("the cone starts wide, settles the longer one target is held, and never closes", () => {
83		const swing = aimCone(0, 0);
84		const second = aimCone(1, 0);
85		const settled = aimCone(3, 0);
86		expect(swing).toBeGreaterThan(0.08); // several degrees on the swing
87		expect(second).toBeLessThan(swing / 2);
88		expect(settled).toBeLessThan(second);
89		expect(settled).toBeGreaterThanOrEqual(CONE_FLOOR);
90		expect(aimCone(99, 0)).toBeCloseTo(CONE_FLOOR, 6);
91		});
92
93		test("a target crossing the view costs the bot accuracy", () => {
94		expect(aimCone(3, 1)).toBeGreaterThan(aimCone(3, 0) * 3);
95		expect(aimCone(3, 0.5)).toBeGreaterThan(aimCone(3, 0));
96		expect(aimCone(3, 0.5)).toBeLessThan(aimCone(3, 1));
97		// Nonsense from the caller is clamped, not multiplied out.
98		expect(aimCone(3, 50)).toBeCloseTo(aimCone(3, 1), 9);
99		});
100
101		test("crossing is measured across the sight line, not along it", () => {
102		const bot = { x: 0, y: 0 };
103		const walking = emptyTrack();
104		acquire(walking, "t", 0, { x: 300, y: 0 }, rolls(0, 0.5));
105		// Straight down the barrel: nothing to track.
106		expect(crossRate(walking, bot, { x: 260, y: 0 }, 0.1)).toBeCloseTo(0, 6);
107		const strafing = emptyTrack();
108		acquire(strafing, "t", 0, { x: 300, y: 0 }, rolls(0, 0.5));
109		// Straight across it at a run: all of it but the turn of the sight line.
110		expect(crossRate(strafing, bot, { x: 300, y: 25 }, 0.1)).toBeCloseTo(250, -1);
111		// And it remembers where the target went, so the next tick measures again.
112		expect(crossRate(strafing, bot, { x: 300, y: 25 }, 0.1)).toBeCloseTo(0, 6);
113		});
114
115		test("the error wanders inside the cone instead of being redrawn every tick", () => {
116		const track = emptyTrack();
117		acquire(track, "one", 0, { x: 0, y: 0 }, rolls(0, 1));
118		// Drawn at the edge of the swing cone on acquisition.
119		expect(Math.abs(track.error)).toBeCloseTo(aimCone(0, 0), 9);
120		// One tick moves it a little, not to somewhere unrelated.
121		const before = track.error;
122		const after = drift(track, aimCone(0, 0), 1 / 30, rolls(0.9));
123		expect(Math.abs(after - before)).toBeLessThan(aimCone(0, 0) / 4);
124		// And it is squeezed toward the barrel as the cone closes around it.
125		for (let i = 0; i < 90; i++) drift(track, aimCone(3, 0), 1 / 30, rolls(0.5, 1, 0));
126		expect(Math.abs(track.error)).toBeLessThanOrEqual(aimCone(3, 0) + 1e-12);
127		});
128
129		// ------------------------------------------------------------- through a bot
130
131	17	const facing = (state: MatchState): { bot: Player; prey: Player } => {
132	18	const bot = state.players.find((p) => p.side === "def")!;
133	19	const prey = state.players.find((p) => p.side === "atk")!;
		@@ -1,240 +1,63 @@
1	1	/**
2		* The arena: one match, always running, and the seats people sit in.
	2	* The arena: this game's one live match, served the way `engine/arena.ts`
	3	* serves any match — ticking only while somebody is connected, one playing
	4	* seat an address, a positionless view for whoever has no seat, and every
	5	* snapshot built for one viewer from what they can see.
3	6	*
4		* The match ticks whether anybody is watching or not, so a visitor never
5		* arrives at a frozen board — they get the round that is happening. Taking a
6		* seat replaces a bot in place: same body, same credits, same position, so
7		* joining mid-round hands you a live player rather than a lobby.
8		*
9		* Every snapshot is built for one viewer: enemies they cannot see are not in
10		* it. The client never learns a position it has no line of sight to.
	7	* What is this game's own is here: taking a seat replaces a bot in the
	8	* emptiest team (same body, same credits, same position, so joining
	9	* mid-round hands you a live player rather than a lobby), the commands a
	10	* client may send, the shape of the snapshot, and the kill feed read off the
	11	* match a tick at a time.
11	12	*/
12	13
13	14	import { agentById, sightBlocked } from "./abilities.ts";
14	15	import { runBots } from "./bots.ts";
15	16	import { recordResult } from "./db.ts";
	17	import { makeArena, type Command, type Why } from "./engine/arena.ts";
16	18	import { fallsBetween, marksOf, trimFeed, type Fall, type Mark } from "./killfeed.ts";
17	19	import type { Point } from "./map.ts";
18		import {
19		buyAbility,
20		buyShield,
21		buyWeapon,
22		newMatch,
23		pickAgent,
24		setInput,
25		tick,
26		visible,
27		} from "./match.ts";
	20	import { buyAbility, buyShield, buyWeapon, newMatch, pickAgent, setInput, tick, visible } from "./match.ts";
28	21	import type { MatchState, Player } from "./state.ts";
29	22	import { isWeaponId, WEAPONS } from "./weapons.ts";
30	23
31		export const TICK = 1 / 30;
	24	export { broadcastEvery, TICK, type Command, type Seat, type Why } from "./engine/arena.ts";
32	25
33		/**
34		* How many ticks apart the snapshots go out.
35		*
36		* The simulation runs at 30Hz and used to broadcast every other tick, which
37		* gave the browser fifteen positions a second to draw sixty frames from —
38		* not many, and with interpolation it also doubles the delay the drawing has
39		* to sit behind the present. A small room gets every tick: it is the case
40		* that matters (one or two people playing each other), the payload is a
41		* couple of kilobytes of JSON a seat, and the arena only runs at all while
42		* somebody is connected. Above that the cost multiplies by seats and the
43		* older cadence comes back.
44		*/
45		export const broadcastEvery = (filled: number): number => (filled <= 2 ? 1 : 2);
46
47		export type Seat = {
48		playerId: string;
49		token: string;
50		address: string;
51		send: (data: string) => void;
52		/** The scoreboard as this seat last received it, so it is only resent when it changes. */
53		board: string;
54		};
55
56		let state: MatchState = newMatch();
57		const seats = new Map<string, Seat>();
58		// A session is a cookie, and a cookie costs one HTTP request — free for
59		// anyone to mint as many of as they like. The address is the one thing here
60		// a single machine cannot hand itself two of, so it is what a playing seat
61		// is actually rationed by; the session on top of it is only what lets a
62		// reload find its way back to the same seat rather than a fresh one.
63		const addressSeats = new Map<string, string>();
64		let ticks = 0;
	26	const state: MatchState = newMatch();
65	27	let lastResult: string \| null = null;
66	28	// The kill feed is read off the match a tick at a time; the rules keep no
67	29	// list of their own, and this is a view, not a rule.
68	30	let marks: Mark[] = marksOf(state.players);
69	31	let feed: Fall[] = [];
70	32
71		export const match = (): MatchState => state;
	33	const round2 = (n: number): number => Math.round(n * 10) / 10;
72	34
73		export const findPlayer = (id: string): Player \| undefined => state.players.find((p) => p.id === id);
74
75		/**
76		* A name nobody else in this match is using.
77		*
78		* The kill feed, the round log and the scoreboard all address people by
79		* name: two players called Kit make a line that reads as a team kill this
80		* game cannot have. The bots are dealt distinct names; a person who picks
81		* one that is taken gets a number after it, inside the sixteen characters a
82		* name is allowed.
83		*/
84		function freeName(want: string, exceptId: string): string {
85		const taken = new Set(state.players.filter((p) => p.id !== exceptId).map((p) => p.name));
86		if (!taken.has(want)) return want;
87		for (let n = 2; n < 100; n++) {
88		const tried = `${want.slice(0, 13)} ${n}`;
89		if (!taken.has(tried)) return tried;
90		}
91		return want;
92		}
93
94		/**
95		* Whether this address already plays under a different session. Checked
96		* before a socket is even offered a seat, so the caller can hand it a
97		* spectator view instead of upgrading it into a second side's vision.
98		*/
99		export function addressCapped(address: string, session: string): boolean {
100		const holder = addressSeats.get(address);
101		return holder !== undefined && holder !== session;
102		}
103
104		/**
105		* Sit somebody down in the emptiest team, replacing a bot where it stands.
106		*
107		* Both claims go in right here, synchronously, before the caller ever opens
108		* a socket. A websocket upgrade completes on a later tick, so two requests
109		* arriving close together both used to read the maps before either had
110		* written to them — one client, two seats, opposite sides, the vision of
111		* both. Claiming inline closes that window regardless of how the two
112		* requests were related.
113		*/
114		export function takeSeat(address: string, session: string, name: string): Player \| null {
115		const existing = seats.get(session);
116		const held = existing ? findPlayer(existing.playerId) : undefined;
117		if (held) {
118		held.name = freeName(name, held.id);
119		return held;
120		}
121		if (addressCapped(address, session)) return null;
	35	/** Sit in the emptiest team, on a bot's seat, keeping its body as it stands. */
	36	function sit(state: MatchState): Player \| null {
122	37	const humans = { red: 0, blue: 0 };
123	38	for (const player of state.players) if (!player.bot) humans[player.team] += 1;
124	39	const wanted = humans.red <= humans.blue ? "red" : "blue";
125		const seat =
126		state.players.find((p) => p.bot && p.team === wanted) ?? state.players.find((p) => p.bot);
	40	const seat = state.players.find((p) => p.bot && p.team === wanted) ?? state.players.find((p) => p.bot);
127	41	if (!seat) return null;
128	42	seat.bot = false;
129		seat.name = freeName(name, seat.id);
130	43	seat.think = 0;
131	44	seat.input = { mx: 0, my: 0, angle: seat.angle, fire: false, use: false, reload: false, cast: null };
132		addressSeats.set(address, session);
133		seats.set(session, { playerId: seat.id, token: "", address, send: () => {}, board: "" });
134	45	return seat;
135	46	}
136	47
137		/** The socket that actually opened fills in how to reach it and its token. */
138		export function attach(session: string, playerId: string, address: string, token: string, send: (data: string) => void): void {
139		seats.set(session, { playerId, token, address, send, board: "" });
	48	/** The seat goes back to a bot, mid-round and all. */
	49	function stand(_state: MatchState, player: Player): void {
	50	player.bot = true;
	51	player.think = 0;
	52	player.input.fire = false;
	53	player.input.use = false;
140	54	}
141	55
142		/**
143		* A person leaving gives the seat back to a bot, mid-round and all — but only
144		* if this is still the socket the session is on. A reload opens the new
145		* socket before the old one's close event arrives; without the token, that
146		* late close would delete the reconnect's seat entry and hand a live human's
147		* seat to a bot mid-round.
148		*/
149		export function release(session: string, token: string): void {
150		const seat = seats.get(session);
151		if (!seat \|\| seat.token !== token) return;
152		seats.delete(session);
153		if (addressSeats.get(seat.address) === session) addressSeats.delete(seat.address);
154		const player = findPlayer(seat.playerId);
155		if (player && !stillHeld(seat.playerId)) {
156		player.bot = true;
157		player.think = 0;
158		player.input.fire = false;
159		player.input.use = false;
160		}
161		}
162
163		/**
164		* Test-only hygiene: give back whatever this address currently holds. The
165		* arena is one match shared by the whole test run, over real HTTP, from one
166		* loopback address — this is how a test that needs that address free gets it
167		* free, rather than depending on every other test in the file to clean up
168		* after itself.
169		*/
170		export function releaseAddress(address: string): void {
171		const session = addressSeats.get(address);
172		if (session !== undefined) release(session, seats.get(session)?.token ?? "");
173		}
174
175		const stillHeld = (playerId: string): boolean =>
176		[...seats.values()].some((s) => s.playerId === playerId);
177
178		export const seatCount = (): number => seats.size;
179
180		// -------------------------------------------------------------- spectators
181
182		// A connection that never carried a session the page minted gets no side and
183		// no seat: only the public state everyone already sees on the page itself.
184		const spectators = new Map<string, { send: (data: string) => void; why: Why }>();
185
186		/**
187		* Why this connection is watching. The client says so in words, and the two
188		* have different answers — open the tab that is playing, or let the page keep
189		* its cookie — so which one it is travels with the snapshot.
190		*/
191		export type Why = "address" \| "cookie" \| "unsaid";
192
193		export function spectatorSnapshot(why: Why = "unsaid"): string {
194		return JSON.stringify({
195		t: "s",
196		spectator: true,
197		why,
198		phase: state.phase,
199		clock: round2(Math.max(0, state.clock)),
200		round: state.round,
201		score: state.score,
202		attackers: state.attackers,
203		result: state.result,
204		last: state.last,
205		events: state.events.slice(0, 5).map((e) => e.text),
206		// Names and a gun, the same as a seat is sent, and for the same reason it
207		// is safe there: the feed says what happened, never where.
208		feed: feed.map((f) => ({
209		k: f.killer,
210		v: f.victim,
211		w: f.weapon ? WEAPONS[f.weapon].name : null,
212		h: f.headshot,
213		t: round2(Math.max(0, state.now - f.at)),
214		})),
215		});
216		}
217
218		export function watch(token: string, send: (data: string) => void, why: Why = "unsaid"): void {
219		spectators.set(token, { send, why });
220		send(spectatorSnapshot(why));
221		}
222
223		export function unwatch(token: string): void {
224		spectators.delete(token);
225		}
226
227		// ------------------------------------------------------------- the commands
228
229		export type Command = { t: string; [key: string]: unknown };
230
231	56	const num = (value: unknown): number \| undefined =>
232	57	typeof value === "number" && Number.isFinite(value) ? value : undefined;
233	58
234	59	/** Everything a client may ask for, validated here and nowhere else. */
235		export function command(playerId: string, message: Command): void {
236		const player = findPlayer(playerId);
237		if (!player \|\| player.bot) return;
	60	function runCommand(state: MatchState, player: Player, message: Command): void {
238	61	switch (message.t) {
239	62	case "i":
240	63	setInput(player, {
		@@ -260,36 +83,38 @@ export function command(playerId: string, message: Command): void {
260	83	}
261	84	}
262	85
263		// ------------------------------------------------------------- the snapshot
	86	// Names and a gun, never a position: the feed says what happened, not
	87	// where, so it can never be read as a call-out.
	88	const feedFor = (state: MatchState) =>
	89	feed.map((f) => ({
	90	k: f.killer,
	91	v: f.victim,
	92	w: f.weapon ? WEAPONS[f.weapon].name : null,
	93	h: f.headshot,
	94	t: round2(Math.max(0, state.now - f.at)),
	95	}));
264	96
265		const round2 = (n: number): number => Math.round(n * 10) / 10;
266
267		/** The full snapshot for one viewer, as one string. */
268		export const snapshot = (viewerId: string): string => JSON.stringify(snapshotFor(viewerId));
269
270		/**
271		* The snapshot a seat is actually sent on this tick. The scoreboard — ten
272		* names, agents and tallies — was almost half of every snapshot and changes
273		* a few times a round, so it goes out only when it differs from what this
274		* seat last received; the client keeps the one it has. Everything else is
275		* the full snapshot, every time.
276		*/
277		export function snapshotForSeat(seat: Seat): string {
278		const full = snapshotFor(seat.playerId);
279		const board = JSON.stringify(full.board);
280		if (board === seat.board) delete (full as { board?: unknown }).board;
281		else seat.board = board;
282		return JSON.stringify(full);
	97	/** The public state everyone already sees on the page itself. */
	98	function spectatorShape(state: MatchState, _why: Why) {
	99	return {
	100	phase: state.phase,
	101	clock: round2(Math.max(0, state.clock)),
	102	round: state.round,
	103	score: state.score,
	104	attackers: state.attackers,
	105	result: state.result,
	106	last: state.last,
	107	events: state.events.slice(0, 5).map((e) => e.text),
	108	feed: feedFor(state),
	109	};
283	110	}
284	111
285		function snapshotFor(viewerId: string) {
286		const me = findPlayer(viewerId) ?? state.players[0]!;
	112	/** The snapshot for one seat: `seen` is exactly who the arena says they may see. */
	113	function snapshotShape(state: MatchState, me: Player, seen: Player[]) {
287	114	const agent = agentById(me.agent);
288		const seen = state.players.filter((p) => visible(state, me, p));
289	115	const canSee = (point: Point): boolean => !sightBlocked(me, point, state.zones);
290	116
291	117	return {
292		t: "s",
293	118	phase: state.phase,
294	119	clock: round2(Math.max(0, state.clock)),
295	120	round: state.round,
		@@ -356,6 +181,9 @@ function snapshotFor(viewerId: string) {
356	181	},
357	182	orbs: state.orbs.filter((o) => !o.taken).map((o) => ({ x: o.x, y: o.y })),
358	183	shots: state.shots.filter((s) => canSee({ x: s.x1, y: s.y1 }) \|\| canSee({ x: s.x2, y: s.y2 })),
	184	// The scoreboard — ten names, agents and tallies — was almost half of
	185	// every snapshot and changes a few times a round, so the arena sends it
	186	// only when it differs from what the seat last received.
359	187	board: state.players.map((p) => ({
360	188	id: p.id,
361	189	name: p.name,
		@@ -372,15 +200,7 @@ function snapshotFor(viewerId: string) {
372	200	ultNeeds: agentById(p.agent).abilities.x.points,
373	201	})),
374	202	events: state.events.slice(0, 5).map((e) => e.text),
375		// Names and a gun, never a position: the feed says what happened, not
376		// where, so it can never be read as a call-out.
377		feed: feed.map((f) => ({
378		k: f.killer,
379		v: f.victim,
380		w: f.weapon ? WEAPONS[f.weapon].name : null,
381		h: f.headshot,
382		t: round2(Math.max(0, state.now - f.at)),
383		})),
	203	feed: feedFor(state),
384	204	};
385	205	}
386	206
		@@ -389,7 +209,7 @@ function snapshotFor(viewerId: string) {
389	209	* killer stands is what tells a gun kill from an ability kill — the position
390	210	* is used here and goes no further.
391	211	*/
392		function readFalls(): void {
	212	function readFalls(state: MatchState): void {
393	213	const after = marksOf(state.players);
394	214	const shooters = new Set<string>();
395	215	for (const shot of state.shots) {
		@@ -407,77 +227,49 @@ function readFalls(): void {
407	227	feed = trimFeed(feed, state.now);
408	228	}
409	229
410		// ----------------------------------------------------------------- the loop
411
412		/**
413		* Nobody watching, nothing happens.
414		*
415		* The arena used to tick around the clock, so bots played out rounds for an
416		* empty room — burning a share of a small box's CPU and filling the record
417		* with matches no one saw. The world now freezes when the last connection
418		* goes and carries on from exactly where it stopped when someone arrives, so
419		* a visitor never finds a score that ran up while they were away.
420		*
421		* A spectator counts as somebody: watching is watching.
422		*/
423		const attended = (): boolean => seats.size > 0 \|\| spectators.size > 0;
424
425		/** How many connections the arena is playing for: seats plus watchers. */
426		export const attendance = (): number => seats.size + spectators.size;
427
428		function step(): void {
429		runBots(state, TICK);
430		tick(state, TICK);
431		readFalls();
	230	/** One tick of this game: the bots, the rules, the feed, and the record. */
	231	function step(state: MatchState, dt: number): void {
	232	runBots(state, dt);
	233	tick(state, dt);
	234	readFalls(state);
432	235	if (state.result && state.result !== lastResult) {
433	236	lastResult = state.result;
434	237	recordResult(state.result, state.score.red, state.score.blue, state.round);
435	238	}
436	239	if (state.result === null) lastResult = null;
437		ticks += 1;
438		if (ticks % broadcastEvery(seats.size) !== 0) return;
439		for (const seat of seats.values()) {
440		try {
441		seat.send(snapshotForSeat(seat));
442		} catch {
443		// A socket that will not take a frame is closed already; the close
444		// handler gives the seat back.
445		}
446		}
447		for (const spectator of spectators.values()) {
448		try {
449		spectator.send(spectatorSnapshot(spectator.why));
450		} catch {
451		// Same story: the close handler drops it from the set.
452		}
453		}
454	240	}
455	241
456		let timer: ReturnType<typeof setInterval> \| null = null;
	242	const arena = makeArena<MatchState, Player>({
	243	state,
	244	players: (s) => s.players,
	245	step,
	246	sit,
	247	stand,
	248	visible,
	249	snapshot: snapshotShape,
	250	sticky: "board",
	251	spectatorSnapshot: spectatorShape,
	252	command: runCommand,
	253	});
457	254
458		/**
459		* One beat of real time. The gate lives here rather than inside `step` so the
460		* tests can still drive the simulation directly with `advance` — a test is an
461		* attendance of its own, and making it prove otherwise would only teach the
462		* suite to work around the rule.
463		*/
464		export function beat(): void {
465		if (attended()) step();
466		}
467
468		export function startArena(): void {
469		if (timer) return;
470		timer = setInterval(beat, TICK * 1000);
471		// The clock must never hold the process open on its own.
472		(timer as unknown as { unref?: () => void }).unref?.();
473		}
474
475		export function stopArena(): void {
476		if (timer) clearInterval(timer);
477		timer = null;
478		}
479
480		/** Used by the tests: run the arena forward without waiting for real time. */
481		export function advance(seconds: number): void {
482		for (let i = 0; i < Math.round(seconds / TICK); i++) step();
483		}
	255	export const {
	256	match,
	257	findPlayer,
	258	addressCapped,
	259	takeSeat,
	260	attach,
	261	release,
	262	releaseAddress,
	263	seatCount,
	264	watch,
	265	unwatch,
	266	spectatorSnapshot,
	267	command,
	268	snapshot,
	269	snapshotForSeat,
	270	attendance,
	271	beat,
	272	advance,
	273	} = arena;
	274	export const startArena = arena.start;
	275	export const stopArena = arena.stop;
		@@ -8,7 +8,7 @@
8	8	*/
9	9
10	10	import { agentById, castable, flashDuration, sightBlocked, type Ability } from "./abilities.ts";
11		import { acquire, aimCone, canFire, crossRate, drift, heldFor, lose } from "./aim.ts";
	11	import { acquire, aimCone, canFire, crossRate, drift, heldFor, lose } from "./engine/aim.ts";
12	12	import { pathStep, rayHitWall, siteAt, siteCentre, walkDistance, type Point, type Site } from "./map.ts";
13	13	import { buyAbility, buyShield, buyWeapon, random, RUN_SPEED, SPIKE_REACH, visible } from "./match.ts";
14	14	import type { MatchState, Player, Slot } from "./state.ts";
		@@ -400,8 +400,8 @@ test("the bundled client connects, paints the HUD and draws a frame", async () =
400	400	// the rule.
401	401	// The lead is the cap plus the slack the guess is allowed over the answer
402	402	// (predict.js LEAD_SLACK: the lag your own keys take to reach the server).
403		const { moveSpeed } = await import("./glide.ts");
404		const { LEAD_MAX, LEAD_SLACK } = await import("../static/predict.js");
	403	const { moveSpeed } = await import("./engine/glide.ts");
	404	const { LEAD_MAX, LEAD_SLACK } = await import("../static/engine/predict.js");
405	405	expect(lead).toBeLessThan((LEAD_MAX + LEAD_SLACK) * moveSpeed(seat) + 10);
406	406	expect(Math.abs(sideways)).toBeLessThan(6);
407	407	// Nothing on the server moved: this is a drawing, and the match is still
		@@ -0,0 +1,124 @@
	1	/**
	2	* How a bot points a gun, tested as the pure maths it is. That the gate is
	3	* actually wired to a trigger is the game's to prove: `src/aim.test.ts`.
	4	*/
	5
	6	import { expect, test } from "bun:test";
	7	import {
	8	acquire,
	9	aimCone,
	10	canFire,
	11	CONE_FLOOR,
	12	crossRate,
	13	drift,
	14	emptyTrack,
	15	FORGET,
	16	heldFor,
	17	lose,
	18	REACTION_MAX,
	19	REACTION_MIN,
	20	reactionTime,
	21	} from "./aim.ts";
	22
	23	const rolls = (...values: number[]) => {
	24	let at = 0;
	25	return () => values[at++ % values.length]!;
	26	};
	27
	28	test("the reaction a bot draws is between 200 and 350ms, whatever the roll", () => {
	29	expect(reactionTime(0)).toBeCloseTo(REACTION_MIN, 9);
	30	expect(reactionTime(1)).toBeCloseTo(REACTION_MAX, 9);
	31	expect(reactionTime(0.5)).toBeCloseTo((REACTION_MIN + REACTION_MAX) / 2, 9);
	32	// A roll out of range is still a reaction, not a bot that never shoots.
	33	expect(reactionTime(-3)).toBe(REACTION_MIN);
	34	expect(reactionTime(9)).toBe(REACTION_MAX);
	35	});
	36
	37	test("the trigger gate is a pure function of when acquisition happened", () => {
	38	const track = emptyTrack();
	39	// Nothing in sight is never a shot, however long the round has run.
	40	expect(canFire(track, 100)).toBe(false);
	41
	42	acquire(track, "bot-red-1", 10, { x: 0, y: 0 }, rolls(0, 0.5));
	43	expect(track.reaction).toBeCloseTo(REACTION_MIN, 9);
	44	expect(canFire(track, 10)).toBe(false);
	45	expect(canFire(track, 10.19)).toBe(false);
	46	expect(canFire(track, 10.21)).toBe(true);
	47	expect(canFire(track, 12)).toBe(true);
	48	expect(heldFor(track, 12)).toBeCloseTo(2, 9);
	49	});
	50
	51	test("a new target starts the reaction again; the same one does not", () => {
	52	const track = emptyTrack();
	53	acquire(track, "one", 5, { x: 100, y: 100 }, rolls(1, 0.5));
	54	expect(track.since).toBe(5);
	55	acquire(track, "one", 5.3, { x: 180, y: 100 }, rolls(0, 0.5));
	56	expect(track.since).toBe(5); // the hold carries on
	57	expect(canFire(track, 5.4)).toBe(true);
	58	acquire(track, "two", 5.4, { x: 0, y: 0 }, rolls(0, 0.5));
	59	expect(track.since).toBe(5.4); // swinging onto somebody else costs again
	60	expect(canFire(track, 5.5)).toBe(false);
	61	});
	62
	63	test("a hold survives a blink out of sight, and no longer", () => {
	64	const track = emptyTrack();
	65	acquire(track, "one", 1, { x: 0, y: 0 }, rolls(0, 0.5));
	66	lose(track, 1 + FORGET / 2);
	67	expect(track.id).toBe("one");
	68	// Back a moment later: the same hold, already through its reaction.
	69	acquire(track, "one", 1 + FORGET / 2, { x: 0, y: 0 }, rolls(0, 0.5));
	70	expect(track.since).toBe(1);
	71	// Gone for longer than that and it is a fresh acquisition.
	72	lose(track, 3);
	73	expect(track.id).toBe(null);
	74	acquire(track, "one", 3, { x: 0, y: 0 }, rolls(0, 0.5));
	75	expect(track.since).toBe(3);
	76	expect(canFire(track, 3.1)).toBe(false);
	77	});
	78
	79	test("the cone starts wide, settles the longer one target is held, and never closes", () => {
	80	const swing = aimCone(0, 0);
	81	const second = aimCone(1, 0);
	82	const settled = aimCone(3, 0);
	83	expect(swing).toBeGreaterThan(0.08); // several degrees on the swing
	84	expect(second).toBeLessThan(swing / 2);
	85	expect(settled).toBeLessThan(second);
	86	expect(settled).toBeGreaterThanOrEqual(CONE_FLOOR);
	87	expect(aimCone(99, 0)).toBeCloseTo(CONE_FLOOR, 6);
	88	});
	89
	90	test("a target crossing the view costs the bot accuracy", () => {
	91	expect(aimCone(3, 1)).toBeGreaterThan(aimCone(3, 0) * 3);
	92	expect(aimCone(3, 0.5)).toBeGreaterThan(aimCone(3, 0));
	93	expect(aimCone(3, 0.5)).toBeLessThan(aimCone(3, 1));
	94	// Nonsense from the caller is clamped, not multiplied out.
	95	expect(aimCone(3, 50)).toBeCloseTo(aimCone(3, 1), 9);
	96	});
	97
	98	test("crossing is measured across the sight line, not along it", () => {
	99	const bot = { x: 0, y: 0 };
	100	const walking = emptyTrack();
	101	acquire(walking, "t", 0, { x: 300, y: 0 }, rolls(0, 0.5));
	102	// Straight down the barrel: nothing to track.
	103	expect(crossRate(walking, bot, { x: 260, y: 0 }, 0.1)).toBeCloseTo(0, 6);
	104	const strafing = emptyTrack();
	105	acquire(strafing, "t", 0, { x: 300, y: 0 }, rolls(0, 0.5));
	106	// Straight across it at a run: all of it but the turn of the sight line.
	107	expect(crossRate(strafing, bot, { x: 300, y: 25 }, 0.1)).toBeCloseTo(250, -1);
	108	// And it remembers where the target went, so the next tick measures again.
	109	expect(crossRate(strafing, bot, { x: 300, y: 25 }, 0.1)).toBeCloseTo(0, 6);
	110	});
	111
	112	test("the error wanders inside the cone instead of being redrawn every tick", () => {
	113	const track = emptyTrack();
	114	acquire(track, "one", 0, { x: 0, y: 0 }, rolls(0, 1));
	115	// Drawn at the edge of the swing cone on acquisition.
	116	expect(Math.abs(track.error)).toBeCloseTo(aimCone(0, 0), 9);
	117	// One tick moves it a little, not to somewhere unrelated.
	118	const before = track.error;
	119	const after = drift(track, aimCone(0, 0), 1 / 30, rolls(0.9));
	120	expect(Math.abs(after - before)).toBeLessThan(aimCone(0, 0) / 4);
	121	// And it is squeezed toward the barrel as the cone closes around it.
	122	for (let i = 0; i < 90; i++) drift(track, aimCone(3, 0), 1 / 30, rolls(0.5, 1, 0));
	123	expect(Math.abs(track.error)).toBeLessThanOrEqual(aimCone(3, 0) + 1e-12);
	124	});
		@@ -0,0 +1,143 @@
	1	/**
	2	* The shape of a served match, over a toy game: the rules every served game
	3	* needs and none should have to re-derive. These are the two holes that were
	4	* closed the hard way — a seat is rationed by address, and a client is sent
	5	* only what it can see — plus the idle gate and the reload race.
	6	*/
	7
	8	import { expect, test } from "bun:test";
	9	import { broadcastEvery, makeArena, TICK, type Command } from "./arena.ts";
	10
	11	type Toy = { id: string; name: string; bot: boolean; side: "a" \| "b"; x: number; seen: boolean };
	12	type World = { ticks: number; players: Toy[]; heard: Command[] };
	13
	14	/** Two sides of two; everybody on side "b" is out of side "a"'s sight unless marked seen. */
	15	function toyGame() {
	16	const world: World = {
	17	ticks: 0,
	18	heard: [],
	19	players: [
	20	{ id: "a1", name: "Ash", bot: true, side: "a", x: 10, seen: false },
	21	{ id: "a2", name: "Bex", bot: true, side: "a", x: 20, seen: false },
	22	{ id: "b1", name: "Cade", bot: true, side: "b", x: 30, seen: false },
	23	{ id: "b2", name: "Dune", bot: true, side: "b", x: 40, seen: true },
	24	],
	25	};
	26	return makeArena<World, Toy>({
	27	state: world,
	28	players: (s) => s.players,
	29	step: (s) => void (s.ticks += 1),
	30	sit: (s) => {
	31	const seat = s.players.find((p) => p.bot) ?? null;
	32	if (seat) seat.bot = false;
	33	return seat;
	34	},
	35	stand: (_s, p) => void (p.bot = true),
	36	visible: (_s, viewer, other) => viewer.side === other.side \|\| other.seen,
	37	snapshot: (s, me, seen) => ({
	38	me: { id: me.id, x: me.x },
	39	players: seen.map((p) => ({ id: p.id, x: p.x })),
	40	board: s.players.map((p) => ({ id: p.id, name: p.name, bot: p.bot })),
	41	}),
	42	sticky: "board",
	43	spectatorSnapshot: (s) => ({ ticks: s.ticks, names: s.players.map((p) => p.name) }),
	44	command: (s, _p, message) => void s.heard.push(message),
	45	});
	46	}
	47
	48	test("nobody watching, nothing happens; a watcher is somebody; a test drives it regardless", () => {
	49	const arena = toyGame();
	50	arena.beat();
	51	arena.beat();
	52	expect(arena.match().ticks).toBe(0);
	53	arena.watch("w", () => {});
	54	arena.beat();
	55	expect(arena.match().ticks).toBe(1);
	56	arena.unwatch("w");
	57	arena.beat();
	58	expect(arena.match().ticks).toBe(1);
	59	arena.advance(1);
	60	expect(arena.match().ticks).toBe(1 + Math.round(1 / TICK));
	61	expect(arena.attendance()).toBe(0);
	62	});
	63
	64	test("a playing seat is rationed by address, and a session finds its own seat back", () => {
	65	const arena = toyGame();
	66	const first = arena.takeSeat("10.0.0.1", "session-1", "Kit");
	67	expect(first?.bot).toBe(false);
	68	expect(first?.name).toBe("Kit");
	69	// A second cookie from the same machine is not a second seat.
	70	expect(arena.addressCapped("10.0.0.1", "session-2")).toBe(true);
	71	expect(arena.takeSeat("10.0.0.1", "session-2", "Kit 2")).toBeNull();
	72	// The same session asking again is handed the seat it holds, renamed.
	73	const again = arena.takeSeat("10.0.0.1", "session-1", "Kat");
	74	expect(again?.id).toBe(first!.id);
	75	expect(again?.name).toBe("Kat");
	76	expect(arena.seatCount()).toBe(1);
	77	// Another machine sits down beside them.
	78	const other = arena.takeSeat("10.0.0.2", "session-3", "Kat");
	79	expect(other?.id).not.toBe(first!.id);
	80	// And two people may not share a name: the second gets a number.
	81	expect(other?.name).toBe("Kat 2");
	82	});
	83
	84	test("a late close from a reload does not take the live seat with it", () => {
	85	const arena = toyGame();
	86	const seat = arena.takeSeat("10.0.0.1", "s", "Kit")!;
	87	arena.attach("s", seat.id, "10.0.0.1", "old-token", () => {});
	88	arena.attach("s", seat.id, "10.0.0.1", "new-token", () => {});
	89	arena.release("s", "old-token");
	90	expect(seat.bot).toBe(false);
	91	expect(arena.seatCount()).toBe(1);
	92	arena.release("s", "new-token");
	93	expect(seat.bot).toBe(true);
	94	expect(arena.seatCount()).toBe(0);
	95	expect(arena.addressCapped("10.0.0.1", "elsewhere")).toBe(false);
	96	});
	97
	98	test("a viewer is sent only the bodies the game says they can see", () => {
	99	const arena = toyGame();
	100	const snap = JSON.parse(arena.snapshot("a1")) as { t: string; players: { id: string }[] };
	101	expect(snap.t).toBe("s");
	102	expect(snap.players.map((p) => p.id).sort()).toEqual(["a1", "a2", "b2"]);
	103	expect(JSON.stringify(snap.players)).not.toContain('"b1"');
	104	});
	105
	106	test("a spectator is sent the public state and never a position", () => {
	107	const arena = toyGame();
	108	const got: string[] = [];
	109	arena.watch("w", (data) => got.push(data), "cookie");
	110	expect(got.length).toBe(1);
	111	const snap = JSON.parse(got[0]!) as Record<string, unknown>;
	112	expect(snap).toMatchObject({ t: "s", spectator: true, why: "cookie", ticks: 0 });
	113	expect(snap.players).toBeUndefined();
	114	expect(snap.me).toBeUndefined();
	115	expect(got[0]).not.toContain('"x"');
	116	arena.unwatch("w");
	117	});
	118
	119	test("the sticky field goes out once, then only when it changes", () => {
	120	const arena = toyGame();
	121	const seat = { playerId: "a1", token: "t", address: "10.0.0.1", send: () => {}, board: "" };
	122	const first = JSON.parse(arena.snapshotForSeat(seat)) as { board?: unknown[] };
	123	expect(first.board?.length).toBe(4);
	124	const second = JSON.parse(arena.snapshotForSeat(seat)) as { board?: unknown[] };
	125	expect(second.board).toBeUndefined();
	126	arena.match().players[3]!.name = "Eve";
	127	const third = JSON.parse(arena.snapshotForSeat(seat)) as { board?: { name: string }[] };
	128	expect(third.board?.[3]?.name).toBe("Eve");
	129	// The full snapshot is always the full snapshot.
	130	expect((JSON.parse(arena.snapshot("a1")) as { board: unknown[] }).board.length).toBe(4);
	131	});
	132
	133	test("the loop sends at the cadence the room asks for, and a bot's commands are dropped", () => {
	134	const arena = toyGame();
	135	const got: string[] = [];
	136	const seat = arena.takeSeat("10.0.0.1", "s", "Kit")!;
	137	arena.attach("s", seat.id, "10.0.0.1", "t", (data) => got.push(data));
	138	arena.advance(1);
	139	expect(got.length).toBe(Math.round(1 / TICK) / broadcastEvery(1));
	140	arena.command(seat.id, { t: "i" });
	141	arena.command("b2", { t: "i" }); // a bot: nobody may drive it from outside
	142	expect(arena.match().heard.length).toBe(1);
	143	});
		@@ -0,0 +1,332 @@
	1	/**
	2	* The shape of a served match: one world, always running while somebody is
	3	* connected, and the seats people sit in.
	4	*
	5	* Nothing here knows what the game is. The game hands over its state and a
	6	* handful of answers — how to step it, who is in it, what one viewer may see
	7	* and what a snapshot looks like — and this module keeps the rules every
	8	* served game needs and none should re-derive:
	9	*
	10	* - The idle gate: nobody watching, nothing happens. The world freezes when
	11	* the last connection goes and carries on when someone arrives.
	12	* - A playing seat is rationed by address, not by cookie: a cookie costs one
	13	* HTTP request, an address is the one thing a machine cannot mint two of.
	14	* Both claims go in synchronously, before a socket is ever offered a seat.
	15	* - A connection with no seat watches: it is sent the public state and no
	16	* position in it.
	17	* - Every snapshot is built for one viewer, from the bodies the game says
	18	* that viewer can see. The client never learns a position it has no line
	19	* of sight to.
	20	*/
	21
	22	export const TICK = 1 / 30;
	23
	24	/**
	25	* How many ticks apart the snapshots go out.
	26	*
	27	* The simulation runs at 30Hz. A small room gets every tick: it is the case
	28	* that matters (one or two people playing each other), the payload is a
	29	* couple of kilobytes of JSON a seat, and the arena only runs at all while
	30	* somebody is connected. Above that the cost multiplies by seats and the
	31	* older cadence — every other tick — comes back.
	32	*/
	33	export const broadcastEvery = (filled: number): number => (filled <= 2 ? 1 : 2);
	34
	35	export type Seat = {
	36	playerId: string;
	37	token: string;
	38	address: string;
	39	send: (data: string) => void;
	40	/** The sticky part of the snapshot as this seat last received it, so it is only resent when it changes. */
	41	board: string;
	42	};
	43
	44	/**
	45	* Why this connection is watching. The client says so in words, and the two
	46	* have different answers — open the tab that is playing, or let the page keep
	47	* its cookie — so which one it is travels with the snapshot.
	48	*/
	49	export type Why = "address" \| "cookie" \| "unsaid";
	50
	51	export type Command = { t: string; [key: string]: unknown };
	52
	53	/** What the arena needs of a body: a way to find it, address it, and tell a bot from a person. */
	54	export type Body = { id: string; name: string; bot: boolean };
	55
	56	/** The game, as the arena sees it. */
	57	export type Game<S, P extends Body> = {
	58	/** The one world. Mutated in place; the arena never replaces it. */
	59	state: S;
	60	players: (state: S) => P[];
	61	/** One fixed step of the world, bots and rules and all. */
	62	step: (state: S, dt: number) => void;
	63	/** Hand a bot's seat to a person: the same body, made human. Null when there is none. */
	64	sit: (state: S) => P \| null;
	65	/** Give a seat back to a bot. */
	66	stand: (state: S, player: P) => void;
	67	/** May this viewer be sent this body? The server's answer, never the client's. */
	68	visible: (state: S, viewer: P, other: P) => boolean;
	69	/** The snapshot for one viewer, given exactly the bodies they may see. */
	70	snapshot: (state: S, viewer: P, seen: P[]) => Record<string, unknown>;
	71	/**
	72	* A field of the snapshot resent only when it differs from what the seat
	73	* last received; the client keeps the one it has. Null sends everything.
	74	*/
	75	sticky: string \| null;
	76	/** The public view for a connection with no seat. Must carry no position. */
	77	spectatorSnapshot: (state: S, why: Why) => Record<string, unknown>;
	78	/** Everything a client may ask for, validated by the game and nowhere else. */
	79	command: (state: S, player: P, message: Command) => void;
	80	};
	81
	82	export function makeArena<S, P extends Body>(game: Game<S, P>) {
	83	const state = game.state;
	84	const seats = new Map<string, Seat>();
	85	// A session is a cookie, and a cookie costs one HTTP request — free for
	86	// anyone to mint as many of as they like. The address is the one thing here
	87	// a single machine cannot hand itself two of, so it is what a playing seat
	88	// is actually rationed by; the session on top of it is only what lets a
	89	// reload find its way back to the same seat rather than a fresh one.
	90	const addressSeats = new Map<string, string>();
	91	let ticks = 0;
	92
	93	const match = (): S => state;
	94	const findPlayer = (id: string): P \| undefined => game.players(state).find((p) => p.id === id);
	95
	96	/**
	97	* A name nobody else in this match is using. Two players under one name
	98	* make a feed line that reads as a team kill; a person who picks a taken
	99	* name gets a number after it, inside the sixteen characters a name is
	100	* allowed.
	101	*/
	102	function freeName(want: string, exceptId: string): string {
	103	const taken = new Set(
	104	game
	105	.players(state)
	106	.filter((p) => p.id !== exceptId)
	107	.map((p) => p.name),
	108	);
	109	if (!taken.has(want)) return want;
	110	for (let n = 2; n < 100; n++) {
	111	const tried = `${want.slice(0, 13)} ${n}`;
	112	if (!taken.has(tried)) return tried;
	113	}
	114	return want;
	115	}
	116
	117	/**
	118	* Whether this address already plays under a different session. Checked
	119	* before a socket is even offered a seat, so the caller can hand it a
	120	* spectator view instead of upgrading it into a second side's vision.
	121	*/
	122	function addressCapped(address: string, session: string): boolean {
	123	const holder = addressSeats.get(address);
	124	return holder !== undefined && holder !== session;
	125	}
	126
	127	/**
	128	* Sit somebody down, replacing a bot where it stands.
	129	*
	130	* Both claims go in right here, synchronously, before the caller ever opens
	131	* a socket. A websocket upgrade completes on a later tick, so two requests
	132	* arriving close together both used to read the maps before either had
	133	* written to them — one client, two seats, opposite sides, the vision of
	134	* both. Claiming inline closes that window regardless of how the two
	135	* requests were related.
	136	*/
	137	function takeSeat(address: string, session: string, name: string): P \| null {
	138	const existing = seats.get(session);
	139	const held = existing ? findPlayer(existing.playerId) : undefined;
	140	if (held) {
	141	held.name = freeName(name, held.id);
	142	return held;
	143	}
	144	if (addressCapped(address, session)) return null;
	145	const seat = game.sit(state);
	146	if (!seat) return null;
	147	seat.name = freeName(name, seat.id);
	148	addressSeats.set(address, session);
	149	seats.set(session, { playerId: seat.id, token: "", address, send: () => {}, board: "" });
	150	return seat;
	151	}
	152
	153	/** The socket that actually opened fills in how to reach it and its token. */
	154	function attach(session: string, playerId: string, address: string, token: string, send: (data: string) => void): void {
	155	seats.set(session, { playerId, token, address, send, board: "" });
	156	}
	157
	158	const stillHeld = (playerId: string): boolean => [...seats.values()].some((s) => s.playerId === playerId);
	159
	160	/**
	161	* A person leaving gives the seat back to a bot, mid-round and all — but only
	162	* if this is still the socket the session is on. A reload opens the new
	163	* socket before the old one's close event arrives; without the token, that
	164	* late close would delete the reconnect's seat entry and hand a live human's
	165	* seat to a bot mid-round.
	166	*/
	167	function release(session: string, token: string): void {
	168	const seat = seats.get(session);
	169	if (!seat \|\| seat.token !== token) return;
	170	seats.delete(session);
	171	if (addressSeats.get(seat.address) === session) addressSeats.delete(seat.address);
	172	const player = findPlayer(seat.playerId);
	173	if (player && !stillHeld(seat.playerId)) game.stand(state, player);
	174	}
	175
	176	/**
	177	* Test-only hygiene: give back whatever this address currently holds. The
	178	* arena is one match shared by the whole test run, over real HTTP, from one
	179	* loopback address — this is how a test that needs that address free gets it
	180	* free, rather than depending on every other test in the file to clean up
	181	* after itself.
	182	*/
	183	function releaseAddress(address: string): void {
	184	const session = addressSeats.get(address);
	185	if (session !== undefined) release(session, seats.get(session)?.token ?? "");
	186	}
	187
	188	const seatCount = (): number => seats.size;
	189
	190	// ------------------------------------------------------------ spectators
	191
	192	// A connection that never carried a session the page minted gets no side and
	193	// no seat: only the public state everyone already sees on the page itself.
	194	const spectators = new Map<string, { send: (data: string) => void; why: Why }>();
	195
	196	const spectatorSnapshot = (why: Why = "unsaid"): string =>
	197	JSON.stringify({ t: "s", spectator: true, why, ...game.spectatorSnapshot(state, why) });
	198
	199	function watch(token: string, send: (data: string) => void, why: Why = "unsaid"): void {
	200	spectators.set(token, { send, why });
	201	send(spectatorSnapshot(why));
	202	}
	203
	204	function unwatch(token: string): void {
	205	spectators.delete(token);
	206	}
	207
	208	// ----------------------------------------------------------- the commands
	209
	210	function command(playerId: string, message: Command): void {
	211	const player = findPlayer(playerId);
	212	if (!player \|\| player.bot) return;
	213	game.command(state, player, message);
	214	}
	215
	216	// ----------------------------------------------------------- the snapshot
	217
	218	function snapshotFor(viewerId: string): Record<string, unknown> {
	219	const players = game.players(state);
	220	const me = findPlayer(viewerId) ?? players[0]!;
	221	const seen = players.filter((p) => game.visible(state, me, p));
	222	return { t: "s", ...game.snapshot(state, me, seen) };
	223	}
	224
	225	/** The full snapshot for one viewer, as one string. */
	226	const snapshot = (viewerId: string): string => JSON.stringify(snapshotFor(viewerId));
	227
	228	/**
	229	* The snapshot a seat is actually sent on this tick: everything, every time,
	230	* except the sticky field, which goes out only when it differs from what
	231	* this seat last received.
	232	*/
	233	function snapshotForSeat(seat: Seat): string {
	234	const full = snapshotFor(seat.playerId);
	235	if (game.sticky !== null) {
	236	const part = JSON.stringify(full[game.sticky]);
	237	if (part === seat.board) delete full[game.sticky];
	238	else seat.board = part;
	239	}
	240	return JSON.stringify(full);
	241	}
	242
	243	// --------------------------------------------------------------- the loop
	244
	245	/**
	246	* Nobody watching, nothing happens.
	247	*
	248	* An arena that ticks around the clock plays out rounds for an empty room —
	249	* burning a share of a small box's CPU and filling the record with matches
	250	* no one saw. The world freezes when the last connection goes and carries on
	251	* from exactly where it stopped when someone arrives, so a visitor never
	252	* finds a score that ran up while they were away.
	253	*
	254	* A spectator counts as somebody: watching is watching.
	255	*/
	256	const attended = (): boolean => seats.size > 0 \|\| spectators.size > 0;
	257
	258	/** How many connections the arena is playing for: seats plus watchers. */
	259	const attendance = (): number => seats.size + spectators.size;
	260
	261	function step(): void {
	262	game.step(state, TICK);
	263	ticks += 1;
	264	if (ticks % broadcastEvery(seats.size) !== 0) return;
	265	for (const seat of seats.values()) {
	266	try {
	267	seat.send(snapshotForSeat(seat));
	268	} catch {
	269	// A socket that will not take a frame is closed already; the close
	270	// handler gives the seat back.
	271	}
	272	}
	273	for (const spectator of spectators.values()) {
	274	try {
	275	spectator.send(spectatorSnapshot(spectator.why));
	276	} catch {
	277	// Same story: the close handler drops it from the set.
	278	}
	279	}
	280	}
	281
	282	let timer: ReturnType<typeof setInterval> \| null = null;
	283
	284	/**
	285	* One beat of real time. The gate lives here rather than inside `step` so the
	286	* tests can still drive the simulation directly with `advance` — a test is an
	287	* attendance of its own, and making it prove otherwise would only teach the
	288	* suite to work around the rule.
	289	*/
	290	function beat(): void {
	291	if (attended()) step();
	292	}
	293
	294	function start(): void {
	295	if (timer) return;
	296	timer = setInterval(beat, TICK * 1000);
	297	// The clock must never hold the process open on its own.
	298	(timer as unknown as { unref?: () => void }).unref?.();
	299	}
	300
	301	function stop(): void {
	302	if (timer) clearInterval(timer);
	303	timer = null;
	304	}
	305
	306	/** Used by the tests: run the arena forward without waiting for real time. */
	307	function advance(seconds: number): void {
	308	for (let i = 0; i < Math.round(seconds / TICK); i++) step();
	309	}
	310
	311	return {
	312	match,
	313	findPlayer,
	314	addressCapped,
	315	takeSeat,
	316	attach,
	317	release,
	318	releaseAddress,
	319	seatCount,
	320	watch,
	321	unwatch,
	322	spectatorSnapshot,
	323	command,
	324	snapshot,
	325	snapshotForSeat,
	326	attendance,
	327	beat,
	328	start,
	329	stop,
	330	advance,
	331	};
	332	}