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

/**

 * The bots' flashes, measured.

 *

 * A flash used to reach 900 units — 70% of the map — and a bot threw every

 * charge the moment it was bought, so in a bot round somebody was blind

 * most of the time. The numbers below are the bug and the fix: a headless

 * match, the share of live player-seconds spent blind, and how many flashes

 * go off a round. Before this file: 4.4% blind, 6.5 flashes a round, and a

 * flash blinded 0.86 players on average — 0.20 of them the thrower, 0.43 a

 * team mate, 0.23 an enemy.

 */

import { expect, test } from "bun:test";

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

import { attackSite, FLASH_REPEAT, FLASH_SPACING, flashCall, flashSpot, runBots } from "./bots.ts";

import { siteCentre } from "./map.ts";

import { newMatch, ROUND_TIME, tick } from "./match.ts";

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

const flashZones = (state: MatchState): Set<number> =>

  new Set(state.zones.filter((z) => z.kind === "flash").map((z) => z.id));

/** Held where it stands: a plant in progress is the one thing that sets a body's speed to zero. */

const pin = (p: Player): void => {

  p.planting = 1;

};

/**

 * One live round in the side corridor of the site the attack is going to:

 * an Ember bot with two flashes at the bottom of it, 860 from the site — an

 * entry, as far as its kit is concerned — and an enemy standing still at

 * the top facing down it, 800 away, so a 620 throw pops 180 in front of

 * the enemy's face. Everybody else is parked on the far site, not looking.

 */

function corridor(): { state: MatchState; bot: Player; enemy: Player; mates: Player[]; x: number } {

  const state = newMatch(21);

  state.phase = "live";

  state.clock = ROUND_TIME;

  const site = attackSite(state);

  const x = site === "A" ? 120 : 2280;

  const far = siteCentre(site === "A" ? "B" : "A");

  const atk = state.players.filter((p) => p.side === "atk");

  const def = state.players.filter((p) => p.side === "def");

  for (const p of state.players) {

    p.bot = false;

    p.x = far.x;

    p.y = far.y;

    p.angle = Math.PI / 2;

    p.input.angle = p.angle;

    p.input.mx = 0;

    p.input.my = 0;

    p.spike = false;

  }

  state.spike.carried = null;

  state.spike.x = far.x;

  state.spike.y = far.y;

  const bot = atk[0]!;

  bot.bot = true;

  bot.agent = "ember";

  bot.charges = { c: 2, q: 0, e: 0, x: 0 };

  bot.x = x;

  bot.y = 1150;

  bot.angle = -Math.PI / 2;

  bot.input.angle = bot.angle;

  pin(bot);

  const enemy = def[0]!;

  enemy.x = x;

  enemy.y = 350;

  enemy.angle = Math.PI / 2;

  enemy.input.angle = Math.PI / 2;

  // A sandbag: the bot shoots at it too, and these tests are about the flash.

  enemy.hp = 1e6;

  return { state, bot, enemy, mates: atk.slice(1), x };

}

const play = (state: MatchState, seconds: number, seen?: Set<number>): void => {

  for (let i = 0; i < Math.round(seconds * 30); i++) {

    runBots(state, 1 / 30);

    tick(state, 1 / 30);

    if (seen) for (const id of flashZones(state)) seen.add(id);

  }

};

test("a bot throws one flash at the enemy in front of it, not both charges at once", () => {

  const { state, bot, enemy } = corridor();

  const seen = new Set<number>();

  play(state, 0.1, seen);

  expect(seen.size).toBe(1);

  // The one that went does its job: the enemy facing the thrower is blinded.

  play(state, 1.5, seen);

  expect(enemy.blind).toBeGreaterThan(0);

  // The second charge stays in hand for the repeat, however often it thinks.

  play(state, FLASH_REPEAT - 2, seen);

  expect(seen.size).toBe(1);

  expect(bot.charges.c).toBe(1);

  // And it is not lost: once the repeat has passed it goes.

  for (let i = 0; i < 3 * 30 && seen.size < 2; i++) play(state, 1 / 30, seen);

  expect(seen.size).toBe(2);

});

test("a team waits between flashes: one bot's throw holds a team mate's", () => {

  const { state, bot, mates, x } = corridor();

  const mate = mates[0]!;

  // A second thrower right beside the first, with two flashes of its own.

  mate.bot = true;

  mate.agent = "ember";

  mate.charges = { c: 2, q: 0, e: 0, x: 0 };

  mate.x = x;

  mate.y = 1190;

  mate.angle = -Math.PI / 2;

  mate.input.angle = mate.angle;

  pin(mate);

  play(state, FLASH_SPACING - 0.5);

  expect(4 - bot.charges.c - mate.charges.c).toBe(1);

  // Past the team's spacing the other thrower's own goes.

  play(state, 1.5);

  expect(4 - bot.charges.c - mate.charges.c).toBe(2);

  expect(bot.charges.c).toBe(1);

  expect(mate.charges.c).toBe(1);

});

