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

/**

 * 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, flashDuration, sightBlocked, type Ability } from "./abilities.ts";

import { acquire, aimCone, canFire, crossRate, drift, heldFor, lose } from "./engine/aim.ts";

import { pathStep, rayHitWall, siteAt, siteCentre, walkDistance, type Point, type Site } from "./map.ts";

import { buyAbility, buyShield, buyWeapon, random, RUN_SPEED, SPIKE_REACH, visible } from "./match.ts";

import type { MatchState, Player, Slot } from "./state.ts";

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

  }

  // A throw is made standing still, down the line it was decided on: the

  // aim below used to swing the barrel up to 13° the same tick, and a flash

  // decided for open floor went into the wall beside the thrower's head.

  if (bot.input.cast !== null) {

    bot.input.mx = 0;

    bot.input.my = 0;

    bot.input.fire = false;

    return;

  }

  // --- 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) {

    lose(bot.aim, state.now);

    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;

  }

  // A hold costs what a hold costs: a moment to notice, a barrel that starts

  // wrong and settles, and more of both when the target is crossing the view.

  const roll = () => random(state);

  acquire(bot.aim, target.id, state.now, target, roll);

  const crossing = crossRate(bot.aim, bot, target, dt) / RUN_SPEED;

  const cone = aimCone(heldFor(bot.aim, state.now), crossing);

  const range = Math.hypot(target.x - bot.x, target.y - bot.y);

  const aim = Math.atan2(target.y - bot.y, target.x - bot.x) + drift(bot.aim, cone, dt, roll);

  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 = canFire(bot.aim, state.now) && 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;

  }

}

/**

 * Seconds a team waits between flashes: two pops back to back is a strobe.

 * Before any of this, bots threw every charge the moment the round went

 * live — 6.5 flashes a round, 4.4% of live player-seconds spent blind, and

 * each flash blinding 0.2 throwers and 0.43 team mates against 0.23 enemies.

 * `src/bots.test.ts` keeps the numbers.

 */

export const FLASH_SPACING = 6;

/** Seconds one thrower waits between its own: two charges are an entry and an exit, not a pair. */

export const FLASH_REPEAT = 12;

/** Where this flash pops if thrown at that point: full range down the line, or the first wall. */

export const flashSpot = (bot: Point, ability: Ability, point: Point): Point =>

  rayHitWall(bot, Math.atan2(point.y - bot.y, point.x - bot.x), ability.range);

/**

 * Whether a bot should throw this flash at this point right now. A flash is

 * for taking one angle, so it goes out only when it would do that and

 * nothing else: not so close that the thrower, or a team mate, could be

 * inside it by the time it pops — a fuse is long enough to run into one;

 * not while a team mate is looking at where it will pop; not inside a few

 * seconds of the team's last; and, thrown at an enemy, only when the pop

 * would blind them as they stand — a flash that flies past somebody facing

 * you pops behind their head, and does nothing but light up your own side.

 */

export function flashCall(state: MatchState, bot: Player, ability: Ability, point: Point, target: Player | null): boolean {

  const spot = flashSpot(bot, ability, point);

  const stride = RUN_SPEED * 1.35 * ability.fuse;

  const reach = ability.radius + stride;

  if (Math.hypot(spot.x - bot.x, spot.y - bot.y) <= reach) return false;

  if (target && flashDuration(1, target, spot, target.angle, sightBlocked(spot, target, state.zones), ability.radius) <= 0) return false;

  for (const mate of state.players) {

    if (mate.side !== bot.side) continue;

    if (state.now - mate.flashedAt < (mate.id === bot.id ? FLASH_REPEAT : FLASH_SPACING)) return false;

    if (!mate.alive || mate.id === bot.id) continue;

    const gap = Math.hypot(spot.x - mate.x, spot.y - mate.y);

    if (gap <= stride || flashDuration(1, mate, spot, mate.angle, sightBlocked(spot, mate, state.zones), reach) > 0) return false;

  }

  return true;

}

/** 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") {

      // A flash is for taking a site: on the way in for the attack, on the

      // way back to the spike for the retake. Not for every duel on the way.

      // It goes at an enemy in view, or short of the site so the pop sits

      // between the team and whoever holds it; and only when it would take

      // that one angle and blind nobody else (`flashCall`).

      const taking = bot.side === "atk" ? !spike.planted : spike.planted;

      const near = distToGoal < ability.range + ability.radius * 0.8;

      const short = distToGoal > ability.range;

      const at = taking && near ? target ?? (short ? centre : null) : null;

      if (at && flashCall(state, bot, ability, at, target)) {

        bot.flashedAt = state.now;

        return void tryCast(slot, at);

      }

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

}