bccb5ce
@@ -1,23 +1,82 @@
# val
Five attackers with the spike, five defenders, and abilities on cooldown. First to 13.
Five attackers with the spike, five defenders, abilities on cooldown. First to 13.
This is an app: the forge runs it. Production follows the default branch;
every open pull gets a preview at its own address with its own copy of the
data. Everything the app keeps lives under `FORGE_APP_DATA`, which is what
makes "production data" and "preview data" two different things.
A top-down 5v5 played in a browser. One match is always running on the
server: open the page and you are given a seat in the round that is
happening, taken from a bot where it stands. When a match ends it shows the
result for a few seconds and starts a new one, so nobody ever arrives at a
frozen board.
## What is real
Everything that decides a round is computed on the server and only the
server:
- **Movement, shooting and hit detection.** The client sends intent — a
  direction, an angle, a held key — never a position. Damage is by hit
  location (how close the ray passes the target) with falloff and armour:
  a Vandal head shot kills through full armour at any range, a Phantom's
  does not past fifteen metres.
- **Line of sight.** A snapshot only carries the enemies that viewer can
  see. A wall of the map blocks the sight line, a smoke blocks it, a flash
  blinds by the angle you were facing, and a blinded player is sent no
  enemies at all. A dead player watches through their living team mates'
  eyes rather than through walls, so dying is not a wallhack to call out.
  No spawn can see the other spawn: mid is staggered on purpose. A patched
  client learns nothing a plain one does not.
- **The spike.** 100s round, 4s plant, 45s fuse, 7s defuse with a
  checkpoint at 3.5s — a defender killed past half way leaves the defuse
  half done for the next one.
- **Credits.** 800 to start, 9,000 cap, +200 a kill, +300 to the team on a
  plant, loss bonus 1,900 / 2,400 / 2,900. A buy you cannot afford is
  refused server-side.
- **Bots** fill every empty seat and use their kit: smokes on the way in,
  flashes before the entry, a recon dart, a molly on the planted spike.
Agents: Ember, Veil, Sable, Mender, Rook — two basics bought with credits
(charges last the round), a free signature on a cooldown, and an ultimate
paid for with ult points from kills, plants and the two orbs on the map.
Guns: Classic, Ghost, Sheriff, Spectre, Phantom, Vandal, Operator.
## What is not
- One map, one match at a time, ten seats. There is no matchmaking, no
  ranking and no account: your seat belongs to a session cookie.
- No overtime — first to 13 ends it at 12–12 too.
- Sight is a full circle rather than a view cone; top-down has no vertical,
  so the hit location comes from how precisely the shot passes the target.
- Assists are counted as a field but never awarded.
- The live match lives in memory and is gone if the process restarts; only
  finished match results are written to SQLite under `FORGE_APP_DATA`.
