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

/**

 * The arena: one match, always running, and the seats people sit in.

 *

 * 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.

 */

import { agentById, sightBlocked } from "./abilities.ts";

import { runBots } from "./bots.ts";

import { recordResult } from "./db.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 type { MatchState, Player } from "./state.ts";

import { isWeaponId, WEAPONS } from "./weapons.ts";

export const TICK = 1 / 30;

/**

 * 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;

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;

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;

  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);

  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: "" });

}

/**

 * 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;

  switch (message.t) {

    case "i":

      setInput(player, {

        mx: num(message.mx),

        my: num(message.my),

        angle: num(message.a),

        fire: typeof message.f === "boolean" ? message.f : undefined,

        use: typeof message.u === "boolean" ? message.u : undefined,

        reload: typeof message.r === "boolean" ? message.r : undefined,

        cast: message.c === "c" || message.c === "q" || message.c === "e" || message.c === "x" ? message.c : undefined,

      });

      break;

    case "buy": {

      const what = String(message.what ?? "");

      if (isWeaponId(what)) buyWeapon(state, player, what);

      else if (what === "light" || what === "heavy") buyShield(state, player, what);

      else if (what === "c" || what === "q") buyAbility(state, player, what);

      break;

    }

    case "agent":

      if (typeof message.id === "string") pickAgent(state, player, message.id);

      break;

  }

}

// ------------------------------------------------------------- the snapshot

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);

}

function snapshotFor(viewerId: string) {

  const me = findPlayer(viewerId) ?? state.players[0]!;

  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,

    score: state.score,

    attackers: state.attackers,

    result: state.result,

    last: state.last,

    me: {

      id: me.id,

      side: me.side,

      team: me.team,

      agent: me.agent,

      alive: me.alive,

      x: round2(me.x),

      y: round2(me.y),

      angle: round2(me.angle),

      hp: Math.round(me.hp),

      armour: Math.round(me.armour),

      credits: me.credits,

      weapon: me.weapon,

      ammo: me.ammo,

      reloading: me.reloadIn > 0,

      charges: me.charges,

      cooldown: { c: round2(me.cooldown.c), q: round2(me.cooldown.q), e: round2(me.cooldown.e), x: 0 },

      ult: me.ult,

      ultNeeds: agent.abilities.x.points,

      blind: round2(me.blind),

      slow: round2(me.slow),

      haste: round2(me.haste),

      spike: me.spike,

      planting: round2(me.planting),

      // Your own two ways of being held still, so the browser's prediction

      // of your own body runs at the speed the server is about to use.

      defusing: me.defusing > 0,

      bot: me.bot,

    },

    players: seen.map((p) => ({

      id: p.id,

      name: p.name,

      agent: p.agent,

      x: round2(p.x),

      y: round2(p.y),

      angle: round2(p.angle),

      hp: Math.round(p.hp),

      armour: Math.round(p.armour),

      alive: p.alive,

      mate: p.side === me.side,

      spike: p.spike,

      blind: p.blind > 0,

      revealed: p.revealed > 0,

    })),

    zones: state.zones

      .filter((z) => (z.kind === "trip" ? z.side === me.side : true))

      .map((z) => ({ k: z.kind, x: round2(z.x), y: round2(z.y), r: z.r, f: round2(z.fuse), l: round2(z.life) })),

    spike: {

      planted: state.spike.planted,

      carried: state.spike.carried !== null,

      fuse: round2(state.spike.fuse),

      defuse: round2(state.spike.defuse),

      checkpoint: state.spike.checkpoint,

      // A loose spike is the attackers' business until it is armed.

      x: state.spike.planted || me.side === "atk" ? round2(state.spike.x) : null,

      y: state.spike.planted || me.side === "atk" ? round2(state.spike.y) : null,

    },

    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 })),

    board: state.players.map((p) => ({

      id: p.id,

      name: p.name,

      team: p.team,

      side: p.side,

      agent: p.agent,

      bot: p.bot,

      alive: p.alive,

      kills: p.kills,

      deaths: p.deaths,

      damage: Math.round(p.damageDone),

      credits: p.team === me.team ? p.credits : null,

      ult: p.ult,

      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)),

    })),

  };

}

/**

 * Who fell on this tick. A shot that landed this tick and started where the

 * killer stands is what tells a gun kill from an ability kill — the position

 * is used here and goes no further.

 */

function readFalls(): void {

  const after = marksOf(state.players);

  const shooters = new Set<string>();

  for (const shot of state.shots) {

    if (!shot.hit || shot.age > 0) continue;

    for (const player of state.players)

      if (Math.hypot(player.x - shot.x1, player.y - shot.y1) < 2) shooters.add(player.id);

  }

  const falls = fallsBetween(marks, after, {

    at: state.now,

    events: state.events.slice(0, 6).map((e) => e.text),

    shooters,

  });

  marks = after;

  if (falls.length) feed = [...feed, ...falls];

  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();

  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;

/**

 * 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();

}