benjivers/val Public Public: anyone can read this; the crew can change it.

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

import {

  AGENTS,

  agentById,

  buyableSlots,

  cast,

  castable,

  facingFlash,

  FLASH_CONE,

  FLASH_EDGE,

  FLASH_GRACE,

  flashDuration,

  flashReach,

  sightBlocked,

  SLOTS,

  type Ability,

} from "./abilities.ts";

import { HEIGHT, WIDTH } from "./map.ts";

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

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

import { FOV } from "../static/engine/raycast.js";

const flashes = (): Ability[] => AGENTS.flatMap((a) => SLOTS.map((s) => a.abilities[s])).filter((a) => a.kind === "flash");

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: 1100, 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, 360)).toBeGreaterThan(1.6);

  expect(flashDuration(1.7, staring, at, facingAway, false, 360)).toBe(0);

  // Turned just past the edge of the screen is a shorter blind than staring.

  const glance = flashDuration(1.7, staring, at, facingIt - 0.8, false, 360);

  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: 1100, y: 1000 }, { x: 1000, y: 1000 }, Math.PI, true, 360);

  expect(blind).toBe(0);

});

test("a flash reaches a room, not the map", () => {

  // The map is 2400 by 1520. A 900 radius was 70% of it by area and 75% of

  // its width across: weather, not a thrown object. A site is a few hundred

  // units across, and that is the scale every flash is kept to.

  expect(flashes().length).toBeGreaterThan(0);

  for (const flash of flashes()) {

    expect(flash.radius).toBeGreaterThanOrEqual(300);

    expect(flash.radius).toBeLessThanOrEqual(400);

    expect((Math.PI * flash.radius * flash.radius) / (WIDTH * HEIGHT)).toBeLessThan(0.12);

    expect((2 * flash.radius) / WIDTH).toBeLessThanOrEqual(0.3);

    // And it is a thrown object: it lands past its own radius from the thrower.

    expect(flash.range).toBeGreaterThan(flash.radius);

  }

});

test("distance matters inside the radius: the centre is the full duration, the edge a flicker", () => {

  const at = { x: 1000, y: 1000 };

  const r = 360;

  const facingIt = Math.PI;

  const stand = (d: number) => ({ x: 1000 + d, y: 1000 });

  expect(flashDuration(1.7, stand(60), at, facingIt, false, r)).toBe(1.7);

  expect(flashDuration(1.7, stand(0.4 * r), at, facingIt, false, r)).toBe(1.7);

  const half = flashDuration(1.7, stand(0.7 * r), at, facingIt, false, r);

  expect(half).toBeGreaterThan(0.3 * 1.7);

  expect(half).toBeLessThan(0.7 * 1.7);

  const edge = flashDuration(1.7, stand(r), at, facingIt, false, r);

  expect(edge).toBeGreaterThan(0);

  expect(edge).toBeLessThanOrEqual(FLASH_EDGE * 1.7 + 0.01);

  // Past the radius there is nothing, however hard you were staring.

  expect(flashDuration(1.7, stand(r + 1), at, facingIt, false, r)).toBe(0);

  expect(flashDuration(1.7, stand(899), at, facingIt, false, r)).toBe(0);

  // Closer is never shorter.

  let last = Infinity;

  for (let d = 20; d <= r; d += 20) {

    const now = flashDuration(1.7, stand(d), at, facingIt, false, r);

    expect(now).toBeLessThanOrEqual(last);

    last = now;

  }

});

const deg = (n: number) => (n * Math.PI) / 180;

test("facing is the gate: on screen is the full duration, behind your back is nothing", () => {

  // The browser draws FOV wide. Anything inside half of that was on your

  // screen: you looked at it, you pay all of it. Past the screen's edge a

  // little grace for turning, gone quickly; beyond that, nothing at all.

  expect(FLASH_CONE).toBeCloseTo(FOV / 2, 9);

  expect(FLASH_GRACE).toBeLessThanOrEqual(deg(56));

  const at = { x: 1000, y: 1000 };

  const near = { x: 1100, y: 1000 };

  const straight = Math.PI;

  for (const off of [0, 15, 30, 37]) {

    expect(flashDuration(1.7, near, at, straight + deg(off), false, 360)).toBe(1.7);

    expect(flashDuration(1.7, near, at, straight - deg(off), false, 360)).toBe(1.7);

  }

  // The grace falls away quickly: half way through it, well under half is left.

  const grace = flashDuration(1.7, near, at, straight + deg(46), false, 360);

  expect(grace).toBeGreaterThan(0);

  expect(grace).toBeLessThan(0.5 * 1.7);

  expect(flashDuration(1.7, near, at, straight + deg(53), false, 360)).toBeLessThan(0.1);

  // Used to blind at full strength out to 45° and taper to 100°.

  for (const off of [55, 60, 70, 100, 180]) {

    expect(flashDuration(1.7, near, at, straight + deg(off), false, 360)).toBe(0);

    expect(facingFlash(near, at, straight + deg(off))).toBe(0);

  }

  // Turning further is never a longer blind.

  let last = Infinity;

  for (let off = 0; off <= 180; off += 1) {

    const now = facingFlash(near, at, straight + deg(off));

    expect(now).toBeLessThanOrEqual(last);

    last = now;

  }

});

test("facing decides whether, distance decides how long", () => {

  const at = { x: 1000, y: 1000 };

  const r = 360;

  const stand = (d: number) => ({ x: 1000 + d, y: 1000 });

  // Facing it exactly is never survivable because of a distance table:

  // every distance the light carries to blinds, and further is shorter.

  let last = Infinity;

  for (let d = 10; d <= r; d += 10) {

    const blind = flashDuration(1.7, stand(d), at, Math.PI, false, r);

    expect(blind).toBeGreaterThan(0);

    expect(blind).toBeLessThanOrEqual(last);

    last = blind;

  }

  expect(flashReach(r, r)).toBeCloseTo(FLASH_EDGE, 9);

  expect(flashReach(r + 1, r)).toBe(0);

  // And a close flash never blinds a player who had their back to it.

  for (let d = 10; d <= r; d += 10) {

    expect(flashDuration(1.7, stand(d), at, 0, false, r)).toBe(0);

    expect(flashDuration(1.7, stand(d), at, Math.PI / 2, false, r)).toBe(0);

    expect(flashDuration(1.7, stand(d), at, Math.PI - deg(60), false, r)).toBe(0);

  }

  // Behind a wall or a smoke you were not looking at it, whatever your angle says.

  expect(flashDuration(1.7, stand(10), at, Math.PI, true, r)).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";

  // Along the back corridor, which is open from one side of the map to the other.

  player.x = 400;

  player.y = 1400;

  player.angle = 0;

  const behind = { x: 1000, y: 1400 };

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

  }

});