## Playing
WASD move, the mouse aims, click fires, **R** reloads, **F** plants and
defuses (hold it), **C / Q / E / X** cast, **B** opens the buy. On a phone
the left thumb walks and the right thumb aims and fires.
```sh
PORT=8080 FORGE_APP_DATA=./data bun run src/server.ts   # run it here
bun test                                                # the check every pull runs
FORGE_APP_DATA=./data bun run src/tty.ts                # the terminal interface
VAL_URL=http://127.0.0.1:8080 bun run src/tty.ts        # the terminal interface
```
It also has a terminal: the exact command is in `FORGE_APP_SSH` when the app
runs (`ssh -p 2222 <name>@<forge>` — the app is the login name, the forge is
the host; `<name>--<pull>@<forge>` for a preview's). It opens `src/tty.ts` on
a real pty over the same data.
The terminal plays the same match over the same socket: it draws the grid,
the scoreboard and the round, and takes a seat. The exact command that
reaches it is in `FORGE_APP_SSH` when the app runs, and the page prints it.
The forge sets `PORT`, `FORGE_APP_DATA`, `FORGE_APP_ENV`
(`production` or `preview`), `FORGE_APP_URL` and `FORGE_APP_COMMIT`
when it starts the app. `forge.json` says how.
The forge sets `PORT`, `FORGE_APP_DATA`, `FORGE_APP_ENV`, `FORGE_APP_URL`,
`FORGE_APP_SSH` and `FORGE_APP_COMMIT` when it starts the app; `forge.json`
says how.
## Shape
`src/map.ts` the grid and its geometry · `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
live match and its sockets · `src/server.ts` the door · `static/val.js` the
browser. The rules are pure functions and the tests play whole matches
headlessly.
@@ -0,0 +1,142 @@
import { expect, test } from "bun:test";
import { AGENTS, agentById, buyableSlots, cast, castable, flashDuration, sightBlocked, SLOTS } from "./abilities.ts";
import { newMatch, startRound, tick } from "./match.ts";
import type { MatchState, Player, Zone } from "./state.ts";
const live = (): MatchState => {
  const state = newMatch(11);
  state.phase = "live";
  state.clock = 100;
  return state;
};
const attacker = (state: MatchState): Player => state.players.find((p) => p.side === "atk")!;
test("every agent has two bought basics, a free signature and an ultimate", () => {
  expect(AGENTS.length).toBe(5);
  for (const agent of AGENTS) {
    for (const slot of SLOTS) expect(agent.abilities[slot].name.length).toBeGreaterThan(0);
    for (const slot of buyableSlots) expect(agent.abilities[slot].cost).toBeGreaterThan(0);
    expect(agent.abilities.e.cost).toBe(0);
    expect(agent.abilities.e.cooldown).toBeGreaterThan(0);
    expect(agent.abilities.x.points).toBeGreaterThanOrEqual(6);
  }
});
test("a flash blinds by the angle you were facing", () => {
  const at = { x: 1000, y: 1000 };
  const staring = { x: 1200, y: 1000 };
  const facingIt = Math.PI; // looking back down the line at the flash
  const facingAway = 0;
  expect(flashDuration(1.7, staring, at, facingIt, false)).toBeGreaterThan(1.6);
  expect(flashDuration(1.7, staring, at, facingAway, false)).toBe(0);
  // Half turned away is a shorter blind than staring straight at it.
  const glance = flashDuration(1.7, staring, at, facingIt - 1.2, false);
  expect(glance).toBeGreaterThan(0);
  expect(glance).toBeLessThan(1.7);
});
test("a wall between you and the flash means no blind at all", () => {
  const blind = flashDuration(1.7, { x: 1200, y: 1000 }, { x: 1000, y: 1000 }, Math.PI, true);
  expect(blind).toBe(0);
});
test("a smoke blocks the sight line for as long as it lives", () => {
  const smoke: Zone = {
    id: 1, kind: "smoke", owner: "x", side: "atk", x: 1200, y: 1000, r: 140,
    life: 8, fuse: 0, beat: 0, pulses: 0, damage: 0, blocks: true, solid: false,
  };
  // Straight down the mid corridor, which is open floor end to end.
  const from = { x: 1100, y: 1000 };
  const to = { x: 1300, y: 1000 };
  expect(sightBlocked(from, to, [])).toBe(false);
  expect(sightBlocked(from, to, [smoke])).toBe(true);
  // Standing off the line, the smoke is not in the way.
  expect(sightBlocked({ x: 1100, y: 700 }, { x: 1300, y: 700 }, [smoke])).toBe(false);
});
test("a charge is spent on a cast and refused when there is none", () => {
  const state = live();
  const player = attacker(state);
  player.agent = "veil";
  player.charges.c = 1;
  expect(cast(state, player, "c")).toBe(true);
  expect(player.charges.c).toBe(0);
  expect(state.zones.some((z) => z.kind === "smoke")).toBe(true);
  expect(cast(state, player, "c")).toBe(false);
  expect(castable(player, "c")).toBe(false);
});
test("the signature goes on cooldown and comes back on its own", () => {
  const state = live();
  const player = attacker(state);
  player.agent = "veil";
  const cooldown = agentById("veil").abilities.e.cooldown;
  expect(cast(state, player, "e")).toBe(true);
  expect(player.charges.e).toBe(0);
  expect(player.cooldown.e).toBe(cooldown);
  for (let i = 0; i < Math.ceil(cooldown * 10) + 4; i++) tick(state, 0.1);
  expect(player.cooldown.e).toBe(0);
  expect(castable(player, "e")).toBe(true);
});
test("an ultimate costs its points and empties the meter", () => {
  const state = live();
  const player = attacker(state);
  player.agent = "sable";
  player.ult = 3;
  expect(cast(state, player, "x")).toBe(false);
  player.ult = 7;
  expect(cast(state, player, "x")).toBe(true);
  expect(player.ult).toBe(0);
  // Hunt reveals every enemy and leaves the caster's own side alone.
  for (const other of state.players) expect(other.revealed > 0).toBe(other.side !== player.side);
});
test("a molly burns whoever stands in it and leaves the thrower's team alone", () => {
  const state = live();
  const player = attacker(state);
  player.agent = "ember";
  player.charges.q = 1;
  const victim = state.players.find((p) => p.side === "def")!;
  const mate = state.players.find((p) => p.side === "atk" && p.id !== player.id)!;
  victim.x = player.x + 120;
  victim.y = player.y;
  mate.x = player.x + 120;
  mate.y = player.y;
  player.angle = 0;
  player.x = victim.x - 120;
  cast(state, player, "q");
  for (const zone of state.zones) {
    zone.x = victim.x;
    zone.y = victim.y;
  }
  for (let i = 0; i < 20; i++) tick(state, 0.1);
  expect(victim.hp).toBeLessThan(100);
  expect(mate.hp).toBe(100);
});
test("a wall is solid: it blocks the sight line that was open", () => {
  const state = live();
  const player = attacker(state);
  player.agent = "rook";
  // Along the back corridor, which is open from one side of the map to the other.
  player.x = 400;
  player.y = 1400;
  player.angle = 0;
  const behind = { x: 1000, y: 1400 };
  const openBefore = !sightBlocked(player, behind, state.zones);
  expect(cast(state, player, "e")).toBe(true);
  expect(openBefore).toBe(true);
  expect(sightBlocked(player, behind, state.zones)).toBe(true);
  expect(state.zones.every((z) => z.solid)).toBe(true);
});
test("a round starts with the signature ready and no bought charges", () => {
  const state = newMatch(3);
  startRound(state, true);
  for (const player of state.players) {
    expect(player.charges.c).toBe(0);
    expect(player.charges.q).toBe(0);
    expect(player.charges.e).toBe(1);
  }
});
@@ -0,0 +1,273 @@
/**
 * Agents and their kits.
 *
 * Five agents, each with two basics bought with credits (charges last the
 * round), one signature that is free and comes back on a cooldown, and one
 * ultimate paid for in ult points. The effects themselves are a short list of
 * kinds — flash, smoke, molly, dart, heal, wall, trip — so an agent is data,
 * not code.
 *
 * The two rules worth testing on their own: a flash blinds by the angle you
 * were facing and only with line of sight, and a smoke blocks that sight.
 */
import { rayHitWall, segmentHitsCircle, wallBetween, type Point } from "./map.ts";
import type { MatchState, Player, Slot, Zone } from "./state.ts";
export type Kind =
  | "flash"
  | "smoke"
  | "molly"
  | "dart"
  | "heal"
  | "wall"
  | "trip"
  | "haste"
  | "rage"
  | "revealall"
  | "slowall";
export type Ability = {
  slot: Slot;
  name: string;
  kind: Kind;
  /** Credits for a basic; 0 for the signature and the ultimate. */
  cost: number;
  charges: number;
  /** Seconds the signature takes to come back. 0 means it does not. */
  cooldown: number;
  /** Ult points the ultimate costs. */
  points: number;
  range: number;
  radius: number;
  duration: number;
  damage: number;
  fuse: number;
  text: string;
};
export type Agent = {
  id: string;
  name: string;
  role: string;
  blurb: string;
  abilities: Record<Slot, Ability>;
};
const basic = (a: Partial<Ability> & { slot: Slot; name: string; kind: Kind; text: string }): Ability => ({
  cost: 200,
  charges: 1,
  cooldown: 0,
  points: 0,
  range: 700,
  radius: 110,
  duration: 10,
  damage: 0,
  fuse: 0,
  ...a,
});
export const AGENTS: Agent[] = [
  {
    id: "ember",
    name: "Ember",
    role: "Duelist",
    blurb: "Flash in, burn them off the plant, come back from nothing.",
    abilities: {
      c: basic({ slot: "c", name: "Flashfire", kind: "flash", cost: 250, charges: 2, range: 620, radius: 900, fuse: 0.55, duration: 1.7, text: "Throws a flash that pops after half a second and blinds anyone looking near it." }),
      q: basic({ slot: "q", name: "Blaze", kind: "molly", cost: 200, charges: 1, range: 620, radius: 95, duration: 6, damage: 26, text: "A pool of fire: 26 damage a second to anyone standing in it." }),
      e: basic({ slot: "e", name: "Second Wind", kind: "haste", cost: 0, charges: 1, cooldown: 35, duration: 4, text: "Signature. Four seconds of speed — take the angle before they re-peek." }),
      x: basic({ slot: "x", name: "Rebirth", kind: "rage", cost: 0, charges: 0, points: 6, duration: 6, text: "Ultimate. Full health, armour back, every basic charge refilled, six seconds of speed." }),
    },
  },
  {
    id: "veil",
    name: "Veil",
    role: "Controller",
    blurb: "Takes the sightline away and gives the site to whoever she likes.",
    abilities: {
      c: basic({ slot: "c", name: "Cloudburst", kind: "smoke", cost: 100, charges: 2, range: 760, radius: 105, duration: 8, text: "A short smoke. Cheap enough to throw two on a pistol round." }),
      q: basic({ slot: "q", name: "Blind Spot", kind: "flash", cost: 250, charges: 1, range: 600, radius: 850, fuse: 0.5, duration: 1.6, text: "A flash for the entry you are about to make." }),
      e: basic({ slot: "e", name: "Curtain", kind: "smoke", cost: 0, charges: 1, cooldown: 35, range: 900, radius: 150, duration: 15, text: "Signature. A wide smoke for fifteen seconds — nobody sees through it, server side." }),
      x: basic({ slot: "x", name: "Blackout", kind: "smoke", cost: 0, charges: 0, points: 7, range: 1100, radius: 280, duration: 12, damage: -1, text: "Ultimate. A site-sized smoke that slows every enemy inside it." }),
    },
  },
  {
    id: "sable",
    name: "Sable",
    role: "Initiator",
    blurb: "Finds them before the team walks in, and moves them off the angle.",
    abilities: {
      c: basic({ slot: "c", name: "Recon Dart", kind: "dart", cost: 250, charges: 1, range: 900, radius: 340, duration: 6, text: "Sticks and sweeps three times, revealing enemies it can see for two seconds each." }),
      q: basic({ slot: "q", name: "Shock Bolt", kind: "molly", cost: 150, charges: 2, range: 820, radius: 90, duration: 1.1, damage: 70, text: "A bolt that cracks for 70 a second — clears a corner or finishes a plant." }),
      e: basic({ slot: "e", name: "Owl Flash", kind: "flash", cost: 0, charges: 1, cooldown: 40, range: 640, radius: 900, fuse: 0.6, duration: 1.6, text: "Signature. A flash on a cooldown, so there is always one for the retake." }),
      x: basic({ slot: "x", name: "Hunt", kind: "revealall", cost: 0, charges: 0, points: 7, duration: 6, text: "Ultimate. Every enemy on the map is revealed for six seconds." }),
    },
  },
  {
    id: "mender",
    name: "Mender",
    role: "Sentinel",
    blurb: "Holds the flank shut and keeps the entry alive long enough to trade.",
    abilities: {
      c: basic({ slot: "c", name: "Healing Pulse", kind: "heal", cost: 200, charges: 2, range: 260, radius: 260, duration: 3, damage: 60, text: "Heals you or the nearest hurt ally 60 health over three seconds." }),
      q: basic({ slot: "q", name: "Barrier", kind: "wall", cost: 400, charges: 1, range: 520, radius: 120, duration: 12, text: "A solid wall for twelve seconds: nothing walks through it and nothing sees through it." }),
      e: basic({ slot: "e", name: "Tripwire", kind: "trip", cost: 0, charges: 1, cooldown: 40, range: 300, radius: 120, duration: 45, text: "Signature. Watches the flank: the enemy who walks in is revealed and slowed." }),
      x: basic({ slot: "x", name: "Lockdown", kind: "slowall", cost: 0, charges: 0, points: 8, duration: 5, text: "Ultimate. Every enemy is slowed and revealed for five seconds." }),
    },
  },
  {
    id: "rook",
    name: "Rook",
    role: "Initiator",
    blurb: "Builds the angle he wants and sets the site on fire when it is lost.",
    abilities: {
      c: basic({ slot: "c", name: "Smoke Grenade", kind: "smoke", cost: 150, charges: 1, range: 800, radius: 130, duration: 10, text: "One smoke, thrown long." }),
      q: basic({ slot: "q", name: "Flashbang", kind: "flash", cost: 200, charges: 2, range: 600, radius: 800, fuse: 0.6, duration: 1.5, text: "Two flashes: one for the entry, one for the exit." }),
      e: basic({ slot: "e", name: "Stone Wall", kind: "wall", cost: 0, charges: 1, cooldown: 45, range: 480, radius: 130, duration: 10, text: "Signature. A free wall, back every forty-five seconds." }),
      x: basic({ slot: "x", name: "Firestorm", kind: "molly", cost: 0, charges: 0, points: 7, range: 900, radius: 210, duration: 8, damage: 34, text: "Ultimate. A site-wide fire nobody defuses through." }),
    },
  },
];
export const agentById = (id: string): Agent => AGENTS.find((a) => a.id === id) ?? AGENTS[0]!;
export const isAgentId = (value: unknown): value is string =>
  typeof value === "string" && AGENTS.some((a) => a.id === value);
export const SLOTS: Slot[] = ["c", "q", "e", "x"];
/** Bought before the round; the signature and the ultimate are never for sale. */
export const buyableSlots: Slot[] = ["c", "q"];
/**
 * How long a flash blinds, in seconds. Facing it is the worst case; looking
 * away is free; a wall or a smoke between you and it means nothing at all.
 * `blocked` is the caller's line-of-sight answer, so this stays pure.
 */
export function flashDuration(
  full: number,
  from: Point,
  at: Point,
  facing: number,
  blocked: boolean,
): number {
  if (blocked) return 0;
  const toFlash = Math.atan2(at.y - from.y, at.x - from.x);
  let off = Math.abs(((toFlash - facing + Math.PI * 3) % (Math.PI * 2)) - Math.PI);
  off = Math.min(off, Math.PI);
  const wide = (100 * Math.PI) / 180;
  if (off > wide) return 0;
  const narrow = (45 * Math.PI) / 180;
  const facingFactor = off <= narrow ? 1 : 1 - ((off - narrow) / (wide - narrow)) * 0.75;
  const distance = Math.hypot(from.x - at.x, from.y - at.y);
  const near = distance < 900 ? 1 : distance < 1500 ? 0.6 : 0.35;
  return Math.round(full * facingFactor * near * 100) / 100;
}
/** Whether a sight line survives the smokes and walls standing on the map. */
export const sightBlocked = (from: Point, to: Point, zones: Zone[]): boolean => {
  if (wallBetween(from, to)) return true;
  for (const zone of zones)
    if (zone.blocks && zone.fuse <= 0 && segmentHitsCircle(from, to, zone, zone.r)) return true;
  return false;
};
/** Can this player cast this slot right now, and why not. */
export function castable(player: Player, slot: Slot): boolean {
  if (!player.alive) return false;
  const ability = agentById(player.agent).abilities[slot];
  if (slot === "x") return player.ult >= ability.points;
  if (player.cooldown[slot] > 0) return false;
  return player.charges[slot] > 0;
}
/** Where an ability lands: down the aim line, stopped by the first wall. */
export const castPoint = (player: Player, range: number): Point =>
  rayHitWall(player, player.angle, range);
const zone = (state: MatchState, z: Omit<Zone, "id">): Zone => {
  const made = { ...z, id: state.nextZone++ };
  state.zones.push(made);
  return made;
};
/**
 * Spend the charge and put the effect on the map. Returns false when the
 * cast was refused — no charge, still on cooldown, not enough ult points —
 * so the caller never has to guess.
 */
export function cast(state: MatchState, player: Player, slot: Slot): boolean {
  if (!castable(player, slot)) return false;
  const agent = agentById(player.agent);
  const ability = agent.abilities[slot];
  const spot = castPoint(player, ability.range);
  const base = { owner: player.id, side: player.side, life: ability.duration, fuse: ability.fuse, beat: 0, pulses: 0, damage: ability.damage, blocks: false, solid: false };
  switch (ability.kind) {
    case "flash":
      zone(state, { ...base, kind: "flash", x: spot.x, y: spot.y, r: ability.radius, life: ability.fuse + 0.2, damage: ability.duration });
      break;
    case "smoke":
      zone(state, { ...base, kind: "smoke", x: spot.x, y: spot.y, r: ability.radius, blocks: true });
      break;
    case "molly":
      zone(state, { ...base, kind: "molly", x: spot.x, y: spot.y, r: ability.radius, beat: 0.5 });
      break;
    case "dart":
      zone(state, { ...base, kind: "dart", x: spot.x, y: spot.y, r: ability.radius, beat: 0.6, pulses: 3 });
      break;
    case "trip":
      zone(state, { ...base, kind: "trip", x: spot.x, y: spot.y, r: ability.radius, fuse: 1 });
      break;
    case "heal": {
      const hurt = state.players
        .filter((p) => p.alive && p.side === player.side && p.hp < 100 && Math.hypot(p.x - player.x, p.y - player.y) <= ability.range)
        .sort((a, b) => a.hp - b.hp)[0];
      const target = hurt ?? player;
      zone(state, { ...base, kind: "heal", x: target.x, y: target.y, r: 40, beat: 0.5, owner: target.id });
      break;
    }
    case "wall": {
      // Three blockers across the aim line: solid to walk through and to see
      // through, and made of circles so every other test still works.
      const across = player.angle + Math.PI / 2;
      for (let i = -1; i <= 1; i++)
        zone(state, {
          ...base,
          kind: "wall",
          x: spot.x + Math.cos(across) * i * (ability.radius * 0.7),
          y: spot.y + Math.sin(across) * i * (ability.radius * 0.7),
          r: ability.radius * 0.45,
          blocks: true,
          solid: true,
        });
      break;
    }
    case "haste":
      player.haste = Math.max(player.haste, ability.duration);
      break;
    case "rage":
      player.hp = 100;
      player.armour = Math.max(player.armour, 25);
      player.haste = Math.max(player.haste, ability.duration);
      for (const s of buyableSlots) player.charges[s] = Math.max(player.charges[s], agent.abilities[s].charges);
      break;
    case "revealall":
      for (const other of state.players)
        if (other.side !== player.side) other.revealed = Math.max(other.revealed, ability.duration);
      break;
    case "slowall":
      for (const other of state.players)
        if (other.side !== player.side) {
          other.revealed = Math.max(other.revealed, ability.duration);
          other.slow = Math.max(other.slow, ability.duration);
        }
      break;
  }
  if (slot === "x") player.ult = 0;
  else {
    player.charges[slot] = Math.max(0, player.charges[slot] - 1);
    if (ability.cooldown > 0) player.cooldown[slot] = ability.cooldown;
  }
  return true;
}
@@ -0,0 +1,256 @@
/**
 * 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 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 } from "./weapons.ts";
export const TICK = 1 / 30;
const BROADCAST_EVERY = 2;
export type Seat = { playerId: string; send: (data: string) => void };
let state: MatchState = newMatch();
const seats = new Map<string, Seat>();
let ticks = 0;
let lastResult: string | null = null;
export const match = (): MatchState => state;
export const findPlayer = (id: string): Player | undefined => state.players.find((p) => p.id === id);
/** Sit somebody down in the emptiest team, replacing a bot where it stands. */
export function takeSeat(session: string, name: string): Player | null {
  const existing = seats.get(session);
  const held = existing ? findPlayer(existing.playerId) : undefined;
  if (held) {
    held.name = name;
    return held;
  }
  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 = name;
  seat.think = 0;
  seat.input = { mx: 0, my: 0, angle: seat.angle, fire: false, use: false, reload: false, cast: null };
  return seat;
}
export function attach(session: string, playerId: string, send: (data: string) => void): void {
  seats.set(session, { playerId, send });
}
/** A person leaving gives the seat back to a bot, mid-round and all. */
export function release(session: string): void {
  const seat = seats.get(session);
  seats.delete(session);
  if (!seat) return;
  const player = findPlayer(seat.playerId);
  if (player && !stillHeld(seat.playerId)) {
    player.bot = true;
    player.think = 0;
    player.input.fire = false;
    player.input.use = false;
  }
}
const stillHeld = (playerId: string): boolean =>
  [...seats.values()].some((s) => s.playerId === playerId);
export const seatCount = (): number => seats.size;
// ------------------------------------------------------------- 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;
export function snapshot(viewerId: string): 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 JSON.stringify({
    t: "s",
    phase: state.phase,
    clock: round2(Math.max(0, state.clock)),
    round: state.round,
    score: state.score,
    attackers: state.attackers,
    result: state.result,
    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),
      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),
  });
}
// ----------------------------------------------------------------- the loop
function step(): void {
  runBots(state, TICK);
  tick(state, TICK);
  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 % BROADCAST_EVERY !== 0) return;
  for (const seat of seats.values()) {
    try {
      seat.send(snapshot(seat.playerId));
    } catch {
      // A socket that will not take a frame is closed already; the close
      // handler gives the seat back.
    }
  }
}
let timer: ReturnType<typeof setInterval> | null = null;
export function startArena(): void {
  if (timer) return;
  timer = setInterval(step, 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();
}
@@ -0,0 +1,257 @@
/**
 * Bots. They fill the seats nobody is sitting in, and they use their kit:
 * a smoke on the way in, a flash before the entry, a dart to find the hold,
 * a molly on the planted spike, an ultimate when it is worth something.
 *
 * A bot only ever writes to its own `input`, the same field a browser writes
 * to, so the match loop cannot tell them apart and neither can a cheat.
 */
import { agentById, castable } from "./abilities.ts";
import { pathStep, siteAt, siteCentre, walkDistance, type Point, type Site } from "./map.ts";
import { buyAbility, buyShield, buyWeapon, random, SPIKE_REACH, visible } from "./match.ts";
import type { MatchState, Player, Slot } from "./state.ts";
import { WEAPONS, type WeaponId } from "./weapons.ts";
/**
 * The site the attacking bots agree on this round. It comes from the match
 * id and the round number, never the running seed: five bots have to reach
 * the same answer on every tick or they walk in circles between the sites.
 */
export function attackSite(state: MatchState): Site {
  let hash = 0;
  for (const ch of state.id) hash = (hash * 31 + ch.charCodeAt(0)) % 9973;
  return (hash + state.round) % 2 === 0 ? "A" : "B";
}
const holdSpots = (state: MatchState): Point[] => {
  const a = siteCentre("A");
  const b = siteCentre("B");
  return [
    { x: a.x + 60, y: a.y + 90 },
    { x: a.x - 40, y: a.y - 20 },
    { x: 1200, y: 640 },
    { x: b.x - 60, y: b.y + 90 },
    { x: b.x + 40, y: b.y - 20 },
  ];
};
const ladder: { weapon: WeaponId; shield: "light" | "heavy" | null; floor: number }[] = [
  { weapon: "operator", shield: "heavy", floor: 6200 },
  { weapon: "vandal", shield: "heavy", floor: 4400 },
  { weapon: "phantom", shield: "heavy", floor: 4200 },
  { weapon: "spectre", shield: "heavy", floor: 2900 },
  { weapon: "spectre", shield: "light", floor: 2100 },
  { weapon: "sheriff", shield: "light", floor: 1300 },
  { weapon: "ghost", shield: "light", floor: 950 },
  { weapon: "classic", shield: "light", floor: 400 },
];
/**
 * What a bot buys. It saves on a broken economy — under 2000 with an empty
 * gun rack is an eco round, and the credits are worth more next round.
 */
export function botBuy(state: MatchState, player: Player): void {
  const saving = player.credits < 2000 && state.round > 1 && player.weapon === "classic" && state.lossStreak[player.team] > 0;
  if (!saving) {
    const pick = ladder.find((step) => player.credits >= step.floor);
    if (pick && WEAPONS[pick.weapon].cost > 0) buyWeapon(state, player, pick.weapon);
    if (pick?.shield) buyShield(state, player, player.credits > 3500 ? "heavy" : pick.shield);
  }
  const agent = agentById(player.agent);
  // Abilities last: a flash is worth more than the last hundred credits.
  for (const slot of ["c", "q", "c", "q"] as Slot[]) {
    const ability = agent.abilities[slot];
    if (player.credits >= ability.cost + (saving ? 400 : 0)) buyAbility(state, player, slot);
  }
}
const enemiesSeen = (state: MatchState, bot: Player): Player[] =>
  state.players.filter((p) => p.alive && p.side !== bot.side && visible(state, bot, p));
const towards = (bot: Player, point: Point): { mx: number; my: number } => {
  const dx = point.x - bot.x;
  const dy = point.y - bot.y;
  const len = Math.hypot(dx, dy) || 1;
  return { mx: dx / len, my: dy / len };
};
const turn = (bot: Player, target: number, rate: number): void => {
  let diff = ((target - bot.angle + Math.PI * 3) % (Math.PI * 2)) - Math.PI;
  bot.input.angle = bot.angle + Math.max(-rate, Math.min(rate, diff));
};
/** One bot's decision for this tick. */
export function botThink(state: MatchState, bot: Player, dt: number): void {
  if (!bot.alive) return;
  if (state.phase === "buy") {
    if (bot.think <= 0) {
      botBuy(state, bot);
      bot.think = 99;
    }
    bot.input.mx = 0;
    bot.input.my = 0;
    return;
  }
  // The buy left the timer parked; the first live tick starts it thinking.
  if (bot.think > 5) bot.think = 0;
  bot.think -= dt;
  const spike = state.spike;
  const site = spike.planted && spike.site ? spike.site : attackSite(state);
  const target = enemiesSeen(state, bot).sort(
    (a, b) => Math.hypot(a.x - bot.x, a.y - bot.y) - Math.hypot(b.x - bot.x, b.y - bot.y),
  )[0];
  // --- where to be
  let goal: Point = siteCentre(site);
  if (bot.side === "atk") {
    if (spike.planted) goal = { x: spike.x + (random(state) - 0.5) * 220, y: spike.y + (random(state) - 0.5) * 220 };
    else if (!spike.carried && !bot.spike) {
      const loose = { x: spike.x, y: spike.y };
      if (walkDistance(bot, loose) < 8) goal = loose;
    }
  } else {
    const spots = holdSpots(state);
    const index = Number(bot.id.slice(-1)) % spots.length;
    goal = spike.planted ? { x: spike.x, y: spike.y } : spots[index]!;
  }
  bot.goal = goal;
  const distToGoal = Math.hypot(goal.x - bot.x, goal.y - bot.y);
  const step = pathStep(bot, goal);
  const walk = towards(bot, step);
  bot.input.mx = walk.mx;
  bot.input.my = walk.my;
  // --- the kit
  if (bot.think <= 0) {
    bot.think = 0.4 + random(state) * 0.5;
    useKit(state, bot, target ?? null, site, distToGoal);
  }
  // --- the spike
  bot.input.use = false;
  if (bot.side === "atk" && bot.spike && !spike.planted) {
    const onSite = siteAt(bot.x, bot.y) === site;
    if (onSite && (!target || bot.planting > 0)) {
      bot.input.use = true;
      bot.input.mx = 0;
      bot.input.my = 0;
    }
  }
  if (bot.side === "def" && spike.planted && Math.hypot(bot.x - spike.x, bot.y - spike.y) < SPIKE_REACH - 6) {
    const safe = !target || spike.fuse < 8;
    if (safe) {
      bot.input.use = true;
      bot.input.mx = 0;
      bot.input.my = 0;
    }
  }
  if (bot.blind > 0) {
    // Blinded: back off and stop shooting, like a person would.
    bot.input.fire = false;
    bot.input.mx *= -0.6;
    bot.input.my *= -0.6;
    return;
  }
  // --- the gun
  bot.input.reload = bot.ammo === 0;
  if (!target) {
    bot.input.fire = false;
    if (Math.hypot(bot.input.mx, bot.input.my) > 0.01)
      turn(bot, Math.atan2(bot.input.my, bot.input.mx), 6 * dt);
    return;
  }
  const range = Math.hypot(target.x - bot.x, target.y - bot.y);
  const aim = Math.atan2(target.y - bot.y, target.x - bot.x) + (random(state) - 0.5) * 0.06;
  turn(bot, aim, 7 * dt);
  const off = Math.abs(((aim - bot.angle + Math.PI * 3) % (Math.PI * 2)) - Math.PI);
  const weapon = WEAPONS[bot.weapon];
  bot.input.fire = off < 0.07 && range < weapon.range && bot.ammo > 0;
  // Stand still to shoot at range, close the gap up front.
  if (range > 420) {
    bot.input.mx *= 0.15;
    bot.input.my *= 0.15;
  } else if (range < 160) {
    const away = towards(bot, target);
    bot.input.mx = -away.mx * 0.5;
    bot.input.my = -away.my * 0.5;
  }
}
/** Ability decisions, kept in one place so each is a sentence you can read. */
function useKit(state: MatchState, bot: Player, target: Player | null, site: Site, distToGoal: number): void {
  const agent = agentById(bot.agent);
  const spike = state.spike;
  const centre = siteCentre(site);
  const aimAt = (point: Point): void => {
    bot.input.angle = Math.atan2(point.y - bot.y, point.x - bot.x);
    bot.angle = bot.input.angle;
  };
  const tryCast = (slot: Slot, point: Point): boolean => {
    if (!castable(bot, slot)) return false;
    aimAt(point);
    bot.input.cast = slot;
    return true;
  };
  for (const slot of ["x", "c", "q", "e"] as Slot[]) {
    const ability = agent.abilities[slot];
    if (!castable(bot, slot)) continue;
    const kind = ability.kind;
    if (kind === "rage" || kind === "haste") {
      if (bot.hp < 70 || (target && distToGoal < 500)) return void tryCast(slot, centre);
      continue;
    }
    if (kind === "revealall" || kind === "slowall") {
      if (target || distToGoal < 420) return void tryCast(slot, centre);
      continue;
    }
    if (kind === "heal") {
      const hurt = state.players.find((p) => p.alive && p.side === bot.side && p.hp <= 60 && Math.hypot(p.x - bot.x, p.y - bot.y) < ability.range);
      if (hurt) return void tryCast(slot, hurt);
      continue;
    }
    if (kind === "molly") {
      // Fire on the planted spike, or on the choke ahead of us.
      if (bot.side === "def" && spike.planted && Math.hypot(bot.x - spike.x, bot.y - spike.y) < ability.range)
        return void tryCast(slot, spike);
      if (target && Math.hypot(target.x - bot.x, target.y - bot.y) < ability.range && Math.hypot(target.x - bot.x, target.y - bot.y) > 120)
        return void tryCast(slot, target);
      continue;
    }
    if (kind === "flash") {
      const enemyClose = target && Math.hypot(target.x - bot.x, target.y - bot.y) < ability.range;
      if (enemyClose) return void tryCast(slot, target!);
      if (bot.side === "atk" && distToGoal < ability.range && distToGoal > 150) return void tryCast(slot, centre);
      continue;
    }
    if (kind === "smoke") {
      if (bot.side === "atk" && distToGoal < ability.range && distToGoal > 260) return void tryCast(slot, centre);
      if (bot.side === "def" && spike.planted && Math.hypot(bot.x - spike.x, bot.y - spike.y) < ability.range && Math.hypot(bot.x - spike.x, bot.y - spike.y) > 200)
        return void tryCast(slot, spike);
      continue;
    }
    if (kind === "dart") {
      if (distToGoal < ability.range && distToGoal > 200) return void tryCast(slot, centre);
      continue;
    }
    if (kind === "wall") {
      if (target && Math.hypot(target.x - bot.x, target.y - bot.y) < ability.range && bot.hp < 60)
        return void tryCast(slot, target);
      if (bot.side === "def" && !spike.planted && distToGoal < 200 && state.clock > 60) return void tryCast(slot, centre);
      continue;
    }
    if (kind === "trip") {
      if (bot.side === "def" && distToGoal < 160) return void tryCast(slot, { x: bot.x + (random(state) - 0.5) * 200, y: bot.y + (random(state) - 0.5) * 200 });
      continue;
    }
  }
}
/** Drive every seat that nobody is sitting in. */
export function runBots(state: MatchState, dt: number): void {
  for (const player of state.players) if (player.bot) botThink(state, player, dt);
}
@@ -0,0 +1,43 @@
/**
 * What survives a restart: finished matches. The live match lives in memory
 * — it is gone the moment the process is — but its result is written here,
 * under FORGE_APP_DATA, so the page can say what happened before you arrived.
 */
import { Database } from "bun:sqlite";
import { mkdirSync } from "node:fs";
import { join } from "node:path";
const dataDir = process.env.FORGE_APP_DATA ?? "./data";
mkdirSync(dataDir, { recursive: true });
export const db = new Database(join(dataDir, "app.db"));
db.exec("PRAGMA journal_mode = WAL");
db.exec(
  `CREATE TABLE IF NOT EXISTS result (
     id INTEGER PRIMARY KEY,
     summary TEXT NOT NULL,
     red INTEGER NOT NULL,
     blue INTEGER NOT NULL,
     rounds INTEGER NOT NULL,
     ended_at TEXT NOT NULL DEFAULT (datetime('now'))
   )`,
);
export type Result = { summary: string; red: number; blue: number; rounds: number; ended_at: string };
export const recordResult = (summary: string, red: number, blue: number, rounds: number): void => {
  db.query("INSERT INTO result (summary, red, blue, rounds) VALUES (?1, ?2, ?3, ?4)").run(
    summary.slice(0, 120),
    red,
    blue,
    rounds,
  );
};
export const recentResults = (limit = 5): Result[] =>
  db
    .query<Result, [number]>(
      "SELECT summary, red, blue, rounds, ended_at FROM result ORDER BY id DESC LIMIT ?1",
    )
    .all(Math.max(1, Math.min(50, limit)));
@@ -0,0 +1,28 @@
import { expect, test } from "bun:test";
import { award, CREDIT_CAP, lossBonus, roundReward, spend, START_CREDITS } from "./economy.ts";
test("a round starts on 800 and nothing goes past 9000", () => {
  expect(START_CREDITS).toBe(800);
  expect(award(8900, 200)).toBe(CREDIT_CAP);
  expect(award(100, -500)).toBe(0);
});
test("the loss bonus rises 1900 / 2400 / 2900 and stops", () => {
  expect(lossBonus(1)).toBe(1900);
  expect(lossBonus(2)).toBe(2400);
  expect(lossBonus(3)).toBe(2900);
  expect(lossBonus(7)).toBe(2900);
});
test("a losing attack that planted keeps the plant bonus on top", () => {
  expect(roundReward(false, 1, false)).toBe(1900);
  expect(roundReward(false, 1, true)).toBe(1900 + 300);
  expect(roundReward(true, 3, false)).toBe(3000);
});
test("a buy you cannot afford is refused, never a debt", () => {
  expect(spend(800, 2900)).toEqual({ ok: false, credits: 800 });
  expect(spend(2900, 2900)).toEqual({ ok: true, credits: 0 });
  expect(spend(800, -100).ok).toBe(false);
  expect(spend(800, Number.NaN).ok).toBe(false);
});
@@ -0,0 +1,34 @@
/**
 * Credits. The whole economy is four numbers and a losing streak, and all of
 * it is pure: the match calls these and stores what comes back.
 */
export const START_CREDITS = 800;
export const CREDIT_CAP = 9000;
export const KILL_REWARD = 200;
export const PLANT_REWARD = 300;
export const WIN_REWARD = 3000;
/** Rising with the streak, and capped at the third step. */
export const LOSS_BONUS = [1900, 2400, 2900];
export const clampCredits = (credits: number): number =>
  Math.max(0, Math.min(CREDIT_CAP, Math.floor(credits)));
export const award = (credits: number, amount: number): number => clampCredits(credits + amount);
/** The loss bonus for a team that has now lost `streak` rounds in a row. */
export const lossBonus = (streak: number): number =>
  LOSS_BONUS[Math.min(Math.max(streak, 1), LOSS_BONUS.length) - 1]!;
/** What a round's end pays each member of a team. */
export function roundReward(won: boolean, lossStreak: number, planted: boolean): number {
  if (won) return WIN_REWARD;
  // A team that lost the round but got the spike down keeps a little more.
  return lossBonus(lossStreak) + (planted ? PLANT_REWARD : 0);
}
/** A purchase either happens at a price or is refused; never a debt. */
export function spend(credits: number, cost: number): { ok: boolean; credits: number } {
  if (!Number.isFinite(cost) || cost < 0 || cost > credits) return { ok: false, credits };
  return { ok: true, credits: clampCredits(credits - cost) };
}
@@ -0,0 +1,265 @@
/**
 * The map: one grid, and the geometry everything else asks questions of.
 *
 * 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.
 * Tiles are 80 units; a player is a circle of radius 16, so a one-tile
 * 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.
 */
export const TILE = 80;
// '#' wall · '.' floor · 'A'/'B' plant site · 'a' attacker spawn · 'd' defender spawn
const ROWS_SRC = [
  "##############################",
  "#........###.dddd.###........#",
  "#.AAAAA..###.dddd.###..BBBBB.#",
  "#.AAAAA..##........##..BBBBB.#",
  "#.AAAAA..##.#....#.##..BBBBB.#",
  "#.AAAAA..##........##..BBBBB.#",
  "#...##......#....#......##...#",
  "#..####....#......#....####..#",
  "#..####..###......###..####..#",
  "#..####..####....####..####..#",
  "#..####..####.##.####..####..#",
  "#........####.##.####........#",
  "#..####..####....####..####..#",
  "#..####..#####..#####..####..#",
  "#..####..#####..#####..####..#",
  "#..####..###......###..####..#",
  "#........##..aaaa..##........#",
  "#............aaaa............#",
  "##############################",
];
export const COLS = ROWS_SRC[0]!.length;
export const ROWS = ROWS_SRC.length;
export const WIDTH = COLS * TILE;
export const HEIGHT = ROWS * TILE;
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);
};
/** 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);
  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 siteCentre = (site: Site): Point => {
  const cells = siteCells(site);
  const sum = cells.reduce((a, p) => ({ x: a.x + p.x, y: a.y + p.y }), { x: 0, y: 0 });
  return { x: sum.x / cells.length, y: sum.y / cells.length };
};
/** 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 the grid: each axis is moved and resolved on its
 * own, so running along a wall slides instead of sticking.
 */
export function moveCircle(x: number, y: number, dx: number, dy: number, r: number): Point {
  let nx = x;
  let ny = y;
  if (dx !== 0) {
    const test = nx + dx;
    if (!blockedCircle(test, ny, r)) nx = test;
    else {
      const col = Math.floor(test / TILE);
      nx = dx > 0 ? col * TILE - r - 0.01 : (col + 1) * TILE + r + 0.01;
      if (blockedCircle(nx, ny, r)) nx = x;
    }
  }
  if (dy !== 0) {
    const test = ny + dy;
    if (!blockedCircle(nx, test, r)) ny = test;
    else {
      const row = Math.floor(test / TILE);
      ny = dy > 0 ? row * TILE - r - 0.01 : (row + 1) * TILE + r + 0.01;
      if (blockedCircle(nx, ny, r)) ny = y;
    }
  }
  return { x: nx, y: ny };
}
/** True when a circle at (x,y) overlaps any solid tile. */
export function blockedCircle(x: number, y: number, r: number): boolean {
  const c0 = Math.floor((x - r) / TILE);
  const c1 = Math.floor((x + r) / TILE);
  const r0 = Math.floor((y - r) / TILE);
  const r1 = Math.floor((y + r) / TILE);
  for (let row = r0; row <= r1; row++)
    for (let col = c0; col <= c1; col++) {
      if (!solidTile(col, row)) continue;
      const nearX = Math.max(col * TILE, Math.min(x, col * TILE + TILE));
      const nearY = Math.max(row * TILE, Math.min(y, row * TILE + TILE));
      const dx = x - nearX;
      const dy = y - nearY;
      if (dx * dx + dy * dy < r * r) return true;
    }
  return false;
}
/**
 * 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;
}
@@ -0,0 +1,373 @@
import { expect, test } from "bun:test";
import { runBots } from "./bots.ts";
import {
  aliveOn,
  buyAbility,
  buyShield,
  buyWeapon,
  DEFUSE_CHECKPOINT,
  DEFUSE_TIME,
  FUSE_TIME,
  newMatch,
  PLANT_TIME,
  ROUND_TIME,
  SWAP_AFTER,
  tick,
  visible,
  WIN_ROUNDS,
} from "./match.ts";
import { siteCentre, spawnCells, wallBetween } from "./map.ts";
import type { MatchState, Player } from "./state.ts";
const live = (seed = 5): MatchState => {
  const state = newMatch(seed);
  state.phase = "live";
  state.clock = ROUND_TIME;
  return state;
};
const atk = (state: MatchState): Player[] => state.players.filter((p) => p.side === "atk");
const def = (state: MatchState): Player[] => state.players.filter((p) => p.side === "def");
const run = (state: MatchState, seconds: number): void => {
  for (let i = 0; i < Math.round(seconds * 30); i++) tick(state, 1 / 30);
};
/** Put a carrier on a site with the spike, everyone else out of the way. */
function onSite(state: MatchState): Player {
  const spot = siteCentre("A");
  const carrier = atk(state)[0]!;
  for (const player of state.players) {
    player.spike = false;
    player.x = 1200;
    player.y = 1320;
  }
  carrier.spike = true;
  carrier.x = spot.x;
  carrier.y = spot.y;
  state.spike = { carried: carrier.id, x: spot.x, y: spot.y, planted: false, fuse: 0, site: null, defuse: 0, checkpoint: 0 };
  return carrier;
}
test("a match starts in the buy phase with ten seats and a spike carrier", () => {
  const state = newMatch(1);
  expect(state.players.length).toBe(10);
  expect(atk(state).length).toBe(5);
  expect(def(state).length).toBe(5);
  expect(state.phase).toBe("buy");
  expect(state.players.some((p) => p.spike)).toBe(true);
  expect(state.players.every((p) => p.credits === 800)).toBe(true);
});
test("planting takes four seconds of standing on a site and arms the fuse", () => {
  const state = live();
  const carrier = onSite(state);
  carrier.input.use = true;
  run(state, PLANT_TIME - 1);
  expect(state.spike.planted).toBe(false);
  run(state, 1.2);
  expect(state.spike.planted).toBe(true);
  expect(state.spike.site).toBe("A");
  expect(Math.round(state.spike.fuse)).toBeLessThanOrEqual(FUSE_TIME);
  // The plant pays the attacking team and charges the planter's ult.
  expect(atk(state).every((p) => p.credits >= 800 + 300)).toBe(true);
  expect(carrier.ult).toBeGreaterThan(0);
});
test("a plant off a site does nothing at all", () => {
  const state = live();
  const carrier = onSite(state);
  carrier.x = 1200;
  carrier.y = 1320; // attacker spawn, not a site
  carrier.input.use = true;
  run(state, PLANT_TIME + 2);
  expect(state.spike.planted).toBe(false);
});
test("a defuse killed at the half way mark leaves the checkpoint for the next defender", () => {
  const state = live();
  const carrier = onSite(state);
  carrier.input.use = true;
  run(state, PLANT_TIME + 0.2);
  expect(state.spike.planted).toBe(true);
  carrier.input.use = false;
  const first = def(state)[0]!;
  first.x = state.spike.x;
  first.y = state.spike.y;
  first.input.use = true;
  run(state, DEFUSE_CHECKPOINT + 0.2);
  expect(state.spike.checkpoint).toBe(DEFUSE_CHECKPOINT);
  expect(state.spike.defuse).toBeGreaterThanOrEqual(DEFUSE_CHECKPOINT);
  // He dies here. The defuse falls back to the checkpoint, not to zero.
  first.hp = 1;
  first.alive = false;
  first.deaths += 1;
  state.spike.defuse = state.spike.checkpoint;
  expect(state.spike.defuse).toBe(DEFUSE_CHECKPOINT);
  const second = def(state)[1]!;
  second.x = state.spike.x;
  second.y = state.spike.y;
  second.input.use = true;
  // Half a defuse is left, so well under the full seven seconds finishes it.
  run(state, DEFUSE_TIME - DEFUSE_CHECKPOINT + 0.3);
  expect(state.phase).toBe("end");
  expect(state.events.some((e) => e.text.includes("defused"))).toBe(true);
});
test("an interrupted defuse before the checkpoint starts again from nothing", () => {
  const state = live();
  const carrier = onSite(state);
  carrier.input.use = true;
  run(state, PLANT_TIME + 0.2);
  carrier.input.use = false;
  const defender = def(state)[0]!;
  defender.x = state.spike.x;
  defender.y = state.spike.y;
  defender.input.use = true;
  run(state, 2);
  expect(state.spike.defuse).toBeGreaterThan(1.5);
  defender.input.use = false;
  run(state, 0.2);
  expect(state.spike.defuse).toBe(0);
  expect(state.spike.checkpoint).toBe(0);
});
test("the spike detonating wins the round for the attackers", () => {
  const state = live();
  const carrier = onSite(state);
  carrier.input.use = true;
  run(state, PLANT_TIME + 0.2);
  carrier.input.use = false;
  state.spike.fuse = 1;
  run(state, 1.5);
  expect(state.phase).toBe("end");
  expect(state.score[state.attackers]).toBe(1);
});
test("time running out with no plant is a defence win, but the clock stops mattering once it is down", () => {
  const timeout = live();
  timeout.clock = 0.5;
  run(timeout, 1);
  expect(timeout.phase).toBe("end");
  expect(timeout.score[timeout.attackers]).toBe(0);
  const planted = live();
  const carrier = onSite(planted);
  carrier.input.use = true;
  run(planted, PLANT_TIME + 0.2);
  carrier.input.use = false;
  planted.clock = 0.2;
  run(planted, 1);
  expect(planted.phase).toBe("live");
});
test("eliminating a team ends the round, and a planted spike still wins it", () => {
  const wipe = live();
  for (const player of def(wipe)) player.alive = false;
  run(wipe, 0.1);
  expect(wipe.phase).toBe("end");
  expect(wipe.score[wipe.attackers]).toBe(1);
  const traded = live();
  const carrier = onSite(traded);
  carrier.input.use = true;
  run(traded, PLANT_TIME + 0.2);
  for (const player of atk(traded)) player.alive = false;
  run(traded, 0.1);
  // Everyone is dead but the spike is armed: the round is not over yet.
  expect(traded.phase).toBe("live");
});
test("a buy is refused server-side when the credits are not there", () => {
  const state = newMatch(2);
  const player = state.players[0]!;
  player.agent = "ember";
  player.credits = 800;
  expect(buyWeapon(state, player, "vandal")).toBe(false);
  expect(player.weapon).toBe("classic");
  expect(buyWeapon(state, player, "ghost")).toBe(true);
  expect(player.credits).toBe(300);
  expect(buyShield(state, player, "heavy")).toBe(false);
  // 250 for the flash leaves fifty, and fifty buys nothing.
  expect(buyAbility(state, player, "c")).toBe(true);
  expect(player.credits).toBe(50);
  expect(buyAbility(state, player, "c")).toBe(false);
  expect(buyAbility(state, player, "q")).toBe(false);
  // And nothing is for sale once the round is live.
  player.credits = 9000;
  state.phase = "live";
  expect(buyWeapon(state, player, "vandal")).toBe(false);
});
test("a basic is bought by the charge and never past its limit", () => {
  const state = newMatch(2);
  const player = state.players.find((p) => p.agent === "veil")!;
  player.credits = 9000;
  expect(buyAbility(state, player, "c")).toBe(true);
  expect(buyAbility(state, player, "c")).toBe(true);
  expect(player.charges.c).toBe(2);
  expect(buyAbility(state, player, "c")).toBe(false);
  expect(buyAbility(state, player, "e")).toBe(false);
  expect(buyAbility(state, player, "x")).toBe(false);
});
test("sides swap after twelve rounds and a thirteenth round wins the match", () => {
  const state = newMatch(4);
  const started = state.attackers;
  state.round = SWAP_AFTER;
  state.phase = "live";
  state.score[started] = WIN_ROUNDS - 2;
  for (const player of def(state)) player.alive = false;
  run(state, 0.1);
  expect(state.phase).toBe("end");
  run(state, 6);
  expect(state.round).toBe(SWAP_AFTER + 1);
  expect(state.attackers).not.toBe(started);
  // One more round, taken by whoever now attacks the old defenders' side.
  const winners = state.attackers === started ? started : state.attackers;
  state.phase = "live";
  state.score[started] = WIN_ROUNDS - 1;
  for (const player of state.players) if (player.team !== started) player.alive = false;
  run(state, 0.1);
  expect(state.score[started]).toBe(WIN_ROUNDS);
  expect(state.phase).toBe("over");
  expect(state.result).toContain(`${started} win`);
  expect(winners.length).toBeGreaterThan(0);
});
test("an ended match never parks: it shows the result and starts a fresh one", () => {
  const state = newMatch(6);
  state.phase = "live";
  state.score[state.attackers] = WIN_ROUNDS - 1;
  for (const player of def(state)) player.alive = false;
  run(state, 0.1);
  expect(state.phase).toBe("over");
  expect(state.result).not.toBe(null);
  run(state, 13);
  expect(state.phase).toBe("buy");
  expect(state.round).toBe(1);
  expect(state.score).toEqual({ red: 0, blue: 0 });
  expect(state.result).toBe(null);
  expect(state.players.length).toBe(10);
});
test("line of sight is the server's answer: a smoke hides an enemy in the open", () => {
  const state = live();
  const viewer = atk(state)[0]!;
  const enemy = def(state)[0]!;
  viewer.x = 1200;
  viewer.y = 1320;
  enemy.x = 1200;
  enemy.y = 1000;
  expect(visible(state, viewer, enemy)).toBe(true);
  state.zones.push({
    id: 99, kind: "smoke", owner: "x", side: "def", x: 1200, y: 1160, r: 150,
    life: 8, fuse: 0, beat: 0, pulses: 0, damage: 0, blocks: true, solid: false,
  });
  expect(visible(state, viewer, enemy)).toBe(false);
  // A revealed enemy is seen through anything; so is a team mate.
  enemy.revealed = 2;
  expect(visible(state, viewer, enemy)).toBe(true);
});
test("a wall hides two players from each other, and open floor does not", () => {
  const state = live();
  const viewer = atk(state)[0]!;
  const enemy = def(state)[0]!;
  viewer.blind = 0;
  enemy.revealed = 0;
  // Either side of the block between A site and the middle of the map.
  viewer.x = 400;
  viewer.y = 400;
  enemy.x = 1200;
  enemy.y = 400;
  expect(wallBetween(viewer, enemy)).toBe(true);
  expect(visible(state, viewer, enemy)).toBe(false);
  // The same two down the open back corridor, with nothing in between.
  viewer.x = 400;
  viewer.y = 1400;
  enemy.x = 1000;
  enemy.y = 1400;
  expect(wallBetween(viewer, enemy)).toBe(false);
  expect(visible(state, viewer, enemy)).toBe(true);
});
test("no spawn can see a spawn: mid is staggered, not a corridor", () => {
  for (const from of spawnCells("atk"))
    for (const to of spawnCells("def")) expect(wallBetween(from, to)).toBe(true);
});
test("a dead player watches through the team, never through walls", () => {
  const state = live();
  const viewer = atk(state)[0]!;
  const mate = atk(state)[1]!;
  const enemy = def(state)[0]!;
  for (const player of atk(state)) {
    player.alive = false;
    player.x = 400;
    player.y = 400;
  }
  enemy.revealed = 0;
  enemy.x = 1000;
  enemy.y = 1400;
  // Every attacker is dead: the enemy across the map is nobody's to see.
  expect(visible(state, viewer, enemy)).toBe(false);
  // One team mate alive with a sight line, and the dead player sees it too.
  mate.alive = true;
  mate.x = 400;
  mate.y = 1400;
  expect(visible(state, viewer, enemy)).toBe(true);
  // That team mate behind a wall takes the vision away again.
  mate.x = 400;
  mate.y = 400;
  expect(visible(state, viewer, enemy)).toBe(false);
});
test("a blinded player sees nothing", () => {
  const state = live();
  const viewer = atk(state)[0]!;
  const enemy = def(state)[0]!;
  viewer.x = 1200;
  viewer.y = 1320;
  enemy.x = 1200;
  enemy.y = 1000;
  viewer.blind = 1.4;
  expect(visible(state, viewer, enemy)).toBe(false);
});
test("a killed carrier drops the spike where they fell", () => {
  const state = live();
  const carrier = onSite(state);
  const killer = def(state)[0]!;
  killer.x = carrier.x + 40;
  killer.y = carrier.y;
  killer.angle = Math.PI;
  killer.weapon = "operator";
  killer.input.fire = true;
  run(state, 1);
  if (!carrier.alive) {
    expect(state.spike.carried).toBe(null);
    expect(Math.hypot(state.spike.x - carrier.x, state.spike.y - carrier.y)).toBeLessThan(80);
  }
  expect(state.shots.length + state.events.length).toBeGreaterThan(0);
});
test("bots play the round: they buy, they take a site and they use their kit", () => {
  const state = newMatch(42);
  let casts = 0;
  let rounds = 0;
  for (let i = 0; i < 30 * 60 * 6; i++) {
    runBots(state, 1 / 30);
    tick(state, 1 / 30);
    casts += state.zones.length > 0 ? 1 : 0;
    if (state.round > rounds) rounds = state.round;
  }
  expect(rounds).toBeGreaterThan(1);
  expect(state.score.red + state.score.blue).toBeGreaterThan(1);
  // Something was on the map: smokes, flashes, mollies, walls.
  expect(casts).toBeGreaterThan(100);
  // And somebody bought a real gun with the credits they won.
  expect(state.players.some((p) => p.weapon !== "classic")).toBe(true);
  expect(aliveOn(state, "atk").length + aliveOn(state, "def").length).toBeGreaterThan(0);
});
@@ -0,0 +1,652 @@
/**
 * The match: one round loop, server-authoritative, and the only place a
 * number changes.
 *
 * `tick(state, dt)` is the whole game — call it with a fixed step and it
 * runs without a clock, a socket or a browser, which is how the tests play
 * whole rounds in a millisecond. Inputs arrive as intent (a direction, an
 * angle, a held key); nothing a client says is taken as a position.
 */
import { cast, castable, agentById, buyableSlots, flashDuration, sightBlocked, SLOTS } from "./abilities.ts";
import { award, clampCredits, roundReward, spend, START_CREDITS } from "./economy.ts";
import {
  blockedCircle,
  clearPaths,
  moveCircle,
  orbSpots,
  rayHitWall,
  segmentPoint,
  siteAt,
  spawnCells,
  type Point,
} from "./map.ts";
import { emptyInput, type Input, type MatchState, type Player, type Side, type Slot, type Team } from "./state.ts";
import { applyDamage, damage, shotSpread, SHIELD, WEAPONS, zoneFromMiss, type WeaponId } from "./weapons.ts";
export const PLAYER_R = 16;
export const RUN_SPEED = 250;
export const BUY_TIME = 14;
export const ROUND_TIME = 100;
export const PLANT_TIME = 4;
export const FUSE_TIME = 45;
export const DEFUSE_TIME = 7;
export const DEFUSE_CHECKPOINT = 3.5;
export const END_TIME = 5;
export const OVER_TIME = 12;
export const SWAP_AFTER = 12;
export const WIN_ROUNDS = 13;
export const ROSTER = 5;
export const SPIKE_REACH = 46;
const TEAMS: Team[] = ["red", "blue"];
/** Deterministic randomness: the same seed plays the same round. */
export function random(state: MatchState): number {
  state.seed = (state.seed + 0x6d2b79f5) | 0;
  let t = state.seed;
  t = Math.imul(t ^ (t >>> 15), t | 1);
  t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
  return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
}
const say = (state: MatchState, text: string): void => {
  state.events.unshift({ text, age: 0 });
  state.events.length = Math.min(state.events.length, 12);
};
export const sideOf = (state: MatchState, team: Team): Side =>
  team === state.attackers ? "atk" : "def";
export const teammates = (state: MatchState, side: Side): Player[] =>
  state.players.filter((p) => p.side === side);
export const aliveOn = (state: MatchState, side: Side): Player[] =>
  state.players.filter((p) => p.side === side && p.alive);
const BOT_NAMES = [
  "Ash", "Bex", "Cade", "Dune", "Enzo", "Fay", "Gus", "Hale", "Ivo", "Juno",
  "Kit", "Lux", "Mox", "Nell", "Orla", "Pike", "Quill", "Rio", "Sage", "Tove",
];
export function makePlayer(state: MatchState, team: Team, index: number): Player {
  const agent = ["ember", "veil", "sable", "mender", "rook"][index % 5]!;
  const name = BOT_NAMES[(TEAMS.indexOf(team) * 7 + index * 3 + Math.floor(random(state) * 20)) % BOT_NAMES.length]!;
  return {
    id: `bot-${team}-${index}`,
    name: `${name}`,
    bot: true,
    agent,
    team,
    side: sideOf(state, team),
    x: 0,
    y: 0,
    angle: 0,
    hp: 100,
    armour: 0,
    alive: true,
    credits: START_CREDITS,
    weapon: "classic",
    ammo: WEAPONS.classic.magazine,
    reloadIn: 0,
    fireIn: 0,
    charges: { c: 0, q: 0, e: 1, x: 0 },
    cooldown: { c: 0, q: 0, e: 0, x: 0 },
    ult: 0,
    blind: 0,
    slow: 0,
    haste: 0,
    revealed: 0,
    spike: false,
    planting: 0,
    defusing: 0,
    kills: 0,
    deaths: 0,
    assists: 0,
    damageDone: 0,
    input: emptyInput(),
    goal: null,
    think: 0,
    spray: 0,
    joinedAt: 0,
  };
}
export function newMatch(seed = Date.now() % 100000): MatchState {
  const state: MatchState = {
    id: `m${seed.toString(36)}${Math.floor(seed / 7) % 997}`,
    phase: "buy",
    clock: BUY_TIME,
    round: 1,
    score: { red: 0, blue: 0 },
    attackers: "red",
    lossStreak: { red: 0, blue: 0 },
    players: [],
    zones: [],
    nextZone: 1,
    spike: { carried: null, x: 0, y: 0, planted: false, fuse: 0, site: null, defuse: 0, checkpoint: 0 },
    orbs: orbSpots().map((p) => ({ ...p, taken: false })),
    shots: [],
    events: [],
    result: null,
    seed,
    now: 0,
  };
  for (const team of TEAMS)
    for (let i = 0; i < ROSTER; i++) state.players.push(makePlayer(state, team, i));
  startRound(state, true);
  say(state, "Round 1 — buy phase");
  return state;
}
/** A fresh match on the same seats: an ended match never parks. */
export function resetMatch(state: MatchState): void {
  const fresh = newMatch((state.seed + 7919) % 100000);
  fresh.players = state.players;
  fresh.attackers = state.attackers === "red" ? "blue" : "red";
  for (const player of fresh.players) {
    player.kills = 0;
    player.deaths = 0;
    player.assists = 0;
    player.damageDone = 0;
    player.ult = 0;
    player.credits = START_CREDITS;
    player.weapon = "classic";
  }
  Object.assign(state, fresh);
  startRound(state, true);
  say(state, "New match — round 1");
}
function placeAtSpawn(state: MatchState, player: Player, index: number): void {
  const cells = spawnCells(player.side);
  const spot = cells[index % cells.length]!;
  player.x = spot.x + (random(state) - 0.5) * 20;
  player.y = spot.y + (random(state) - 0.5) * 20;
  const centre = player.side === "atk" ? { x: 1200, y: 400 } : { x: 1200, y: 1200 };
  player.angle = Math.atan2(centre.y - player.y, centre.x - player.x);
}
export function startRound(state: MatchState, first = false): void {
  clearPaths();
  state.phase = "buy";
  state.clock = BUY_TIME;
  state.zones = [];
  state.shots = [];
  state.spike = { carried: null, x: 0, y: 0, planted: false, fuse: 0, site: null, defuse: 0, checkpoint: 0 };
  state.orbs = orbSpots().map((p) => ({ ...p, taken: false }));
  const byTeam: Record<Team, number> = { red: 0, blue: 0 };
  for (const player of state.players) {
    player.side = sideOf(state, player.team);
    // A gun survives the round its owner does; armour never does.
    if (!player.alive || first) player.weapon = "classic";
    player.armour = 0;
    player.hp = 100;
    player.alive = true;
    player.ammo = WEAPONS[player.weapon].magazine;
    player.reloadIn = 0;
    player.fireIn = 0;
    player.blind = 0;
    player.slow = 0;
    player.haste = 0;
    player.revealed = 0;
    player.spike = false;
    player.planting = 0;
    player.defusing = 0;
    player.spray = 0;
    player.goal = null;
    player.think = 0;
    player.input = emptyInput();
    // Basics are bought fresh every round; the signature comes back free.
    player.charges = { c: 0, q: 0, e: 1, x: 0 };
    player.cooldown = { c: 0, q: 0, e: 0, x: 0 };
    if (first) player.credits = START_CREDITS;
    placeAtSpawn(state, player, byTeam[player.team]++);
  }
  giveSpike(state);
}
function giveSpike(state: MatchState): void {
  const attackers = aliveOn(state, "atk");
  if (attackers.length === 0) return;
  const carrier = attackers[Math.floor(random(state) * attackers.length)]!;
  carrier.spike = true;
  state.spike.carried = carrier.id;
  state.spike.x = carrier.x;
  state.spike.y = carrier.y;
}
/** Buying is refused server-side: no credits, no gun, no argument. */
export function buyWeapon(state: MatchState, player: Player, id: WeaponId): boolean {
  if (state.phase !== "buy") return false;
  const cost = WEAPONS[id].cost;
  const paid = spend(player.credits, cost);
  if (!paid.ok) return false;
  player.credits = paid.credits;
  player.weapon = id;
  player.ammo = WEAPONS[id].magazine;
  return true;
}
export function buyShield(state: MatchState, player: Player, kind: "light" | "heavy"): boolean {
  if (state.phase !== "buy") return false;
  const shield = SHIELD[kind];
  if (player.armour >= shield.armour) return false;
  const paid = spend(player.credits, shield.cost);
  if (!paid.ok) return false;
  player.credits = paid.credits;
  player.armour = shield.armour;
  return true;
}
export function buyAbility(state: MatchState, player: Player, slot: Slot): boolean {
  if (state.phase !== "buy" || !buyableSlots.includes(slot)) return false;
  const ability = agentById(player.agent).abilities[slot];
  if (player.charges[slot] >= ability.charges) return false;
  const paid = spend(player.credits, ability.cost);
  if (!paid.ok) return false;
  player.credits = paid.credits;
  player.charges[slot] += 1;
  return true;
}
export function pickAgent(state: MatchState, player: Player, agent: string): boolean {
  if (state.phase !== "buy" || player.charges.c > 0 || player.charges.q > 0) return false;
  player.agent = agent;
  return true;
}
// ---------------------------------------------------------------- the tick
export function tick(state: MatchState, dt: number): void {
  state.now += dt;
  for (const shot of state.shots) shot.age += dt;
  state.shots = state.shots.filter((s) => s.age < 0.12);
  for (const event of state.events) event.age += dt;
  if (state.phase === "over") {
    state.clock -= dt;
    if (state.clock <= 0) resetMatch(state);
    return;
  }
  if (state.phase === "end") {
    state.clock -= dt;
    if (state.clock <= 0) nextRound(state);
    return;
  }
  state.clock -= dt;
  if (state.phase === "buy") {
    for (const player of state.players) movePlayer(state, player, dt, true);
    if (state.clock <= 0) {
      state.phase = "live";
      state.clock = ROUND_TIME;
      say(state, "Round live");
    }
    return;
  }
  for (const player of state.players) {
    if (player.blind > 0) player.blind = Math.max(0, player.blind - dt);
    if (player.slow > 0) player.slow = Math.max(0, player.slow - dt);
    if (player.haste > 0) player.haste = Math.max(0, player.haste - dt);
    if (player.revealed > 0) player.revealed = Math.max(0, player.revealed - dt);
    for (const slot of SLOTS)
      if (player.cooldown[slot] > 0) {
        player.cooldown[slot] = Math.max(0, player.cooldown[slot] - dt);
        // The signature charge comes back on its own when the wait is over.
        if (player.cooldown[slot] === 0) player.charges[slot] = Math.max(player.charges[slot], 1);
      }
    player.spray = Math.max(0, player.spray - dt * 6);
    if (!player.alive) continue;
    movePlayer(state, player, dt, false);
    useAbility(state, player);
    shoot(state, player, dt);
    spikeWork(state, player, dt);
    orbs(state, player);
  }
  if (state.spike.planted) state.spike.fuse = Math.max(0, state.spike.fuse - dt);
  zones(state, dt);
  endConditions(state);
}
function speedOf(player: Player): number {
  let speed = RUN_SPEED;
  if (player.haste > 0) speed *= 1.35;
  if (player.slow > 0) speed *= 0.55;
  if (player.planting > 0 || player.defusing > 0) speed = 0;
  if (player.weapon === "operator") speed *= 0.86;
  return speed;
}
function movePlayer(state: MatchState, player: Player, dt: number, penned: boolean): void {
  if (!player.alive) return;
  const input = player.input;
  if (Number.isFinite(input.angle)) player.angle = input.angle;
  let mx = input.mx;
  let my = input.my;
  const len = Math.hypot(mx, my);
  if (len > 1) {
    mx /= len;
    my /= len;
  }
  const speed = speedOf(player) * dt;
  if (speed === 0 || (mx === 0 && my === 0)) return;
  let next = moveCircle(player.x, player.y, mx * speed, my * speed, PLAYER_R);
  // In the buy phase nobody leaves their own spawn.
  if (penned) {
    const cells = spawnCells(player.side);
    const near = cells.reduce((best, c) => (Math.hypot(c.x - next.x, c.y - next.y) < Math.hypot(best.x - next.x, best.y - next.y) ? c : best));
    if (Math.hypot(near.x - next.x, near.y - next.y) > 120) return;
  }
  // Walls put down by abilities are as solid as the map's.
  for (const zone of state.zones) {
    if (!zone.solid || zone.fuse > 0) continue;
    const gap = Math.hypot(next.x - zone.x, next.y - zone.y);
    if (gap < zone.r + PLAYER_R) {
      const push = zone.r + PLAYER_R - gap;
      const angle = gap === 0 ? 0 : Math.atan2(next.y - zone.y, next.x - zone.x);
      const shoved = { x: next.x + Math.cos(angle) * push, y: next.y + Math.sin(angle) * push };
      if (!blockedCircle(shoved.x, shoved.y, PLAYER_R)) next = shoved;
      else next = { x: player.x, y: player.y };
    }
  }
  player.x = next.x;
  player.y = next.y;
}
function useAbility(state: MatchState, player: Player): void {
  const slot = player.input.cast;
  if (slot === null) return;
  player.input.cast = null;
  if (state.phase !== "live" || player.blind > 0.8) return;
  if (cast(state, player, slot)) {
    const ability = agentById(player.agent).abilities[slot];
    if (slot === "x") say(state, `${player.name} used ${ability.name}`);
  }
}
function shoot(state: MatchState, player: Player, dt: number): void {
  player.fireIn = Math.max(0, player.fireIn - dt);
  if (player.reloadIn > 0) {
    player.reloadIn -= dt;
    if (player.reloadIn <= 0) {
      player.ammo = WEAPONS[player.weapon].magazine;
      player.reloadIn = 0;
    }
    return;
  }
  const weapon = WEAPONS[player.weapon];
  if (player.input.reload && player.ammo < weapon.magazine) {
    player.input.reload = false;
    player.reloadIn = weapon.reload;
    return;
  }
  if (!player.input.fire || player.fireIn > 0) return;
  if (!weapon.auto) player.input.fire = false;
  if (player.ammo <= 0) {
    player.reloadIn = weapon.reload;
    return;
  }
  player.ammo -= 1;
  player.fireIn = 1 / weapon.rate;
  player.spray = Math.min(6, player.spray + 1);
  const moving = Math.hypot(player.input.mx, player.input.my) > 0.1 ? 1 : 0;
  // Blind aim is a guess: the shot goes somewhere near where you were looking.
  const wobble = player.blind > 0 ? 0.5 : 0;
  const spread = shotSpread(player.weapon, moving) + player.spray * 0.006 + wobble;
  const angle = player.angle + (random(state) - 0.5) * 2 * spread;
  const from: Point = { x: player.x, y: player.y };
  const wall = rayHitWall(from, angle, weapon.range);
  let stop = wall;
  // A wall an ability put up stops bullets too; smoke does not.
  for (const zone of state.zones) {
    if (!zone.solid || zone.fuse > 0) continue;
    const near = segmentPoint(from, wall, zone);
    if (near.dist <= zone.r && near.travel < Math.hypot(stop.x - from.x, stop.y - from.y))
      stop = { x: from.x + Math.cos(angle) * near.travel, y: from.y + Math.sin(angle) * near.travel };
  }
  let best: { target: Player; travel: number; miss: number } | null = null;
  for (const other of state.players) {
    if (!other.alive || other.side === player.side || other.id === player.id) continue;
    const near = segmentPoint(from, stop, other);
    if (near.dist > PLAYER_R || near.travel < 1) continue;
    if (best === null || near.travel < best.travel) best = { target: other, travel: near.travel, miss: near.dist };
  }
  const end = best ? { x: from.x + Math.cos(angle) * best.travel, y: from.y + Math.sin(angle) * best.travel } : stop;
  state.shots.push({ x1: from.x, y1: from.y, x2: end.x, y2: end.y, hit: best !== null, age: 0 });
  if (!best) return;
  const zone = zoneFromMiss(best.miss, PLAYER_R);
  const dealt = damage(player.weapon, zone, best.travel);
  hurt(state, best.target, dealt, player, zone === "head" ? "headshot" : "");
}
function hurt(state: MatchState, target: Player, amount: number, from: Player | null, note: string): void {
  if (!target.alive) return;
  const before = target.hp + target.armour;
  const after = applyDamage(target.hp, target.armour, amount);
  target.hp = after.hp;
  target.armour = after.armour;
  if (from) from.damageDone += Math.max(0, before - (target.hp + target.armour));
  if (target.hp > 0) return;
  target.alive = false;
  target.deaths += 1;
  target.planting = 0;
  // A defuse dies with the defender, back to the half-way checkpoint.
  if (target.defusing > 0) {
    target.defusing = 0;
    state.spike.defuse = state.spike.checkpoint;
  }
  if (target.spike) {
    target.spike = false;
    state.spike.carried = null;
    state.spike.x = target.x;
    state.spike.y = target.y;
  }
  if (from && from.side !== target.side) {
    from.kills += 1;
    from.credits = award(from.credits, 200);
    from.ult = Math.min(10, from.ult + 1);
    say(state, `${from.name} ${note === "headshot" ? "headshot" : "killed"} ${target.name}`);
  } else {
    say(state, `${target.name} died`);
  }
}
function spikeWork(state: MatchState, player: Player, dt: number): void {
  const spike = state.spike;
  if (player.side === "atk" && !spike.planted) {
    if (!spike.carried && !player.spike && Math.hypot(player.x - spike.x, player.y - spike.y) < SPIKE_REACH) {
      player.spike = true;
      spike.carried = player.id;
      say(state, `${player.name} picked up the spike`);
    }
    if (player.spike) {
      spike.x = player.x;
      spike.y = player.y;
      const site = siteAt(player.x, player.y);
      if (player.input.use && site) {
        player.planting += dt;
        if (player.planting >= PLANT_TIME) {
          spike.planted = true;
          spike.site = site;
          spike.fuse = FUSE_TIME;
          spike.carried = null;
          player.spike = false;
          player.planting = 0;
          player.ult = Math.min(10, player.ult + 1);
          for (const mate of teammates(state, "atk")) mate.credits = award(mate.credits, 300);
          say(state, `${player.name} planted on ${site}`);
        }
      } else player.planting = 0;
    }
    return;
  }
  if (player.side === "def" && spike.planted) {
    const close = Math.hypot(player.x - spike.x, player.y - spike.y) < SPIKE_REACH;
    if (player.input.use && close) {
      spike.defuse += dt;
      player.defusing = spike.defuse;
      // Half way is a checkpoint: the next defender starts from there.
      if (spike.defuse >= DEFUSE_CHECKPOINT && spike.checkpoint === 0) {
        spike.checkpoint = DEFUSE_CHECKPOINT;
        say(state, `${player.name} is half way through the defuse`);
      }
    } else if (player.defusing > 0) {
      player.defusing = 0;
      spike.defuse = spike.checkpoint;
    }
  }
}
function orbs(state: MatchState, player: Player): void {
  for (const orb of state.orbs)
    if (!orb.taken && Math.hypot(player.x - orb.x, player.y - orb.y) < 40) {
      orb.taken = true;
      player.ult = Math.min(10, player.ult + 1);
      say(state, `${player.name} took an ult orb`);
    }
}
function zones(state: MatchState, dt: number): void {
  for (const zone of state.zones) {
    if (zone.fuse > 0) {
      zone.fuse -= dt;
      if (zone.fuse > 0) continue;
      if (zone.kind === "flash") {
        // Pop: everyone with a sight line to it, blinded by how far their
        // back was turned. Smoke between them and it saves them.
        for (const player of state.players) {
          if (!player.alive) continue;
          const blocked = sightBlocked(zone, player, state.zones);
          const within = Math.hypot(player.x - zone.x, player.y - zone.y) <= zone.r;
          const blind = within ? flashDuration(zone.damage, player, zone, player.angle, blocked) : 0;
          if (blind > 0) player.blind = Math.max(player.blind, blind);
        }
      }
      continue;
    }
    zone.life -= dt;
    zone.beat -= dt;
    if (zone.kind === "molly" && zone.beat <= 0) {
      zone.beat = 0.5;
      const owner = state.players.find((p) => p.id === zone.owner) ?? null;
      for (const player of state.players)
        if (player.alive && player.side !== zone.side && Math.hypot(player.x - zone.x, player.y - zone.y) <= zone.r)
          hurt(state, player, Math.round(zone.damage / 2), owner, "");
    }
    if (zone.kind === "dart" && zone.beat <= 0 && zone.pulses > 0) {
      zone.beat = 1.6;
      zone.pulses -= 1;
      for (const player of state.players)
        if (player.alive && player.side !== zone.side && Math.hypot(player.x - zone.x, player.y - zone.y) <= zone.r && !sightBlocked(zone, player, state.zones))
          player.revealed = Math.max(player.revealed, 2);
    }
    if (zone.kind === "heal" && zone.beat <= 0) {
      zone.beat = 0.5;
      const target = state.players.find((p) => p.id === zone.owner);
      if (target && target.alive) {
        target.hp = Math.min(100, target.hp + zone.damage / 6);
        zone.x = target.x;
        zone.y = target.y;
      }
    }
    if (zone.kind === "trip" && zone.life > 0) {
      const caught = state.players.find(
        (p) => p.alive && p.side !== zone.side && Math.hypot(p.x - zone.x, p.y - zone.y) <= zone.r,
      );
      if (caught) {
        caught.revealed = Math.max(caught.revealed, 4);
        caught.slow = Math.max(caught.slow, 3);
        zone.life = 0;
        say(state, `${caught.name} tripped a wire`);
      }
    }
    // Blackout: a smoke that carries a slow (marked with negative damage).
    if (zone.kind === "smoke" && zone.damage < 0)
      for (const player of state.players)
        if (player.alive && player.side !== zone.side && Math.hypot(player.x - zone.x, player.y - zone.y) <= zone.r)
          player.slow = Math.max(player.slow, 0.5);
  }
  state.zones = state.zones.filter((z) => z.life > 0 || z.fuse > 0);
}
function endConditions(state: MatchState): void {
  const spike = state.spike;
  if (spike.planted && spike.defuse >= DEFUSE_TIME) return finishRound(state, "def", "Spike defused");
  if (aliveOn(state, "def").length === 0) return finishRound(state, "atk", "Defenders eliminated");
  if (aliveOn(state, "atk").length === 0 && !spike.planted)
    return finishRound(state, "def", "Attackers eliminated");
  if (spike.planted) {
    if (spike.fuse <= 0) return finishRound(state, "atk", "Spike detonated");
  } else if (state.clock <= 0) return finishRound(state, "def", "Time out");
}
function finishRound(state: MatchState, winners: Side, why: string): void {
  const winningTeam: Team = winners === "atk" ? state.attackers : state.attackers === "red" ? "blue" : "red";
  const losingTeam: Team = winningTeam === "red" ? "blue" : "red";
  state.score[winningTeam] += 1;
  state.lossStreak[losingTeam] += 1;
  state.lossStreak[winningTeam] = 0;
  for (const player of state.players) {
    const won = player.team === winningTeam;
    player.credits = clampCredits(
      player.credits + roundReward(won, state.lossStreak[player.team], state.spike.planted && player.side === "atk"),
    );
  }
  state.phase = "end";
  state.clock = END_TIME;
  say(state, `${why} — ${winningTeam} take round ${state.round} (${state.score.red}–${state.score.blue})`);
  if (state.score[winningTeam] >= WIN_ROUNDS) {
    state.phase = "over";
    state.clock = OVER_TIME;
    state.result = `${winningTeam} win ${state.score.red}–${state.score.blue}`;
    say(state, `Match over — ${state.result}. A new one starts in ${OVER_TIME} seconds.`);
  }
}
function nextRound(state: MatchState): void {
  state.round += 1;
  // Sides swap once twelve rounds are behind us.
  if (state.round === SWAP_AFTER + 1) {
    state.attackers = state.attackers === "red" ? "blue" : "red";
    say(state, "Sides swap");
  }
  startRound(state);
  say(state, `Round ${state.round} — buy phase`);
}
/** What one player is allowed to see: their own side, and what light reaches. */
export function visible(state: MatchState, viewer: Player, other: Player): boolean {
  if (other.id === viewer.id || other.side === viewer.side) return true;
  if (!other.alive) return false;
  if (other.revealed > 0) return true;
  if (viewer.blind > 0) return false;
  // A dead player watches the round out through their team's eyes, not
  // through the walls: what a living team mate can see, and nothing more.
  // Otherwise dying and staying connected would be a wallhack to call out.
  if (!viewer.alive)
    return state.players.some(
      (mate) => mate.side === viewer.side && mate.alive && mate.blind <= 0 && !sightBlocked(mate, other, state.zones),
    );
  return !sightBlocked(viewer, other, state.zones);
}
export function setInput(player: Player, input: Partial<Input>): void {
  const target = player.input;
  if (typeof input.mx === "number" && Number.isFinite(input.mx)) target.mx = Math.max(-1, Math.min(1, input.mx));
  if (typeof input.my === "number" && Number.isFinite(input.my)) target.my = Math.max(-1, Math.min(1, input.my));
  if (typeof input.angle === "number" && Number.isFinite(input.angle)) target.angle = input.angle;
  if (typeof input.fire === "boolean") target.fire = input.fire;
  if (typeof input.use === "boolean") target.use = input.use;
  if (typeof input.reload === "boolean") target.reload = input.reload;
  if (input.cast === "c" || input.cast === "q" || input.cast === "e" || input.cast === "x") target.cast = input.cast;
}
export { castable, agentById };
@@ -0,0 +1,178 @@
/**
 * The page. The first paint is the match as it stands right now — score,
 * round, phase, scoreboard — server-rendered HTML, so somebody arriving with
 * a cold cache or no JavaScript still sees a live match. The client script
 * then takes the same state over a socket and draws it.
 */
import { AGENTS } from "../abilities.ts";
import type { Result } from "../db.ts";
import type { MatchState } from "../state.ts";
import { WEAPONS, weaponIds } from "../weapons.ts";
export const escape = (s: string): string =>
  s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c] ?? c);
const phaseWord = (state: MatchState): string =>
  state.phase === "buy"
    ? "buy phase"
    : state.phase === "live"
      ? state.spike.planted
        ? `spike down · ${Math.ceil(state.spike.fuse)}s`
        : "live"
      : state.phase === "end"
        ? "round over"
        : "match over";
export function gamePage(opts: {
  state: MatchState;
  script: string;
  name: string;
  env: string;
  commit: string;
  ssh: string | undefined;
  results: Result[];
}): string {
  const { state } = opts;
  const board = [...state.players].sort((a, b) => b.kills - a.kills);
  const row = (side: "atk" | "def"): string =>
    board
      .filter((p) => p.side === side)
      .map(
        (p) =>
          `<tr><td>${escape(p.name)}${p.bot ? " <small>bot</small>" : ""}</td><td>${escape(p.agent)}</td><td>${p.kills}</td><td>${p.deaths}</td></tr>`,
      )
      .join("");
  return `<!doctype html>
<html lang="en">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
<title>val — attack, defend, plant the spike</title>
<link rel="icon" href="data:,">
<style>
  :root { color-scheme: dark; --atk: #e35d5b; --def: #4fb3d9; --ink: #e8e6e3; }
  * { box-sizing: border-box; }
  body { margin: 0; background: #0e0f12; color: var(--ink);
         font: 15px/1.45 system-ui, -apple-system, "Segoe UI", sans-serif; }
  .wrap { max-width: 1100px; margin: 0 auto; padding: .6rem; }
  h1 { font-size: 1.1rem; margin: 0; letter-spacing: .12em; text-transform: uppercase; }
  header.top { display: flex; align-items: center; gap: .75rem; flex-wrap: wrap; }
  .env { font-size: .7rem; padding: .1rem .5rem; border-radius: 99px; background: #2a2d34; }
  #scoreline { display: flex; align-items: center; justify-content: center; gap: .6rem;
               font-variant-numeric: tabular-nums; margin: .4rem 0; font-size: 1.05rem; }
  .red { color: var(--atk); font-weight: 700; } .blue { color: var(--def); font-weight: 700; }
  #clock { font-size: 1.5rem; font-weight: 700; min-width: 3ch; text-align: center; }
  #phase { opacity: .75; font-size: .85rem; }
  #stage { position: relative; width: 100%; aspect-ratio: 30 / 19; background: #14161b;
           border: 1px solid #262a33; border-radius: .6rem; overflow: hidden; touch-action: none; }
  #view { width: 100%; height: 100%; display: block; }
  #flash { position: absolute; inset: 0; background: #fff; opacity: 0; pointer-events: none; }
  #dead { position: absolute; inset: 0; display: none; place-items: center; background: #0008;
          font-size: 1.1rem; letter-spacing: .1em; text-transform: uppercase; }
  #hud { display: flex; gap: .5rem; flex-wrap: wrap; align-items: center; margin: .5rem 0;
         font-variant-numeric: tabular-nums; }
  .chip { background: #1b1e25; border: 1px solid #2a2f3a; border-radius: .4rem; padding: .3rem .55rem;
          font-size: .85rem; }
  .kit { display: flex; gap: .4rem; flex-wrap: wrap; }
  .kit button, .buys button, .agents button { min-height: 44px; min-width: 44px; padding: .4rem .6rem;
          background: #1b1e25; color: var(--ink); border: 1px solid #333a47; border-radius: .45rem;
          font: inherit; font-size: .8rem; cursor: pointer; }
  .kit button[disabled], .buys button[disabled] { opacity: .35; cursor: not-allowed; }
  .kit b { display: block; font-size: .7rem; opacity: .7; }
  #buy { display: none; margin: .5rem 0; padding: .6rem; background: #151820; border: 1px solid #2a2f3a;
         border-radius: .6rem; }
  #buy.on { display: block; }
  .buys, .agents { display: flex; gap: .4rem; flex-wrap: wrap; margin: .35rem 0; }
  #log { margin: .5rem 0; font-size: .82rem; opacity: .8; min-height: 3.2em; }
  #log div { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
  table { width: 100%; border-collapse: collapse; font-size: .85rem; }
  th, td { text-align: left; padding: .25rem .4rem; border-bottom: 1px solid #23262e; }
  td small { opacity: .5; }
  .boards { display: grid; gap: .8rem; grid-template-columns: 1fr; }
  @media (min-width: 720px) { .boards { grid-template-columns: 1fr 1fr; } }
  footer { margin: 1.2rem 0 3rem; font-size: .82rem; opacity: .72; }
  code { background: #1b1e25; padding: .1rem .35rem; border-radius: .3rem; }
  form.name { display: flex; gap: .4rem; margin: .5rem 0; }
  form.name input { flex: 1; min-height: 44px; padding: .4rem .6rem; background: #1b1e25; color: var(--ink);
          border: 1px solid #333a47; border-radius: .45rem; font: inherit; }
  form.name button { min-height: 44px; padding: 0 1rem; background: #3a4356; color: var(--ink);
          border: 0; border-radius: .45rem; font: inherit; cursor: pointer; }
  #touch { display: none; }
  @media (pointer: coarse) { #touch { display: block; } }
</style>
<div class="wrap">
<header class="top">
  <h1>val</h1>
  <span class="env">${escape(opts.env)}${opts.commit ? " @ " + escape(opts.commit) : ""}</span>
  <span class="env" id="conn">connecting…</span>
</header>
<div id="scoreline">
  <span class="red">red ${state.score.red}</span>
  <span id="clock">${Math.max(0, Math.ceil(state.clock))}</span>
  <span class="blue">${state.score.blue} blue</span>
</div>
<div id="phase">round ${state.round} · ${escape(phaseWord(state))} · ${escape(state.attackers)} attacking${state.result ? ` · ${escape(state.result)}` : ""}</div>
<div id="stage">
  <canvas id="view" width="900" height="570"></canvas>
  <div id="flash"></div>
  <div id="dead">waiting for the next round</div>
</div>
<div id="hud">
  <span class="chip" id="hp">100 hp</span>
  <span class="chip" id="gun">Classic 12</span>
  <span class="chip" id="creds">800 cr</span>
  <span class="chip" id="ultmeter">ult 0/6</span>
  <span class="kit" id="kit"></span>
  <button id="buytoggle" class="chip" type="button">buy (B)</button>
</div>
<div id="buy">
  <div><strong>Buy phase</strong> — credits are refused server-side if you cannot afford them.</div>
  <div class="agents" id="agents">${AGENTS.map(
    (a) => `<button type="button" data-agent="${escape(a.id)}" title="${escape(a.blurb)}">${escape(a.name)} <small>${escape(a.role)}</small></button>`,
  ).join("")}</div>
  <div class="buys" id="guns">${weaponIds()
    .map((id) => `<button type="button" data-buy="${id}">${escape(WEAPONS[id].name)} <b>${WEAPONS[id].cost}</b></button>`)
    .join("")}</div>
  <div class="buys" id="gear">
    <button type="button" data-buy="light">Light shield <b>400</b></button>
    <button type="button" data-buy="heavy">Heavy shield <b>1000</b></button>
    <button type="button" data-buy="c">Ability C</button>
    <button type="button" data-buy="q">Ability Q</button>
  </div>
</div>
<div id="log">${state.events
    .slice(0, 3)
    .map((e) => `<div>${escape(e.text)}</div>`)
    .join("")}</div>
<form class="name" method="post" action="/join">
  <input name="name" maxlength="16" placeholder="Your name" value="${escape(opts.name)}" aria-label="Your name">
  <button>Take a seat</button>
</form>
<div class="boards">
  <div><h2 class="env">attackers</h2><table><thead><tr><th>player</th><th>agent</th><th>k</th><th>d</th></tr></thead><tbody id="atkboard">${row("atk")}</tbody></table></div>
  <div><h2 class="env">defenders</h2><table><thead><tr><th>player</th><th>agent</th><th>k</th><th>d</th></tr></thead><tbody id="defboard">${row("def")}</tbody></table></div>
</div>
<footer>
  <p><strong>Controls.</strong> WASD move · mouse aims · click fires · R reloads ·
     <strong>F</strong> plants and defuses (hold it) · C / Q / E / X cast · B opens the buy.
     On a phone: left thumb walks, right thumb aims and fires, the buttons under the map do the rest.</p>
  <p>Five attackers carry the spike, five defenders stop them. 100s round, 4s plant, 45s fuse,
     7s defuse with a checkpoint at half. First to 13, sides swap at 12. Bots fill every seat
     nobody is in, and they use their kit.</p>
  <p>Terminal: ${opts.ssh ? `<code>${escape(opts.ssh)}</code>` : "off in this environment."}</p>
  ${opts.results.length ? `<p>Last matches: ${opts.results.map((r) => `${escape(r.summary)} <small>(${escape(r.ended_at)})</small>`).join(" · ")}</p>` : ""}
</footer>
</div>
<script src="${escape(opts.script)}" defer></script>
</html>
`;
}
@@ -6,46 +6,90 @@
import { join } from "node:path";
process.env.FORGE_APP_DATA = mkdtempSync(join(tmpdir(), "app-"));
process.env.PORT = "0";
const { server } = await import("./server.ts");
const { match, snapshot, advance } = await import("./arena.ts");
const base = `http://${server.hostname}:${server.port}`;
test("serves the page", async () => {
test("serves a live match on the first paint, with no script needed", async () => {
  const response = await fetch(base + "/");
  expect(response.status).toBe(200);
  expect(await response.text()).toContain("<h1>");
  const body = await response.text();
  expect(body).toContain("<h1>val</h1>");
  // The score, the round and both team sheets are in the HTML itself.
  expect(body).toContain("red " + match().score.red);
  expect(body).toContain("round " + match().round);
  for (const player of match().players) expect(body).toContain(player.name);
});
test("keeps a note", async () => {
test("the page hands out a session cookie and the script is named by content", async () => {
  const response = await fetch(base + "/", { redirect: "manual" });
  const cookie = response.headers.get("set-cookie") ?? "";
  expect(cookie).toContain("val_session=");
  expect(cookie).toContain("HttpOnly");
  const body = await response.text();
  const src = /src="(\/static\/val\.[0-9a-f]+\.js)"/.exec(body);
  expect(src).not.toBe(null);
  const script = await fetch(base + src![1]!);
  expect(script.status).toBe(200);
  expect(script.headers.get("cache-control")).toContain("immutable");
  expect(await script.text()).toContain("WebSocket");
});
test("a name is taken from a same-origin form and sanitised", async () => {
  const form = new FormData();
  form.set("body", "hello from a test");
  const posted = await fetch(base + "/notes", { method: "POST", body: form, redirect: "manual" });
  form.set("name", '  Wren<script>"  ');
  const posted = await fetch(base + "/join", { method: "POST", body: form, redirect: "manual" });
  expect(posted.status).toBe(303);
  expect(await (await fetch(base + "/")).text()).toContain("hello from a test");
  const cookie = posted.headers.getSetCookie().join(" ");
  expect(cookie).toContain("val_name=");
  // The angle brackets and the quote never reach the cookie or the match.
  expect(cookie).not.toContain("<");
  expect(cookie).not.toContain("%3C");
  expect(match().players.every((p) => !p.name.includes("<"))).toBe(true);
  // The seat that name took is a real player in the running match.
  expect(match().players.some((p) => !p.bot && p.name.includes("Wren"))).toBe(true);
});
test("refuses a cross-site post", async () => {
  const form = new FormData();
  form.set("name", "Evil");
  const posted = await fetch(base + "/join", {
    method: "POST",
    body: form,
    redirect: "manual",
    headers: { origin: "https://evil.example", "sec-fetch-site": "cross-site" },
  });
  expect(posted.status).toBe(403);
  expect(match().players.some((p) => p.name === "Evil")).toBe(false);
});
test("stands on the security floor", async () => {
  const response = await fetch(base + "/");
  expect(response.headers.get("content-security-policy")).toContain("default-src 'self'");
  expect(response.headers.get("x-content-type-options")).toBe("nosniff");
  const missing = await fetch(base + "/nope");
  expect(missing.status).toBe(404);
  expect(missing.headers.get("content-security-policy")).toContain("default-src 'self'");
});
test("a bug answers with the floor, not the runtime's page", async () => {
  // A percent-escape that is not one makes the search params throw.
  const response = await fetch(base + "/notes", {
  // A percent-escape that is not one: whether the runtime decodes it or
  // throws, the answer carries the floor and never a stack trace.
  const response = await fetch(base + "/join", {
    method: "POST",
    headers: { "content-type": "application/x-www-form-urlencoded" },
    body: "body=%E0%A4%A",
    body: "name=%E0%A4%A",
    redirect: "manual",
  });
  expect(response.status).toBe(200);
  expect([303, 500]).toContain(response.status);
  expect(await response.text()).not.toContain("src/server.ts");
  expect(response.headers.get("content-security-policy")).toContain("default-src 'self'");
});
test("a body is capped by the bytes read, whatever it claims", async () => {
  // The cap counts bytes as they arrive and never reads Content-Length, so
  // a chunked body with no length is refused the same way this one is.
  const response = await fetch(base + "/notes", {
  const response = await fetch(base + "/join", {
    method: "POST",
    headers: { "content-type": "application/x-www-form-urlencoded" },
    body: "body=" + "x".repeat(1024 * 1024),
    body: "name=" + "x".repeat(1024 * 1024),
  });
  expect(response.status).toBe(413);
});
@@ -56,15 +100,79 @@
test("HEAD sees the app up", async () => {
  expect(await response.text()).toBe("");
});
test("refuses a cross-site post", async () => {
  const form = new FormData();
  form.set("body", "from another site");
  const posted = await fetch(base + "/notes", {
    method: "POST",
    body: form,
    redirect: "manual",
    headers: { origin: "https://evil.example", "sec-fetch-site": "cross-site" },
  });
  expect(posted.status).toBe(403);
  expect(await (await fetch(base + "/")).text()).not.toContain("from another site");
test("the map is served as data, once, for the client to draw", async () => {
  const response = await fetch(base + "/map.json");
  const body = (await response.json()) as { rows: string[]; tile: number };
  expect(body.tile).toBe(80);
  expect(body.rows.length).toBeGreaterThan(10);
  expect(body.rows.some((r) => r.includes("A"))).toBe(true);
  expect(body.rows.some((r) => r.includes("B"))).toBe(true);
});
test("a websocket is refused to another site", async () => {
  const response = await server.fetch(
    new Request(base + "/ws", { headers: { "sec-fetch-site": "cross-site", origin: "https://evil.example" } }),
  );
  expect(response.status).toBe(403);
});
test("a snapshot only carries the enemies that viewer can see", () => {
  const state = match();
  const viewer = state.players.find((p) => p.side === "atk")!;
  const enemy = state.players.find((p) => p.side === "def")!;
  viewer.x = 1200;
  viewer.y = 1320;
  viewer.blind = 0;
  enemy.x = 1200;
  enemy.y = 1240;
  enemy.revealed = 0;
  const near = JSON.parse(snapshot(viewer.id)) as { players: { id: string }[] };
  expect(near.players.some((p) => p.id === enemy.id)).toBe(true);
  // Behind the wall on the far side of the map, the same enemy is gone.
  enemy.x = 200;
  enemy.y = 200;
  const far = JSON.parse(snapshot(viewer.id)) as { players: { id: string }[]; board: unknown[] };
  expect(far.players.some((p) => p.id === enemy.id)).toBe(false);
  // The scoreboard still lists everyone; it carries no position.
  expect(far.board.length).toBe(10);
  expect(JSON.stringify(far.board)).not.toContain('"x"');
});
test("a command from a seat plants the spike, and nonsense from anyone else does nothing", async () => {
  const { command } = await import("./arena.ts");
  const { siteCentre } = await import("./map.ts");
  const state = match();
  state.phase = "live";
  state.clock = 100;
  const spot = siteCentre("B");
  const carrier = state.players.find((p) => p.side === "atk")!;
  // Nobody is a bot for these five seconds: no fight can end the round
  // underneath the plant and make this depend on who shot whom.
  for (const player of state.players) {
    player.bot = false;
    player.alive = true;
    player.hp = 100;
    player.input.fire = false;
  }
  carrier.x = spot.x;
  carrier.y = spot.y;
  carrier.spike = true;
  state.spike = { carried: carrier.id, x: spot.x, y: spot.y, planted: false, fuse: 0, site: null, defuse: 0, checkpoint: 0 };
  // Garbage is ignored, and a seat nobody holds cannot be driven.
  command(carrier.id, { t: "i", mx: "left" as unknown as number, a: Number.NaN, u: "yes" });
  command("nobody", { t: "i", u: true });
  expect(carrier.input.use).toBe(false);
  command(carrier.id, { t: "i", u: true, mx: 0, my: 0 });
  advance(5);
  expect(state.spike.planted).toBe(true);
  expect(state.spike.site).toBe("B");
  for (const player of state.players) player.bot = true;
});
test("the match keeps running and is never parked", () => {
  const state = match();
  const before = state.now;
  advance(30);
  expect(state.now).toBeGreaterThan(before);
  expect(["buy", "live", "end", "over"]).toContain(state.phase);
});
@@ -1,29 +1,23 @@
/**
 * val — a small app with real data.
 * 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.
 *
 * Notes live in a SQLite file under FORGE_APP_DATA. Production and each
 * preview get their own directory, so a preview starts with production's
 * notes and never writes back to them.
 * 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
 * server chose.
 */
import { Database } from "bun:sqlite";
import { mkdirSync } from "node:fs";
import { createHash, randomUUID } from "node:crypto";
import { join } from "node:path";
const dataDir = process.env.FORGE_APP_DATA ?? "./data";
mkdirSync(dataDir, { recursive: true });
const db = new Database(join(dataDir, "app.db"));
db.exec("PRAGMA journal_mode = WAL");
db.exec(
  "CREATE TABLE IF NOT EXISTS note (id INTEGER PRIMARY KEY, body TEXT NOT NULL, created_at TEXT NOT NULL DEFAULT (datetime('now')))",
);
import { attach, command, findPlayer, match, release, snapshot, startArena, takeSeat, type Command } from "./arena.ts";
import { recentResults } from "./db.ts";
import { gridRows, TILE } from "./map.ts";
import { gamePage } from "./pages/game.ts";
const env = process.env.FORGE_APP_ENV ?? "local";
const pull = process.env.FORGE_APP_PULL;
const commit = (process.env.FORGE_APP_COMMIT ?? "").slice(0, 7);
const escape = (s: string): string =>
  s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c] ?? c);
const where = env === "preview" ? `preview of pull #${pull ?? "?"}` : env;
// The security floor every response stands on. Scripts and styles come from
// this origin (inline styles allowed, inline scripts not), nothing frames us,
@@ -42,17 +36,20 @@
const SECURITY = {
    ? { "strict-transport-security": "max-age=31536000" }
    : {}),
};
const html = (body: string, status = 200): Response =>
  new Response(body, { status, headers: { "content-type": "text/html; charset=utf-8", ...SECURITY } });
const html = (body: string, status = 200, extra: Record<string, string> = {}): Response =>
  new Response(body, { status, headers: { "content-type": "text/html; charset=utf-8", ...SECURITY, ...extra } });
// A browser on another site can make a person's browser POST here; it cannot
// make that request look same-origin. Browsers say where a request came from
// (Sec-Fetch-Site, or Origin); a request that names another site is refused.
// The address the forge published is the one that counts, but a browser
// reaching the app by another name (localhost, an IP, a tunnel) sends that
// host in both the URL and the Origin — a cross-site request never can.
const sameOrigin = (request: Request): boolean => {
  const site = request.headers.get("sec-fetch-site");
  if (site !== null) return site === "same-origin" || site === "none";
  const origin = request.headers.get("origin");
  return origin === null || origin === publicOrigin;
  return origin === null || origin === publicOrigin || origin === new URL(request.url).origin;
};
// A request body is read up to a cap and no further, counting the bytes as
@@ -104,68 +101,116 @@
async function readForm(request: Request): Promise<FormData | undefined> {
  }).formData();
}
function page(): string {
  const notes = db
    .query<{ id: number; body: string; created_at: string }, []>(
      "SELECT id, body, created_at FROM note ORDER BY id DESC LIMIT 100",
    )
    .all();
  const where =
    env === "preview" ? `preview of pull #${pull ?? "?"}` : env;
  return `<!doctype html>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>val</title>
<style>
  :root { color-scheme: light dark; font: 16px/1.5 system-ui, sans-serif; }
  body { max-width: 40rem; margin: 3rem auto; padding: 0 1rem; }
  .env { display: inline-block; padding: .1rem .5rem; border-radius: 999px; font-size: .8rem;
         background: ${env === "production" ? "#16a34a" : "#2563eb"}; color: white; }
  form { display: flex; gap: .5rem; margin: 1.5rem 0; }
  input { flex: 1; padding: .6rem .8rem; font: inherit; border: 1px solid #8884; border-radius: .5rem; }
  button { padding: .6rem 1rem; font: inherit; border: 0; border-radius: .5rem; background: #111; color: white; }
  li { padding: .5rem 0; border-top: 1px solid #8883; list-style: none; }
  small { opacity: .6; }
</style>
<h1>val</h1>
<p>Five attackers with the spike, five defenders, and abilities on cooldown. First to 13.</p>
<p><span class="env">${escape(where)}</span> <small>${commit ? "@ " + commit : ""}</small></p>
<form method="post" action="/notes">
  <input name="body" placeholder="Write a note" required maxlength="500" autofocus>
  <button>Add</button>
</form>
<ul>${notes
    .map((n) => `<li>${escape(n.body)} <small>${n.created_at}</small></li>`)
    .join("")}</ul>
<p><small>${notes.length === 0 ? "No notes yet. Notes written here stay in this environment's data." : `${notes.length} note${notes.length === 1 ? "" : "s"} in ${escape(where)} data.`}</small></p>
`;
}
// ------------------------------------------------------------- the client
export const server = Bun.serve({
// The client script is named by its content: a change is a new URL, so a
// year-long cache is never stale.
const scriptPath = join(import.meta.dir, "..", "static", "val.js");
const scriptBody = await Bun.file(scriptPath).text();
const scriptHash = createHash("sha256").update(scriptBody).digest("hex").slice(0, 10);
const scriptUrl = `/static/val.${scriptHash}.js`;
// ------------------------------------------------------------- sessions
const cookies = (request: Request): Record<string, string> => {
  const out: Record<string, string> = {};
  for (const part of (request.headers.get("cookie") ?? "").split(";")) {
    const at = part.indexOf("=");
    if (at < 1) continue;
    out[part.slice(0, at).trim()] = decodeURIComponent(part.slice(at + 1).trim());
  }
  return out;
};
const SESSION = "val_session";
const NAME = "val_name";
/** A name is one line of plain text, sixteen characters, nothing clever. */
const cleanName = (raw: unknown): string => {
  const text = String(raw ?? "")
    .replace(/[\u0000-\u001f\u007f<>"'\\]/g, "")
    .trim()
    .slice(0, 16);
  return text.length >= 1 ? text : "";
};
const setCookie = (name: string, value: string, httpOnly: boolean): string =>
  `${name}=${encodeURIComponent(value)}; Path=/; SameSite=Lax; Max-Age=604800${httpOnly ? "; HttpOnly" : ""}${publicOrigin.startsWith("https:") ? "; Secure" : ""}`;
type SocketData = { session: string; playerId: string };
// ---------------------------------------------------------------- routing
export const server = Bun.serve<SocketData, Record<string, never>>({
  port: Number(process.env.PORT ?? 8080),
  hostname: process.env.HOST ?? "127.0.0.1",
  async fetch(request) {
  async fetch(request, self) {
    const url = new URL(request.url);
    const jar = cookies(request);
    const session = jar[SESSION] ?? randomUUID();
    const fresh = jar[SESSION] === undefined;
    if (request.method === "POST" && !sameOrigin(request))
      return new Response("forbidden", { status: 403 });
    if (request.method === "POST" && url.pathname === "/notes") {
      return new Response("forbidden", { status: 403, headers: SECURITY });
    if (request.method === "POST" && url.pathname === "/join") {
      const form = await readForm(request);
      if (form === undefined)
        return new Response("too large", { status: 413, headers: SECURITY });
      const body = String(form.get("body") ?? "").trim().slice(0, 500);
      if (body) db.query("INSERT INTO note (body) VALUES (?1)").run(body);
      return Response.redirect("/", 303);
      if (form === undefined) return new Response("too large", { status: 413, headers: SECURITY });
      const name = cleanName(form.get("name"));
      const headers = new Headers({ location: "/", ...SECURITY });
      headers.append("set-cookie", setCookie(SESSION, session, true));
      if (name) {
        headers.append("set-cookie", setCookie(NAME, name, false));
        takeSeat(session, name);
      }
      return new Response(null, { status: 303, headers });
    }
    // HEAD is GET without the body: a health check sees the app up.
    // The socket: one seat per session, taken from a bot where it stands.
    if (url.pathname === "/ws") {
      if (!sameOrigin(request)) return new Response("forbidden", { status: 403, headers: SECURITY });
      const name = cleanName(jar[NAME]) || `Guest-${session.slice(0, 4)}`;
      const player = takeSeat(session, name);
      if (!player) return new Response("no seats", { status: 503, headers: SECURITY });
      const upgraded = self.upgrade(request, { data: { session, playerId: player.id } });
      return upgraded ? undefined : new Response("expected a websocket", { status: 426, headers: SECURITY });
    }
    if (url.pathname === "/" && (request.method === "GET" || request.method === "HEAD")) {
      const full = html(page());
      const body = gamePage({
        state: match(),
        script: scriptUrl,
        name: cleanName(jar[NAME]),
        env: where,
        commit,
        ssh: process.env.FORGE_APP_SSH,
        results: recentResults(3),
      });
      const response = html(body, 200, fresh ? { "set-cookie": setCookie(SESSION, session, true) } : {});
      return request.method === "HEAD"
        ? new Response(null, { status: full.status, headers: full.headers })
        : full;
        ? new Response(null, { status: response.status, headers: response.headers })
        : response;
    }
    // The map is the same for everybody and changes only when the code does.
    if (url.pathname === "/map.json" && (request.method === "GET" || request.method === "HEAD"))
      return Response.json(
        { rows: gridRows(), tile: TILE },
        { headers: { "cache-control": "public, max-age=300", ...SECURITY } },
      );
    if (url.pathname === scriptUrl)
      return new Response(scriptBody, {
        headers: {
          "content-type": "text/javascript; charset=utf-8",
          "cache-control": "public, max-age=31536000, immutable",
          ...SECURITY,
        },
      });
    // Files under ./static are served as they are, cached for a year: name
    // them by content (app.3f2a9c.js) and a change is a new name, never a
    // stale cache. The path is confined to the directory.
    // them by content and a change is a new name, never a stale cache. The
    // path is confined to the directory.
    if (url.pathname.startsWith("/static/") && !url.pathname.includes("..")) {
      const file = Bun.file(join(import.meta.dir, "..", url.pathname.slice(1)));
      if (await file.exists())
@@ -175,6 +220,32 @@
export const server = Bun.serve({
    }
    return new Response("not found", { status: 404, headers: SECURITY });
  },
  websocket: {
    maxPayloadLength: 4 * 1024,
    open(socket) {
      const { session, playerId } = socket.data;
      attach(session, playerId, (data) => socket.send(data));
      socket.send(snapshot(playerId));
    },
    message(socket, raw) {
      // Anything a client sends is a claim: it is parsed, bounded and given
      // to the arena, which decides what it is allowed to mean.
      if (typeof raw !== "string" || raw.length > 4096) return;
      let parsed: unknown;
      try {
        parsed = JSON.parse(raw);
      } catch {
        return;
      }
      if (typeof parsed !== "object" || parsed === null) return;
      command(socket.data.playerId, parsed as Command);
    },
    close(socket) {
      release(socket.data.session);
    },
  },
  // A bug answers with the floor and nothing else: never the runtime's own
  // error page, which carries source and paths, and never without the
  // headers. The detail goes to the log, where it belongs.
@@ -184,4 +255,7 @@
export const server = Bun.serve({
  },
});
startArena();
console.log(`val listening on http://${server.hostname}:${server.port} (${env})`);
export { findPlayer };
@@ -0,0 +1,124 @@
/**
 * The shape of a match. Types only, so the ability module and the match loop
 * can both speak about a player without importing each other.
 */
import type { Point, Site } from "./map.ts";
import type { WeaponId } from "./weapons.ts";
export type Side = "atk" | "def";
export type Slot = "c" | "q" | "e" | "x";
export type Team = "red" | "blue";
export type Phase = "buy" | "live" | "end" | "over";
export type ZoneKind = "smoke" | "molly" | "wall" | "trip" | "dart" | "flash" | "heal";
/** Anything an ability leaves on the map, with a clock on it. */
export type Zone = {
  id: number;
  kind: ZoneKind;
  owner: string;
  side: Side;
  x: number;
  y: number;
  r: number;
  /** Seconds of life left. */
  life: number;
  /** Seconds before it goes off (a flash in the air, a trip arming). */
  fuse: number;
  /** Seconds to the next damage tick or recon pulse. */
  beat: number;
  pulses: number;
  damage: number;
  /** Blocks line of sight (smoke, wall). */
  blocks: boolean;
  /** Blocks movement (wall). */
  solid: boolean;
};
export type Input = {
  mx: number;
  my: number;
  angle: number;
  fire: boolean;
  /** Plant, defuse, pick the spike up: one key for all of it. */
  use: boolean;
  reload: boolean;
  cast: Slot | null;
};
export const emptyInput = (): Input => ({
  mx: 0,
  my: 0,
  angle: 0,
  fire: false,
  use: false,
  reload: false,
  cast: null,
});
export type Player = {
  id: string;
  name: string;
  bot: boolean;
  agent: string;
  team: Team;
  side: Side;
  x: number;
  y: number;
  angle: number;
  hp: number;
  armour: number;
  alive: boolean;
  credits: number;
  weapon: WeaponId;
  /** Kept through a round they survived, reset to the Classic when they die. */
  ammo: number;
  reloadIn: number;
  fireIn: number;
  /** Basic charges bought this round, and signature/ult readiness. */
  charges: Record<Slot, number>;
  cooldown: Record<Slot, number>;
  ult: number;
  blind: number;
  slow: number;
  haste: number;
  /** Seconds this player stays visible to the other team however dark it is. */
  revealed: number;
  spike: boolean;
  planting: number;
  defusing: number;
  kills: number;
  deaths: number;
  assists: number;
  damageDone: number;
  input: Input;
  /** Bot scratch space: where it is walking and when it last thought. */
  goal: Point | null;
  think: number;
  spray: number;
  joinedAt: number;
};
export type MatchState = {
  id: string;
  phase: Phase;
  /** Seconds left in the phase. */
  clock: number;
  round: number;
  score: Record<Team, number>;
  /** Which team attacks this round. */
  attackers: Team;
  lossStreak: Record<Team, number>;
  players: Player[];
  zones: Zone[];
  nextZone: number;
  spike: { carried: string | null; x: number; y: number; planted: boolean; fuse: number; site: Site | null; defuse: number; checkpoint: number };
  orbs: { x: number; y: number; taken: boolean }[];
  shots: { x1: number; y1: number; x2: number; y2: number; hit: boolean; age: number }[];
  events: { text: string; age: number }[];
  result: string | null;
  seed: number;
  now: number;
};
@@ -1,74 +1,174 @@
/**
 * val, in a terminal. The forge runs this on a pty when someone
 * `ssh`es to the app, with FORGE_APP_DATA pointing at the same data the
 * web page uses. j/k move, a adds a note, d deletes the one under the
 * cursor, q leaves. Plain ANSI, no dependencies.
 * val, in a terminal. The forge runs this on a pty when somebody ssh-es to
 * the app; it takes a seat over the same socket the browser uses, so what a
 * person can do on the page they can do here: walk, shoot, cast, plant,
 * defuse and buy.
 *
 * The map is the same grid, one character a tile. Plain ANSI, no dependencies.
 */
import { Database } from "bun:sqlite";
import { mkdirSync } from "node:fs";
import { join } from "node:path";
const base =
  process.env.VAL_URL ??
  (process.env.PORT ? `http://127.0.0.1:${process.env.PORT}` : undefined) ??
  process.env.FORGE_APP_URL ??
  "http://127.0.0.1:8080";
const dataDir = process.env.FORGE_APP_DATA ?? "./data";
mkdirSync(dataDir, { recursive: true });
const db = new Database(join(dataDir, "app.db"));
db.exec("PRAGMA journal_mode = WAL");
db.exec(
  "CREATE TABLE IF NOT EXISTS note (id INTEGER PRIMARY KEY, body TEXT NOT NULL, created_at TEXT NOT NULL DEFAULT (datetime('now')))",
);
const where = process.env.FORGE_APP_ENV === "preview" ? `preview of #${process.env.FORGE_APP_PULL ?? "?"}` : (process.env.FORGE_APP_ENV ?? "local");
type Note = { id: number; body: string; created_at: string };
const notes = (): Note[] => db.query<Note, []>("SELECT id, body, created_at FROM note ORDER BY id DESC").all();
let cursor = 0;
let typing: string | undefined;
const out = (s: string): void => { process.stdout.write(s); };
const esc = "\x1b[";
const out = (s: string): void => void process.stdout.write(s);
type Snapshot = {
  phase: string;
  clock: number;
  round: number;
  score: { red: number; blue: number };
  attackers: string;
  result: string | null;
  me: Record<string, any>;
  players: Record<string, any>[];
  zones: { k: string; x: number; y: number; r: number }[];
  spike: { planted: boolean; fuse: number; defuse: number; x: number | null; y: number | null };
  board: Record<string, any>[];
  events: string[];
};
let map: { rows: string[]; tile: number } | null = null;
let snap: Snapshot | null = null;
let socket: WebSocket | null = null;
let status = "connecting";
let aim = -Math.PI / 2;
let move = { mx: 0, my: 0, until: 0 };
let firing = 0;
let using = 0;
let buying = false;
const send = (message: unknown): void => {
  if (socket && socket.readyState === 1) socket.send(JSON.stringify(message));
};
async function connect(): Promise<void> {
  try {
    const page = await fetch(base + "/");
    const cookie = (page.headers.get("set-cookie") ?? "").split(";")[0] ?? "";
    map = (await (await fetch(base + "/map.json")).json()) as { rows: string[]; tile: number };
    const ws = new WebSocket(base.replace(/^http/, "ws") + "/ws", {
      headers: { cookie, origin: new URL(base).origin },
    } as unknown as string[]);
    socket = ws;
    ws.onopen = () => (status = "live");
    ws.onclose = () => {
      status = "reconnecting";
      socket = null;
      setTimeout(connect, 2000);
    };
    ws.onmessage = (event) => {
      snap = JSON.parse(String(event.data)) as Snapshot;
    };
  } catch (error) {
    status = `cannot reach ${base}`;
    setTimeout(connect, 3000);
  }
}
const colour = (s: string, code: number): string => `${esc}${code}m${s}${esc}0m`;
function draw(): void {
  const rows = notes();
  if (!map) {
    out(`${esc}2J${esc}Hval — ${status}\r\n`);
    return;
  }
  const rows = map.rows.map((row) => row.split("").map((c) => (c === "#" ? colour("▓", 90) : c === "A" || c === "B" ? colour(c, 33) : c === "a" || c === "d" ? colour("·", 90) : " ")));
  const put = (x: number, y: number, ch: string): void => {
    const col = Math.floor(x / map!.tile);
    const row = Math.floor(y / map!.tile);
    if (rows[row] && rows[row]![col] !== undefined) rows[row]![col] = ch;
  };
  const lines: string[] = [];
  lines.push(`${esc}1mval${esc}0m  ${esc}2m${where}${esc}0m`);
  if (snap) {
    for (const zone of snap.zones) put(zone.x, zone.y, colour(zone.k === "smoke" ? "▒" : zone.k === "molly" ? "≈" : zone.k === "wall" ? "█" : "*", zone.k === "molly" ? 31 : 37));
    if (snap.spike.x !== null && snap.spike.y !== null)
      put(snap.spike.x, snap.spike.y, colour(snap.spike.planted ? "◈" : "◇", 33));
    for (const player of snap.players) {
      if (!player.alive) continue;
      const mark = player.id === snap.me.id ? colour("@", 97) : colour(player.name[0] ?? "?", player.mate ? 36 : 31);
      put(player.x, player.y, mark);
    }
    const me = snap.me;
    const phase = snap.phase === "live" && snap.spike.planted ? `spike ${Math.ceil(snap.spike.fuse)}s` : snap.phase;
    lines.push(
      `${colour("val", 1)}  ${colour("red " + snap.score.red, 31)} — ${colour(snap.score.blue + " blue", 36)}  round ${snap.round}  ${phase} ${Math.ceil(snap.clock)}s  ${snap.attackers} attacking  [${status}]`,
    );
    lines.push(
      `${me.alive ? colour(`${me.hp}hp${me.armour ? "+" + me.armour : ""}`, 32) : colour("dead", 90)}  ${me.weapon} ${me.ammo}  ${me.credits}cr  ult ${me.ult}/${me.ultNeeds}  C${me.charges.c} Q${me.charges.q} E${me.charges.e}${me.spike ? colour("  SPIKE", 33) : ""}${me.blind > 0 ? colour("  BLIND", 97) : ""}  aim ${((aim * 180) / Math.PI).toFixed(0)}°`,
    );
  } else lines.push(`val — ${status}`);
  lines.push("");
  if (rows.length === 0) lines.push(`${esc}2mNo notes yet. Press a to add one.${esc}0m`);
  rows.forEach((n, i) => {
    const mark = i === cursor ? "▸" : " ";
    const body = i === cursor ? `${esc}1m${n.body}${esc}0m` : n.body;
    lines.push(`${mark} ${body}  ${esc}2m${n.created_at}${esc}0m`);
  });
  for (const row of rows) lines.push(" " + row.join(""));
  lines.push("");
  lines.push(typing === undefined ? `${esc}2mj/k move · a add · d delete · q quit${esc}0m` : `New note: ${typing}${esc}7m ${esc}0m`);
  out(`${esc}2J${esc}H` + lines.join("\r\n"));
  if (snap) {
    for (const side of ["atk", "def"] as const) {
      const team = snap.board
        .filter((p) => p.side === side)
        .map((p) => `${p.alive ? "" : colour("✕", 90)}${p.name}${p.bot ? "" : "*"} ${p.kills}/${p.deaths}`)
        .join("  ");
      lines.push(colour(side === "atk" ? "atk " : "def ", side === "atk" ? 31 : 36) + team);
    }
    lines.push("");
    for (const event of snap.events.slice(0, 3)) lines.push(colour("· " + event, 90));
  }
  lines.push("");
  lines.push(
    buying
      ? colour("buy: 1 Classic 2 Ghost 3 Sheriff 4 Spectre 5 Phantom 6 Vandal 7 Operator · 8 light 9 heavy · c/q ability · b closes", 33)
      : colour("wasd move · ←/→ aim · space fire · f plant/defuse · c q e x cast · b buy · r reload · q quit", 90),
  );
  out(`${esc}H${esc}J` + lines.join("\r\n"));
}
const BUYS: Record<string, string> = {
  "1": "classic", "2": "ghost", "3": "sheriff", "4": "spectre", "5": "phantom", "6": "vandal", "7": "operator",
  "8": "light", "9": "heavy",
};
process.stdin.setRawMode?.(true);
process.stdin.resume();
process.stdin.setEncoding("utf8");
draw();
process.stdin.on("data", (key: string) => {
  if (typing !== undefined) {
    if (key === "\r") {
      const body = typing.trim();
      if (body) db.query("INSERT INTO note (body) VALUES (?1)").run(body.slice(0, 500));
      typing = undefined;
      cursor = 0;
    } else if (key === "\x1b") typing = undefined;
    else if (key === "\x7f") typing = typing.slice(0, -1);
    else if (key >= " ") typing += key;
    draw();
  const now = Date.now();
  if (key === "\x03" || (key === "q" && !buying)) {
    out(`${esc}2J${esc}H`);
    process.exit(0);
  }
  if (buying) {
    if (BUYS[key]) send({ t: "buy", what: BUYS[key] });
    else if (key === "c" || key === "q") send({ t: "buy", what: key });
    else if (key === "b" || key === "\x1b") buying = false;
    return;
  }
  if (key === "q" || key === "\x03") { out(`${esc}2J${esc}H`); process.exit(0); }
  const count = notes().length;
  if (key === "j" || key === "\x1b[B") cursor = Math.min(cursor + 1, Math.max(0, count - 1));
  if (key === "k" || key === "\x1b[A") cursor = Math.max(cursor - 1, 0);
  if (key === "a") typing = "";
  if (key === "d") {
    const n = notes()[cursor];
    if (n) db.query("DELETE FROM note WHERE id = ?1").run(n.id);
    cursor = Math.min(cursor, Math.max(0, notes().length - 1));
  }
  draw();
  if (key === "b") return void (buying = true);
  if (key === "w") move = { mx: move.mx, my: -1, until: now + 400 };
  if (key === "s") move = { mx: move.mx, my: 1, until: now + 400 };
  if (key === "a") move = { mx: -1, my: move.my, until: now + 400 };
  if (key === "d") move = { mx: 1, my: move.my, until: now + 400 };
  if (key === "\x1b[D") aim -= Math.PI / 12;
  if (key === "\x1b[C") aim += Math.PI / 12;
  if (key === "\x1b[A") move = { mx: move.mx, my: -1, until: now + 400 };
  if (key === "\x1b[B") move = { mx: move.mx, my: 1, until: now + 400 };
  if (key === " ") firing = now + 220;
  if (key === "f") using = now + 700;
  if (key === "r") send({ t: "i", r: true });
  if (key === "c" || key === "e" || key === "x") send({ t: "i", c: key });
});
// Twenty times a second, the same intent the browser sends.
setInterval(() => {
  const now = Date.now();
  if (now > move.until) move = { mx: 0, my: 0, until: 0 };
  send({ t: "i", mx: move.mx, my: move.my, a: aim, f: firing > now, u: using > now, r: false });
}, 50);
setInterval(draw, 120);
process.stdout.on("resize", draw);
out(`${esc}2J`);
draw();
void connect();
@@ -0,0 +1,53 @@
import { expect, test } from "bun:test";
import { applyDamage, damage, isLethal, shotSpread, WEAPONS, zoneFromMiss } from "./weapons.ts";
test("a Vandal head shot kills through full armour at any range, a Phantom's does not", () => {
  for (const distance of [100, 800, 2000]) expect(isLethal(100, 50, damage("vandal", "head", distance))).toBe(true);
  // The Phantom only manages it inside fifteen metres; past that the falloff
  // leaves the target alive, which is the whole argument between the two guns.
  expect(isLethal(100, 50, damage("phantom", "head", 300))).toBe(true);
  expect(isLethal(100, 50, damage("phantom", "head", 900))).toBe(false);
  expect(isLethal(100, 50, damage("phantom", "head", 2000))).toBe(false);
  // Both still one-tap a head with no armour on.
  expect(isLethal(100, 0, damage("phantom", "head", 2000))).toBe(true);
});
test("the Phantom falls off with range and the Vandal does not", () => {
  expect(damage("phantom", "body", 100)).toBe(39);
  expect(damage("phantom", "body", 1600)).toBe(31);
  expect(damage("vandal", "body", 100)).toBe(damage("vandal", "body", 2300));
});
test("armour is absorbed point for point but empties first", () => {
  const hit = applyDamage(100, 50, 40);
  expect(hit.armour).toBe(50 - 27);
  expect(hit.hp).toBe(87);
  // A hundred health behind fifty armour is a hundred and fifty to chew through.
  let hp = 100;
  let armour = 50;
  let shots = 0;
  while (hp > 0) {
    ({ hp, armour } = applyDamage(hp, armour, 40));
    shots++;
  }
  expect(shots).toBe(4);
});
test("body shots never kill in one, whatever the gun, except the Operator", () => {
  expect(isLethal(100, 0, damage("operator", "body", 500))).toBe(true);
  for (const id of ["classic", "ghost", "sheriff", "spectre", "phantom", "vandal"] as const)
    expect(isLethal(100, 0, damage(id, "body", 500))).toBe(false);
});
test("where the ray passes decides the hit location", () => {
  expect(zoneFromMiss(0, 16)).toBe("head");
  expect(zoneFromMiss(8, 16)).toBe("body");
  expect(zoneFromMiss(15, 16)).toBe("legs");
});
test("running widens the cone and standing still does not", () => {
  expect(shotSpread("vandal", 0)).toBe(WEAPONS.vandal.spread);
  expect(shotSpread("vandal", 1)).toBeGreaterThan(shotSpread("vandal", 0));
  // The Operator is the accurate one and the Spectre is not.
  expect(shotSpread("operator", 0)).toBeLessThan(shotSpread("spectre", 0));
});
@@ -0,0 +1,194 @@
/**
 * Guns: the damage table and what a shot does with it. Pure functions —
 * nothing here knows about a match.
 *
 * Distance is in world units; fifty units is a metre, so the map is about
 * forty-eight metres across and the Phantom's fifteen-metre falloff lands
 * where it should. The rule that matters: a Vandal head shot kills through
 * full armour at any range, a Phantom head shot does not.
 */
export type WeaponId =
  | "classic"
  | "ghost"
  | "sheriff"
  | "spectre"
  | "phantom"
  | "vandal"
  | "operator";
export type Zone = "head" | "body" | "legs";
export type Band = { upTo: number; head: number; body: number; legs: number };
export type Weapon = {
  id: WeaponId;
  name: string;
  cost: number;
  /** Shots a second. */
  rate: number;
  magazine: number;
  reload: number;
  /** Cone half-angle in radians when standing still, and the walking penalty. */
  spread: number;
  movePenalty: number;
  range: number;
  auto: boolean;
  bands: Band[];
};
const METRE = 50;
export const WEAPONS: Record<WeaponId, Weapon> = {
  classic: {
    id: "classic",
    name: "Classic",
    cost: 0,
    rate: 6.75,
    magazine: 12,
    reload: 1.75,
    spread: 0.022,
    movePenalty: 0.05,
    range: 1600,
    auto: false,
    bands: [{ upTo: Infinity, head: 78, body: 26, legs: 22 }],
  },
  ghost: {
    id: "ghost",
    name: "Ghost",
    cost: 500,
    rate: 6.75,
    magazine: 15,
    reload: 1.5,
    spread: 0.016,
    movePenalty: 0.05,
    range: 1800,
    auto: false,
    bands: [
      { upTo: 30 * METRE, head: 105, body: 30, legs: 26 },
      { upTo: Infinity, head: 88, body: 25, legs: 21 },
    ],
  },
  sheriff: {
    id: "sheriff",
    name: "Sheriff",
    cost: 800,
    rate: 4,
    magazine: 6,
    reload: 2.25,
    spread: 0.02,
    movePenalty: 0.09,
    range: 2000,
    auto: false,
    bands: [
      { upTo: 30 * METRE, head: 159, body: 55, legs: 46 },
      { upTo: Infinity, head: 145, body: 50, legs: 42 },
    ],
  },
  spectre: {
    id: "spectre",
    name: "Spectre",
    cost: 1600,
    rate: 13.33,
    magazine: 30,
    reload: 2.5,
    spread: 0.03,
    movePenalty: 0.03,
    range: 1600,
    auto: true,
    bands: [
      { upTo: 20 * METRE, head: 78, body: 26, legs: 22 },
      { upTo: Infinity, head: 66, body: 22, legs: 18 },
    ],
  },
  phantom: {
    id: "phantom",
    name: "Phantom",
    cost: 2900,
    rate: 11,
    magazine: 30,
    reload: 2.5,
    spread: 0.021,
    movePenalty: 0.06,
    range: 2400,
    auto: true,
    bands: [
      { upTo: 15 * METRE, head: 156, body: 39, legs: 33 },
      { upTo: 30 * METRE, head: 140, body: 35, legs: 29 },
      { upTo: Infinity, head: 124, body: 31, legs: 26 },
    ],
  },
  vandal: {
    id: "vandal",
    name: "Vandal",
    cost: 2900,
    rate: 9.75,
    magazine: 25,
    reload: 2.5,
    spread: 0.024,
    movePenalty: 0.07,
    range: 2400,
    auto: true,
    bands: [{ upTo: Infinity, head: 160, body: 40, legs: 34 }],
  },
  operator: {
    id: "operator",
    name: "Operator",
    cost: 4700,
    rate: 0.6,
    magazine: 5,
    reload: 3.7,
    spread: 0.004,
    movePenalty: 0.2,
    range: 2800,
    auto: false,
    bands: [{ upTo: Infinity, head: 255, body: 150, legs: 120 }],
  },
};
export const weaponIds = (): WeaponId[] => Object.keys(WEAPONS) as WeaponId[];
export const isWeaponId = (value: unknown): value is WeaponId =>
  typeof value === "string" && value in WEAPONS;
/** Raw damage for a hit: the band the distance falls in, by zone. */
export function damage(id: WeaponId, zone: Zone, distance: number): number {
  const weapon = WEAPONS[id];
  const band = weapon.bands.find((b) => distance <= b.upTo) ?? weapon.bands[weapon.bands.length - 1]!;
  return band[zone];
}
/**
 * Armour absorbs point for point — a hundred health behind fifty armour is a
 * hundred and fifty to chew through — but it takes two thirds of each hit,
 * so it runs out before health does.
 */
export function applyDamage(
  hp: number,
  armour: number,
  amount: number,
): { hp: number; armour: number } {
  const toArmour = Math.min(armour, Math.ceil(amount * (2 / 3)));
  return { hp: Math.max(0, hp - (amount - toArmour)), armour: armour - toArmour };
}
/** True when this hit kills outright: the test the Vandal exists to pass. */
export const isLethal = (hp: number, armour: number, amount: number): boolean =>
  applyDamage(hp, armour, amount).hp <= 0;
/**
 * Where a shot lands, from how close the ray passes the target's centre.
 * Top-down has no vertical, so precision stands in for it: dead centre is a
 * head shot, the outer edge is legs.
 */
export function zoneFromMiss(miss: number, radius: number): Zone {
  if (miss <= radius * 0.33) return "head";
  if (miss <= radius * 0.75) return "body";
  return "legs";
}
/** Cone half-angle for a shot: standing still is accurate, running is not. */
export const shotSpread = (id: WeaponId, speedFraction: number): number =>
  WEAPONS[id].spread + WEAPONS[id].movePenalty * Math.min(1, Math.max(0, speedFraction));
export const SHIELD = { light: { cost: 400, armour: 25 }, heavy: { cost: 1000, armour: 50 } };
@@ -0,0 +1,429 @@
/**
 * val, in a browser. It draws what the server sends and sends what the
 * person does — nothing else. There is no position here the server did not
 * hand over, and no enemy in a snapshot the server decided you cannot see,
 * so a patched client learns nothing a plain one does not.
 */
"use strict";
const $ = (id) => document.getElementById(id);
const view = $("view");
const ctx = view.getContext("2d");
const KEY_SLOT = { KeyC: "c", KeyQ: "q", KeyE: "e", KeyX: "x" };
const AGENT_COLOUR = { ember: "#f08a4b", veil: "#8f7fe8", sable: "#4fd6a0", mender: "#e0c060", rook: "#d96a8f" };
let map = null;
let snap = null;
let socket = null;
const shown = new Map(); // smoothed positions, so 15 frames a second look like 60
const keys = new Set();
let pointer = null; // aim target in canvas pixels
let firing = false;
let stick = null; // { id, ox, oy, mx, my }
let aimTouch = null;
// ------------------------------------------------------------------ socket
function connect() {
  const url = (location.protocol === "https:" ? "wss://" : "ws://") + location.host + "/ws";
  socket = new WebSocket(url);
  socket.onopen = () => ($("conn").textContent = "live");
  socket.onclose = () => {
    $("conn").textContent = "reconnecting…";
    setTimeout(connect, 1500);
  };
  socket.onmessage = (event) => {
    const data = JSON.parse(event.data);
    if (data.t === "s") {
      snap = data;
      paintHud(data);
    }
  };
}
const send = (message) => {
  if (socket && socket.readyState === 1) socket.send(JSON.stringify(message));
};
// ------------------------------------------------------------------- input
addEventListener("keydown", (event) => {
  if (event.target instanceof HTMLInputElement) return;
  if (event.code === "KeyB") {
    toggleBuy();
    event.preventDefault();
    return;
  }
  if (KEY_SLOT[event.code]) {
    send({ t: "i", c: KEY_SLOT[event.code] });
    event.preventDefault();
    return;
  }
  keys.add(event.code);
  if (["KeyW", "KeyA", "KeyS", "KeyD", "Space", "KeyF", "KeyR"].includes(event.code)) event.preventDefault();
});
addEventListener("keyup", (event) => keys.delete(event.code));
addEventListener("blur", () => keys.clear());
view.addEventListener("pointermove", (event) => {
  if (event.pointerType === "touch") return;
  const box = view.getBoundingClientRect();
  pointer = { x: ((event.clientX - box.left) / box.width) * view.width, y: ((event.clientY - box.top) / box.height) * view.height };
});
view.addEventListener("pointerdown", (event) => {
  view.setPointerCapture(event.pointerId);
  const box = view.getBoundingClientRect();
  const x = event.clientX - box.left;
  if (event.pointerType === "touch") {
    if (x < box.width / 2) stick = { id: event.pointerId, ox: event.clientX, oy: event.clientY, mx: 0, my: 0 };
    else {
      aimTouch = { id: event.pointerId, x: ((event.clientX - box.left) / box.width) * view.width, y: ((event.clientY - box.top) / box.height) * view.height };
      firing = true;
    }
    event.preventDefault();
    return;
  }
  pointer = { x: ((event.clientX - box.left) / box.width) * view.width, y: ((event.clientY - box.top) / box.height) * view.height };
  firing = true;
});
view.addEventListener("pointermove", (event) => {
  if (stick && event.pointerId === stick.id) {
    const dx = event.clientX - stick.ox;
    const dy = event.clientY - stick.oy;
    const len = Math.hypot(dx, dy) || 1;
    const reach = Math.min(len, 48) / 48;
    stick.mx = (dx / len) * reach;
    stick.my = (dy / len) * reach;
  }
  if (aimTouch && event.pointerId === aimTouch.id) {
    const box = view.getBoundingClientRect();
    aimTouch.x = ((event.clientX - box.left) / box.width) * view.width;
    aimTouch.y = ((event.clientY - box.top) / box.height) * view.height;
  }
});
const endPointer = (event) => {
  if (stick && event.pointerId === stick.id) stick = null;
  else if (aimTouch && event.pointerId === aimTouch.id) {
    aimTouch = null;
    firing = false;
  } else firing = false;
};
view.addEventListener("pointerup", endPointer);
view.addEventListener("pointercancel", endPointer);
view.addEventListener("contextmenu", (event) => event.preventDefault());
// The buy opens itself every buy phase; closing it is remembered until the
// next one, so nobody has to fight the panel to watch the round start.
function toggleBuy() {
  const open = $("buy").classList.toggle("on");
  $("buy").dataset.closed = open ? "" : "1";
}
$("buytoggle").addEventListener("click", toggleBuy);
for (const button of document.querySelectorAll("[data-buy]"))
  button.addEventListener("click", () => send({ t: "buy", what: button.dataset.buy }));
for (const button of document.querySelectorAll("[data-agent]"))
  button.addEventListener("click", () => send({ t: "agent", id: button.dataset.agent }));
// Twenty times a second the server hears what this person is doing.
setInterval(() => {
  if (!snap || !map) return;
  let mx = 0;
  let my = 0;
  if (keys.has("KeyW")) my -= 1;
  if (keys.has("KeyS")) my += 1;
  if (keys.has("KeyA")) mx -= 1;
  if (keys.has("KeyD")) mx += 1;
  if (stick) {
    mx = stick.mx;
    my = stick.my;
  }
  const aim = aimTouch || pointer;
  const me = worldToScreen(snap.me);
  const angle = aim ? Math.atan2(aim.y - me.y, aim.x - me.x) : snap.me.angle;
  send({
    t: "i",
    mx,
    my,
    a: angle,
    f: firing || keys.has("Space"),
    u: keys.has("KeyF"),
    r: keys.has("KeyR"),
  });
}, 50);
// ------------------------------------------------------------------ drawing
function resize() {
  const box = view.getBoundingClientRect();
  const dpr = Math.min(devicePixelRatio || 1, 2);
  view.width = Math.round(box.width * dpr);
  view.height = Math.round(box.height * dpr);
}
addEventListener("resize", resize);
const scale = () => (map ? view.width / (map.rows[0].length * map.tile) : 1);
const worldToScreen = (p) => ({ x: p.x * scale(), y: p.y * scale() });
function smooth(id, x, y, angle) {
  const now = shown.get(id);
  if (!now) {
    shown.set(id, { x, y, angle });
    return { x, y, angle };
  }
  now.x += (x - now.x) * 0.35;
  now.y += (y - now.y) * 0.35;
  let turn = ((angle - now.angle + Math.PI * 3) % (Math.PI * 2)) - Math.PI;
  now.angle += turn * 0.4;
  return now;
}
function drawMap(s) {
  const t = map.tile * s;
  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 =
        cell === "#" ? "#20242d" : cell === "A" || cell === "B" ? "#2c2a22" : cell === "a" ? "#2a2024" : cell === "d" ? "#1e2630" : "#171a21";
      ctx.fillRect(col * t, row * t, t + 0.6, t + 0.6);
      if (cell === "A" || cell === "B") {
        ctx.fillStyle = "#6b5f3a";
        ctx.font = `${Math.round(t * 0.5)}px system-ui`;
        ctx.fillText(cell, col * t + t * 0.3, row * t + t * 0.68);
      }
    }
}
function drawZone(z, s) {
  const x = z.x * s;
  const y = z.y * s;
  const r = z.r * s;
  ctx.save();
  if (z.k === "smoke") {
    ctx.fillStyle = "rgba(190,195,205,0.72)";
    ctx.beginPath();
    ctx.arc(x, y, r, 0, 7);
    ctx.fill();
  } else if (z.k === "molly") {
    ctx.fillStyle = "rgba(230,110,50,0.45)";
    ctx.strokeStyle = "#f08a4b";
    ctx.beginPath();
    ctx.arc(x, y, r, 0, 7);
    ctx.fill();
    ctx.stroke();
  } else if (z.k === "wall") {
    ctx.fillStyle = "rgba(120,200,255,0.55)";
    ctx.beginPath();
    ctx.arc(x, y, r, 0, 7);
    ctx.fill();
  } else if (z.k === "flash") {
    ctx.fillStyle = z.f > 0 ? "#ffe9a8" : "rgba(255,255,255,0.9)";
    ctx.beginPath();
    ctx.arc(x, y, z.f > 0 ? 5 * s : 30 * s, 0, 7);
    ctx.fill();
  } else if (z.k === "dart") {
    ctx.strokeStyle = "rgba(90,220,170,0.7)";
    ctx.beginPath();
    ctx.arc(x, y, r, 0, 7);
    ctx.stroke();
  } else if (z.k === "trip") {
    ctx.strokeStyle = "rgba(230,200,90,0.8)";
    ctx.beginPath();
    ctx.arc(x, y, r, 0, 7);
    ctx.stroke();
  } else if (z.k === "heal") {
    ctx.fillStyle = "rgba(120,230,140,0.5)";
    ctx.beginPath();
    ctx.arc(x, y, 14 * s, 0, 7);
    ctx.fill();
  }
  ctx.restore();
}
function drawPlayer(p, s, me) {
  const pos = smooth(p.id, p.x, p.y, p.angle);
  const x = pos.x * s;
  const y = pos.y * s;
  const r = 16 * s;
  const mine = p.id === me.id;
  ctx.fillStyle = p.mate ? (mine ? "#eaeaea" : "#4fb3d9") : "#e35d5b";
  if (!p.alive) ctx.fillStyle = "#555a63";
  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();
  if (p.alive) {
    ctx.strokeStyle = mine ? "#fff" : ctx.fillStyle;
    ctx.beginPath();
    ctx.moveTo(x, y);
    ctx.lineTo(x + Math.cos(pos.angle) * r * 2, y + Math.sin(pos.angle) * r * 2);
    ctx.stroke();
  }
  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)";
    ctx.beginPath();
    ctx.arc(x, y - r * 1.6, r * 0.35, 0, 7);
    ctx.fill();
  }
  if (!mine) {
    ctx.fillStyle = "rgba(235,235,235,0.75)";
    ctx.font = `${Math.round(11 * Math.max(1, s * 2))}px system-ui`;
    ctx.textAlign = "center";
    ctx.fillText(p.name, x, y - r * 1.9);
    ctx.textAlign = "left";
  }
  if (p.alive && 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);
  }
}
function frame() {
  requestAnimationFrame(frame);
  if (!map) return;
  const s = scale();
  ctx.clearRect(0, 0, view.width, view.height);
  drawMap(s);
  if (!snap) return;
  for (const orb of snap.orbs) {
    ctx.fillStyle = "#c9a0ff";
    ctx.beginPath();
    ctx.arc(orb.x * s, orb.y * s, 9 * s, 0, 7);
    ctx.fill();
  }
  for (const zone of snap.zones) if (zone.k !== "smoke") drawZone(zone, s);
  if (snap.spike.x !== null) {
    const x = snap.spike.x * s;
    const y = snap.spike.y * s;
    ctx.fillStyle = snap.spike.planted ? (Math.floor(Date.now() / 250) % 2 ? "#ff5b4a" : "#8a2a22") : "#c8b45c";
    ctx.fillRect(x - 7 * s, y - 7 * s, 14 * s, 14 * s);
    if (snap.spike.planted && snap.spike.defuse > 0) {
      ctx.fillStyle = "#4fd6a0";
      ctx.fillRect(x - 20 * s, y + 12 * s, 40 * s * (snap.spike.defuse / 7), 4);
    }
  }
  for (const shot of snap.shots) {
    ctx.strokeStyle = shot.hit ? "rgba(255,120,110,0.85)" : "rgba(255,240,180,0.55)";
    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();
  }
  for (const player of snap.players) drawPlayer(player, s, snap.me);
  // Smoke goes on last: it hides what is behind it on screen too.
  for (const zone of snap.zones) if (zone.k === "smoke") drawZone(zone, s);
  if (snap.me.planting > 0) bar(snap.me.planting / 4, "#e0a040", "planting");
  else if (snap.spike.planted && snap.spike.defuse > 0 && snap.me.side === "def") bar(snap.spike.defuse / 7, "#4fd6a0", "defusing");
  $("flash").style.opacity = Math.min(0.95, snap.me.blind * 0.8);
  $("dead").style.display = snap.me.alive ? "none" : "grid";
}
function bar(fraction, colour, label) {
  const w = view.width * 0.4;
  const x = view.width / 2 - w / 2;
  const y = view.height * 0.86;
  ctx.fillStyle = "#0009";
  ctx.fillRect(x, y, w, 16);
  ctx.fillStyle = colour;
  ctx.fillRect(x, y, w * Math.min(1, fraction), 16);
  ctx.fillStyle = "#fff";
  ctx.font = "12px system-ui";
  ctx.textAlign = "center";
  ctx.fillText(label, view.width / 2, y + 12);
  ctx.textAlign = "left";
}
// --------------------------------------------------------------------- hud
const KITS = {};
function paintHud(s) {
  $("clock").textContent = Math.ceil(s.phase === "live" && s.spike.planted ? s.spike.fuse : s.clock);
  document.querySelector("#scoreline .red").textContent = "red " + s.score.red;
  document.querySelector("#scoreline .blue").textContent = s.score.blue + " blue";
  $("phase").textContent =
    `round ${s.round} · ${s.phase === "buy" ? "buy phase" : s.phase === "live" ? (s.spike.planted ? "spike down" : "live") : s.phase === "end" ? "round over" : "match over"} · ${s.attackers} attacking · you are ${s.me.side === "atk" ? "attacking" : "defending"}${s.result ? " · " + s.result : ""}`;
  $("hp").textContent = `${s.me.hp} hp${s.me.armour ? " +" + s.me.armour : ""}`;
  $("gun").textContent = `${s.me.weapon}${s.me.reloading ? " reloading" : " " + s.me.ammo}`;
  $("creds").textContent = `${s.me.credits} cr`;
  $("ultmeter").textContent = `ult ${s.me.ult}/${s.me.ultNeeds}`;
  $("buy").classList.toggle("on", s.phase === "buy" && $("buy").dataset.closed !== "1");
  if (s.phase !== "buy") $("buy").dataset.closed = "";
  const kit = $("kit");
  const shape = ["c", "q", "e", "x"].map((slot) => `${slot}${s.me.charges[slot]}${Math.ceil(s.me.cooldown[slot])}`).join("|") + s.me.agent + s.me.ult;
  if (KITS.shape !== shape) {
    KITS.shape = shape;
    kit.innerHTML = "";
    for (const slot of ["c", "q", "e", "x"]) {
      const button = document.createElement("button");
      const ready = slot === "x" ? s.me.ult >= s.me.ultNeeds : s.me.charges[slot] > 0 && s.me.cooldown[slot] <= 0;
      button.disabled = !ready;
      const count = slot === "x" ? `${s.me.ult}/${s.me.ultNeeds}` : s.me.cooldown[slot] > 0 ? `${Math.ceil(s.me.cooldown[slot])}s` : s.me.charges[slot];
      button.innerHTML = `${slot.toUpperCase()} <b>${count}</b>`;
      button.type = "button";
      button.addEventListener("click", () => send({ t: "i", c: slot }));
      kit.append(button);
    }
  }
  const log = $("log");
  const text = s.events.slice(0, 3).join("\n");
  if (log.dataset.text !== text) {
    log.dataset.text = text;
    log.innerHTML = "";
    for (const line of s.events.slice(0, 3)) {
      const div = document.createElement("div");
      div.textContent = line;
      log.append(div);
    }
  }
  for (const side of ["atk", "def"]) {
    const body = $(side + "board");
    const rows = s.board.filter((p) => p.side === side).sort((a, b) => b.kills - a.kills);
    const key = rows.map((p) => `${p.name}${p.kills}${p.deaths}${p.alive}${p.credits}`).join();
    if (body.dataset.key === key) continue;
    body.dataset.key = key;
    body.innerHTML = "";
    for (const player of rows) {
      const tr = document.createElement("tr");
      const cells = [
        player.name + (player.bot ? " (bot)" : "") + (player.alive ? "" : " ✕"),
        player.agent + (player.credits !== null ? ` · ${player.credits}cr` : ""),
        String(player.kills),
        String(player.deaths),
      ];
      for (const value of cells) {
        const td = document.createElement("td");
        td.textContent = value;
        tr.append(td);
      }
      if (player.id === s.me.id) tr.style.fontWeight = "700";
      body.append(tr);
    }
  }
}
fetch("/map.json")
  .then((r) => r.json())
  .then((data) => {
    map = data;
    resize();
    connect();
  });
requestAnimationFrame(frame);
		@@ -1,23 +1,82 @@
1	1	# val
2	2
3		Five attackers with the spike, five defenders, and abilities on cooldown. First to 13.
	3	Five attackers with the spike, five defenders, abilities on cooldown. First to 13.
4	4
5		This is an app: the forge runs it. Production follows the default branch;
6		every open pull gets a preview at its own address with its own copy of the
7		data. Everything the app keeps lives under `FORGE_APP_DATA`, which is what
8		makes "production data" and "preview data" two different things.
	5	A top-down 5v5 played in a browser. One match is always running on the
	6	server: open the page and you are given a seat in the round that is
	7	happening, taken from a bot where it stands. When a match ends it shows the
	8	result for a few seconds and starts a new one, so nobody ever arrives at a
	9	frozen board.
	10
	11	## What is real
	12
	13	Everything that decides a round is computed on the server and only the
	14	server:
	15
	16	- Movement, shooting and hit detection. The client sends intent — a
	17	direction, an angle, a held key — never a position. Damage is by hit
	18	location (how close the ray passes the target) with falloff and armour:
	19	a Vandal head shot kills through full armour at any range, a Phantom's
	20	does not past fifteen metres.
	21	- Line of sight. A snapshot only carries the enemies that viewer can
	22	see. A wall of the map blocks the sight line, a smoke blocks it, a flash
	23	blinds by the angle you were facing, and a blinded player is sent no
	24	enemies at all. A dead player watches through their living team mates'
	25	eyes rather than through walls, so dying is not a wallhack to call out.
	26	No spawn can see the other spawn: mid is staggered on purpose. A patched
	27	client learns nothing a plain one does not.
	28	- The spike. 100s round, 4s plant, 45s fuse, 7s defuse with a
	29	checkpoint at 3.5s — a defender killed past half way leaves the defuse
	30	half done for the next one.
	31	- Credits. 800 to start, 9,000 cap, +200 a kill, +300 to the team on a
	32	plant, loss bonus 1,900 / 2,400 / 2,900. A buy you cannot afford is
	33	refused server-side.
	34	- Bots fill every empty seat and use their kit: smokes on the way in,
	35	flashes before the entry, a recon dart, a molly on the planted spike.
	36
	37	Agents: Ember, Veil, Sable, Mender, Rook — two basics bought with credits
	38	(charges last the round), a free signature on a cooldown, and an ultimate
	39	paid for with ult points from kills, plants and the two orbs on the map.
	40
	41	Guns: Classic, Ghost, Sheriff, Spectre, Phantom, Vandal, Operator.
	42
	43	## What is not
	44
	45	- One map, one match at a time, ten seats. There is no matchmaking, no
	46	ranking and no account: your seat belongs to a session cookie.
	47	- No overtime — first to 13 ends it at 12–12 too.
	48	- Sight is a full circle rather than a view cone; top-down has no vertical,
	49	so the hit location comes from how precisely the shot passes the target.
	50	- Assists are counted as a field but never awarded.
	51	- The live match lives in memory and is gone if the process restarts; only
	52	finished match results are written to SQLite under `FORGE_APP_DATA`.
	53
	54	## Playing
	55
	56	WASD move, the mouse aims, click fires, R reloads, F plants and
	57	defuses (hold it), C / Q / E / X cast, B opens the buy. On a phone
	58	the left thumb walks and the right thumb aims and fires.
9	59
10	60	```sh
11	61	PORT=8080 FORGE_APP_DATA=./data bun run src/server.ts # run it here
12	62	bun test # the check every pull runs
13		FORGE_APP_DATA=./data bun run src/tty.ts # the terminal interface
	63	VAL_URL=http://127.0.0.1:8080 bun run src/tty.ts # the terminal interface
14	64	```
15	65
16		It also has a terminal: the exact command is in `FORGE_APP_SSH` when the app
17		runs (`ssh -p 2222 <name>@<forge>` — the app is the login name, the forge is
18		the host; `<name>--<pull>@<forge>` for a preview's). It opens `src/tty.ts` on
19		a real pty over the same data.
	66	The terminal plays the same match over the same socket: it draws the grid,
	67	the scoreboard and the round, and takes a seat. The exact command that
	68	reaches it is in `FORGE_APP_SSH` when the app runs, and the page prints it.
20	69
21		The forge sets `PORT`, `FORGE_APP_DATA`, `FORGE_APP_ENV`
22		(`production` or `preview`), `FORGE_APP_URL` and `FORGE_APP_COMMIT`
23		when it starts the app. `forge.json` says how.
	70	The forge sets `PORT`, `FORGE_APP_DATA`, `FORGE_APP_ENV`, `FORGE_APP_URL`,
	71	`FORGE_APP_SSH` and `FORGE_APP_COMMIT` when it starts the app; `forge.json`
	72	says how.
	73
	74	## Shape
	75
	76	`src/map.ts` the grid and its geometry · `src/weapons.ts` the damage table ·
	77	`src/economy.ts` credits · `src/abilities.ts` the agent kits ·
	78	`src/match.ts` the round loop (`tick(state, dt)` is the whole game and takes
	79	no clock) · `src/bots.ts` the seats nobody is in · `src/arena.ts` the one
	80	live match and its sockets · `src/server.ts` the door · `static/val.js` the
	81	browser. The rules are pure functions and the tests play whole matches
	82	headlessly.
		@@ -0,0 +1,142 @@
	1	import { expect, test } from "bun:test";
	2	import { AGENTS, agentById, buyableSlots, cast, castable, flashDuration, sightBlocked, SLOTS } from "./abilities.ts";
	3	import { newMatch, startRound, tick } from "./match.ts";
	4	import type { MatchState, Player, Zone } from "./state.ts";
	5
	6	const live = (): MatchState => {
	7	const state = newMatch(11);
	8	state.phase = "live";
	9	state.clock = 100;
	10	return state;
	11	};
	12	const attacker = (state: MatchState): Player => state.players.find((p) => p.side === "atk")!;
	13
	14	test("every agent has two bought basics, a free signature and an ultimate", () => {
	15	expect(AGENTS.length).toBe(5);
	16	for (const agent of AGENTS) {
	17	for (const slot of SLOTS) expect(agent.abilities[slot].name.length).toBeGreaterThan(0);
	18	for (const slot of buyableSlots) expect(agent.abilities[slot].cost).toBeGreaterThan(0);
	19	expect(agent.abilities.e.cost).toBe(0);
	20	expect(agent.abilities.e.cooldown).toBeGreaterThan(0);
	21	expect(agent.abilities.x.points).toBeGreaterThanOrEqual(6);
	22	}
	23	});
	24
	25	test("a flash blinds by the angle you were facing", () => {
	26	const at = { x: 1000, y: 1000 };
	27	const staring = { x: 1200, y: 1000 };
	28	const facingIt = Math.PI; // looking back down the line at the flash
	29	const facingAway = 0;
	30	expect(flashDuration(1.7, staring, at, facingIt, false)).toBeGreaterThan(1.6);
	31	expect(flashDuration(1.7, staring, at, facingAway, false)).toBe(0);
	32	// Half turned away is a shorter blind than staring straight at it.
	33	const glance = flashDuration(1.7, staring, at, facingIt - 1.2, false);
	34	expect(glance).toBeGreaterThan(0);
	35	expect(glance).toBeLessThan(1.7);
	36	});
	37
	38	test("a wall between you and the flash means no blind at all", () => {
	39	const blind = flashDuration(1.7, { x: 1200, y: 1000 }, { x: 1000, y: 1000 }, Math.PI, true);
	40	expect(blind).toBe(0);
	41	});
	42
	43	test("a smoke blocks the sight line for as long as it lives", () => {
	44	const smoke: Zone = {
	45	id: 1, kind: "smoke", owner: "x", side: "atk", x: 1200, y: 1000, r: 140,
	46	life: 8, fuse: 0, beat: 0, pulses: 0, damage: 0, blocks: true, solid: false,
	47	};
	48	// Straight down the mid corridor, which is open floor end to end.
	49	const from = { x: 1100, y: 1000 };
	50	const to = { x: 1300, y: 1000 };
	51	expect(sightBlocked(from, to, [])).toBe(false);
	52	expect(sightBlocked(from, to, [smoke])).toBe(true);
	53	// Standing off the line, the smoke is not in the way.
	54	expect(sightBlocked({ x: 1100, y: 700 }, { x: 1300, y: 700 }, [smoke])).toBe(false);
	55	});
	56
	57	test("a charge is spent on a cast and refused when there is none", () => {
	58	const state = live();
	59	const player = attacker(state);
	60	player.agent = "veil";
	61	player.charges.c = 1;
	62	expect(cast(state, player, "c")).toBe(true);
	63	expect(player.charges.c).toBe(0);
	64	expect(state.zones.some((z) => z.kind === "smoke")).toBe(true);
	65	expect(cast(state, player, "c")).toBe(false);
	66	expect(castable(player, "c")).toBe(false);
	67	});
	68
	69	test("the signature goes on cooldown and comes back on its own", () => {
	70	const state = live();
	71	const player = attacker(state);
	72	player.agent = "veil";
	73	const cooldown = agentById("veil").abilities.e.cooldown;
	74	expect(cast(state, player, "e")).toBe(true);
	75	expect(player.charges.e).toBe(0);
	76	expect(player.cooldown.e).toBe(cooldown);
	77	for (let i = 0; i < Math.ceil(cooldown * 10) + 4; i++) tick(state, 0.1);
	78	expect(player.cooldown.e).toBe(0);
	79	expect(castable(player, "e")).toBe(true);
	80	});
	81
	82	test("an ultimate costs its points and empties the meter", () => {
	83	const state = live();
	84	const player = attacker(state);
	85	player.agent = "sable";
	86	player.ult = 3;
	87	expect(cast(state, player, "x")).toBe(false);
	88	player.ult = 7;
	89	expect(cast(state, player, "x")).toBe(true);
	90	expect(player.ult).toBe(0);
	91	// Hunt reveals every enemy and leaves the caster's own side alone.
	92	for (const other of state.players) expect(other.revealed > 0).toBe(other.side !== player.side);
	93	});
	94
	95	test("a molly burns whoever stands in it and leaves the thrower's team alone", () => {
	96	const state = live();
	97	const player = attacker(state);
	98	player.agent = "ember";
	99	player.charges.q = 1;
	100	const victim = state.players.find((p) => p.side === "def")!;
	101	const mate = state.players.find((p) => p.side === "atk" && p.id !== player.id)!;
	102	victim.x = player.x + 120;
	103	victim.y = player.y;
	104	mate.x = player.x + 120;
	105	mate.y = player.y;
	106	player.angle = 0;
	107	player.x = victim.x - 120;
	108	cast(state, player, "q");
	109	for (const zone of state.zones) {
	110	zone.x = victim.x;
	111	zone.y = victim.y;
	112	}
	113	for (let i = 0; i < 20; i++) tick(state, 0.1);
	114	expect(victim.hp).toBeLessThan(100);
	115	expect(mate.hp).toBe(100);
	116	});
	117
	118	test("a wall is solid: it blocks the sight line that was open", () => {
	119	const state = live();
	120	const player = attacker(state);
	121	player.agent = "rook";
	122	// Along the back corridor, which is open from one side of the map to the other.
	123	player.x = 400;
	124	player.y = 1400;
	125	player.angle = 0;
	126	const behind = { x: 1000, y: 1400 };
	127	const openBefore = !sightBlocked(player, behind, state.zones);
	128	expect(cast(state, player, "e")).toBe(true);
	129	expect(openBefore).toBe(true);
	130	expect(sightBlocked(player, behind, state.zones)).toBe(true);
	131	expect(state.zones.every((z) => z.solid)).toBe(true);
	132	});
	133
	134	test("a round starts with the signature ready and no bought charges", () => {
	135	const state = newMatch(3);
	136	startRound(state, true);
	137	for (const player of state.players) {
	138	expect(player.charges.c).toBe(0);
	139	expect(player.charges.q).toBe(0);
	140	expect(player.charges.e).toBe(1);
	141	}
	142	});
		@@ -0,0 +1,273 @@
	1	/**
	2	* Agents and their kits.
	3	*
	4	* Five agents, each with two basics bought with credits (charges last the
	5	* round), one signature that is free and comes back on a cooldown, and one
	6	* ultimate paid for in ult points. The effects themselves are a short list of
	7	* kinds — flash, smoke, molly, dart, heal, wall, trip — so an agent is data,
	8	* not code.
	9	*
	10	* The two rules worth testing on their own: a flash blinds by the angle you
	11	* were facing and only with line of sight, and a smoke blocks that sight.
	12	*/
	13
	14	import { rayHitWall, segmentHitsCircle, wallBetween, type Point } from "./map.ts";
	15	import type { MatchState, Player, Slot, Zone } from "./state.ts";
	16
	17	export type Kind =
	18	\| "flash"
	19	\| "smoke"
	20	\| "molly"
	21	\| "dart"
	22	\| "heal"
	23	\| "wall"
	24	\| "trip"
	25	\| "haste"
	26	\| "rage"
	27	\| "revealall"
	28	\| "slowall";
	29
	30	export type Ability = {
	31	slot: Slot;
	32	name: string;
	33	kind: Kind;
	34	/** Credits for a basic; 0 for the signature and the ultimate. */
	35	cost: number;
	36	charges: number;
	37	/** Seconds the signature takes to come back. 0 means it does not. */
	38	cooldown: number;
	39	/** Ult points the ultimate costs. */
	40	points: number;
	41	range: number;
	42	radius: number;
	43	duration: number;
	44	damage: number;
	45	fuse: number;
	46	text: string;
	47	};
	48
	49	export type Agent = {
	50	id: string;
	51	name: string;
	52	role: string;
	53	blurb: string;
	54	abilities: Record<Slot, Ability>;
	55	};
	56
	57	const basic = (a: Partial<Ability> & { slot: Slot; name: string; kind: Kind; text: string }): Ability => ({
	58	cost: 200,
	59	charges: 1,
	60	cooldown: 0,
	61	points: 0,
	62	range: 700,
	63	radius: 110,
	64	duration: 10,
	65	damage: 0,
	66	fuse: 0,
	67	...a,
	68	});
	69
	70	export const AGENTS: Agent[] = [
	71	{
	72	id: "ember",
	73	name: "Ember",
	74	role: "Duelist",
	75	blurb: "Flash in, burn them off the plant, come back from nothing.",
	76	abilities: {
	77	c: basic({ slot: "c", name: "Flashfire", kind: "flash", cost: 250, charges: 2, range: 620, radius: 900, fuse: 0.55, duration: 1.7, text: "Throws a flash that pops after half a second and blinds anyone looking near it." }),
	78	q: basic({ slot: "q", name: "Blaze", kind: "molly", cost: 200, charges: 1, range: 620, radius: 95, duration: 6, damage: 26, text: "A pool of fire: 26 damage a second to anyone standing in it." }),
	79	e: basic({ slot: "e", name: "Second Wind", kind: "haste", cost: 0, charges: 1, cooldown: 35, duration: 4, text: "Signature. Four seconds of speed — take the angle before they re-peek." }),
	80	x: basic({ slot: "x", name: "Rebirth", kind: "rage", cost: 0, charges: 0, points: 6, duration: 6, text: "Ultimate. Full health, armour back, every basic charge refilled, six seconds of speed." }),
	81	},
	82	},
	83	{
	84	id: "veil",
	85	name: "Veil",
	86	role: "Controller",
	87	blurb: "Takes the sightline away and gives the site to whoever she likes.",
	88	abilities: {
	89	c: basic({ slot: "c", name: "Cloudburst", kind: "smoke", cost: 100, charges: 2, range: 760, radius: 105, duration: 8, text: "A short smoke. Cheap enough to throw two on a pistol round." }),
	90	q: basic({ slot: "q", name: "Blind Spot", kind: "flash", cost: 250, charges: 1, range: 600, radius: 850, fuse: 0.5, duration: 1.6, text: "A flash for the entry you are about to make." }),
	91	e: basic({ slot: "e", name: "Curtain", kind: "smoke", cost: 0, charges: 1, cooldown: 35, range: 900, radius: 150, duration: 15, text: "Signature. A wide smoke for fifteen seconds — nobody sees through it, server side." }),
	92	x: basic({ slot: "x", name: "Blackout", kind: "smoke", cost: 0, charges: 0, points: 7, range: 1100, radius: 280, duration: 12, damage: -1, text: "Ultimate. A site-sized smoke that slows every enemy inside it." }),
	93	},
	94	},
	95	{
	96	id: "sable",
	97	name: "Sable",
	98	role: "Initiator",
	99	blurb: "Finds them before the team walks in, and moves them off the angle.",
	100	abilities: {
	101	c: basic({ slot: "c", name: "Recon Dart", kind: "dart", cost: 250, charges: 1, range: 900, radius: 340, duration: 6, text: "Sticks and sweeps three times, revealing enemies it can see for two seconds each." }),
	102	q: basic({ slot: "q", name: "Shock Bolt", kind: "molly", cost: 150, charges: 2, range: 820, radius: 90, duration: 1.1, damage: 70, text: "A bolt that cracks for 70 a second — clears a corner or finishes a plant." }),
	103	e: basic({ slot: "e", name: "Owl Flash", kind: "flash", cost: 0, charges: 1, cooldown: 40, range: 640, radius: 900, fuse: 0.6, duration: 1.6, text: "Signature. A flash on a cooldown, so there is always one for the retake." }),
	104	x: basic({ slot: "x", name: "Hunt", kind: "revealall", cost: 0, charges: 0, points: 7, duration: 6, text: "Ultimate. Every enemy on the map is revealed for six seconds." }),
	105	},
	106	},
	107	{
	108	id: "mender",
	109	name: "Mender",
	110	role: "Sentinel",
	111	blurb: "Holds the flank shut and keeps the entry alive long enough to trade.",
	112	abilities: {
	113	c: basic({ slot: "c", name: "Healing Pulse", kind: "heal", cost: 200, charges: 2, range: 260, radius: 260, duration: 3, damage: 60, text: "Heals you or the nearest hurt ally 60 health over three seconds." }),
	114	q: basic({ slot: "q", name: "Barrier", kind: "wall", cost: 400, charges: 1, range: 520, radius: 120, duration: 12, text: "A solid wall for twelve seconds: nothing walks through it and nothing sees through it." }),
	115	e: basic({ slot: "e", name: "Tripwire", kind: "trip", cost: 0, charges: 1, cooldown: 40, range: 300, radius: 120, duration: 45, text: "Signature. Watches the flank: the enemy who walks in is revealed and slowed." }),
	116	x: basic({ slot: "x", name: "Lockdown", kind: "slowall", cost: 0, charges: 0, points: 8, duration: 5, text: "Ultimate. Every enemy is slowed and revealed for five seconds." }),
	117	},
	118	},
	119	{
	120	id: "rook",
	121	name: "Rook",
	122	role: "Initiator",
	123	blurb: "Builds the angle he wants and sets the site on fire when it is lost.",
	124	abilities: {
	125	c: basic({ slot: "c", name: "Smoke Grenade", kind: "smoke", cost: 150, charges: 1, range: 800, radius: 130, duration: 10, text: "One smoke, thrown long." }),
	126	q: basic({ slot: "q", name: "Flashbang", kind: "flash", cost: 200, charges: 2, range: 600, radius: 800, fuse: 0.6, duration: 1.5, text: "Two flashes: one for the entry, one for the exit." }),
	127	e: basic({ slot: "e", name: "Stone Wall", kind: "wall", cost: 0, charges: 1, cooldown: 45, range: 480, radius: 130, duration: 10, text: "Signature. A free wall, back every forty-five seconds." }),
	128	x: basic({ slot: "x", name: "Firestorm", kind: "molly", cost: 0, charges: 0, points: 7, range: 900, radius: 210, duration: 8, damage: 34, text: "Ultimate. A site-wide fire nobody defuses through." }),
	129	},
	130	},
	131	];
	132
	133	export const agentById = (id: string): Agent => AGENTS.find((a) => a.id === id) ?? AGENTS[0]!;
	134	export const isAgentId = (value: unknown): value is string =>
	135	typeof value === "string" && AGENTS.some((a) => a.id === value);
	136
	137	export const SLOTS: Slot[] = ["c", "q", "e", "x"];
	138	/** Bought before the round; the signature and the ultimate are never for sale. */
	139	export const buyableSlots: Slot[] = ["c", "q"];
	140
	141	/**
	142	* How long a flash blinds, in seconds. Facing it is the worst case; looking
	143	* away is free; a wall or a smoke between you and it means nothing at all.
	144	* `blocked` is the caller's line-of-sight answer, so this stays pure.
	145	*/
	146	export function flashDuration(
	147	full: number,
	148	from: Point,
	149	at: Point,
	150	facing: number,
	151	blocked: boolean,
	152	): number {
	153	if (blocked) return 0;
	154	const toFlash = Math.atan2(at.y - from.y, at.x - from.x);
	155	let off = Math.abs(((toFlash - facing + Math.PI * 3) % (Math.PI * 2)) - Math.PI);
	156	off = Math.min(off, Math.PI);
	157	const wide = (100 * Math.PI) / 180;
	158	if (off > wide) return 0;
	159	const narrow = (45 * Math.PI) / 180;
	160	const facingFactor = off <= narrow ? 1 : 1 - ((off - narrow) / (wide - narrow)) * 0.75;
	161	const distance = Math.hypot(from.x - at.x, from.y - at.y);
	162	const near = distance < 900 ? 1 : distance < 1500 ? 0.6 : 0.35;
	163	return Math.round(full * facingFactor * near * 100) / 100;
	164	}
	165
	166	/** Whether a sight line survives the smokes and walls standing on the map. */
	167	export const sightBlocked = (from: Point, to: Point, zones: Zone[]): boolean => {
	168	if (wallBetween(from, to)) return true;
	169	for (const zone of zones)
	170	if (zone.blocks && zone.fuse <= 0 && segmentHitsCircle(from, to, zone, zone.r)) return true;
	171	return false;
	172	};
	173
	174	/** Can this player cast this slot right now, and why not. */
	175	export function castable(player: Player, slot: Slot): boolean {
	176	if (!player.alive) return false;
	177	const ability = agentById(player.agent).abilities[slot];
	178	if (slot === "x") return player.ult >= ability.points;
	179	if (player.cooldown[slot] > 0) return false;
	180	return player.charges[slot] > 0;
	181	}
	182
	183	/** Where an ability lands: down the aim line, stopped by the first wall. */
	184	export const castPoint = (player: Player, range: number): Point =>
	185	rayHitWall(player, player.angle, range);
	186
	187	const zone = (state: MatchState, z: Omit<Zone, "id">): Zone => {
	188	const made = { ...z, id: state.nextZone++ };
	189	state.zones.push(made);
	190	return made;
	191	};
	192
	193	/**
	194	* Spend the charge and put the effect on the map. Returns false when the
	195	* cast was refused — no charge, still on cooldown, not enough ult points —
	196	* so the caller never has to guess.
	197	*/
	198	export function cast(state: MatchState, player: Player, slot: Slot): boolean {
	199	if (!castable(player, slot)) return false;
	200	const agent = agentById(player.agent);
	201	const ability = agent.abilities[slot];
	202	const spot = castPoint(player, ability.range);
	203	const base = { owner: player.id, side: player.side, life: ability.duration, fuse: ability.fuse, beat: 0, pulses: 0, damage: ability.damage, blocks: false, solid: false };
	204
	205	switch (ability.kind) {
	206	case "flash":
	207	zone(state, { ...base, kind: "flash", x: spot.x, y: spot.y, r: ability.radius, life: ability.fuse + 0.2, damage: ability.duration });
	208	break;
	209	case "smoke":
	210	zone(state, { ...base, kind: "smoke", x: spot.x, y: spot.y, r: ability.radius, blocks: true });
	211	break;
	212	case "molly":
	213	zone(state, { ...base, kind: "molly", x: spot.x, y: spot.y, r: ability.radius, beat: 0.5 });
	214	break;
	215	case "dart":
	216	zone(state, { ...base, kind: "dart", x: spot.x, y: spot.y, r: ability.radius, beat: 0.6, pulses: 3 });
	217	break;
	218	case "trip":
	219	zone(state, { ...base, kind: "trip", x: spot.x, y: spot.y, r: ability.radius, fuse: 1 });
	220	break;
	221	case "heal": {
	222	const hurt = state.players
	223	.filter((p) => p.alive && p.side === player.side && p.hp < 100 && Math.hypot(p.x - player.x, p.y - player.y) <= ability.range)
	224	.sort((a, b) => a.hp - b.hp)[0];
	225	const target = hurt ?? player;
	226	zone(state, { ...base, kind: "heal", x: target.x, y: target.y, r: 40, beat: 0.5, owner: target.id });
	227	break;
	228	}
	229	case "wall": {
	230	// Three blockers across the aim line: solid to walk through and to see
	231	// through, and made of circles so every other test still works.
	232	const across = player.angle + Math.PI / 2;
	233	for (let i = -1; i <= 1; i++)
	234	zone(state, {
	235	...base,
	236	kind: "wall",
	237	x: spot.x + Math.cos(across) * i * (ability.radius * 0.7),
	238	y: spot.y + Math.sin(across) * i * (ability.radius * 0.7),
	239	r: ability.radius * 0.45,
	240	blocks: true,
	241	solid: true,
	242	});
	243	break;
	244	}
	245	case "haste":
	246	player.haste = Math.max(player.haste, ability.duration);
	247	break;
	248	case "rage":
	249	player.hp = 100;
	250	player.armour = Math.max(player.armour, 25);
	251	player.haste = Math.max(player.haste, ability.duration);
	252	for (const s of buyableSlots) player.charges[s] = Math.max(player.charges[s], agent.abilities[s].charges);
	253	break;
	254	case "revealall":
	255	for (const other of state.players)
	256	if (other.side !== player.side) other.revealed = Math.max(other.revealed, ability.duration);
	257	break;
	258	case "slowall":
	259	for (const other of state.players)
	260	if (other.side !== player.side) {
	261	other.revealed = Math.max(other.revealed, ability.duration);
	262	other.slow = Math.max(other.slow, ability.duration);
	263	}
	264	break;
	265	}
	266
	267	if (slot === "x") player.ult = 0;
	268	else {
	269	player.charges[slot] = Math.max(0, player.charges[slot] - 1);
	270	if (ability.cooldown > 0) player.cooldown[slot] = ability.cooldown;
	271	}
	272	return true;
	273	}
		@@ -0,0 +1,256 @@
	1	/**
	2	* The arena: one match, always running, and the seats people sit in.
	3	*
	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.
	11	*/
	12
	13	import { agentById, sightBlocked } from "./abilities.ts";
	14	import { runBots } from "./bots.ts";
	15	import { recordResult } from "./db.ts";
	16	import type { Point } from "./map.ts";
	17	import {
	18	buyAbility,
	19	buyShield,
	20	buyWeapon,
	21	newMatch,
	22	pickAgent,
	23	setInput,
	24	tick,
	25	visible,
	26	} from "./match.ts";
	27	import type { MatchState, Player } from "./state.ts";
	28	import { isWeaponId } from "./weapons.ts";
	29
	30	export const TICK = 1 / 30;
	31	const BROADCAST_EVERY = 2;
	32
	33	export type Seat = { playerId: string; send: (data: string) => void };
	34
	35	let state: MatchState = newMatch();
	36	const seats = new Map<string, Seat>();
	37	let ticks = 0;
	38	let lastResult: string \| null = null;
	39
	40	export const match = (): MatchState => state;
	41
	42	export const findPlayer = (id: string): Player \| undefined => state.players.find((p) => p.id === id);
	43
	44	/** Sit somebody down in the emptiest team, replacing a bot where it stands. */
	45	export function takeSeat(session: string, name: string): Player \| null {
	46	const existing = seats.get(session);
	47	const held = existing ? findPlayer(existing.playerId) : undefined;
	48	if (held) {
	49	held.name = name;
	50	return held;
	51	}
	52	const humans = { red: 0, blue: 0 };
	53	for (const player of state.players) if (!player.bot) humans[player.team] += 1;
	54	const wanted = humans.red <= humans.blue ? "red" : "blue";
	55	const seat =
	56	state.players.find((p) => p.bot && p.team === wanted) ?? state.players.find((p) => p.bot);
	57	if (!seat) return null;
	58	seat.bot = false;
	59	seat.name = name;
	60	seat.think = 0;
	61	seat.input = { mx: 0, my: 0, angle: seat.angle, fire: false, use: false, reload: false, cast: null };
	62	return seat;
	63	}
	64
	65	export function attach(session: string, playerId: string, send: (data: string) => void): void {
	66	seats.set(session, { playerId, send });
	67	}
	68
	69	/** A person leaving gives the seat back to a bot, mid-round and all. */
	70	export function release(session: string): void {
	71	const seat = seats.get(session);
	72	seats.delete(session);
	73	if (!seat) return;
	74	const player = findPlayer(seat.playerId);
	75	if (player && !stillHeld(seat.playerId)) {
	76	player.bot = true;
	77	player.think = 0;
	78	player.input.fire = false;
	79	player.input.use = false;
	80	}
	81	}
	82
	83	const stillHeld = (playerId: string): boolean =>
	84	[...seats.values()].some((s) => s.playerId === playerId);
	85
	86	export const seatCount = (): number => seats.size;
	87
	88	// ------------------------------------------------------------- the commands
	89
	90	export type Command = { t: string; [key: string]: unknown };
	91
	92	const num = (value: unknown): number \| undefined =>
	93	typeof value === "number" && Number.isFinite(value) ? value : undefined;
	94
	95	/** Everything a client may ask for, validated here and nowhere else. */
	96	export function command(playerId: string, message: Command): void {
	97	const player = findPlayer(playerId);
	98	if (!player \|\| player.bot) return;
	99	switch (message.t) {
	100	case "i":
	101	setInput(player, {
	102	mx: num(message.mx),
	103	my: num(message.my),
	104	angle: num(message.a),
	105	fire: typeof message.f === "boolean" ? message.f : undefined,
	106	use: typeof message.u === "boolean" ? message.u : undefined,
	107	reload: typeof message.r === "boolean" ? message.r : undefined,
	108	cast: message.c === "c" \|\| message.c === "q" \|\| message.c === "e" \|\| message.c === "x" ? message.c : undefined,
	109	});
	110	break;
	111	case "buy": {
	112	const what = String(message.what ?? "");
	113	if (isWeaponId(what)) buyWeapon(state, player, what);
	114	else if (what === "light" \|\| what === "heavy") buyShield(state, player, what);
	115	else if (what === "c" \|\| what === "q") buyAbility(state, player, what);
	116	break;
	117	}
	118	case "agent":
	119	if (typeof message.id === "string") pickAgent(state, player, message.id);
	120	break;
	121	}
	122	}
	123
	124	// ------------------------------------------------------------- the snapshot
	125
	126	const round2 = (n: number): number => Math.round(n * 10) / 10;
	127
	128	export function snapshot(viewerId: string): string {
	129	const me = findPlayer(viewerId) ?? state.players[0]!;
	130	const agent = agentById(me.agent);
	131	const seen = state.players.filter((p) => visible(state, me, p));
	132	const canSee = (point: Point): boolean => !sightBlocked(me, point, state.zones);
	133
	134	return JSON.stringify({
	135	t: "s",
	136	phase: state.phase,
	137	clock: round2(Math.max(0, state.clock)),
	138	round: state.round,
	139	score: state.score,
	140	attackers: state.attackers,
	141	result: state.result,
	142	me: {
	143	id: me.id,
	144	side: me.side,
	145	team: me.team,
	146	agent: me.agent,
	147	alive: me.alive,
	148	x: round2(me.x),
	149	y: round2(me.y),
	150	angle: round2(me.angle),
	151	hp: Math.round(me.hp),
	152	armour: Math.round(me.armour),
	153	credits: me.credits,
	154	weapon: me.weapon,
	155	ammo: me.ammo,
	156	reloading: me.reloadIn > 0,
	157	charges: me.charges,
	158	cooldown: { c: round2(me.cooldown.c), q: round2(me.cooldown.q), e: round2(me.cooldown.e), x: 0 },
	159	ult: me.ult,
	160	ultNeeds: agent.abilities.x.points,
	161	blind: round2(me.blind),
	162	slow: round2(me.slow),
	163	haste: round2(me.haste),
	164	spike: me.spike,
	165	planting: round2(me.planting),
	166	bot: me.bot,
	167	},
	168	players: seen.map((p) => ({
	169	id: p.id,
	170	name: p.name,
	171	agent: p.agent,
	172	x: round2(p.x),
	173	y: round2(p.y),
	174	angle: round2(p.angle),
	175	hp: Math.round(p.hp),
	176	armour: Math.round(p.armour),
	177	alive: p.alive,
	178	mate: p.side === me.side,
	179	spike: p.spike,
	180	blind: p.blind > 0,
	181	revealed: p.revealed > 0,
	182	})),
	183	zones: state.zones
	184	.filter((z) => (z.kind === "trip" ? z.side === me.side : true))
	185	.map((z) => ({ k: z.kind, x: round2(z.x), y: round2(z.y), r: z.r, f: round2(z.fuse), l: round2(z.life) })),
	186	spike: {
	187	planted: state.spike.planted,
	188	carried: state.spike.carried !== null,
	189	fuse: round2(state.spike.fuse),
	190	defuse: round2(state.spike.defuse),
	191	checkpoint: state.spike.checkpoint,
	192	// A loose spike is the attackers' business until it is armed.
	193	x: state.spike.planted \|\| me.side === "atk" ? round2(state.spike.x) : null,
	194	y: state.spike.planted \|\| me.side === "atk" ? round2(state.spike.y) : null,
	195	},
	196	orbs: state.orbs.filter((o) => !o.taken).map((o) => ({ x: o.x, y: o.y })),
	197	shots: state.shots.filter((s) => canSee({ x: s.x1, y: s.y1 }) \|\| canSee({ x: s.x2, y: s.y2 })),
	198	board: state.players.map((p) => ({
	199	id: p.id,
	200	name: p.name,
	201	team: p.team,
	202	side: p.side,
	203	agent: p.agent,
	204	bot: p.bot,
	205	alive: p.alive,
	206	kills: p.kills,
	207	deaths: p.deaths,
	208	damage: Math.round(p.damageDone),
	209	credits: p.team === me.team ? p.credits : null,
	210	ult: p.ult,
	211	ultNeeds: agentById(p.agent).abilities.x.points,
	212	})),
	213	events: state.events.slice(0, 5).map((e) => e.text),
	214	});
	215	}
	216
	217	// ----------------------------------------------------------------- the loop
	218
	219	function step(): void {
	220	runBots(state, TICK);
	221	tick(state, TICK);
	222	if (state.result && state.result !== lastResult) {
	223	lastResult = state.result;
	224	recordResult(state.result, state.score.red, state.score.blue, state.round);
	225	}
	226	if (state.result === null) lastResult = null;
	227	ticks += 1;
	228	if (ticks % BROADCAST_EVERY !== 0) return;
	229	for (const seat of seats.values()) {
	230	try {
	231	seat.send(snapshot(seat.playerId));
	232	} catch {
	233	// A socket that will not take a frame is closed already; the close
	234	// handler gives the seat back.
	235	}
	236	}
	237	}
	238
	239	let timer: ReturnType<typeof setInterval> \| null = null;
	240
	241	export function startArena(): void {
	242	if (timer) return;
	243	timer = setInterval(step, TICK * 1000);
	244	// The clock must never hold the process open on its own.
	245	(timer as unknown as { unref?: () => void }).unref?.();
	246	}
	247
	248	export function stopArena(): void {
	249	if (timer) clearInterval(timer);
	250	timer = null;
	251	}
	252
	253	/** Used by the tests: run the arena forward without waiting for real time. */
	254	export function advance(seconds: number): void {
	255	for (let i = 0; i < Math.round(seconds / TICK); i++) step();
	256	}
		@@ -0,0 +1,257 @@
	1	/**
	2	* Bots. They fill the seats nobody is sitting in, and they use their kit:
	3	* a smoke on the way in, a flash before the entry, a dart to find the hold,
	4	* a molly on the planted spike, an ultimate when it is worth something.
	5	*
	6	* A bot only ever writes to its own `input`, the same field a browser writes
	7	* to, so the match loop cannot tell them apart and neither can a cheat.
	8	*/
	9
	10	import { agentById, castable } from "./abilities.ts";
	11	import { pathStep, siteAt, siteCentre, walkDistance, type Point, type Site } from "./map.ts";
	12	import { buyAbility, buyShield, buyWeapon, random, SPIKE_REACH, visible } from "./match.ts";
	13	import type { MatchState, Player, Slot } from "./state.ts";
	14	import { WEAPONS, type WeaponId } from "./weapons.ts";
	15
	16	/**
	17	* The site the attacking bots agree on this round. It comes from the match
	18	* id and the round number, never the running seed: five bots have to reach
	19	* the same answer on every tick or they walk in circles between the sites.
	20	*/
	21	export function attackSite(state: MatchState): Site {
	22	let hash = 0;
	23	for (const ch of state.id) hash = (hash * 31 + ch.charCodeAt(0)) % 9973;
	24	return (hash + state.round) % 2 === 0 ? "A" : "B";
	25	}
	26
	27	const holdSpots = (state: MatchState): Point[] => {
	28	const a = siteCentre("A");
	29	const b = siteCentre("B");
	30	return [
	31	{ x: a.x + 60, y: a.y + 90 },
	32	{ x: a.x - 40, y: a.y - 20 },
	33	{ x: 1200, y: 640 },
	34	{ x: b.x - 60, y: b.y + 90 },
	35	{ x: b.x + 40, y: b.y - 20 },
	36	];
	37	};
	38
	39	const ladder: { weapon: WeaponId; shield: "light" \| "heavy" \| null; floor: number }[] = [
	40	{ weapon: "operator", shield: "heavy", floor: 6200 },
	41	{ weapon: "vandal", shield: "heavy", floor: 4400 },
	42	{ weapon: "phantom", shield: "heavy", floor: 4200 },
	43	{ weapon: "spectre", shield: "heavy", floor: 2900 },
	44	{ weapon: "spectre", shield: "light", floor: 2100 },
	45	{ weapon: "sheriff", shield: "light", floor: 1300 },
	46	{ weapon: "ghost", shield: "light", floor: 950 },
	47	{ weapon: "classic", shield: "light", floor: 400 },
	48	];
	49
	50	/**
	51	* What a bot buys. It saves on a broken economy — under 2000 with an empty
	52	* gun rack is an eco round, and the credits are worth more next round.
	53	*/
	54	export function botBuy(state: MatchState, player: Player): void {
	55	const saving = player.credits < 2000 && state.round > 1 && player.weapon === "classic" && state.lossStreak[player.team] > 0;
	56	if (!saving) {
	57	const pick = ladder.find((step) => player.credits >= step.floor);
	58	if (pick && WEAPONS[pick.weapon].cost > 0) buyWeapon(state, player, pick.weapon);
	59	if (pick?.shield) buyShield(state, player, player.credits > 3500 ? "heavy" : pick.shield);
	60	}
	61	const agent = agentById(player.agent);
	62	// Abilities last: a flash is worth more than the last hundred credits.
	63	for (const slot of ["c", "q", "c", "q"] as Slot[]) {
	64	const ability = agent.abilities[slot];
	65	if (player.credits >= ability.cost + (saving ? 400 : 0)) buyAbility(state, player, slot);
	66	}
	67	}
	68
	69	const enemiesSeen = (state: MatchState, bot: Player): Player[] =>
	70	state.players.filter((p) => p.alive && p.side !== bot.side && visible(state, bot, p));
	71
	72	const towards = (bot: Player, point: Point): { mx: number; my: number } => {
	73	const dx = point.x - bot.x;
	74	const dy = point.y - bot.y;
	75	const len = Math.hypot(dx, dy) \|\| 1;
	76	return { mx: dx / len, my: dy / len };
	77	};
	78
	79	const turn = (bot: Player, target: number, rate: number): void => {
	80	let diff = ((target - bot.angle + Math.PI * 3) % (Math.PI * 2)) - Math.PI;
	81	bot.input.angle = bot.angle + Math.max(-rate, Math.min(rate, diff));
	82	};
	83
	84	/** One bot's decision for this tick. */
	85	export function botThink(state: MatchState, bot: Player, dt: number): void {
	86	if (!bot.alive) return;
	87	if (state.phase === "buy") {
	88	if (bot.think <= 0) {
	89	botBuy(state, bot);
	90	bot.think = 99;
	91	}
	92	bot.input.mx = 0;
	93	bot.input.my = 0;
	94	return;
	95	}
	96	// The buy left the timer parked; the first live tick starts it thinking.
	97	if (bot.think > 5) bot.think = 0;
	98	bot.think -= dt;
	99	const spike = state.spike;
	100	const site = spike.planted && spike.site ? spike.site : attackSite(state);
	101	const target = enemiesSeen(state, bot).sort(
	102	(a, b) => Math.hypot(a.x - bot.x, a.y - bot.y) - Math.hypot(b.x - bot.x, b.y - bot.y),
	103	)[0];
	104
	105	// --- where to be
	106	let goal: Point = siteCentre(site);
	107	if (bot.side === "atk") {
	108	if (spike.planted) goal = { x: spike.x + (random(state) - 0.5) * 220, y: spike.y + (random(state) - 0.5) * 220 };
	109	else if (!spike.carried && !bot.spike) {
	110	const loose = { x: spike.x, y: spike.y };
	111	if (walkDistance(bot, loose) < 8) goal = loose;
	112	}
	113	} else {
	114	const spots = holdSpots(state);
	115	const index = Number(bot.id.slice(-1)) % spots.length;
	116	goal = spike.planted ? { x: spike.x, y: spike.y } : spots[index]!;
	117	}
	118	bot.goal = goal;
	119
	120	const distToGoal = Math.hypot(goal.x - bot.x, goal.y - bot.y);
	121	const step = pathStep(bot, goal);
	122	const walk = towards(bot, step);
	123	bot.input.mx = walk.mx;
	124	bot.input.my = walk.my;
	125
	126	// --- the kit
	127	if (bot.think <= 0) {
	128	bot.think = 0.4 + random(state) * 0.5;
	129	useKit(state, bot, target ?? null, site, distToGoal);
	130	}
	131
	132	// --- the spike
	133	bot.input.use = false;
	134	if (bot.side === "atk" && bot.spike && !spike.planted) {
	135	const onSite = siteAt(bot.x, bot.y) === site;
	136	if (onSite && (!target \|\| bot.planting > 0)) {
	137	bot.input.use = true;
	138	bot.input.mx = 0;
	139	bot.input.my = 0;
	140	}
	141	}
	142	if (bot.side === "def" && spike.planted && Math.hypot(bot.x - spike.x, bot.y - spike.y) < SPIKE_REACH - 6) {
	143	const safe = !target \|\| spike.fuse < 8;
	144	if (safe) {
	145	bot.input.use = true;
	146	bot.input.mx = 0;
	147	bot.input.my = 0;
	148	}
	149	}
	150	if (bot.blind > 0) {
	151	// Blinded: back off and stop shooting, like a person would.
	152	bot.input.fire = false;
	153	bot.input.mx *= -0.6;
	154	bot.input.my *= -0.6;
	155	return;
	156	}
	157
	158	// --- the gun
	159	bot.input.reload = bot.ammo === 0;
	160	if (!target) {
	161	bot.input.fire = false;
	162	if (Math.hypot(bot.input.mx, bot.input.my) > 0.01)
	163	turn(bot, Math.atan2(bot.input.my, bot.input.mx), 6 * dt);
	164	return;
	165	}
	166	const range = Math.hypot(target.x - bot.x, target.y - bot.y);
	167	const aim = Math.atan2(target.y - bot.y, target.x - bot.x) + (random(state) - 0.5) * 0.06;
	168	turn(bot, aim, 7 * dt);
	169	const off = Math.abs(((aim - bot.angle + Math.PI * 3) % (Math.PI * 2)) - Math.PI);
	170	const weapon = WEAPONS[bot.weapon];
	171	bot.input.fire = off < 0.07 && range < weapon.range && bot.ammo > 0;
	172	// Stand still to shoot at range, close the gap up front.
	173	if (range > 420) {
	174	bot.input.mx *= 0.15;
	175	bot.input.my *= 0.15;
	176	} else if (range < 160) {
	177	const away = towards(bot, target);
	178	bot.input.mx = -away.mx * 0.5;
	179	bot.input.my = -away.my * 0.5;
	180	}
	181	}
	182
	183	/** Ability decisions, kept in one place so each is a sentence you can read. */
	184	function useKit(state: MatchState, bot: Player, target: Player \| null, site: Site, distToGoal: number): void {
	185	const agent = agentById(bot.agent);
	186	const spike = state.spike;
	187	const centre = siteCentre(site);
	188	const aimAt = (point: Point): void => {
	189	bot.input.angle = Math.atan2(point.y - bot.y, point.x - bot.x);
	190	bot.angle = bot.input.angle;
	191	};
	192	const tryCast = (slot: Slot, point: Point): boolean => {
	193	if (!castable(bot, slot)) return false;
	194	aimAt(point);
	195	bot.input.cast = slot;
	196	return true;
	197	};
	198
	199	for (const slot of ["x", "c", "q", "e"] as Slot[]) {
	200	const ability = agent.abilities[slot];
	201	if (!castable(bot, slot)) continue;
	202	const kind = ability.kind;
	203
	204	if (kind === "rage" \|\| kind === "haste") {
	205	if (bot.hp < 70 \|\| (target && distToGoal < 500)) return void tryCast(slot, centre);
	206	continue;
	207	}
	208	if (kind === "revealall" \|\| kind === "slowall") {
	209	if (target \|\| distToGoal < 420) return void tryCast(slot, centre);
	210	continue;
	211	}
	212	if (kind === "heal") {
	213	const hurt = state.players.find((p) => p.alive && p.side === bot.side && p.hp <= 60 && Math.hypot(p.x - bot.x, p.y - bot.y) < ability.range);
	214	if (hurt) return void tryCast(slot, hurt);
	215	continue;
	216	}
	217	if (kind === "molly") {
	218	// Fire on the planted spike, or on the choke ahead of us.
	219	if (bot.side === "def" && spike.planted && Math.hypot(bot.x - spike.x, bot.y - spike.y) < ability.range)
	220	return void tryCast(slot, spike);
	221	if (target && Math.hypot(target.x - bot.x, target.y - bot.y) < ability.range && Math.hypot(target.x - bot.x, target.y - bot.y) > 120)
	222	return void tryCast(slot, target);
	223	continue;
	224	}
	225	if (kind === "flash") {
	226	const enemyClose = target && Math.hypot(target.x - bot.x, target.y - bot.y) < ability.range;
	227	if (enemyClose) return void tryCast(slot, target!);
	228	if (bot.side === "atk" && distToGoal < ability.range && distToGoal > 150) return void tryCast(slot, centre);
	229	continue;
	230	}
	231	if (kind === "smoke") {
	232	if (bot.side === "atk" && distToGoal < ability.range && distToGoal > 260) return void tryCast(slot, centre);
	233	if (bot.side === "def" && spike.planted && Math.hypot(bot.x - spike.x, bot.y - spike.y) < ability.range && Math.hypot(bot.x - spike.x, bot.y - spike.y) > 200)
	234	return void tryCast(slot, spike);
	235	continue;
	236	}
	237	if (kind === "dart") {
	238	if (distToGoal < ability.range && distToGoal > 200) return void tryCast(slot, centre);
	239	continue;
	240	}
	241	if (kind === "wall") {
	242	if (target && Math.hypot(target.x - bot.x, target.y - bot.y) < ability.range && bot.hp < 60)
	243	return void tryCast(slot, target);
	244	if (bot.side === "def" && !spike.planted && distToGoal < 200 && state.clock > 60) return void tryCast(slot, centre);
	245	continue;
	246	}
	247	if (kind === "trip") {
	248	if (bot.side === "def" && distToGoal < 160) return void tryCast(slot, { x: bot.x + (random(state) - 0.5) * 200, y: bot.y + (random(state) - 0.5) * 200 });
	249	continue;
	250	}
	251	}
	252	}
	253
	254	/** Drive every seat that nobody is sitting in. */
	255	export function runBots(state: MatchState, dt: number): void {
	256	for (const player of state.players) if (player.bot) botThink(state, player, dt);
	257	}
		@@ -0,0 +1,43 @@
	1	/**
	2	* What survives a restart: finished matches. The live match lives in memory
	3	* — it is gone the moment the process is — but its result is written here,
	4	* under FORGE_APP_DATA, so the page can say what happened before you arrived.
	5	*/
	6
	7	import { Database } from "bun:sqlite";
	8	import { mkdirSync } from "node:fs";
	9	import { join } from "node:path";
	10
	11	const dataDir = process.env.FORGE_APP_DATA ?? "./data";
	12	mkdirSync(dataDir, { recursive: true });
	13
	14	export const db = new Database(join(dataDir, "app.db"));
	15	db.exec("PRAGMA journal_mode = WAL");
	16	db.exec(
	17	`CREATE TABLE IF NOT EXISTS result (
	18	id INTEGER PRIMARY KEY,
	19	summary TEXT NOT NULL,
	20	red INTEGER NOT NULL,
	21	blue INTEGER NOT NULL,
	22	rounds INTEGER NOT NULL,
	23	ended_at TEXT NOT NULL DEFAULT (datetime('now'))
	24	)`,
	25	);
	26
	27	export type Result = { summary: string; red: number; blue: number; rounds: number; ended_at: string };
	28
	29	export const recordResult = (summary: string, red: number, blue: number, rounds: number): void => {
	30	db.query("INSERT INTO result (summary, red, blue, rounds) VALUES (?1, ?2, ?3, ?4)").run(
	31	summary.slice(0, 120),
	32	red,
	33	blue,
	34	rounds,
	35	);
	36	};
	37
	38	export const recentResults = (limit = 5): Result[] =>
	39	db
	40	.query<Result, [number]>(
	41	"SELECT summary, red, blue, rounds, ended_at FROM result ORDER BY id DESC LIMIT ?1",
	42	)
	43	.all(Math.max(1, Math.min(50, limit)));
		@@ -0,0 +1,28 @@
	1	import { expect, test } from "bun:test";
	2	import { award, CREDIT_CAP, lossBonus, roundReward, spend, START_CREDITS } from "./economy.ts";
	3
	4	test("a round starts on 800 and nothing goes past 9000", () => {
	5	expect(START_CREDITS).toBe(800);
	6	expect(award(8900, 200)).toBe(CREDIT_CAP);
	7	expect(award(100, -500)).toBe(0);
	8	});
	9
	10	test("the loss bonus rises 1900 / 2400 / 2900 and stops", () => {
	11	expect(lossBonus(1)).toBe(1900);
	12	expect(lossBonus(2)).toBe(2400);
	13	expect(lossBonus(3)).toBe(2900);
	14	expect(lossBonus(7)).toBe(2900);
	15	});
	16
	17	test("a losing attack that planted keeps the plant bonus on top", () => {
	18	expect(roundReward(false, 1, false)).toBe(1900);
	19	expect(roundReward(false, 1, true)).toBe(1900 + 300);
	20	expect(roundReward(true, 3, false)).toBe(3000);
	21	});
	22
	23	test("a buy you cannot afford is refused, never a debt", () => {
	24	expect(spend(800, 2900)).toEqual({ ok: false, credits: 800 });
	25	expect(spend(2900, 2900)).toEqual({ ok: true, credits: 0 });
	26	expect(spend(800, -100).ok).toBe(false);
	27	expect(spend(800, Number.NaN).ok).toBe(false);
	28	});
		@@ -0,0 +1,34 @@
	1	/**
	2	* Credits. The whole economy is four numbers and a losing streak, and all of
	3	* it is pure: the match calls these and stores what comes back.
	4	*/
	5
	6	export const START_CREDITS = 800;
	7	export const CREDIT_CAP = 9000;
	8	export const KILL_REWARD = 200;
	9	export const PLANT_REWARD = 300;
	10	export const WIN_REWARD = 3000;
	11	/** Rising with the streak, and capped at the third step. */
	12	export const LOSS_BONUS = [1900, 2400, 2900];
	13
	14	export const clampCredits = (credits: number): number =>
	15	Math.max(0, Math.min(CREDIT_CAP, Math.floor(credits)));
	16
	17	export const award = (credits: number, amount: number): number => clampCredits(credits + amount);
	18
	19	/** The loss bonus for a team that has now lost `streak` rounds in a row. */
	20	export const lossBonus = (streak: number): number =>
	21	LOSS_BONUS[Math.min(Math.max(streak, 1), LOSS_BONUS.length) - 1]!;
	22
	23	/** What a round's end pays each member of a team. */
	24	export function roundReward(won: boolean, lossStreak: number, planted: boolean): number {
	25	if (won) return WIN_REWARD;
	26	// A team that lost the round but got the spike down keeps a little more.
	27	return lossBonus(lossStreak) + (planted ? PLANT_REWARD : 0);
	28	}
	29
	30	/** A purchase either happens at a price or is refused; never a debt. */
	31	export function spend(credits: number, cost: number): { ok: boolean; credits: number } {
	32	if (!Number.isFinite(cost) \|\| cost < 0 \|\| cost > credits) return { ok: false, credits };
	33	return { ok: true, credits: clampCredits(credits - cost) };
	34	}
		@@ -0,0 +1,265 @@
	1	/**
	2	* The map: one grid, and the geometry everything else asks questions of.
	3	*
	4	* Two sites (A left, B right), a mid corridor between the spawns, and a back
	5	* corridor along the bottom that links A main, spawn and B main — the flank.
	6	* Tiles are 80 units; a player is a circle of radius 16, so a one-tile
	7	* corridor is comfortably wide and a wall is never thin enough for a ray to
	8	* step over.
	9	*
	10	* Everything here is a pure function of the grid: collision, line of sight
	11	* and the walk distance a bot uses to path. No state.
	12	*/
	13
	14	export const TILE = 80;
	15
	16	// '#' wall · '.' floor · 'A'/'B' plant site · 'a' attacker spawn · 'd' defender spawn
	17	const ROWS_SRC = [
	18	"##############################",
	19	"#........###.dddd.###........#",
	20	"#.AAAAA..###.dddd.###..BBBBB.#",
	21	"#.AAAAA..##........##..BBBBB.#",
	22	"#.AAAAA..##.#....#.##..BBBBB.#",
	23	"#.AAAAA..##........##..BBBBB.#",
	24	"#...##......#....#......##...#",
	25	"#..####....#......#....####..#",
	26	"#..####..###......###..####..#",
	27	"#..####..####....####..####..#",
	28	"#..####..####.##.####..####..#",
	29	"#........####.##.####........#",
	30	"#..####..####....####..####..#",
	31	"#..####..#####..#####..####..#",
	32	"#..####..#####..#####..####..#",
	33	"#..####..###......###..####..#",
	34	"#........##..aaaa..##........#",
	35	"#............aaaa............#",
	36	"##############################",
	37	];
	38
	39	export const COLS = ROWS_SRC[0]!.length;
	40	export const ROWS = ROWS_SRC.length;
	41	export const WIDTH = COLS * TILE;
	42	export const HEIGHT = ROWS * TILE;
	43
	44	export const grid: string[] = ROWS_SRC;
	45	export const gridRows = (): string[] => ROWS_SRC.slice();
	46
	47	export type Site = "A" \| "B";
	48	export type Point = { x: number; y: number };
	49
	50	const at = (col: number, row: number): string =>
	51	row < 0 \|\| row >= ROWS \|\| col < 0 \|\| col >= COLS ? "#" : ROWS_SRC[row]![col]!;
	52
	53	export const solidTile = (col: number, row: number): boolean => at(col, row) === "#";
	54
	55	export const tileOf = (x: number, y: number): { col: number; row: number } => ({
	56	col: Math.floor(x / TILE),
	57	row: Math.floor(y / TILE),
	58	});
	59
	60	export const centreOf = (col: number, row: number): Point => ({
	61	x: col * TILE + TILE / 2,
	62	y: row * TILE + TILE / 2,
	63	});
	64
	65	export const solidAt = (x: number, y: number): boolean => {
	66	const t = tileOf(x, y);
	67	return solidTile(t.col, t.row);
	68	};
	69
	70	/** The site a point plants on, or null: the spike only arms inside a site. */
	71	export const siteAt = (x: number, y: number): Site \| null => {
	72	const t = tileOf(x, y);
	73	const c = at(t.col, t.row);
	74	return c === "A" \|\| c === "B" ? c : null;
	75	};
	76
	77	const cellsOf = (mark: string): Point[] => {
	78	const out: Point[] = [];
	79	for (let row = 0; row < ROWS; row++)
	80	for (let col = 0; col < COLS; col++) if (at(col, row) === mark) out.push(centreOf(col, row));
	81	return out;
	82	};
	83
	84	export const spawnCells = (side: "atk" \| "def"): Point[] => cellsOf(side === "atk" ? "a" : "d");
	85	export const siteCells = (site: Site): Point[] => cellsOf(site);
	86
	87	export const siteCentre = (site: Site): Point => {
	88	const cells = siteCells(site);
	89	const sum = cells.reduce((a, p) => ({ x: a.x + p.x, y: a.y + p.y }), { x: 0, y: 0 });
	90	return { x: sum.x / cells.length, y: sum.y / cells.length };
	91	};
	92
	93	/** Ult orbs: one on each half of mid, free for whoever walks over them. */
	94	export const orbSpots = (): Point[] => [centreOf(4, 11), centreOf(25, 11)];
	95
	96	/**
	97	* Slide a circle through the grid: each axis is moved and resolved on its
	98	* own, so running along a wall slides instead of sticking.
	99	*/
	100	export function moveCircle(x: number, y: number, dx: number, dy: number, r: number): Point {
	101	let nx = x;
	102	let ny = y;
	103	if (dx !== 0) {
	104	const test = nx + dx;
	105	if (!blockedCircle(test, ny, r)) nx = test;
	106	else {
	107	const col = Math.floor(test / TILE);
	108	nx = dx > 0 ? col * TILE - r - 0.01 : (col + 1) * TILE + r + 0.01;
	109	if (blockedCircle(nx, ny, r)) nx = x;
	110	}
	111	}
	112	if (dy !== 0) {
	113	const test = ny + dy;
	114	if (!blockedCircle(nx, test, r)) ny = test;
	115	else {
	116	const row = Math.floor(test / TILE);
	117	ny = dy > 0 ? row * TILE - r - 0.01 : (row + 1) * TILE + r + 0.01;
	118	if (blockedCircle(nx, ny, r)) ny = y;
	119	}
	120	}
	121	return { x: nx, y: ny };
	122	}
	123
	124	/** True when a circle at (x,y) overlaps any solid tile. */
	125	export function blockedCircle(x: number, y: number, r: number): boolean {
	126	const c0 = Math.floor((x - r) / TILE);
	127	const c1 = Math.floor((x + r) / TILE);
	128	const r0 = Math.floor((y - r) / TILE);
	129	const r1 = Math.floor((y + r) / TILE);
	130	for (let row = r0; row <= r1; row++)
	131	for (let col = c0; col <= c1; col++) {
	132	if (!solidTile(col, row)) continue;
	133	const nearX = Math.max(col * TILE, Math.min(x, col * TILE + TILE));
	134	const nearY = Math.max(row * TILE, Math.min(y, row * TILE + TILE));
	135	const dx = x - nearX;
	136	const dy = y - nearY;
	137	if (dx * dx + dy * dy < r * r) return true;
	138	}
	139	return false;
	140	}
	141
	142	/**
	143	* Does a wall stand between two points? Sampled every third of a tile: a
	144	* wall is a whole tile thick, so nothing is ever stepped over.
	145	*/
	146	export function wallBetween(a: Point, b: Point): boolean {
	147	const dx = b.x - a.x;
	148	const dy = b.y - a.y;
	149	const dist = Math.hypot(dx, dy);
	150	const steps = Math.ceil(dist / (TILE / 3));
	151	for (let i = 1; i < steps; i++) {
	152	const t = i / steps;
	153	if (solidAt(a.x + dx * t, a.y + dy * t)) return true;
	154	}
	155	return false;
	156	}
	157
	158	/** Where a shot stops: the first wall along the ray, or its full range. */
	159	export function rayHitWall(from: Point, angle: number, range: number): Point {
	160	const dx = Math.cos(angle);
	161	const dy = Math.sin(angle);
	162	const step = TILE / 4;
	163	for (let d = step; d <= range; d += step) {
	164	const x = from.x + dx * d;
	165	const y = from.y + dy * d;
	166	if (solidAt(x, y)) return { x: from.x + dx * (d - step), y: from.y + dy * (d - step) };
	167	}
	168	return { x: from.x + dx * range, y: from.y + dy * range };
	169	}
	170
	171	/** Closest approach of a segment to a point, as distance and travel along it. */
	172	export function segmentPoint(a: Point, b: Point, p: Point): { dist: number; travel: number } {
	173	const dx = b.x - a.x;
	174	const dy = b.y - a.y;
	175	const len2 = dx * dx + dy * dy;
	176	const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2));
	177	const cx = a.x + dx * t;
	178	const cy = a.y + dy * t;
	179	return { dist: Math.hypot(p.x - cx, p.y - cy), travel: t * Math.sqrt(len2) };
	180	}
	181
	182	export const segmentHitsCircle = (a: Point, b: Point, c: Point, r: number): boolean =>
	183	segmentPoint(a, b, c).dist <= r;
	184
	185	// Walk distance from a goal tile, breadth-first over floor. Bots ask for it
	186	// every few ticks; the field for a goal is built once and kept for the round.
	187	const fields = new Map<number, Int32Array>();
	188
	189	export const clearPaths = (): void => void fields.clear();
	190
	191	function field(goalCol: number, goalRow: number): Int32Array {
	192	const key = goalRow * COLS + goalCol;
	193	const cached = fields.get(key);
	194	if (cached) return cached;
	195	const dist = new Int32Array(COLS * ROWS).fill(-1);
	196	if (!solidTile(goalCol, goalRow)) {
	197	dist[key] = 0;
	198	const queue: number[] = [key];
	199	for (let head = 0; head < queue.length; head++) {
	200	const here = queue[head]!;
	201	const col = here % COLS;
	202	const row = (here - col) / COLS;
	203	const d = dist[here]!;
	204	for (const [dc, dr] of [
	205	[1, 0],
	206	[-1, 0],
	207	[0, 1],
	208	[0, -1],
	209	] as const) {
	210	const nc = col + dc;
	211	const nr = row + dr;
	212	if (nc < 0 \|\| nc >= COLS \|\| nr < 0 \|\| nr >= ROWS) continue;
	213	const nk = nr * COLS + nc;
	214	if (dist[nk] !== -1 \|\| solidTile(nc, nr)) continue;
	215	dist[nk] = d + 1;
	216	queue.push(nk);
	217	}
	218	}
	219	}
	220	if (fields.size > 64) fields.clear();
	221	fields.set(key, dist);
	222	return dist;
	223	}
	224
	225	/** Walk distance in tiles between two points, or -1 when unreachable. */
	226	export function walkDistance(from: Point, to: Point): number {
	227	const f = tileOf(from.x, from.y);
	228	const g = tileOf(to.x, to.y);
	229	return field(g.col, g.row)[f.row * COLS + f.col] ?? -1;
	230	}
	231
	232	/**
	233	* The next point to walk toward on the way to a goal: the centre of the
	234	* neighbouring tile that is one step closer, so bots round corners instead
	235	* of grinding into them.
	236	*/
	237	export function pathStep(from: Point, to: Point): Point {
	238	const f = tileOf(from.x, from.y);
	239	const g = tileOf(to.x, to.y);
	240	if (f.col === g.col && f.row === g.row) return to;
	241	const dist = field(g.col, g.row);
	242	const here = dist[f.row * COLS + f.col] ?? -1;
	243	if (here <= 0) return to;
	244	let best: Point \| null = null;
	245	let bestD = here;
	246	for (const [dc, dr] of [
	247	[1, 0],
	248	[-1, 0],
	249	[0, 1],
	250	[0, -1],
	251	] as const) {
	252	const nc = f.col + dc;
	253	const nr = f.row + dr;
	254	if (nc < 0 \|\| nc >= COLS \|\| nr < 0 \|\| nr >= ROWS) continue;
	255	const d = dist[nr * COLS + nc] ?? -1;
	256	if (d !== -1 && d < bestD) {
	257	bestD = d;
	258	best = centreOf(nc, nr);
	259	}
	260	}
	261	// Straight to the goal when nothing stands in the way — smoother than
	262	// walking tile centre to tile centre down an open corridor.
	263	if (best && !wallBetween(from, to) && (walkDistance(from, to) ?? 99) < 6) return to;
	264	return best ?? to;
	265	}
		@@ -0,0 +1,373 @@
	1	import { expect, test } from "bun:test";
	2	import { runBots } from "./bots.ts";
	3	import {
	4	aliveOn,
	5	buyAbility,
	6	buyShield,
	7	buyWeapon,
	8	DEFUSE_CHECKPOINT,
	9	DEFUSE_TIME,
	10	FUSE_TIME,
	11	newMatch,
	12	PLANT_TIME,
	13	ROUND_TIME,
	14	SWAP_AFTER,
	15	tick,
	16	visible,
	17	WIN_ROUNDS,
	18	} from "./match.ts";
	19	import { siteCentre, spawnCells, wallBetween } from "./map.ts";
	20	import type { MatchState, Player } from "./state.ts";
	21
	22	const live = (seed = 5): MatchState => {
	23	const state = newMatch(seed);
	24	state.phase = "live";
	25	state.clock = ROUND_TIME;
	26	return state;
	27	};
	28	const atk = (state: MatchState): Player[] => state.players.filter((p) => p.side === "atk");
	29	const def = (state: MatchState): Player[] => state.players.filter((p) => p.side === "def");
	30	const run = (state: MatchState, seconds: number): void => {
	31	for (let i = 0; i < Math.round(seconds * 30); i++) tick(state, 1 / 30);
	32	};
	33
	34	/** Put a carrier on a site with the spike, everyone else out of the way. */
	35	function onSite(state: MatchState): Player {
	36	const spot = siteCentre("A");
	37	const carrier = atk(state)[0]!;
	38	for (const player of state.players) {
	39	player.spike = false;
	40	player.x = 1200;
	41	player.y = 1320;
	42	}
	43	carrier.spike = true;
	44	carrier.x = spot.x;
	45	carrier.y = spot.y;
	46	state.spike = { carried: carrier.id, x: spot.x, y: spot.y, planted: false, fuse: 0, site: null, defuse: 0, checkpoint: 0 };
	47	return carrier;
	48	}
	49
	50	test("a match starts in the buy phase with ten seats and a spike carrier", () => {
	51	const state = newMatch(1);
	52	expect(state.players.length).toBe(10);
	53	expect(atk(state).length).toBe(5);
	54	expect(def(state).length).toBe(5);
	55	expect(state.phase).toBe("buy");
	56	expect(state.players.some((p) => p.spike)).toBe(true);
	57	expect(state.players.every((p) => p.credits === 800)).toBe(true);
	58	});
	59
	60	test("planting takes four seconds of standing on a site and arms the fuse", () => {
	61	const state = live();
	62	const carrier = onSite(state);
	63	carrier.input.use = true;
	64	run(state, PLANT_TIME - 1);
	65	expect(state.spike.planted).toBe(false);
	66	run(state, 1.2);
	67	expect(state.spike.planted).toBe(true);
	68	expect(state.spike.site).toBe("A");
	69	expect(Math.round(state.spike.fuse)).toBeLessThanOrEqual(FUSE_TIME);
	70	// The plant pays the attacking team and charges the planter's ult.
	71	expect(atk(state).every((p) => p.credits >= 800 + 300)).toBe(true);
	72	expect(carrier.ult).toBeGreaterThan(0);
	73	});
	74
	75	test("a plant off a site does nothing at all", () => {
	76	const state = live();
	77	const carrier = onSite(state);
	78	carrier.x = 1200;
	79	carrier.y = 1320; // attacker spawn, not a site
	80	carrier.input.use = true;
	81	run(state, PLANT_TIME + 2);
	82	expect(state.spike.planted).toBe(false);
	83	});
	84
	85	test("a defuse killed at the half way mark leaves the checkpoint for the next defender", () => {
	86	const state = live();
	87	const carrier = onSite(state);
	88	carrier.input.use = true;
	89	run(state, PLANT_TIME + 0.2);
	90	expect(state.spike.planted).toBe(true);
	91	carrier.input.use = false;
	92
	93	const first = def(state)[0]!;
	94	first.x = state.spike.x;
	95	first.y = state.spike.y;
	96	first.input.use = true;
	97	run(state, DEFUSE_CHECKPOINT + 0.2);
	98	expect(state.spike.checkpoint).toBe(DEFUSE_CHECKPOINT);
	99	expect(state.spike.defuse).toBeGreaterThanOrEqual(DEFUSE_CHECKPOINT);
	100
	101	// He dies here. The defuse falls back to the checkpoint, not to zero.
	102	first.hp = 1;
	103	first.alive = false;
	104	first.deaths += 1;
	105	state.spike.defuse = state.spike.checkpoint;
	106	expect(state.spike.defuse).toBe(DEFUSE_CHECKPOINT);
	107
	108	const second = def(state)[1]!;
	109	second.x = state.spike.x;
	110	second.y = state.spike.y;
	111	second.input.use = true;
	112	// Half a defuse is left, so well under the full seven seconds finishes it.
	113	run(state, DEFUSE_TIME - DEFUSE_CHECKPOINT + 0.3);
	114	expect(state.phase).toBe("end");
	115	expect(state.events.some((e) => e.text.includes("defused"))).toBe(true);
	116	});
	117
	118	test("an interrupted defuse before the checkpoint starts again from nothing", () => {
	119	const state = live();
	120	const carrier = onSite(state);
	121	carrier.input.use = true;
	122	run(state, PLANT_TIME + 0.2);
	123	carrier.input.use = false;
	124	const defender = def(state)[0]!;
	125	defender.x = state.spike.x;
	126	defender.y = state.spike.y;
	127	defender.input.use = true;
	128	run(state, 2);
	129	expect(state.spike.defuse).toBeGreaterThan(1.5);
	130	defender.input.use = false;
	131	run(state, 0.2);
	132	expect(state.spike.defuse).toBe(0);
	133	expect(state.spike.checkpoint).toBe(0);
	134	});
	135
	136	test("the spike detonating wins the round for the attackers", () => {
	137	const state = live();
	138	const carrier = onSite(state);
	139	carrier.input.use = true;
	140	run(state, PLANT_TIME + 0.2);
	141	carrier.input.use = false;
	142	state.spike.fuse = 1;
	143	run(state, 1.5);
	144	expect(state.phase).toBe("end");
	145	expect(state.score[state.attackers]).toBe(1);
	146	});
	147
	148	test("time running out with no plant is a defence win, but the clock stops mattering once it is down", () => {
	149	const timeout = live();
	150	timeout.clock = 0.5;
	151	run(timeout, 1);
	152	expect(timeout.phase).toBe("end");
	153	expect(timeout.score[timeout.attackers]).toBe(0);
	154
	155	const planted = live();
	156	const carrier = onSite(planted);
	157	carrier.input.use = true;
	158	run(planted, PLANT_TIME + 0.2);
	159	carrier.input.use = false;
	160	planted.clock = 0.2;
	161	run(planted, 1);
	162	expect(planted.phase).toBe("live");
	163	});
	164
	165	test("eliminating a team ends the round, and a planted spike still wins it", () => {
	166	const wipe = live();
	167	for (const player of def(wipe)) player.alive = false;
	168	run(wipe, 0.1);
	169	expect(wipe.phase).toBe("end");
	170	expect(wipe.score[wipe.attackers]).toBe(1);
	171
	172	const traded = live();
	173	const carrier = onSite(traded);
	174	carrier.input.use = true;
	175	run(traded, PLANT_TIME + 0.2);
	176	for (const player of atk(traded)) player.alive = false;
	177	run(traded, 0.1);
	178	// Everyone is dead but the spike is armed: the round is not over yet.
	179	expect(traded.phase).toBe("live");
	180	});
	181
	182	test("a buy is refused server-side when the credits are not there", () => {
	183	const state = newMatch(2);
	184	const player = state.players[0]!;
	185	player.agent = "ember";
	186	player.credits = 800;
	187	expect(buyWeapon(state, player, "vandal")).toBe(false);
	188	expect(player.weapon).toBe("classic");
	189	expect(buyWeapon(state, player, "ghost")).toBe(true);
	190	expect(player.credits).toBe(300);
	191	expect(buyShield(state, player, "heavy")).toBe(false);
	192	// 250 for the flash leaves fifty, and fifty buys nothing.
	193	expect(buyAbility(state, player, "c")).toBe(true);
	194	expect(player.credits).toBe(50);
	195	expect(buyAbility(state, player, "c")).toBe(false);
	196	expect(buyAbility(state, player, "q")).toBe(false);
	197	// And nothing is for sale once the round is live.
	198	player.credits = 9000;
	199	state.phase = "live";
	200	expect(buyWeapon(state, player, "vandal")).toBe(false);
	201	});
	202
	203	test("a basic is bought by the charge and never past its limit", () => {
	204	const state = newMatch(2);
	205	const player = state.players.find((p) => p.agent === "veil")!;
	206	player.credits = 9000;
	207	expect(buyAbility(state, player, "c")).toBe(true);
	208	expect(buyAbility(state, player, "c")).toBe(true);
	209	expect(player.charges.c).toBe(2);
	210	expect(buyAbility(state, player, "c")).toBe(false);
	211	expect(buyAbility(state, player, "e")).toBe(false);
	212	expect(buyAbility(state, player, "x")).toBe(false);
	213	});
	214
	215	test("sides swap after twelve rounds and a thirteenth round wins the match", () => {
	216	const state = newMatch(4);
	217	const started = state.attackers;
	218	state.round = SWAP_AFTER;
	219	state.phase = "live";
	220	state.score[started] = WIN_ROUNDS - 2;
	221	for (const player of def(state)) player.alive = false;
	222	run(state, 0.1);
	223	expect(state.phase).toBe("end");
	224	run(state, 6);
	225	expect(state.round).toBe(SWAP_AFTER + 1);
	226	expect(state.attackers).not.toBe(started);
	227	// One more round, taken by whoever now attacks the old defenders' side.
	228	const winners = state.attackers === started ? started : state.attackers;
	229	state.phase = "live";
	230	state.score[started] = WIN_ROUNDS - 1;
	231	for (const player of state.players) if (player.team !== started) player.alive = false;
	232	run(state, 0.1);
	233	expect(state.score[started]).toBe(WIN_ROUNDS);
	234	expect(state.phase).toBe("over");
	235	expect(state.result).toContain(`${started} win`);
	236	expect(winners.length).toBeGreaterThan(0);
	237	});
	238
	239	test("an ended match never parks: it shows the result and starts a fresh one", () => {
	240	const state = newMatch(6);
	241	state.phase = "live";
	242	state.score[state.attackers] = WIN_ROUNDS - 1;
	243	for (const player of def(state)) player.alive = false;
	244	run(state, 0.1);
	245	expect(state.phase).toBe("over");
	246	expect(state.result).not.toBe(null);
	247	run(state, 13);
	248	expect(state.phase).toBe("buy");
	249	expect(state.round).toBe(1);
	250	expect(state.score).toEqual({ red: 0, blue: 0 });
	251	expect(state.result).toBe(null);
	252	expect(state.players.length).toBe(10);
	253	});
	254
	255	test("line of sight is the server's answer: a smoke hides an enemy in the open", () => {
	256	const state = live();
	257	const viewer = atk(state)[0]!;
	258	const enemy = def(state)[0]!;
	259	viewer.x = 1200;
	260	viewer.y = 1320;
	261	enemy.x = 1200;
	262	enemy.y = 1000;
	263	expect(visible(state, viewer, enemy)).toBe(true);
	264	state.zones.push({
	265	id: 99, kind: "smoke", owner: "x", side: "def", x: 1200, y: 1160, r: 150,
	266	life: 8, fuse: 0, beat: 0, pulses: 0, damage: 0, blocks: true, solid: false,
	267	});
	268	expect(visible(state, viewer, enemy)).toBe(false);
	269	// A revealed enemy is seen through anything; so is a team mate.
	270	enemy.revealed = 2;
	271	expect(visible(state, viewer, enemy)).toBe(true);
	272	});
	273
	274	test("a wall hides two players from each other, and open floor does not", () => {
	275	const state = live();
	276	const viewer = atk(state)[0]!;
	277	const enemy = def(state)[0]!;
	278	viewer.blind = 0;
	279	enemy.revealed = 0;
	280	// Either side of the block between A site and the middle of the map.
	281	viewer.x = 400;
	282	viewer.y = 400;
	283	enemy.x = 1200;
	284	enemy.y = 400;
	285	expect(wallBetween(viewer, enemy)).toBe(true);
	286	expect(visible(state, viewer, enemy)).toBe(false);
	287	// The same two down the open back corridor, with nothing in between.
	288	viewer.x = 400;
	289	viewer.y = 1400;
	290	enemy.x = 1000;
	291	enemy.y = 1400;
	292	expect(wallBetween(viewer, enemy)).toBe(false);
	293	expect(visible(state, viewer, enemy)).toBe(true);
	294	});
	295
	296	test("no spawn can see a spawn: mid is staggered, not a corridor", () => {
	297	for (const from of spawnCells("atk"))
	298	for (const to of spawnCells("def")) expect(wallBetween(from, to)).toBe(true);
	299	});
	300
	301	test("a dead player watches through the team, never through walls", () => {
	302	const state = live();
	303	const viewer = atk(state)[0]!;
	304	const mate = atk(state)[1]!;
	305	const enemy = def(state)[0]!;
	306	for (const player of atk(state)) {
	307	player.alive = false;
	308	player.x = 400;
	309	player.y = 400;
	310	}
	311	enemy.revealed = 0;
	312	enemy.x = 1000;
	313	enemy.y = 1400;
	314	// Every attacker is dead: the enemy across the map is nobody's to see.
	315	expect(visible(state, viewer, enemy)).toBe(false);
	316	// One team mate alive with a sight line, and the dead player sees it too.
	317	mate.alive = true;
	318	mate.x = 400;
	319	mate.y = 1400;
	320	expect(visible(state, viewer, enemy)).toBe(true);
	321	// That team mate behind a wall takes the vision away again.
	322	mate.x = 400;
	323	mate.y = 400;
	324	expect(visible(state, viewer, enemy)).toBe(false);
	325	});
	326
	327	test("a blinded player sees nothing", () => {
	328	const state = live();
	329	const viewer = atk(state)[0]!;
	330	const enemy = def(state)[0]!;
	331	viewer.x = 1200;
	332	viewer.y = 1320;
	333	enemy.x = 1200;
	334	enemy.y = 1000;
	335	viewer.blind = 1.4;
	336	expect(visible(state, viewer, enemy)).toBe(false);
	337	});
	338
	339	test("a killed carrier drops the spike where they fell", () => {
	340	const state = live();
	341	const carrier = onSite(state);
	342	const killer = def(state)[0]!;
	343	killer.x = carrier.x + 40;
	344	killer.y = carrier.y;
	345	killer.angle = Math.PI;
	346	killer.weapon = "operator";
	347	killer.input.fire = true;
	348	run(state, 1);
	349	if (!carrier.alive) {
	350	expect(state.spike.carried).toBe(null);
	351	expect(Math.hypot(state.spike.x - carrier.x, state.spike.y - carrier.y)).toBeLessThan(80);
	352	}
	353	expect(state.shots.length + state.events.length).toBeGreaterThan(0);
	354	});
	355
	356	test("bots play the round: they buy, they take a site and they use their kit", () => {
	357	const state = newMatch(42);
	358	let casts = 0;
	359	let rounds = 0;
	360	for (let i = 0; i < 30 * 60 * 6; i++) {
	361	runBots(state, 1 / 30);
	362	tick(state, 1 / 30);
	363	casts += state.zones.length > 0 ? 1 : 0;
	364	if (state.round > rounds) rounds = state.round;
	365	}
	366	expect(rounds).toBeGreaterThan(1);
	367	expect(state.score.red + state.score.blue).toBeGreaterThan(1);
	368	// Something was on the map: smokes, flashes, mollies, walls.
	369	expect(casts).toBeGreaterThan(100);
	370	// And somebody bought a real gun with the credits they won.
	371	expect(state.players.some((p) => p.weapon !== "classic")).toBe(true);
	372	expect(aliveOn(state, "atk").length + aliveOn(state, "def").length).toBeGreaterThan(0);
	373	});