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

/**

 * 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 { emptyTrack } from "./aim.ts";

import { BODY_R, moveSpeed, RUN } from "./glide.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";

// A body's size and its speed are shared with the browser, which predicts

// your own movement between snapshots: `src/glide.ts` is the one copy.

export const PLAYER_R = BODY_R;

export const RUN_SPEED = RUN;

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

];

/**

 * Twenty names, shuffled, dealt to the ten seats — drawn without replacement.

 *

 * A name is how a person is addressed: in the kill feed, in the round log, on

 * the scoreboard. Two bots called Kit make "Kit killed Kit", which reads as a

 * team kill that this game cannot even have. Picking each name independently

 * collided in most matches — a uniform pick over twenty names for ten seats

 * is a birthday problem, and no arithmetic spacing survives adding a uniform

 * term to it. Shuffling once and dealing cannot collide at all.

 */

export function dealNames(state: MatchState, count = TEAMS.length * ROSTER): string[] {

  const bag = BOT_NAMES.slice();

  for (let i = bag.length - 1; i > 0; i--) {

    const j = Math.floor(random(state) * (i + 1));

    const swap = bag[i]!;

    bag[i] = bag[j]!;

    bag[j] = swap;

  }

  return bag.slice(0, Math.min(count, bag.length));

}

/**

 * One seat. The name is dealt by the caller so a whole roster is drawn

 * without replacement; on its own it falls back to the seat's own slot,

 * which is distinct for every seat in a match too.

 */

export function makePlayer(

  state: MatchState,

  team: Team,

  index: number,

  name = BOT_NAMES[(TEAMS.indexOf(team) * ROSTER + index) % BOT_NAMES.length]!,

): Player {

  const agent = ["ember", "veil", "sable", "mender", "rook"][index % 5]!;

  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,

    aim: emptyTrack(),

    flashedAt: -99,

    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,

  };

  const names = dealNames(state);

  for (const team of TEAMS)

    for (let i = 0; i < ROSTER; i++)

      state.players.push(makePlayer(state, team, i, names[state.players.length]));

  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.aim = emptyTrack();

    // A new round is a new entry: the team's flash spacing starts clear.

    player.flashedAt = -99;

    // 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]++);

    // The keys are let go of, but the facing the spawn gave is kept as the

    // input's own: an empty input's angle is zero, and the next tick copies

    // the input's angle onto the player, so a round used to point everybody

    // at the site and then swing them east a tick later — a camera that

    // jumped twice in the first hundred milliseconds of every round.

    player.input = { ...emptyInput(), angle: player.angle };

  }

  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 {

  return moveSpeed({

    haste: player.haste > 0,

    slow: player.slow > 0,

    stopped: player.planting > 0 || player.defusing > 0,

    heavy: player.weapon === "operator",

  });

}

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 inside its radius with a sight line to it, blinded by

        // how far their back was turned and how close they stood. 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 blind = flashDuration(zone.damage, player, zone, player.angle, blocked, zone.r);

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