30150dd
@@ -0,0 +1,141 @@
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";
  player.x = 1200;
  player.y = 1320;
  player.angle = -Math.PI / 2;
  const behind = { x: 1200, y: 1320 - 600 };
  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,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,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,320 @@
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 } 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 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,646 @@
/**
 * 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;
  if (!viewer.alive) return true; // a dead player watches the round out
  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,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;
};
@@ -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,141 @@
	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	player.x = 1200;
	123	player.y = 1320;
	124	player.angle = -Math.PI / 2;
	125	const behind = { x: 1200, y: 1320 - 600 };
	126	const openBefore = !sightBlocked(player, behind, state.zones);
	127	expect(cast(state, player, "e")).toBe(true);
	128	expect(openBefore).toBe(true);
	129	expect(sightBlocked(player, behind, state.zones)).toBe(true);
	130	expect(state.zones.every((z) => z.solid)).toBe(true);
	131	});
	132
	133	test("a round starts with the signature ready and no bought charges", () => {
	134	const state = newMatch(3);
	135	startRound(state, true);
	136	for (const player of state.players) {
	137	expect(player.charges.c).toBe(0);
	138	expect(player.charges.q).toBe(0);
	139	expect(player.charges.e).toBe(1);
	140	}
	141	});
		@@ -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,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,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,320 @@
	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 } 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 blinded player sees nothing", () => {
	275	const state = live();
	276	const viewer = atk(state)[0]!;
	277	const enemy = def(state)[0]!;
	278	viewer.x = 1200;
	279	viewer.y = 1320;
	280	enemy.x = 1200;
	281	enemy.y = 1000;
	282	viewer.blind = 1.4;
	283	expect(visible(state, viewer, enemy)).toBe(false);
	284	});
	285
	286	test("a killed carrier drops the spike where they fell", () => {
	287	const state = live();
	288	const carrier = onSite(state);
	289	const killer = def(state)[0]!;
	290	killer.x = carrier.x + 40;
	291	killer.y = carrier.y;
	292	killer.angle = Math.PI;
	293	killer.weapon = "operator";
	294	killer.input.fire = true;
	295	run(state, 1);
	296	if (!carrier.alive) {
	297	expect(state.spike.carried).toBe(null);
	298	expect(Math.hypot(state.spike.x - carrier.x, state.spike.y - carrier.y)).toBeLessThan(80);
	299	}
	300	expect(state.shots.length + state.events.length).toBeGreaterThan(0);
	301	});
	302
	303	test("bots play the round: they buy, they take a site and they use their kit", () => {
	304	const state = newMatch(42);
	305	let casts = 0;
	306	let rounds = 0;
	307	for (let i = 0; i < 30 * 60 * 6; i++) {
	308	runBots(state, 1 / 30);
	309	tick(state, 1 / 30);
	310	casts += state.zones.length > 0 ? 1 : 0;
	311	if (state.round > rounds) rounds = state.round;
	312	}
	313	expect(rounds).toBeGreaterThan(1);
	314	expect(state.score.red + state.score.blue).toBeGreaterThan(1);
	315	// Something was on the map: smokes, flashes, mollies, walls.
	316	expect(casts).toBeGreaterThan(100);
	317	// And somebody bought a real gun with the credits they won.
	318	expect(state.players.some((p) => p.weapon !== "classic")).toBe(true);
	319	expect(aliveOn(state, "atk").length + aliveOn(state, "def").length).toBeGreaterThan(0);
	320	});
		@@ -0,0 +1,124 @@
	1	/**
	2	* The shape of a match. Types only, so the ability module and the match loop
	3	* can both speak about a player without importing each other.
	4	*/
	5
	6	import type { Point, Site } from "./map.ts";
	7	import type { WeaponId } from "./weapons.ts";
	8
	9	export type Side = "atk" \| "def";
	10	export type Slot = "c" \| "q" \| "e" \| "x";
	11	export type Team = "red" \| "blue";
	12
	13	export type Phase = "buy" \| "live" \| "end" \| "over";
	14
	15	export type ZoneKind = "smoke" \| "molly" \| "wall" \| "trip" \| "dart" \| "flash" \| "heal";
	16
	17	/** Anything an ability leaves on the map, with a clock on it. */
	18	export type Zone = {
	19	id: number;
	20	kind: ZoneKind;
	21	owner: string;
	22	side: Side;
	23	x: number;
	24	y: number;
	25	r: number;
	26	/** Seconds of life left. */
	27	life: number;
	28	/** Seconds before it goes off (a flash in the air, a trip arming). */
	29	fuse: number;
	30	/** Seconds to the next damage tick or recon pulse. */
	31	beat: number;
	32	pulses: number;
	33	damage: number;
	34	/** Blocks line of sight (smoke, wall). */
	35	blocks: boolean;
	36	/** Blocks movement (wall). */
	37	solid: boolean;
	38	};
	39
	40	export type Input = {
	41	mx: number;
	42	my: number;
	43	angle: number;
	44	fire: boolean;
	45	/** Plant, defuse, pick the spike up: one key for all of it. */
	46	use: boolean;
	47	reload: boolean;
	48	cast: Slot \| null;
	49	};
	50
	51	export const emptyInput = (): Input => ({
	52	mx: 0,
	53	my: 0,
	54	angle: 0,
	55	fire: false,
	56	use: false,
	57	reload: false,
	58	cast: null,
	59	});
	60
	61	export type Player = {
	62	id: string;
	63	name: string;
	64	bot: boolean;
	65	agent: string;
	66	team: Team;
	67	side: Side;
	68	x: number;
	69	y: number;
	70	angle: number;
	71	hp: number;
	72	armour: number;
	73	alive: boolean;
	74	credits: number;
	75	weapon: WeaponId;
	76	/** Kept through a round they survived, reset to the Classic when they die. */
	77	ammo: number;
	78	reloadIn: number;
	79	fireIn: number;
	80	/** Basic charges bought this round, and signature/ult readiness. */
	81	charges: Record<Slot, number>;
	82	cooldown: Record<Slot, number>;
	83	ult: number;
	84	blind: number;
	85	slow: number;
	86	haste: number;
	87	/** Seconds this player stays visible to the other team however dark it is. */
	88	revealed: number;
	89	spike: boolean;
	90	planting: number;
	91	defusing: number;
	92	kills: number;
	93	deaths: number;
	94	assists: number;
	95	damageDone: number;
	96	input: Input;
	97	/** Bot scratch space: where it is walking and when it last thought. */
	98	goal: Point \| null;
	99	think: number;
	100	spray: number;
	101	joinedAt: number;
	102	};
	103
	104	export type MatchState = {
	105	id: string;
	106	phase: Phase;
	107	/** Seconds left in the phase. */
	108	clock: number;
	109	round: number;
	110	score: Record<Team, number>;
	111	/** Which team attacks this round. */
	112	attackers: Team;
	113	lossStreak: Record<Team, number>;
	114	players: Player[];
	115	zones: Zone[];
	116	nextZone: number;
	117	spike: { carried: string \| null; x: number; y: number; planted: boolean; fuse: number; site: Site \| null; defuse: number; checkpoint: number };
	118	orbs: { x: number; y: number; taken: boolean }[];
	119	shots: { x1: number; y1: number; x2: number; y2: number; hit: boolean; age: number }[];
	120	events: { text: string; age: number }[];
	121	result: string \| null;
	122	seed: number;
	123	now: number;
	124	};
		@@ -0,0 +1,53 @@
	1	import { expect, test } from "bun:test";
	2	import { applyDamage, damage, isLethal, shotSpread, WEAPONS, zoneFromMiss } from "./weapons.ts";
	3
	4	test("a Vandal head shot kills through full armour at any range, a Phantom's does not", () => {
	5	for (const distance of [100, 800, 2000]) expect(isLethal(100, 50, damage("vandal", "head", distance))).toBe(true);
	6	// The Phantom only manages it inside fifteen metres; past that the falloff
	7	// leaves the target alive, which is the whole argument between the two guns.
	8	expect(isLethal(100, 50, damage("phantom", "head", 300))).toBe(true);
	9	expect(isLethal(100, 50, damage("phantom", "head", 900))).toBe(false);
	10	expect(isLethal(100, 50, damage("phantom", "head", 2000))).toBe(false);
	11	// Both still one-tap a head with no armour on.
	12	expect(isLethal(100, 0, damage("phantom", "head", 2000))).toBe(true);
	13	});
	14
	15	test("the Phantom falls off with range and the Vandal does not", () => {
	16	expect(damage("phantom", "body", 100)).toBe(39);
	17	expect(damage("phantom", "body", 1600)).toBe(31);
	18	expect(damage("vandal", "body", 100)).toBe(damage("vandal", "body", 2300));
	19	});
	20
	21	test("armour is absorbed point for point but empties first", () => {
	22	const hit = applyDamage(100, 50, 40);
	23	expect(hit.armour).toBe(50 - 27);
	24	expect(hit.hp).toBe(87);
	25	// A hundred health behind fifty armour is a hundred and fifty to chew through.
	26	let hp = 100;
	27	let armour = 50;
	28	let shots = 0;
	29	while (hp > 0) {
	30	({ hp, armour } = applyDamage(hp, armour, 40));
	31	shots++;
	32	}
	33	expect(shots).toBe(4);
	34	});
	35
	36	test("body shots never kill in one, whatever the gun, except the Operator", () => {
	37	expect(isLethal(100, 0, damage("operator", "body", 500))).toBe(true);
	38	for (const id of ["classic", "ghost", "sheriff", "spectre", "phantom", "vandal"] as const)
	39	expect(isLethal(100, 0, damage(id, "body", 500))).toBe(false);
	40	});
	41
	42	test("where the ray passes decides the hit location", () => {
	43	expect(zoneFromMiss(0, 16)).toBe("head");
	44	expect(zoneFromMiss(8, 16)).toBe("body");
	45	expect(zoneFromMiss(15, 16)).toBe("legs");
	46	});
	47
	48	test("running widens the cone and standing still does not", () => {
	49	expect(shotSpread("vandal", 0)).toBe(WEAPONS.vandal.spread);
	50	expect(shotSpread("vandal", 1)).toBeGreaterThan(shotSpread("vandal", 0));
	51	// The Operator is the accurate one and the Spectre is not.
	52	expect(shotSpread("operator", 0)).toBeLessThan(shotSpread("spectre", 0));
	53	});
		@@ -0,0 +1,194 @@
	1	/**
	2	* Guns: the damage table and what a shot does with it. Pure functions —
	3	* nothing here knows about a match.
	4	*
	5	* Distance is in world units; fifty units is a metre, so the map is about
	6	* forty-eight metres across and the Phantom's fifteen-metre falloff lands
	7	* where it should. The rule that matters: a Vandal head shot kills through
	8	* full armour at any range, a Phantom head shot does not.
	9	*/
	10
	11	export type WeaponId =
	12	\| "classic"
	13	\| "ghost"
	14	\| "sheriff"
	15	\| "spectre"
	16	\| "phantom"
	17	\| "vandal"
	18	\| "operator";
	19
	20	export type Zone = "head" \| "body" \| "legs";
	21
	22	export type Band = { upTo: number; head: number; body: number; legs: number };
	23
	24	export type Weapon = {
	25	id: WeaponId;
	26	name: string;
	27	cost: number;
	28	/** Shots a second. */
	29	rate: number;
	30	magazine: number;
	31	reload: number;
	32	/** Cone half-angle in radians when standing still, and the walking penalty. */
	33	spread: number;
	34	movePenalty: number;
	35	range: number;
	36	auto: boolean;
	37	bands: Band[];
	38	};
	39
	40	const METRE = 50;
	41
	42	export const WEAPONS: Record<WeaponId, Weapon> = {
	43	classic: {
	44	id: "classic",
	45	name: "Classic",
	46	cost: 0,
	47	rate: 6.75,
	48	magazine: 12,
	49	reload: 1.75,
	50	spread: 0.022,
	51	movePenalty: 0.05,
	52	range: 1600,
	53	auto: false,
	54	bands: [{ upTo: Infinity, head: 78, body: 26, legs: 22 }],
	55	},
	56	ghost: {
	57	id: "ghost",
	58	name: "Ghost",
	59	cost: 500,
	60	rate: 6.75,
	61	magazine: 15,
	62	reload: 1.5,
	63	spread: 0.016,
	64	movePenalty: 0.05,
	65	range: 1800,
	66	auto: false,
	67	bands: [
	68	{ upTo: 30 * METRE, head: 105, body: 30, legs: 26 },
	69	{ upTo: Infinity, head: 88, body: 25, legs: 21 },
	70	],
	71	},
	72	sheriff: {
	73	id: "sheriff",
	74	name: "Sheriff",
	75	cost: 800,
	76	rate: 4,
	77	magazine: 6,
	78	reload: 2.25,
	79	spread: 0.02,
	80	movePenalty: 0.09,
	81	range: 2000,
	82	auto: false,
	83	bands: [
	84	{ upTo: 30 * METRE, head: 159, body: 55, legs: 46 },
	85	{ upTo: Infinity, head: 145, body: 50, legs: 42 },
	86	],
	87	},
	88	spectre: {
	89	id: "spectre",
	90	name: "Spectre",
	91	cost: 1600,
	92	rate: 13.33,
	93	magazine: 30,
	94	reload: 2.5,
	95	spread: 0.03,
	96	movePenalty: 0.03,
	97	range: 1600,
	98	auto: true,
	99	bands: [
	100	{ upTo: 20 * METRE, head: 78, body: 26, legs: 22 },
	101	{ upTo: Infinity, head: 66, body: 22, legs: 18 },
	102	],
	103	},
	104	phantom: {
	105	id: "phantom",
	106	name: "Phantom",
	107	cost: 2900,
	108	rate: 11,
	109	magazine: 30,
	110	reload: 2.5,
	111	spread: 0.021,
	112	movePenalty: 0.06,
	113	range: 2400,
	114	auto: true,
	115	bands: [
	116	{ upTo: 15 * METRE, head: 156, body: 39, legs: 33 },
	117	{ upTo: 30 * METRE, head: 140, body: 35, legs: 29 },
	118	{ upTo: Infinity, head: 124, body: 31, legs: 26 },
	119	],
	120	},
	121	vandal: {
	122	id: "vandal",
	123	name: "Vandal",
	124	cost: 2900,
	125	rate: 9.75,
	126	magazine: 25,
	127	reload: 2.5,
	128	spread: 0.024,
	129	movePenalty: 0.07,
	130	range: 2400,
	131	auto: true,
	132	bands: [{ upTo: Infinity, head: 160, body: 40, legs: 34 }],
	133	},
	134	operator: {
	135	id: "operator",
	136	name: "Operator",
	137	cost: 4700,
	138	rate: 0.6,
	139	magazine: 5,
	140	reload: 3.7,
	141	spread: 0.004,
	142	movePenalty: 0.2,
	143	range: 2800,
	144	auto: false,
	145	bands: [{ upTo: Infinity, head: 255, body: 150, legs: 120 }],
	146	},
	147	};
	148
	149	export const weaponIds = (): WeaponId[] => Object.keys(WEAPONS) as WeaponId[];
	150
	151	export const isWeaponId = (value: unknown): value is WeaponId =>
	152	typeof value === "string" && value in WEAPONS;
	153
	154	/** Raw damage for a hit: the band the distance falls in, by zone. */
	155	export function damage(id: WeaponId, zone: Zone, distance: number): number {
	156	const weapon = WEAPONS[id];
	157	const band = weapon.bands.find((b) => distance <= b.upTo) ?? weapon.bands[weapon.bands.length - 1]!;
	158	return band[zone];
	159	}
	160
	161	/**
	162	* Armour absorbs point for point — a hundred health behind fifty armour is a
	163	* hundred and fifty to chew through — but it takes two thirds of each hit,
	164	* so it runs out before health does.
	165	*/
	166	export function applyDamage(
	167	hp: number,
	168	armour: number,
	169	amount: number,
	170	): { hp: number; armour: number } {
	171	const toArmour = Math.min(armour, Math.ceil(amount * (2 / 3)));
	172	return { hp: Math.max(0, hp - (amount - toArmour)), armour: armour - toArmour };
	173	}
	174
	175	/** True when this hit kills outright: the test the Vandal exists to pass. */
	176	export const isLethal = (hp: number, armour: number, amount: number): boolean =>
	177	applyDamage(hp, armour, amount).hp <= 0;
	178
	179	/**
	180	* Where a shot lands, from how close the ray passes the target's centre.
	181	* Top-down has no vertical, so precision stands in for it: dead centre is a
	182	* head shot, the outer edge is legs.
	183	*/
	184	export function zoneFromMiss(miss: number, radius: number): Zone {
	185	if (miss <= radius * 0.33) return "head";
	186	if (miss <= radius * 0.75) return "body";
	187	return "legs";
	188	}
	189
	190	/** Cone half-angle for a shot: standing still is accurate, running is not. */
	191	export const shotSpread = (id: WeaponId, speedFraction: number): number =>
	192	WEAPONS[id].spread + WEAPONS[id].movePenalty * Math.min(1, Math.max(0, speedFraction));
	193
	194	export const SHIELD = { light: { cost: 400, armour: 25 }, heavy: { cost: 1000, armour: 50 } };