test("a bot holds the flash while a team mate stands in it facing the pop", () => {

  const { state, bot, mates, enemy, x } = corridor();

  const mate = mates[0]!;

  mate.x = x;

  mate.y = 650;

  mate.angle = -Math.PI / 2;

  mate.input.angle = mate.angle;

  play(state, 2);

  expect(bot.charges.c).toBe(2);

  expect(flashZones(state).size).toBe(0);

  // The same team mate back beside the thrower, looking the other way, is

  // not in the flash's business: the throw goes, and lands on the enemy.

  mate.y = 1200;

  mate.angle = Math.PI / 2;

  mate.input.angle = mate.angle;

  play(state, 2);

  expect(bot.charges.c).toBe(1);

  expect(mate.blind).toBe(0);

  expect(enemy.blind).toBeGreaterThan(0);

});

test("a bot never throws a flash it could run into, or one that pops behind the enemy's head", () => {

  const { state, bot, enemy, x } = corridor();

  const ability = agentById("ember").abilities.c;

  // Into the wall right behind it: the pop would land inside its own radius.

  expect(flashCall(state, bot, ability, { x, y: 1440 }, null)).toBe(false);

  // Up the corridor at the enemy 800 out: the pop lands in front of it.

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

  expect(spot.y).toBeGreaterThan(enemy.y);

  expect(flashCall(state, bot, ability, enemy, enemy)).toBe(true);

  // An enemy 450 out facing the thrower: the throw flies 620 and pops behind

  // them, where they are not looking. Not thrown.

  enemy.y = 700;

  expect(flashCall(state, bot, ability, enemy, enemy)).toBe(false);

  // Turned around, that same pop is right in front of them. Thrown.

  enemy.angle = -Math.PI / 2;

  expect(flashCall(state, bot, ability, enemy, enemy)).toBe(true);

  enemy.angle = Math.PI / 2;

  enemy.input.angle = enemy.angle;

  play(state, 2);

  expect(bot.charges.c).toBe(2);

});

test("a flash is for taking a site, not for every duel on the way", () => {

  const { state, bot } = corridor();

  // The same bot and the same enemy, but far from the site it is attacking.

  bot.y = 1400;

  const enemyY = 600;

  const enemy = state.players.find((p) => p.side === "def" && p.y === 350)!;

  enemy.y = enemyY;

  play(state, 2);

  expect(bot.charges.c).toBe(2);

});

/** A headless match, and the numbers the issue is about. */

function measure(seeds: number[], minutes: number) {

  let liveSeconds = 0;

  let blindSeconds = 0;

  let anyBlindSeconds = 0;

  let flashes = 0;

  let rounds = 0;

  const hit = { self: 0, own: 0, enemy: 0 };

  for (const seed of seeds) {

    const state = newMatch(seed);

    const seen = new Set<number>();

    const before = new Map<string, number>();

    let round = 0;

    for (let i = 0; i < 30 * 60 * minutes && state.phase !== "over"; i++) {

      if (state.round !== round) {

        round = state.round;

        rounds++;

      }

      runBots(state, 1 / 30);

      const popping = state.phase === "live" ? state.zones.filter((z) => z.kind === "flash" && z.fuse > 0 && z.fuse - 1 / 30 <= 0) : [];

      for (const p of state.players) before.set(p.id, p.blind);

      tick(state, 1 / 30);

      for (const id of flashZones(state))

        if (!seen.has(id)) {

          seen.add(id);

          flashes++;

        }

      const pop = popping[0];

      if (pop)

        for (const p of state.players)

          if (p.blind > (before.get(p.id) ?? 0)) hit[pop.owner === p.id ? "self" : pop.side === p.side ? "own" : "enemy"]++;

      if (state.phase !== "live") continue;

      const alive = state.players.filter((p) => p.alive);

      liveSeconds += alive.length / 30;

      const blind = alive.filter((p) => p.blind > 0).length;

      blindSeconds += blind / 30;

      if (blind > 0) anyBlindSeconds += 1 / 30;

    }

  }

  const per = (n: number) => n / Math.max(1, flashes);

  return {

    rounds,

    flashesPerRound: flashes / rounds,

    blindShare: blindSeconds / liveSeconds,

    anyoneBlindShare: anyBlindSeconds / (liveSeconds / 10),

    perFlash: { self: per(hit.self), own: per(hit.own), enemy: per(hit.enemy) },

  };

}

test("a flash is a tool, not weather: the blind share of a bot match, measured", () => {

  const m = measure([1, 2, 3, 4], 10);

  const pct = (n: number) => `${(n * 100).toFixed(2)}%`;

  const f = (n: number) => n.toFixed(2);

  console.log(

    `flashes: ${m.rounds} rounds, ${f(m.flashesPerRound)} a round (was 6.48); blind ${pct(m.blindShare)} of live player-seconds (was 4.36%), ` +

      `somebody blind ${pct(m.anyoneBlindShare)} of live seconds (was 15.97%); a flash blinds ${f(m.perFlash.self)} self / ${f(m.perFlash.own)} own / ${f(m.perFlash.enemy)} enemy (was 0.20 / 0.43 / 0.23)`,

  );

  expect(m.rounds).toBeGreaterThan(20);

  expect(m.flashesPerRound).toBeLessThan(2);

  expect(m.blindShare).toBeLessThan(0.015);

  expect(m.anyoneBlindShare).toBeLessThan(0.1);

  // A flash is thrown at the other team: it blinds them, and not its own.

  expect(m.perFlash.self).toBeLessThan(0.01);

  expect(m.perFlash.own).toBeLessThan(0.05);

  expect(m.perFlash.enemy).toBeGreaterThan(0.5);

});