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

/**

 * The bot's aim (`engine/aim.ts`), once through a whole bot to prove the

 * reaction gate is actually wired to the trigger and the cone to the barrel.

 */

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

import { acquire, crossRate, emptyTrack, REACTION_MAX, REACTION_MIN } from "./engine/aim.ts";

import { botThink } from "./bots.ts";

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

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

const rolls = (...values: number[]) => {

  let at = 0;

  return () => values[at++ % values.length]!;

};

const facing = (state: MatchState): { bot: Player; prey: Player } => {

  const bot = state.players.find((p) => p.side === "def")!;

  const prey = state.players.find((p) => p.side === "atk")!;

  // Nose to nose in the open, with nothing between them.

  bot.x = 1200;

  bot.y = 640;

  prey.x = 1200 + 200;

  prey.y = 640;

  bot.angle = 0;

  bot.input.angle = 0;

  bot.weapon = "vandal";

  bot.ammo = 25;

  return { bot, prey };

};

const live = (): MatchState => {

  const state = newMatch(4242);

  state.phase = "live";

  state.clock = 100;

  return state;

};

test("a bot that has just seen somebody does not shoot for a reaction", () => {

  const state = live();

  const { bot } = facing(state);

  let firstFire = -1;

  for (let i = 0; i < 30 && firstFire < 0; i++) {

    botThink(state, bot, 1 / 30);

    state.now += 1 / 30;

    if (bot.input.fire) firstFire = i / 30;

  }

  expect(firstFire).toBeGreaterThanOrEqual(REACTION_MIN);

  expect(firstFire).toBeLessThanOrEqual(REACTION_MAX + 0.15);

});

test("a bot that has been tracking you is far tighter than one that just swung on", () => {

  const state = live();

  const { bot, prey } = facing(state);

  const truth = () => Math.atan2(prey.y - bot.y, prey.x - bot.x);

  const spread: number[] = [];

  for (let i = 0; i < 120; i++) {

    botThink(state, bot, 1 / 30);

    state.now += 1 / 30;

    bot.angle = bot.input.angle; // the match loop's job, done by hand

    spread.push(Math.abs(bot.angle - truth()));

  }

  const swing = Math.max(...spread.slice(0, 15));

  const held = Math.max(...spread.slice(80));

  expect(swing).toBeGreaterThan(held * 2);

  expect(held).toBeLessThan(0.03);

});

test("a strafing target keeps a settled bot honest", () => {

  const still = live();

  const a = facing(still);

  const strafing = live();

  const b = facing(strafing);

  let stillWorst = 0;

  let strafeWorst = 0;

  for (let i = 0; i < 180; i++) {

    botThink(still, a.bot, 1 / 30);

    botThink(strafing, b.bot, 1 / 30);

    still.now += 1 / 30;

    strafing.now += 1 / 30;

    a.bot.angle = a.bot.input.angle;

    b.bot.angle = b.bot.input.angle;

    // One stands in the open; the other runs across the sight line.

    b.prey.y = 640 + Math.sin(i / 8) * 90;

    if (i > 60) {

      stillWorst = Math.max(stillWorst, Math.abs(a.bot.angle - Math.atan2(a.prey.y - a.bot.y, a.prey.x - a.bot.x)));

      strafeWorst = Math.max(strafeWorst, Math.abs(b.bot.angle - Math.atan2(b.prey.y - b.bot.y, b.prey.x - b.bot.x)));

    }

  }

  expect(strafeWorst).toBeGreaterThan(stillWorst);

});

test("the aim is still deterministic in the state: one seed, one round", () => {

  const play = (): number[] => {

    const state = live();

    const { bot, prey } = facing(state);

    const out: number[] = [];

    for (let i = 0; i < 60; i++) {

      botThink(state, bot, 1 / 30);

      state.now += 1 / 30;

      bot.angle = bot.input.angle;

      prey.x = 1400 + i;

      out.push(bot.angle, bot.input.fire ? 1 : 0);

    }

    return out;

  };

  expect(play()).toEqual(play());

});

test("a full run of speed is what the crossing term is measured against", () => {

  expect(RUN_SPEED).toBeGreaterThan(0);

  const track = emptyTrack();

  acquire(track, "t", 0, { x: 400, y: 0 }, rolls(0, 0.5));

  const rate = crossRate(track, { x: 0, y: 0 }, { x: 400, y: RUN_SPEED / 30 }, 1 / 30);

  expect(rate / RUN_SPEED).toBeCloseTo(1, 3);

});