f2a8cec · 7bd3e52
@@ -1,4 +1,6 @@
node_modules/
dist/
static/
*.db
*.db-wal
*.db-shm
@@ -9,9 +9,8 @@
preview at its own address, deployed from your branch as you push.
- Work on the branch you were given. You cannot move the default branch;
  a person merges your pull once it is reviewed.
- Keep state under `FORGE_APP_DATA`. Never write elsewhere at runtime.
- Run `bun run check` before you push — types, then tests. It is the check
  the pull shows, and every behaviour you add gets a test that would fail
  without it. `bun test` alone is the fast loop while you work.
- Run `bun test` before you push. It is the check the pull shows, and every
  behaviour you add gets a test that would fail without it.
- `src/tty.ts` is the app's terminal interface. The exact command that
  reaches it is `FORGE_APP_SSH` at runtime; print that verbatim wherever the
  app tells people how to connect. Keep it working and keep it useful: what
@@ -34,7 +33,7 @@
preview at its own address, deployed from your branch as you push.
  come from the environment, never the repository; no `eval`, no shell
  built from user text; a private thing needs a session in an HttpOnly cookie.
  Every request body is capped by the bytes actually read (`readBody` in
  `src/server.ts`) — never by a Content-Length, which a chunked request does
  `src/gate.ts`) — never by a Content-Length, which a chunked request does
  not have and a lie does not honour. `HEAD` answers like `GET`.
  An app with an owner or admin is never claimed by whoever visits first:
  the first sign-in needs a secret only the operator holds — a password from
@@ -3,7 +3,10 @@
  "configVersion": 1,
  "workspaces": {
    "": {
      "name": "cs",
      "name": "cs-engine",
      "dependencies": {
        "@typesafe-ai/sdk": "^0.6.0",
      },
      "devDependencies": {
        "@types/bun": "^1.4.2",
        "typescript": "^7.0.2",
@@ -15,6 +18,8 @@
    "@types/node": ["@types/[email protected]", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-X1P21scMv4zGKLYqjdGjaKa7COa0RKVYYZZN/NfvLQ1JegxFhdhpZG/Lyn8AXx6CDUavKAd11v6BvfpkDByK8g=="],
    "@typesafe-ai/sdk": ["@typesafe-ai/[email protected]", "", {}, "sha512-IddX+Q0XM+VagOUZFeP7wZjaO4SHMdvnh2zEBdrZZnXedWI3BNK1lKhMx3ayrkFWvVLbVcUHJy6AVZlY+e6Jaw=="],
    "@typescript/typescript-aix-ppc64": ["@typescript/[email protected]", "", { "os": "aix", "cpu": "ppc64" }, "sha512-MTKKkWB7p/0E9xi1d1tHtZ5PiLkGEMIq88pK2CubZjOsLtYTLqhgIgi6zepFa+9GHZ6h05NMCkQxGKiPXMxXtQ=="],
    "@typescript/typescript-darwin-arm64": ["@typescript/[email protected]", "", { "os": "darwin", "cpu": "arm64" }, "sha512-gowzar9MwS/aRWp6f3a4KUqzRjAZjOsmGNCM6LcTgXum+dBfgsBVMN+AgvOCCbguXyick6LJhpBszxMebJ8syA=="],
@@ -1,7 +1,7 @@
{
  "app": {
    "run": "bun run src/server.ts",
    "test": "bun run check",
    "test": "bun run test",
    "tty": "bun run src/tty.ts"
  }
}
@@ -1,16 +1,18 @@
{
  "name": "cs",
  "name": "cs-engine",
  "private": true,
  "type": "module",
  "scripts": {
    "start": "bun run src/server.ts",
    "build": "bun run scripts/build.ts",
    "test": "bun test --timeout 20000",
    "typecheck": "tsc --noEmit",
    "check": "tsc --noEmit && bun test --timeout 20000"
    "test": "bun run typecheck && bun test"
  },
  "devDependencies": {
    "@types/bun": "^1.4.2",
    "typescript": "^7.0.2"
  },
  "dependencies": {
    "@typesafe-ai/sdk": "^0.6.0"
  }
}
@@ -1,5 +0,0 @@
/** `--name value` off argv, or null if the flag is missing or has nothing after it. */
export const flagValue = (argv: string[], name: string): string | null => {
  const at = argv.indexOf(`--${name}`);
  return at < 0 ? null : (argv[at + 1] ?? null);
};
@@ -0,0 +1,430 @@
import { expect, test } from "bun:test";
import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import {
  ASSETS,
  assetOf,
  bundle,
  collect,
  differences,
  ENTRIES,
  isNamed,
  GZIP_LEVEL,
  isBundleOf,
  NOTE,
  overshoot,
  row,
  sizes,
  table,
  weigh,
  write,
  type Built,
  type Ceiling,
  type Entry,
} from "./build.ts";
import { GAMES } from "../src/games.ts";
/** What a built file looks like whatever it is: a plain name, its content hash, an extension. */
const STAMPED = /^[a-z][a-z0-9-]*\.[0-9a-f]{10}\.[a-z0-9]+$/;
/** Room enough that the fixture's two-line bundles are never the thing failing. */
const ROOMY = { raw: 100_000, gzip: 100_000 };
/** A throwaway pair of entries: two sources and a directory to write them to. */
function fixture(): { dir: string; entries: Entry[]; source: (n: string, t: string) => void } {
  const dir = mkdtempSync(join(tmpdir(), "build-"));
  const source = (name: string, text: string): void => writeFileSync(join(dir, `${name}.ts`), text);
  source("app", `export const game = "app";\nconsole.log(game);\n`);
  source("sandbox", `export const game = "sandbox";\nconsole.log(game);\n`);
  return {
    dir,
    entries: [
      { name: "app", entry: join(dir, "app.ts"), ceiling: ROOMY },
      { name: "sandbox", entry: join(dir, "sandbox.ts"), ceiling: ROOMY },
    ],
    source,
  };
}
test("the entry table is what the app ships today, each with the size it may not pass", () => {
  expect(ENTRIES).toEqual([
    { name: "app", entry: "src/client/main.ts", ceiling: { raw: 132_000, gzip: 51_500 } },
    { name: "range", entry: "src/range/main.ts", ceiling: { raw: 44_000, gzip: 18_200 } },
    { name: "example", entry: "src/example/main.ts", ceiling: { raw: 26_800, gzip: 11_400 } },
  ]);
  // And it is the registry projected, not a second list beside it: a game's
  // source and its ceiling are written down once, in `src/games.ts`.
  expect(ENTRIES).toEqual(GAMES.map(({ name, entry, ceiling }) => ({ name, entry, ceiling })));
  // Nothing else of a game comes along: this file has no idea what path any of
  // them answers on.
  for (const entry of ENTRIES) expect(Object.keys(entry).sort()).toEqual(["ceiling", "entry", "name"]);
});
test("every entry is bundled to its own name and its own content hash", async () => {
  const { dir, entries } = fixture();
  const built = await write(entries, dir, []);
  expect(built.map((b) => b.name)).toEqual(["app", "sandbox"]);
  for (const { name, file, code } of built) {
    expect(file).toMatch(new RegExp(`^${name}\\.[0-9a-f]{10}\\.js$`));
    const hash = new Bun.CryptoHasher("sha256").update(code).digest("hex").slice(0, 10);
    expect(file).toBe(`${name}.${hash}.js`);
    expect(existsSync(join(dir, file))).toBe(true);
  }
  expect(built[0]?.file).not.toBe(built[1]?.file);
});
test("rebuilding one entry sweeps up its own stale bundle and leaves the other game alone", async () => {
  const { dir, entries, source } = fixture();
  const first = await write(entries, dir, []);
  const [staleApp, sandbox] = first;
  writeFileSync(join(dir, "keep.txt"), "not a bundle");
  source("app", `export const game = "app";\nconsole.log(game, "again");\n`);
  const second = await write(entries, dir, []);
  const [freshApp, sandboxAgain] = second;
  expect(freshApp?.file).not.toBe(staleApp?.file);
  expect(existsSync(join(dir, staleApp?.file as string))).toBe(false);
  expect(existsSync(join(dir, freshApp?.file as string))).toBe(true);
  // The trap: the other game's bundle did not change and must still be there.
  expect(sandboxAgain?.file).toBe(sandbox?.file as string);
  expect(existsSync(join(dir, sandbox?.file as string))).toBe(true);
  expect(readdirSync(dir)).toContain("keep.txt");
});
test("a bundle belongs to one entry by exact name", () => {
  expect(isBundleOf("app", "app.6864d577a4.js")).toBe(true);
  expect(isBundleOf("app", "sandbox.6864d577a4.js")).toBe(false);
  expect(isBundleOf("sandbox", "app.6864d577a4.js")).toBe(false);
  expect(isBundleOf("app", "app.js")).toBe(false);
  expect(isBundleOf("app", "app.6864d577a4.js.map")).toBe(false);
  expect(isBundleOf("app", "appx6864d577a4.js")).toBe(false);
  // A name that is not a plain name never becomes a pattern.
  expect(isBundleOf("a.p", "axp.6864d577a4.js")).toBe(false);
  expect(isBundleOf(".*", "app.6864d577a4.js")).toBe(false);
});
test("two entries cannot share a name, and a name is plain", async () => {
  const { dir } = fixture();
  const entry = join(dir, "app.ts");
  const of = (name: string): Entry => ({ name, entry, ceiling: ROOMY });
  expect(bundle([of("app"), of("app")])).rejects.toThrow(/share a name/);
  expect(bundle([of("../app")])).rejects.toThrow(/plain name/);
});
test("a size is bytes on disk and bytes gzipped at one fixed level", () => {
  const code = `console.log(${JSON.stringify("é".repeat(1000))});\n`;
  const bytes = new TextEncoder().encode(code);
  // Raw counts bytes, not characters: "é" is two of them.
  expect(sizes(code).raw).toBe(bytes.byteLength);
  expect(sizes(code).raw).toBeGreaterThan(code.length);
  expect(sizes(code)).toEqual(sizes(bytes));
  // The level is pinned, so the number is the same on every machine that runs
  // this. A different level is a different number, which is why it is pinned.
  expect(GZIP_LEVEL).toBe(9);
  expect(sizes(code).gzip).toBe(Bun.gzipSync(bytes, { level: GZIP_LEVEL }).byteLength);
  expect(sizes(code).gzip).not.toBe(Bun.gzipSync(bytes, { level: 1 }).byteLength);
  expect(sizes(code)).toEqual(sizes(code));
});
test("a bundle that fits says nothing, and one that does not names the overshoot", () => {
  const ceiling = { raw: 1000, gzip: 500 };
  expect(overshoot("app", { raw: 1000, gzip: 500 }, ceiling)).toBeNull();
  expect(overshoot("app", { raw: 999, gzip: 499 }, ceiling)).toBeNull();
  const raw = overshoot("app", { raw: 1100, gzip: 400 }, ceiling) as string;
  expect(raw).toContain("app is too big");
  expect(raw).toContain("raw 1100 bytes over the 1000 byte ceiling by 100 bytes (10.0%)");
  expect(raw).not.toContain("gzip");
  const gzip = overshoot("range", { raw: 900, gzip: 750 }, ceiling) as string;
  expect(gzip).toContain("range is too big");
  expect(gzip).toContain("gzip 750 bytes over the 500 byte ceiling by 250 bytes (50.0%)");
  expect(gzip).not.toContain("raw");
  // Both at once is one sentence, not two failures to chase.
  const both = overshoot("app", { raw: 1001, gzip: 501 }, ceiling) as string;
  expect(both).toContain("raw 1001 bytes over");
  expect(both).toContain("gzip 501 bytes over");
});
test("a build in another process is the same names and the same bytes as this one", async () => {
  // Nothing is committed any more, so this is what makes a deploy reproducible:
  // every process that boots this tree serves files under the same names, and a
  // browser's year-long cache of `app.<hash>.js` stays correct across deploys
  // that changed nothing. Two builds in one process would share whatever Bun
  // caches between them, so the second one is a child process with its own
  // start-up — the same thing a deploy does — and the whole `code` is compared,
  // not just the hash of it. If Bun's output ever stops being byte-stable this
  // fails here, with the file and the two sizes in hand, rather than in a
  // preview that serves a name nobody else builds.
  const dir = mkdtempSync(join(tmpdir(), "elsewhere-"));
  try {
    const run = Bun.spawnSync(["bun", "run", join(import.meta.dir, "build.ts"), dir], {
      stdout: "pipe",
      stderr: "pipe",
    });
    expect(run.stderr.toString().trim()).toBe("");
    expect(run.exitCode).toBe(0);
    const built = [...(await bundle()), ...collect()];
    // Every difference this build has from that one, as sentences: none.
    expect(differences(built, dir)).toEqual([]);
    // And that directory holds one file per game and per asset and nothing
    // else — a second shooter bundle beside the first is the outage this is
    // about, and it would be both an extra name here and a sentence above.
    expect(readdirSync(dir).sort()).toEqual(built.map((b) => b.file).sort());
    expect(built.map((b) => b.name)).toEqual([...ENTRIES.map((e) => e.name), ...ASSETS.map((a) => a.name)]);
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
}, 60_000);
test("a directory that is not what the sources build says which file, and what to run", async () => {
  const { dir, entries } = fixture();
  try {
    const built = await write(entries, dir, []);
    const [app, sandbox] = built as [Built, Built];
    // What a build just wrote is what the build builds: nothing to say. The
    // fixture's own `.ts` sources sit in this directory too, and are not the
    // build's business — neither is the database beside the bundles in
    // FORGE_APP_DATA.
    expect(differences(built, dir)).toEqual([]);
    writeFileSync(join(dir, "keep.txt"), "not a bundle");
    expect(differences(built, dir)).toEqual([]);
    // The loud half of the outage: two bundles of one game, and nothing says
    // which is the tree.
    writeFileSync(join(dir, "app.0123456789.js"), app.code);
    const two = differences(built, dir);
    expect(two.length).toBe(1);
    expect(two[0]).toContain("1 stale file");
    expect(two[0]).toContain("app.0123456789.js");
    expect(two[0]).toContain(`beside ${app.file}`);
    expect(two[0]).toContain("bun run scripts/build.ts");
    // The quiet half, which used to pass without a word: one valid-looking
    // file, and it is not this tree's.
    rmSync(join(dir, app.file));
    const stale = differences(built, dir);
    expect(stale.length).toBe(1);
    expect(stale[0]).toContain(`has no ${app.file}`);
    expect(stale[0]).toContain("app.0123456789.js");
    expect(stale[0]).toContain("bun run scripts/build.ts");
    // Nothing at all under that name says so in its own words.
    rmSync(join(dir, "app.0123456789.js"));
    expect(differences(built, dir)[0]).toContain("nothing there is named app.<hash>.js");
    expect(differences(built, dir).length).toBe(1);
    // And a file edited in place keeps its name and is caught on its bytes,
    // which is the one thing a content hash cannot notice by itself.
    writeFileSync(join(dir, sandbox.file), `${sandbox.code}// and more\n`);
    const edited = differences([sandbox], dir);
    expect(edited.length).toBe(1);
    expect(edited[0]).toContain(`${join(dir, sandbox.file)} is not what this tree builds`);
    expect(edited[0]).toContain(`${sizes(`${sandbox.code}// and more\n`).raw} bytes there`);
    expect(edited[0]).toContain(`${sizes(sandbox.code).raw} bytes built`);
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});
test("no generated file is in git: the repository tracks nothing named by its own hash", () => {
  const root = join(import.meta.dir, "..");
  // A source export with no `.git` beside it cannot be asked; a checkout can,
  // and that is where this class of outage was born, so it is asked there.
  if (!existsSync(join(root, ".git"))) return;
  const ls = Bun.spawnSync(["git", "ls-files"], { cwd: root, stdout: "pipe", stderr: "pipe" });
  expect(ls.exitCode).toBe(0);
  const said = ls.stdout
    .toString()
    .split("\n")
    .filter((path) => path !== "")
    .filter((path) => path.startsWith("static/") || STAMPED.test(path.split("/").pop() as string))
    .map(
      (path) =>
        `${path} is a generated file and it is committed: run \`git rm --cached ${path}\` — ` +
        `the bundles are built at boot into FORGE_APP_DATA/static, and an artifact in no branch cannot collide in a merge`,
    );
  expect(said).toEqual([]);
  // The reason nobody adds one by accident: a build into the repository's own
  // static/ is ignored where it lands.
  expect(readFileSync(join(root, ".gitignore"), "utf8").split("\n")).toContain("static/");
});
test("a fresh build of every entry is under its ceiling", async () => {
  // The sources as they are now: a fat import fails here on the first build,
  // before anyone has deployed the bundle it produced.
  for (const { name, code, ceiling } of await bundle()) {
    expect(overshoot(`${name} (fresh build)`, sizes(code), ceiling)).toBeNull();
  }
}, 60_000);
test("the bundle every entry is written as is under its ceiling, weighed on disk", async () => {
  // The bytes a browser downloads: the file, not the string the bundler handed
  // back. Nothing is committed any more, so this writes the build to a
  // directory of its own — exactly as a boot writes it to FORGE_APP_DATA — and
  // weighs what landed there.
  const dir = mkdtempSync(join(tmpdir(), "ceilings-"));
  try {
    await write(ENTRIES, dir, []);
    for (const { name, ceiling } of ENTRIES) {
      const files = readdirSync(dir).filter((file) => isBundleOf(name, file));
      expect(files.length).toBe(1);
      const bytes = readFileSync(join(dir, files[0] as string));
      expect(overshoot(`${files[0]} (on disk)`, sizes(bytes), ceiling)).toBeNull();
    }
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
}, 60_000);
test("weighing a committed bundle reads the file and builds nothing", async () => {
  const { dir, entries } = fixture();
  const [built] = await write(entries, dir, []);
  const file = readFileSync(join(dir, built?.file as string));
  // The same ruler `sizes` is: on disk, and gzipped at the pinned level.
  expect(weigh("app", dir)).toEqual(sizes(file));
  expect(weigh("app", dir).raw).toBe(file.byteLength);
  // And it is the artifact, not a fresh build: a file edited in place weighs
  // what it now is, which is the point of quoting it on a page.
  writeFileSync(join(dir, built?.file as string), `${built?.code as string}// and more\n`);
  expect(weigh("app", dir).raw).toBeGreaterThan(file.byteLength);
  // A game with nothing in static/ is the sentence `bundleOf` writes, not a zero.
  expect(() => weigh("nowhere", dir)).toThrow(/has no bundle/);
});
test("the asset table is what the app downloads beside its bundles", () => {
  // The shooter's weights, and nothing else: the registry projected again.
  expect(ASSETS).toEqual([
    { name: "weights", source: "src/client/weights.json", ceiling: { raw: 12_300, gzip: 9_100 } },
  ]);
  expect(ASSETS).toEqual(GAMES.flatMap((game) => game.assets.map((asset) => ({ ...asset }))));
});
test("an asset is copied verbatim, stamped by its own contents, and swept when it changes", () => {
  const dir = mkdtempSync(join(tmpdir(), "assets-"));
  writeFileSync(join(dir, "w.json"), `{"a":1}`);
  const asset = { name: "weights", source: join(dir, "w.json"), ceiling: ROOMY };
  const [first] = collect([asset], dir);
  // The bytes in static/ are the bytes the file holds: an asset is a copy.
  expect(first?.code).toBe(`{"a":1}`);
  expect(first?.file).toMatch(/^weights\.[0-9a-f]{10}\.json$/);
  expect(isNamed("weights", "json", first?.file as string)).toBe(true);
  expect(isBundleOf("weights", first?.file as string)).toBe(false);
  // The hash is the contents', so a retrain is a new name and a sweep.
  writeFileSync(join(dir, "w.json"), `{"a":2}`);
  const [second] = collect([asset], dir);
  expect(second?.file).not.toBe(first?.file);
  // And the finder reads one back by name, or says what to run.
  expect(assetOf(asset, [second?.file as string], dir)).toBe(second?.file as string);
  expect(() => assetOf(asset, [], dir)).toThrow(/has no asset.*run `bun run scripts\/build\.ts`/);
  expect(() => assetOf(asset, [first?.file as string, second?.file as string], dir)).toThrow(/has 2 assets/);
});
test("the asset every game declares is under its ceiling, and is what its source holds", async () => {
  const dir = mkdtempSync(join(tmpdir(), "assets-ceilings-"));
  try {
    await write([], dir);
    const files = readdirSync(dir);
    for (const asset of ASSETS) {
      const file = assetOf(asset, files, dir);
      const bytes = readFileSync(join(dir, file));
      expect(overshoot(`${file} (on disk)`, sizes(bytes), asset.ceiling)).toBeNull();
      // Byte for byte the file the trainer wrote: a copy that is not the source
      // is a policy nobody trained, served to every player.
      expect(bytes.toString("utf8")).toBe(collect([asset])[0]?.code as string);
    }
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});
/** A built file of known contents, for the table below: sizes nobody has to guess at. */
const builtFile = (name: string, code: string, ceiling: Ceiling): Built => ({
  name,
  ext: "js",
  file: `${name}.6864d577a4.js`,
  code,
  ceiling,
});
test("a row is one file weighed once: what it measured, what it may not pass, what is left", () => {
  const code = `console.log("hi");\n`;
  const { raw, gzip } = sizes(code);
  const measured = row(builtFile("app", code, { raw: 400, gzip: 300 }));
  expect(measured.measured).toEqual({ raw, gzip });
  expect(measured.headroom).toEqual({ raw: 400 - raw, gzip: 300 - gzip });
  // Over the ceiling the headroom is negative, in the same column a reader is
  // already scanning — not a row that quietly looks like the others.
  const over = row(builtFile("app", code, { raw: 4, gzip: 3 }));
  expect(over.headroom).toEqual({ raw: 4 - raw, gzip: 3 - gzip });
  expect(over.headroom.raw).toBeLessThan(0);
});
test("the build prints a table of what it built: the sizes and the headroom under each ceiling", () => {
  const code = `console.log("hi");\n`;
  const long = `console.log(${JSON.stringify("x".repeat(500))});\n`;
  const { raw, gzip } = sizes(code);
  const big = sizes(long);
  const printed = table([
    builtFile("app", code, { raw: 400, gzip: 300 }),
    builtFile("range", long, { raw: 900, gzip: 400 }),
  ]);
  const [head, rule, app, range] = printed as [string, string, string, string];
  expect(head.split(/\s+/)).toEqual(["file", "raw", "ceiling", "left", `gzip-${GZIP_LEVEL}`, "ceiling", "left"]);
  expect(rule).toMatch(/^-+( +-+)+$/);
  // Each row is its file and the six numbers, in the order the heading names
  // them: measured, ceiling and what is left, on both rulers.
  expect(app.split(/\s+/)).toEqual([
    "static/app.6864d577a4.js",
    String(raw),
    "400",
    String(400 - raw),
    String(gzip),
    "300",
    String(300 - gzip),
  ]);
  expect(range.split(/\s+/)).toEqual([
    "static/range.6864d577a4.js",
    String(big.raw),
    "900",
    String(900 - big.raw),
    String(big.gzip),
    "400",
    String(400 - big.gzip),
  ]);
  // The columns line up, so two rows can be compared by eye.
  expect(rule.length).toBe(head.length);
  expect(app.length).toBe(rule.length);
  expect(range.length).toBe(rule.length);
  // And the directory it wrote into is the one named in the rows.
  expect(table([builtFile("app", code, { raw: 400, gzip: 300 })], "/tmp/out")[2]).toContain(
    "/tmp/out/app.6864d577a4.js",
  );
  // The note under it carries the units and the ruler, so a pasted table means
  // something away from this file.
  expect(NOTE).toContain("Bytes");
  expect(NOTE).toContain(`gzip-${GZIP_LEVEL}`);
  expect(NOTE).toContain("src/games.ts");
});
test("a file over its ceiling prints a negative headroom, and is still the failure it is", async () => {
  const { dir, entries } = fixture();
  const tight = entries.map((entry) => ({ ...entry, ceiling: { raw: 10, gzip: 10 } }));
  const built = await bundle(tight);
  const printed = table(built);
  expect(printed[0]).toContain("left");
  const app = (printed[2] as string).split(/\s+/);
  expect(Number(app[3])).toBeLessThan(0);
  expect(Number(app[6])).toBeLessThan(0);
  // Printing it is not forgiving it: the same numbers are what the ceiling
  // tests above fail on, with the sentence naming the overshoot.
  for (const { name, code, ceiling } of built) {
    expect(overshoot(name, sizes(code), ceiling)).toContain("is too big");
  }
  rmSync(dir, { recursive: true, force: true });
});
@@ -1,26 +1,353 @@
/**
 * `bun run build` writes the client bundle to static/, for anyone who wants
 * a file on disk to inspect. The server does not read it: it builds its own
 * copy into memory at start-up (see src/bundle.ts), so this file is never
 * committed and never served.
 * The build: every game in the registry, bundled to `<name>.<hash>.js` in a
 * directory, and every asset a game declares beside it, copied to
 * `<name>.<hash>.<ext>` the same way.
 *
 * Nothing it writes is committed. `src/server.ts` calls `write` at start-up,
 * into `FORGE_APP_DATA/static` (`src/bundles.ts` says where), and serves what
 * came out; `bun run scripts/build.ts` runs the same build into the repository's
 * own `static/` — ignored by git — for a person who wants the files on disk to
 * read, weigh or serve another way. Each entry carries the size it may not pass,
 * and `build.test.ts` builds and weighs it.
 *
 * Run as a program it prints a table of what it built — every file, raw and
 * gzipped, against its ceiling and the headroom left under it — so the sizes a
 * pull states are copied from a run rather than remembered.
 *
 * A bundle and an asset are the same thing here — bytes filed under a name and
 * their own content hash, swept when they change and held to a ceiling — and
 * they differ only in where the bytes come from: a bundler, or a file. That is
 * why `write` returns one list of both.
 */
import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { bundle } from "../src/bundle.ts";
import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { extname, join, resolve } from "node:path";
import { type Asset, type Ceiling, GAMES } from "../src/games.ts";
export const STATIC_DIR = join(import.meta.dir, "..", "static");
const ROOT = join(import.meta.dir, "..");
/**
 * Where `bun run scripts/build.ts` writes when nobody says otherwise: the
 * repository's own `static/`, which git ignores. The server never uses it — it
 * passes the directory it wants, under `FORGE_APP_DATA` — and every function
 * here that takes a `dir` or a `where` takes it for the same reason.
 */
export const STATIC_DIR = join(ROOT, "static");
export async function write(): Promise<string> {
  const { name, code } = await bundle();
  mkdirSync(STATIC_DIR, { recursive: true });
  for (const file of readdirSync(STATIC_DIR))
    if (/^app\.[0-9a-f]+\.js$/.test(file) && file !== name) rmSync(join(STATIC_DIR, file));
  writeFileSync(join(STATIC_DIR, name), code);
  return name;
export type { Asset, Ceiling };
/**
 * One bundle: the name it is filed under, the source it starts from, and the
 * size it may not pass. It is the part of a game this file cares about —
 * nothing here knows what path a game answers on or what the header calls it.
 */
export type Entry = { name: string; entry: string; ceiling: Ceiling };
/**
 * What is built, projected from the registry in `src/games.ts`: a game is
 * bundled because it is a game, not because it is also written down here. The
 * ceilings live beside the entries there, with the rule for moving one.
 */
export const ENTRIES: Entry[] = GAMES.map(({ name, entry, ceiling }) => ({ name, entry, ceiling }));
/**
 * And what is copied, projected the same way: every game's assets, flattened,
 * because static/ is one directory and a name in it belongs to one file
 * whichever game declared it.
 */
export const ASSETS: Asset[] = GAMES.flatMap((game) => game.assets.map((asset) => ({ ...asset })));
/** The extension an asset is filed under, taken from the file it is copied from. */
export const extOf = (asset: Asset): string => extname(asset.source).replace(/^\./, "");
/**
 * The one level gzip is ever measured at here. Compression level is the knob
 * that moves the number between machines, so it is pinned: `bun test` on a
 * laptop and on the forge weigh the same bundle the same way. It is not a claim
 * about what a CDN sends — it is a stable ruler.
 */
export const GZIP_LEVEL = 9;
/** What a bundle weighs: bytes on disk, and bytes after gzip at `GZIP_LEVEL`. */
// `Uint8Array<ArrayBuffer>` and not a plain `Uint8Array`: the gzip below will
// not read a view onto a `SharedArrayBuffer`, and saying so here is how a
// caller that holds one finds out at the call rather than at the call inside.
export function sizes(code: string | Uint8Array<ArrayBuffer>): Ceiling {
  const bytes = typeof code === "string" ? new TextEncoder().encode(code) : code;
  return { raw: bytes.byteLength, gzip: Bun.gzipSync(bytes, { level: GZIP_LEVEL }).byteLength };
}
/**
 * A sentence naming the bundle, what it measured, what it may not pass and by
 * how much it passed it — in bytes and in percent — or `null` when it fits.
 */
export function overshoot(name: string, measured: Ceiling, ceiling: Ceiling): string | null {
  const over = (["raw", "gzip"] as const)
    .filter((kind) => measured[kind] > ceiling[kind])
    .map((kind) => {
      const by = measured[kind] - ceiling[kind];
      const percent = ((by / ceiling[kind]) * 100).toFixed(1);
      return `${kind} ${measured[kind]} bytes over the ${ceiling[kind]} byte ceiling by ${by} bytes (${percent}%)`;
    });
  return over.length === 0 ? null : `${name} is too big: ${over.join("; ")}`;
}
// A name becomes part of a file name and part of a regular expression: keep it
// plain, so neither can be surprised by it.
const NAME = /^[a-z][a-z0-9-]*$/;
/** Is this file filed under that name and extension — `app.3f2a9c1b04.js` of `app`? */
export function isNamed(name: string, ext: string, file: string): boolean {
  return NAME.test(name) && NAME.test(ext) && new RegExp(`^${name}\\.[0-9a-f]+\\.${ext}$`).test(file);
}
/** Is this file a bundle of that entry — `app.3f2a9c1b04.js` of `app`? */
export const isBundleOf = (name: string, file: string): boolean => isNamed(name, "js", file);
/**
 * The one `<name>.<hash>.<ext>` among a directory's `files`, or a sentence
 * saying what to do about it: none means nothing built it, and two means a
 * stale one was left behind and whoever picks between them picks at random.
 * `what` is the word the message uses for it — a bundle, an asset — and `where`
 * is the directory those names came from, read out in the message and nowhere
 * else.
 *
 * It is here rather than beside either caller because both — the server, which
 * refuses to boot without every game's files, and the tests, which boot the
 * built ones — are asking the same question of the same directory, and one
 * answer cannot drift from itself.
 */
export function oneNamed(
  name: string,
  ext: string,
  files: readonly string[],
  where = STATIC_DIR,
  what = "bundle",
): string {
  const mine = files.filter((file) => isNamed(name, ext, file));
  const first = mine[0];
  if (mine.length === 1 && first !== undefined) return first;
  const build = "run `bun run scripts/build.ts` to write them there";
  throw new Error(
    mine.length === 0
      ? `the game ${JSON.stringify(name)} has no ${what}: nothing in ${where} is named ${name}.<hash>.${ext} — ${build}`
      : `the game ${JSON.stringify(name)} has ${mine.length} ${what}s in ${where}: ${mine.join(", ")} — ` +
        `all but one are stale, so ${build}`,
  );
}
/** The one `<name>.<hash>.js` in a directory, or the sentence saying what to do. */
export const bundleOf = (name: string, files: readonly string[], where = STATIC_DIR): string =>
  oneNamed(name, "js", files, where);
/** The one `<name>.<hash>.<ext>` of a declared asset, or the same sentence. */
export const assetOf = (asset: Asset, files: readonly string[], where = STATIC_DIR): string =>
  oneNamed(asset.name, extOf(asset), files, where, "asset");
/**
 * What the built bundle of `name` weighs right now: the one
 * `<name>.<hash>.js` in `dir`, on disk and gzipped at `GZIP_LEVEL`. It builds
 * nothing itself — this is the file a browser downloads, already written,
 * weighed by the same ruler the ceilings are held to, so a page that quotes a
 * size and a test that checks a ceiling are reading one number.
 *
 * A missing or duplicated bundle throws here, through `bundleOf`, with the
 * sentence that says what to run about it.
 */
export function weigh(name: string, dir = STATIC_DIR): Ceiling {
  return sizes(readFileSync(join(dir, bundleOf(name, readdirSync(dir), dir))));
}
export type Built = { name: string; ext: string; file: string; code: string; ceiling: Ceiling };
/** `app` and its contents into `app.3f2a9c1b04.js`: the one naming rule here. */
function stamp(name: string, ext: string, code: string, ceiling: Ceiling): Built {
  if (!NAME.test(name)) throw new Error(`entry name ${JSON.stringify(name)} is not a plain name`);
  const hash = new Bun.CryptoHasher("sha256").update(code).digest("hex").slice(0, 10);
  return { name, ext, file: `${name}.${hash}.${ext}`, code, ceiling };
}
/** Bundle every entry and give each the file name its own contents deserve. */
export async function bundle(entries: Entry[] = ENTRIES): Promise<Built[]> {
  if (new Set(entries.map((e) => e.name)).size !== entries.length)
    throw new Error("two entries share a name; each bundle needs its own");
  const built: Built[] = [];
  for (const { name, entry, ceiling } of entries) {
    if (!NAME.test(name)) throw new Error(`entry name ${JSON.stringify(name)} is not a plain name`);
    const out = await Bun.build({
      entrypoints: [resolve(ROOT, entry)],
      target: "browser",
      minify: true,
      format: "esm",
    });
    if (!out.success) throw new Error(out.logs.map(String).join("\n"));
    const output = out.outputs[0];
    if (output === undefined) throw new Error(`the bundle for ${name} produced no output`);
    built.push(stamp(name, "js", await output.text(), ceiling));
  }
  return built;
}
/**
 * Every declared asset, read off disk and stamped with its own content hash —
 * verbatim, because the bytes served are the bytes the file holds. A
 * source that is not there throws here, naming the file, rather than deploying
 * a page that links to nothing.
 */
export function collect(assets: Asset[] = ASSETS, root = ROOT): Built[] {
  if (new Set(assets.map((a) => a.name)).size !== assets.length)
    throw new Error("two assets share a name; each one needs its own");
  return assets.map((asset) => {
    const ext = extOf(asset);
    if (ext === "") throw new Error(`the asset ${JSON.stringify(asset.name)} has no extension: ${asset.source}`);
    return stamp(asset.name, ext, readFileSync(resolve(root, asset.source), "utf8"), asset.ceiling);
  });
}
/**
 * Write every bundle and every asset, and sweep up after each name and
 * extension only: a stale `app.*.js` goes, another game's bundle beside it
 * stays, and so does `weights.*.json`. Anything else in the directory is left
 * where it is.
 */
export async function write(
  entries: Entry[] = ENTRIES,
  dir = STATIC_DIR,
  assets: Asset[] = ASSETS,
  root = ROOT,
): Promise<Built[]> {
  const built = [...(await bundle(entries)), ...collect(assets, root)];
  mkdirSync(dir, { recursive: true });
  const present = readdirSync(dir);
  for (const { name, ext, file, code } of built) {
    for (const old of present) if (old !== file && isNamed(name, ext, old)) rmSync(join(dir, old));
    writeFileSync(join(dir, file), code);
  }
  return built;
}
/**
 * Every way a directory is not what these sources build, as sentences a person
 * can act on: a file this tree builds that is not there, a file filed under a
 * built name whose bytes are not the built bytes, and a second file under a
 * name that belongs to one — the shape of three outages, where two branches
 * each rebuilt the shooter and git kept both.
 *
 * It ignores everything it was not asked about: the database beside the
 * bundles in `FORGE_APP_DATA`, a note somebody left in `static/`. `write`
 * sweeps by name and extension and nothing else, so this reads the same
 * directory the same way.
 *
 * Empty is the only good answer, and it is what `build.test.ts` asserts of a
 * build made in another process: the same names and the same bytes, which is
 * what a year-long `immutable` cache of `app.<hash>.js` is a promise about.
 */
export function differences(built: readonly Built[], dir: string): string[] {
  const present = readdirSync(dir);
  const said: string[] = [];
  const rebuild = `run \`bun run scripts/build.ts ${dir}\` and compare again`;
  for (const { name, ext, file, code } of built) {
    const mine = present.filter((old) => isNamed(name, ext, old));
    const stale = mine.filter((old) => old !== file);
    if (!mine.includes(file)) {
      const instead =
        mine.length === 0 ? `nothing there is named ${name}.<hash>.${ext}` : `it holds ${mine.join(", ")}`;
      said.push(
        `${dir} has no ${file}, which is what this tree builds for ${JSON.stringify(name)}: ` +
          `${instead} — ${rebuild}`,
      );
    } else {
      const there = readFileSync(join(dir, file), "utf8");
      if (there !== code)
        said.push(
          `${join(dir, file)} is not what this tree builds under that name: ` +
            `${sizes(there).raw} bytes there, ${sizes(code).raw} bytes built — ${rebuild}`,
        );
    }
    // Only beside the built file: when that one is missing the sentence above
    // already read out what is there instead, and one name deserves one
    // sentence.
    if (mine.includes(file) && stale.length > 0)
      said.push(
        `${dir} holds ${stale.length} stale file${stale.length === 1 ? "" : "s"} for ${JSON.stringify(name)} ` +
          `beside ${file}: ${stale.join(", ")} — whoever picks between them picks at random, so ${rebuild}`,
      );
  }
  return said;
}
/**
 * One row of the build's table: what was built, what it weighs on both rulers,
 * what it may not pass and what is left under that — negative when it passed it,
 * because a row that is over says so in the same column the others are read in.
 */
export type Row = { name: string; file: string; measured: Ceiling; ceiling: Ceiling; headroom: Ceiling };
/** What one built file measured, weighed once and reported as a row. */
export function row({ name, file, code, ceiling }: Built): Row {
  const measured = sizes(code);
  return {
    name,
    file,
    measured,
    ceiling,
    headroom: { raw: ceiling.raw - measured.raw, gzip: ceiling.gzip - measured.gzip },
  };
}
/** What the table is a table of, printed under it so a pasted table carries its units. */
export const NOTE = [
  "",
  `Bytes. Every row is one file in static/: a game's bundle, or an asset it`,
  `downloads beside one. "raw" is the file on disk and "gzip-${GZIP_LEVEL}" is it compressed`,
  `at the one level the ceilings are measured at; "left" is the headroom under`,
  `that ceiling, and a negative one is a bundle over it, which fails`,
  `scripts/build.test.ts. The ceilings are in src/games.ts, with the rule for`,
  `moving one. Run: bun run scripts/build.ts`,
].join("\n");
/**
 * The whole table, as lines a person reads and a pull quotes: one built file a
 * row, in the order they were built. It is the reason no pull has to remember a
 * size — the numbers a reviewer is given are copied from a run of this.
 */
export function table(built: readonly Built[], where = "static"): string[] {
  const rows = built.map(row);
  const width = Math.max(4, ...rows.map((r) => `${where}/${r.file}`.length));
  const cell = (text: string, size = 8): string => text.padStart(size);
  const head =
    `${"file".padEnd(width)}  ${cell("raw")}  ${cell("ceiling")}  ${cell("left")}  ` +
    `${cell(`gzip-${GZIP_LEVEL}`)}  ${cell("ceiling")}  ${cell("left")}`;
  return [
    head,
    `${"-".repeat(width)}  ${"-".repeat(8)}  ${"-".repeat(8)}  ${"-".repeat(8)}  ${"-".repeat(8)}  ${"-".repeat(8)}  ${"-".repeat(8)}`,
    ...rows.map(
      (r) =>
        `${`${where}/${r.file}`.padEnd(width)}  ${cell(String(r.measured.raw))}  ${cell(String(r.ceiling.raw))}  ` +
        `${cell(String(r.headroom.raw))}  ${cell(String(r.measured.gzip))}  ${cell(String(r.ceiling.gzip))}  ` +
        `${cell(String(r.headroom.gzip))}`,
    ),
  ];
}
/**
 * Run as a program: build into the directory named on the command line, or into
 * the repository's `static/` when none is. Nothing needs this to deploy — the
 * server builds its own — and it is here for a person who wants the files where
 * they can read them, and for `src/engine/bundles.test.ts`, which asks a child
 * process for the bundles because the engine may import nothing outside itself.
 *
 * The sizes are printed, not enforced: the ceiling is a test, so a build that
 * overshoots still writes the file a reviewer can then weigh — and says so
 * under the table, in the sentence the test would fail with.
 */
if (import.meta.main) {
  const name = await write();
  console.log(`static/${name}`);
  const asked = process.argv[2];
  const dir = asked === undefined ? STATIC_DIR : resolve(asked);
  const built = await write(ENTRIES, dir);
  for (const printed of table(built, asked === undefined ? "static" : dir)) console.log(printed);
  console.log(NOTE);
  for (const { name, measured, ceiling } of built.map(row)) {
    const over = overshoot(name, measured, ceiling);
    if (over !== null) console.log(over);
  }
}
@@ -0,0 +1,71 @@
/**
 * This tree's bundle, built and imported. All three games boot their minified
 * file in a test — `src/client/bundle.test.ts`, `src/range/bundle.test.ts` and
 * `src/example/bundle.test.ts` — and this is the step they share: where this
 * game's bundle is, and how to import it more than once when the entry boots
 * itself on the way in.
 *
 * It builds, once, into a directory of its own, because there is no committed
 * bundle to read any more: `src/server.ts` builds into `FORGE_APP_DATA` at
 * start-up and nothing generated is in the repository. So the artifact under
 * test is the one this tree produces, which is what a browser downloads from a
 * deploy of this tree — the question `scripts/build.test.ts` used to ask of a
 * committed file, answered by not having one.
 *
 * The build happens at import, once per test process (about 70 ms for all three
 * games), and every game's bundle comes out of that one build: three test files
 * sharing this module share the directory it wrote.
 *
 * It ships in no bundle: only `.test.ts` files import it, which is why
 * `src/independence.test.ts` lets a range test reach for it and a range module
 * not.
 */
import { copyFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { pathToFileURL } from "node:url";
import { bundleOf, write } from "./build.ts";
/** Where this process's build went: a throwaway directory, never the repository. */
export const BUILT_DIR = mkdtempSync(join(tmpdir(), "built-"));
// Top level, so `bundlePath` below can stay the synchronous name lookup its
// callers read a file with: by the time any of them runs, the files are there.
await write(undefined, BUILT_DIR);
/**
 * Where the one `<name>.<hash>.js` in `dir` is. Which file that is — and what is
 * said when there is no such file, or two of them — is `bundleOf` in
 * `./build.ts`: the test boots the file the server would refuse to boot without.
 */
export function bundlePath(name: string, dir = BUILT_DIR): string {
  return join(dir, bundleOf(name, readdirSync(dir), dir));
}
// An import is cached per specifier, so an entry would boot itself once and
// every later boot would come out of the module cache. Two defences: a
// cache-busting query, and — because Bun keys that cache by path and ignores
// the query — a copy of the built bytes at a path of its own each time.
// The copies go to a throwaway directory, never into the repository.
let copies: string | null = null;
let loads = 0;
/**
 * Import the bundle of `name` as if for the first time: the entry runs, which
 * for every game here means it looks for a page and boots on it. Install the
 * stub page *before* awaiting this.
 */
export async function importBundle(name: string): Promise<unknown> {
  if (copies === null) copies = mkdtempSync(join(tmpdir(), "bundle-"));
  const load = (loads += 1);
  const copy = join(copies, `${name}.${load}.js`);
  copyFileSync(bundlePath(name), copy);
  return import(`${pathToFileURL(copy).href}?load=${load}`);
}
/** Throw the copies away. A test file calls this in `afterAll`; the next one remakes them. */
export function discardBundleCopies(): void {
  if (copies !== null) rmSync(copies, { recursive: true, force: true });
  copies = null;
}
@@ -1,88 +1,281 @@
/**
 * The cost table, held against the guide. `scripts/cost.ts` measures what each
 * group behind the door adds to a bundle; `src/engine/GUIDE.md` prints those
 * numbers beside the paragraph a game author is already reading. A number on a
 * page is a number that rots, so this file measures again and fails when the
 * page and the bundler disagree.
 *
 * Three rules, and they are the whole of the honesty here:
 *
 * 1. Every group the door exports carries a `**Weight**` line under its
 *    heading, so a group that lands behind the door arrives with a number or it
 *    fails here.
 * 2. Every `**Weight**` line in the guide is under a heading that is a group, so
 *    a renamed module cannot leave a stray measurement on the page.
 * 3. Every line's numbers are within `TOLERANCE` of what the script measures
 *    today, and the modules it says come along are exactly the ones that do.
 *
 * **The tolerance**, written here rather than left for a reader to guess: a
 * number passes when it is within 10% of what was measured, or within
 * `GRAIN` — 100 bytes — whichever is wider. The floor is the page's own
 * resolution: the guide writes tenths of a kilobyte, so rounding alone moves a
 * number by up to 50 bytes and must never fail a run. The band above it is for
 * the minifier: a bun release that renames a few identifiers differently, or
 * shortens a helper, moves a bundle by a few percent and is nobody's bug. A
 * group that doubled is far outside both — the smallest measurement on the
 * table is under half a kilobyte, so doubling it moves it by more than 300
 * bytes — which is the drift this test exists to catch.
 *
 * It measures for real: the script's own builds, in a temporary directory of
 * its own that it removes. That is forty-odd `Bun.build` calls and takes well
 * under a second, which is cheaper than a stale page.
 */
import { expect, test } from "bun:test";
import { COMPETITIVE, SHORT } from "../src/client/match.ts";
import { readFileSync } from "node:fs";
import { join } from "node:path";
import {
  TICK_BUDGET_MS, parseArgs, reportLines, rulesFor, sampleTicks, summarize,
  type Cost,
  DOOR,
  FLOOR,
  SLACK,
  WHOLE_DOOR,
  costs,
  entryFor,
  groupsOf,
  guideLine,
  headingOf,
  kb,
  listed,
  moduleOf,
  pullsOf,
  sharesOf,
  table,
  vlq,
} from "./cost.ts";
test("no flags fall back to a short, quick, seeded default", () => {
  expect(parseArgs([])).toEqual({ ticks: 7680, seed: 20260917, rulesName: "short", difficulty: "normal" });
});
const GUIDE = join(import.meta.dir, "..", "src", "engine", "GUIDE.md");
const guide = (): string => readFileSync(GUIDE, "utf8");
test("ticks, seed, rules and difficulty are read off the command line", () => {
  expect(parseArgs(["--ticks", "30000", "--seed", "7", "--rules", "long", "--difficulty", "hard"])).toEqual({
    ticks: 30000, seed: 7, rulesName: "long", difficulty: "hard",
  });
});
/** How far a written number may sit from a measured one before it is drift. */
export const TOLERANCE = 0.1;
test("a malformed or missing value falls back to the default rather than NaN", () => {
  expect(parseArgs(["--ticks", "nope"]).ticks).toBe(7680);
  expect(parseArgs(["--ticks", "-3"]).ticks).toBe(7680);
  expect(parseArgs(["--ticks"]).ticks).toBe(7680);
  expect(parseArgs(["--rules", "medium"]).rulesName).toBe("short");
  expect(parseArgs(["--seed"]).seed).toBe(20260917);
  expect(parseArgs(["--seed", "-3"]).seed).toBe(20260917);
  expect(parseArgs(["--seed", "1.5"]).seed).toBe(20260917);
  expect(parseArgs(["--seed", "0"]).seed).toBe(0); // zero is a fine seed, not a falsy one
  expect(parseArgs(["--difficulty", "extreme"]).difficulty).toBe("normal");
  expect(parseArgs(["--difficulty"]).difficulty).toBe("normal");
});
/** The page's own resolution in bytes: a tenth of a kilobyte, either way. */
export const GRAIN = 100;
test("rulesFor maps the two names the same way measure.ts does", () => {
  expect(rulesFor("short")).toBe(SHORT);
  expect(rulesFor("long")).toBe(COMPETITIVE);
});
/** Is this written number still the measured one? The rule in the docstring, once. */
export const near = (written: number, measured: number): boolean =>
  Math.abs(written - measured) <= Math.max(GRAIN, measured * TOLERANCE);
test("an empty sample summarizes to zeros, not NaN or a thrown error", () => {
  expect(summarize([])).toEqual({
    ticks: 0, meanMs: 0, p50Ms: 0, p95Ms: 0, p99Ms: 0, maxMs: 0, ticksPerSecond: 0, budgetShare: 0,
  });
});
test("percentiles of a known list are nearest-rank, and order does not matter", () => {
  // 1..100 shuffled by a fixed stride, so the list arrives out of order.
  const values = Array.from({ length: 100 }, (_, i) => ((i * 37) % 100) + 1);
  const cost = summarize(values);
  expect(cost.ticks).toBe(100);
  expect(cost.meanMs).toBeCloseTo(50.5, 10);
  expect(cost.p50Ms).toBe(50);
  expect(cost.p95Ms).toBe(95);
  expect(cost.p99Ms).toBe(99);
  expect(cost.maxMs).toBe(100);
});
test("a single tick is its own mean, median and max", () => {
  const cost = summarize([4]);
  expect(cost).toMatchObject({ ticks: 1, meanMs: 4, p50Ms: 4, p95Ms: 4, p99Ms: 4, maxMs: 4 });
});
test("ticks a second and the budget share come off the mean", () => {
  const cost = summarize([1, 3]); // mean 2 ms
  expect(cost.ticksPerSecond).toBe(500);
  expect(cost.budgetShare).toBeCloseTo(2 / TICK_BUDGET_MS, 10);
  expect(TICK_BUDGET_MS).toBeCloseTo(15.625, 10);
});
test("a Float64Array summarizes the same as the plain list of the same numbers", () => {
  expect(summarize(new Float64Array([3, 1, 2]))).toEqual(summarize([3, 1, 2]));
});
test("the report says the ticks, the mean, the spread and the share of the budget", () => {
  const lines = reportLines(summarize([1, 3]));
  expect(lines[0]).toBe("ticks sampled  2");
  expect(lines[1]).toContain("2.000 ms a tick (500 ticks/s)");
  expect(lines[2]).toContain("p50 1.000 ms · p95 3.000 ms");
  expect(lines[3]).toContain("12.8% of the 15.6 ms");
});
/** A weight the guide carries: the heading it sits under, and the line itself. */
export type Written = { heading: string; line: string };
/**
 * The one wall-clock assertion in the repository. 2 ms is roughly fourteen
 * times what a tick costs today (about 0.13 ms on the box that runs the
 * check), so this is a regression alarm rather than a target: it fails when
 * a change to `bots.ts`, `trace.ts` or `world.ts` makes a tick an order of
 * magnitude dearer, and survives a CI box under load.
 * Every `**Weight**` line in the guide, under the heading it belongs to — the
 * whole heading, hashes and all, because the whole door's line sits under a
 * `##` and a group's under a `###`. A line before any heading comes back under
 * the empty name, which the tests below turn into a sentence rather than
 * passing quietly.
 */
test("a tick of the shipped simulation costs well under its 64 Hz budget", () => {
  const cost = summarize(sampleTicks({ ticks: 600, seed: 20260917, rulesName: "short", difficulty: "normal" }));
  expect(cost.ticks).toBe(600);
  expect(cost.meanMs).toBeLessThan(2);
export function weightsOf(markdown: string): Written[] {
  const out: Written[] = [];
  let heading = "";
  for (const line of markdown.split("\n")) {
    const found = /^#{2,3} .+$/.exec(line.trim());
    if (found !== null) heading = line.trim();
    else if (line.startsWith("**Weight**")) out.push({ heading, line: line.trim() });
  }
  return out;
}
/** The numbers and the tail of one written line, or null when it is not one. */
export function readWeight(line: string): { raw: number; gzip: number; tail: string } | null {
  const m = /^\*\*Weight\*\*: ([0-9.]+) kB raw, ([0-9.]+) kB gzipped — (.+)$/.exec(line);
  if (m === null) return null;
  return {
    raw: Number(m[1]) * 1000,
    gzip: Number(m[2]) * 1000,
    tail: (m[3] as string).trim(),
  };
}
/** The measurement, made once and shared by every test below it. */
const measured: Cost[] = await costs();
const groups = measured.filter((cost) => cost.name !== FLOOR && cost.name !== WHOLE_DOOR);
/** What the page prints a number for: every group, and all of them together. */
const priced = measured.filter((cost) => cost.name !== FLOOR);
const byName = new Map(measured.map((cost) => [cost.name, cost]));
test("the door's groups are the modules behind it, values only, in the door's order", () => {
  const F = "fr" + "om";
  const source = [
    `export { a, b as c } ${F} "./one.ts";`,
    `export type { D } ${F} "./one.ts";`,
    `export { e, type G } ${F} "./two.ts";`,
    `export { f } ${F} "./one.ts";`,
  ].join("\n");
  expect(groupsOf(source)).toEqual([
    { name: "one", names: ["a", "c", "f"] },
    { name: "two", names: ["e"] },
  ]);
  // And the real door: one group a module, every one of them measured.
  const real = groupsOf(readFileSync(DOOR, "utf8"));
  expect(real.length).toBeGreaterThan(15);
  expect(real.map((group) => group.name)).toEqual(groups.map((cost) => cost.name));
  expect(new Set(real.map((group) => group.name)).size).toBe(real.length);
});
test("the generated entry imports exactly its group and holds on to every name", () => {
  const entry = entryFor({ name: "mesh", names: ["builder", "finish"] }, "/engine/index.ts", "/tmp/x");
  expect(entry).toContain('import { builder, finish } from "../../engine/index.ts";');
  expect(entry).toContain("globalThis.__cost = [builder, finish];");
  // A group with no names is still an import, because the floor is a measurement.
  expect(entryFor({ name: FLOOR, names: [] }, "/engine/index.ts", "/tmp/x")).toContain(
    'import "../../engine/index.ts";',
  );
});
test("a base64 VLQ segment is the signed numbers it packs", () => {
  expect(vlq("A")).toEqual([0]);
  expect(vlq("C")).toEqual([1]);
  expect(vlq("D")).toEqual([-1]);
  expect(vlq("AAAA")).toEqual([0, 0, 0, 0]);
  expect(vlq("gB")).toEqual([16]);
  expect(vlq("hB")).toEqual([-16]);
  expect(() => vlq("!")).toThrow(/base64 VLQ/);
});
test("a source is an engine module, or it is not one", () => {
  expect(moduleOf("src/engine/math.ts", "/repo", "/repo/src/engine")).toBe("math");
  expect(moduleOf("../tmp/cost-1/math.entry.ts", "/repo", "/repo/src/engine")).toBeNull();
  // The door itself holds no code, so nothing is ever charged to it.
  expect(moduleOf("src/engine/index.ts", "/repo", "/repo/src/engine")).toBeNull();
});
test("the bytes of a bundle are charged to the module the mappings name", () => {
  // Three segments on one generated line of ten bytes: the first owns columns
  // 0..3 and is the first source, the second owns 4..7 and steps on to the
  // second source, and the third is one field — generated code that belongs to
  // no source, so the last two bytes are charged to nobody.
  const map = JSON.stringify({
    sources: ["src/engine/math.ts", "src/engine/mesh.ts", "entry.ts"],
    mappings: "AAAA,ICAA,I",
  });
  const shares = sharesOf(map, "0123456789", "/repo", "/repo/src/engine");
  expect(shares.get("math")).toBe(4);
  expect(shares.get("mesh")).toBe(4);
  expect(shares.has("entry")).toBe(false);
  expect(() => sharesOf("{}", "x")).toThrow(/sources and mappings/);
});
test("a module counts as brought along when it beats the floor, not when it jitters", () => {
  const floor = new Map([["net", 31]]);
  const shares = new Map([
    ["mesh", 800],
    ["net", 32],
    ["math", 120],
  ]);
  // `net` is a byte heavier than the floor's copy of it: that is the minifier,
  // not a dependency. `math` is not in the floor at all, so any of it counts.
  expect(pullsOf("mesh", shares, floor)).toEqual([{ module: "math", raw: 120 }]);
  expect(pullsOf("mesh", new Map([...shares, ["net", 31 + SLACK + 1]]), floor)).toEqual([
    { module: "net", raw: 48 },
    { module: "math", raw: 120 },
  ].sort((a, b) => b.raw - a.raw));
  // The floor keeps everything it holds, because that is what it is for.
  expect(pullsOf(FLOOR, floor, floor)).toEqual([{ module: "net", raw: 31 }]);
});
test("the units and the prose are the units and the prose", () => {
  expect(kb(1814)).toBe("1.8 kB");
  expect(kb(53)).toBe("0.1 kB");
  expect(listed([])).toBe("");
  expect(listed(["math"])).toBe("math");
  expect(listed(["math", "mesh"])).toBe("math and mesh");
  expect(listed(["math", "mesh", "scene"])).toBe("math, mesh and scene");
  expect(guideLine({ name: "trace", raw: 1008, gzip: 599, pulls: [{ module: "math", raw: 83 }] })).toBe(
    "**Weight**: 1.0 kB raw, 0.6 kB gzipped — including math, which comes with it.",
  );
  expect(guideLine({ name: "mesh", raw: 916, gzip: 496, pulls: [] })).toBe(
    "**Weight**: 0.9 kB raw, 0.5 kB gzipped — this module alone.",
  );
  expect(readWeight("**Weight**: 1.0 kB raw, 0.6 kB gzipped — this module alone.")).toEqual({
    raw: 1000,
    gzip: 600,
    tail: "this module alone.",
  });
  expect(readWeight("a paragraph")).toBeNull();
});
test("the measurement is a bundle per group, the floor and the whole door", () => {
  expect(byName.get(FLOOR)?.raw).toBeGreaterThan(0);
  expect(byName.get(FLOOR)?.raw).toBeLessThan(500);
  const whole = byName.get(WHOLE_DOOR);
  expect(whole?.raw).toBeGreaterThan(20_000);
  // Every group is smaller than all of them together, and none is empty.
  for (const cost of groups) {
    expect(cost.raw).toBeGreaterThan(200);
    expect(cost.raw).toBeLessThan(whole?.raw ?? 0);
    expect(cost.gzip).toBeLessThan(cost.raw);
    expect(cost.pulls.map((pull) => pull.module)).not.toContain(cost.name);
  }
  // Tree-shaking is the point: a game that wants the arithmetic does not get
  // the WebGL, and one that wants the renderer does get the arithmetic.
  expect(byName.get("math")?.pulls).toEqual([]);
  expect(byName.get("renderer")?.pulls.map((pull) => pull.module)).toContain("math");
  expect((byName.get("math")?.raw ?? 0) * 3).toBeLessThan(byName.get("renderer")?.raw ?? 0);
});
test("the table a person reads has a row for every group and its units under it", () => {
  const lines = table(measured);
  expect(lines[0]).toContain("raw");
  expect(lines[0]).toContain("gzip-9");
  expect(lines.length).toBe(measured.length + 2);
  for (const cost of measured) expect(lines.some((line) => line.startsWith(cost.name))).toBe(true);
});
test("every group the door offers carries its weight in the guide, and nothing else does", () => {
  const written = weightsOf(guide());
  const under = new Set(written.map((weight) => weight.heading));
  const offences: string[] = [];
  for (const cost of priced)
    if (!under.has(headingOf(cost.name)))
      offences.push(
        `GUIDE.md has no "**Weight**" line under "${headingOf(cost.name)}": ` +
          `run \`bun run scripts/cost.ts --guide\` and put the line it prints there`,
      );
  const headings = new Set(priced.map((cost) => headingOf(cost.name)));
  for (const weight of written)
    if (!headings.has(weight.heading))
      offences.push(
        `GUIDE.md writes a weight under "${weight.heading}", which is not a group the door exports`,
      );
  expect(offences).toEqual([]);
  expect(written.length).toBe(priced.length);
});
test("every weight the guide writes is what the bundler measures today", () => {
  const written = new Map(weightsOf(guide()).map((weight) => [weight.heading, weight.line]));
  const offences: string[] = [];
  for (const cost of priced) {
    const line = written.get(headingOf(cost.name));
    if (line === undefined) continue; // the test above is the one that says so
    const read = readWeight(line);
    if (read === null) {
      offences.push(`GUIDE.md's weight for ${cost.name} is not in the shape "${guideLine(cost)}"`);
      continue;
    }
    const fresh = readWeight(guideLine(cost));
    if (fresh === null) throw new Error("the generated line no longer reads as one");
    if (!near(read.raw, cost.raw) || !near(read.gzip, cost.gzip))
      offences.push(
        `GUIDE.md says ${cost.name} is ${line} — it measures ${cost.raw} B raw and ` +
          `${cost.gzip} B gzipped today, so the line is \`${guideLine(cost)}\``,
      );
    if (read.tail !== fresh.tail)
      offences.push(
        `GUIDE.md says ${cost.name} brings "${read.tail}" and it brings "${fresh.tail}"`,
      );
  }
  expect(offences).toEqual([]);
});
@@ -1,159 +1,389 @@
/**
 * Measures what one tick of the simulation costs: `world.update` stepped at
 * 64 Hz on a seeded ten-player world, the person idle (`NO_INPUT`) the whole
 * way, with every tick's wall clock recorded as a number. Prints one table —
 * mean, p50, p95, p99 and max milliseconds a tick, the ticks a second that
 * implies, and the share of the 15.6 ms a 64 Hz tick is allowed.
 * What each group behind the engine's door costs a bundle, measured:
 *
 *   bun run scripts/cost.ts                        # 7,680 ticks of a SHORT world
 *   bun run scripts/cost.ts --ticks 30000 --seed 7 # longer sample, a different seed
 *   bun run scripts/cost.ts --rules long           # COMPETITIVE rules instead
 *   bun run scripts/cost.ts --difficulty hard      # harder bots instead of normal
 *   bun run scripts/cost.ts            # the table
 *   bun run scripts/cost.ts --guide    # the lines GUIDE.md should carry
 *
 * Same shape as `scripts/measure.ts`: nothing here is imported by the game or
 * the server, the flags parse the same way, and the arithmetic is a pure
 * function (`summarize`) tested on a known list without touching a clock. One
 * world exists at a time and no tick is kept as anything but a number, so a
 * hundred thousand ticks cost one Float64Array rather than a hundred thousand
 * objects.
 * The ceilings in `src/games.ts` weigh whole games, which answers "is the
 * shooter still small" and not the question a game author actually asks —
 * *what does it cost me to import this?* This script answers that one the only
 * honest way: it generates a tiny entry that imports exactly one group from
 * `src/engine/index.ts` and uses every name in it, bundles that entry with the
 * settings `scripts/build.ts` uses for a real game — browser, minified, esm —
 * and weighs the output raw and gzipped at `GZIP_LEVEL`, the same ruler the
 * ceilings are held to.
 *
 * **A group is not independent, and the table says so rather than pretending.**
 * The renderer is drawn with the arithmetic; a bundle that has the renderer in
 * it has that too, and there is no number for "the renderer alone" because no
 * game can buy one. So every measurement is *including what it brings with it*,
 * and what it brought is not asserted from the import lines but read off the
 * build: the source map says which module every byte of the output came from,
 * so a module the bundler loaded and then shook away is charged nothing. That
 * is why the range ships none of the WebGL, and it is the number that says so.
 *
 * Nothing is subtracted from anything. A group's number is what a bundle that
 * imports that group and nothing else actually weighs — the entry's own
 * `globalThis` assignment, which is what keeps the names from being shaken
 * away, included — so the rows can be compared with each other and with the
 * whole-door row at the bottom without a reader holding an offset in their
 * head. The entry with no group in it is a row of its own for the same reason.
 *
 * It ships in no bundle and no game imports it: this is a script a person runs
 * and `cost.test.ts` runs. It writes only inside a directory it makes under the
 * OS temp directory and removes afterwards, like `pack.test.ts` does; nothing
 * lands in the repository and nothing touches `FORGE_APP_DATA`.
 */
import { COMPETITIVE, SHORT, type Rules } from "../src/client/match.ts";
import {
  DEFAULT_DIFFICULTY, DIFFICULTIES, NO_INPUT, createWorld, difficultyLabel, update, type Difficulty,
} from "../src/client/world.ts";
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, relative, resolve } from "node:path";
import { type Ceiling, GZIP_LEVEL, sizes } from "./build.ts";
export type RulesName = "short" | "long";
export type Options = { ticks: number; seed: number; rulesName: RulesName; difficulty: Difficulty };
const ROOT = join(import.meta.dir, "..");
/** 7,680 ticks is two minutes of a 64 Hz match: long enough to cross a plant. */
const DEFAULTS: Options = { ticks: 7680, seed: 20260917, rulesName: "short", difficulty: DEFAULT_DIFFICULTY };
/** `--ticks 30000 --seed 7 --rules long --difficulty hard`, missing or malformed flags keep the default. */
export function parseArgs(argv: string[]): Options {
  const value = (name: string): string | null => {
    const at = argv.indexOf(`--${name}`);
    return at < 0 ? null : (argv[at + 1] ?? null);
  };
  const ticks = value("ticks") === null ? NaN : Number(value("ticks"));
  const seed = value("seed") === null ? NaN : Number(value("seed"));
  const rulesArg = value("rules");
  const difficultyArg = value("difficulty");
  return {
    ticks: Number.isFinite(ticks) && ticks > 0 ? Math.round(ticks) : DEFAULTS.ticks,
    seed: Number.isInteger(seed) && seed >= 0 ? seed : DEFAULTS.seed,
    rulesName: rulesArg === "long" ? "long" : rulesArg === "short" ? "short" : DEFAULTS.rulesName,
    difficulty: isDifficulty(difficultyArg) ? difficultyArg : DEFAULTS.difficulty,
  };
}
export const rulesFor = (name: RulesName): Rules => (name === "long" ? COMPETITIVE : SHORT);
const isDifficulty = (value: string | null): value is Difficulty =>
  DIFFICULTIES.includes(value as Difficulty);
const TICK = 1 / 64;
/** The milliseconds a 64 Hz tick is allowed end to end — simulation and frame both. */
export const TICK_BUDGET_MS = 1000 * TICK;
/** Ticks stepped and thrown away before the sample, so the JIT is warm when it counts. */
const WARMUP_TICKS = 256;
export type Cost = {
  ticks: number;
  meanMs: number;
  p50Ms: number;
  p95Ms: number;
  p99Ms: number;
  maxMs: number;
  ticksPerSecond: number; // what the mean implies if nothing else ran
  budgetShare: number; // fraction of TICK_BUDGET_MS the mean uses
};
/** The engine, and the one file outside it that anybody may name. */
export const ENGINE = join(ROOT, "src", "engine");
export const DOOR = join(ENGINE, "index.ts");
/**
 * Nearest-rank percentile: the value at the smallest rank covering the given
 * share of the sorted sample, so p50 of four values is the second and the
 * top share is the max. No interpolation — every number printed is a tick
 * that actually happened.
 * One group the door offers: the module it comes from — which is the name the
 * guide gives its section — and the runtime names re-exported from it. Types
 * are not in here: `export type { … }` weighs nothing in a bundle, so a group
 * of nothing but types would be measuring the harness.
 */
const percentile = (sorted: number[], share: number): number =>
  sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(share * sorted.length) - 1))] as number;
export type Group = { name: string; names: string[] };
/** Pure arithmetic on a list of per-tick milliseconds. No clock is read here. */
export function summarize(millis: ArrayLike<number>): Cost {
  const values = Array.from(millis);
  if (values.length === 0) {
    return { ticks: 0, meanMs: 0, p50Ms: 0, p95Ms: 0, p99Ms: 0, maxMs: 0, ticksPerSecond: 0, budgetShare: 0 };
/**
 * The groups of a barrel, in the order it writes them, which is the order the
 * guide's sections are in. Only value re-exports count — `export type { … }` is
 * skipped whole, and a `type X` written inside a value clause is skipped with
 * it — and two clauses from one module are one group, because a game importing
 * that module's names gets one module either way.
 */
export function groupsOf(source: string): Group[] {
  const groups = new Map<string, string[]>();
  const pattern = /\bexport\s+(type\s+)?\{([^}]*)\}\s*from\s*["']\.\/([A-Za-z0-9_-]+)\.ts["']/g;
  for (let m = pattern.exec(source); m !== null; m = pattern.exec(source)) {
    if (m[1] !== undefined) continue;
    const module = m[3] as string;
    const names = (m[2] as string)
      .split(",")
      .map((clause) => clause.trim())
      .filter((clause) => clause !== "" && !/^type\s/.test(clause))
      .map((clause) => clause.split(/\s+as\s+/).pop()?.trim() ?? "");
    groups.set(module, [...(groups.get(module) ?? []), ...names.filter((name) => name !== "")]);
  }
  const sorted = [...values].sort((a, b) => a - b);
  let total = 0;
  for (const ms of values) total += ms;
  const meanMs = total / values.length;
  return {
    ticks: values.length,
    meanMs,
    p50Ms: percentile(sorted, 0.5),
    p95Ms: percentile(sorted, 0.95),
    p99Ms: percentile(sorted, 0.99),
    maxMs: sorted[sorted.length - 1] as number,
    ticksPerSecond: meanMs === 0 ? Infinity : 1000 / meanMs,
    budgetShare: meanMs / TICK_BUDGET_MS,
  };
  return [...groups].map(([name, names]) => ({ name, names }));
}
/** The cost as one line a stat, the table this script prints. */
export function reportLines(cost: Cost): string[] {
  const ms = (value: number): string => `${value.toFixed(3)} ms`;
/**
 * The entry that measures a group: import those names through the door, and
 * park them on `globalThis` so the bundler cannot shake away what it was asked
 * to weigh. An assignment to a property of the global object is a side effect,
 * so minification keeps it and everything it reaches.
 */
export function entryFor(group: Group, door = DOOR, dir = ""): string {
  const from = dir === "" ? door : relative(dir, door);
  const path = from.startsWith(".") || from.startsWith("/") ? from : `./${from}`;
  const names = group.names.join(", ");
  return [
    `ticks sampled  ${cost.ticks}`,
    `mean           ${ms(cost.meanMs)} a tick (${Math.round(cost.ticksPerSecond).toLocaleString("en-US")} ticks/s)`,
    `spread         p50 ${ms(cost.p50Ms)} · p95 ${ms(cost.p95Ms)} · p99 ${ms(cost.p99Ms)} · max ${ms(cost.maxMs)}`,
    `budget         ${(cost.budgetShare * 100).toFixed(1)}% of the ${TICK_BUDGET_MS.toFixed(1)} ms a 64 Hz tick is allowed`,
    `// generated by scripts/cost.ts: what ${group.name} costs, and nothing else`,
    names === "" ? `import "${path}";` : `import { ${names} } from "${path}";`,
    `globalThis.__cost = [${names}];`,
    "",
  ].join("\n");
}
/** A module a group brought with it, and the bytes of the bundle that are its. */
export type Pull = { module: string; raw: number };
/** What one group weighs, and what came with it — its own module never among them. */
export type Cost = Ceiling & { name: string; pulls: Pull[] };
/** Every group at once: what a game that used all of it would carry. */
export const WHOLE_DOOR = "the whole door";
/**
 * The floor: the door imported and none of it used. It is not zero — `net`
 * allocates a scratch array at module scope and a bundler may not drop an
 * allocation it cannot prove nobody observes — and every group's number has
 * that floor inside it. So the table prints the floor as its own row, and a
 * module counts as brought along only when it weighs *more* in a group's bundle
 * than it does in this one: `mesh` is not dragging `net` in, and `learn` is.
 */
export const FLOOR = "the door, unused";
/** What one bundle of a generated entry came to: its bytes, and whose bytes they are. */
export type Weighed = Ceiling & { shares: Map<string, number> };
/** One build, with the settings `scripts/build.ts` gives a game. */
const build = (file: string, sourcemap: boolean): Promise<Bun.BuildOutput> =>
  Bun.build({
    entrypoints: [file],
    target: "browser",
    minify: true,
    format: "esm",
    ...(sourcemap ? { sourcemap: "external" as const } : {}),
  });
/** The one output of a build, or the build's own complaint about why there is none. */
async function only(out: Bun.BuildOutput, kind: string, what: string): Promise<string> {
  if (!out.success) throw new Error(out.logs.map(String).join("\n"));
  const output = out.outputs.find((file) => file.kind === kind);
  if (output === undefined) throw new Error(`the entry for ${what} produced no ${kind}`);
  return await output.text();
}
/**
 * The engine module a source map's source path names, or null when the path is
 * not one: the generated entry, and the door itself, which holds no code.
 *
 * A build with no file to write puts its sources relative to the working
 * directory, so `base` is where they are resolved from and the caller's own
 * directory is the only sensible default.
 */
export function moduleOf(source: string, base = process.cwd(), engine = ENGINE): string | null {
  const inside = relative(engine, resolve(base, source));
  if (inside.startsWith("..") || !inside.endsWith(".ts")) return null;
  const module = inside.replace(/\.ts$/, "");
  return module === "index" ? null : module;
}
/** The digits of a base64 VLQ, in the order the format numbers them. */
const DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
 * One segment of a source map's `mappings`, as the signed numbers it packs:
 * base64 VLQ, continuation bit 0x20, sign in the low bit of the first digit.
 * A field it does not carry is simply absent — a one-field segment is generated
 * code that belongs to no source, which is exactly what this file must not
 * charge to a module.
 */
export function vlq(segment: string): number[] {
  const out: number[] = [];
  let value = 0;
  let shift = 0;
  for (const char of segment) {
    const digit = DIGITS.indexOf(char);
    if (digit < 0) throw new Error(`"${segment}" is not a base64 VLQ segment`);
    value += (digit & 0x1f) << shift;
    if ((digit & 0x20) !== 0) {
      shift += 5;
      continue;
    }
    out.push((value & 1) === 1 ? -(value >> 1) : value >> 1);
    value = 0;
    shift = 0;
  }
  return out;
}
/**
 * Whose bytes the bundle is made of: every engine module in it, against the
 * number of generated bytes the source map attributes to it. This is how "what
 * came with it" is measured rather than argued — a module the bundler loaded
 * and then shook away is charged nothing, which is the whole reason the range
 * ships none of the WebGL — and it is per module rather than a bare list
 * because two bundles can hold the same module and one line of it.
 *
 * A span runs from a segment's generated column to the next segment's, or to
 * the end of that line. The count is of the *mapped* output, which is the
 * source-mapped build and so a few bytes longer than the shipped one; the
 * shares are a breakdown of a bundle, not a second measurement of it.
 */
export function sharesOf(
  map: string,
  code: string,
  base = process.cwd(),
  engine = ENGINE,
): Map<string, number> {
  const { sources, mappings } = JSON.parse(map) as { sources?: unknown; mappings?: unknown };
  if (!Array.isArray(sources) || typeof mappings !== "string")
    throw new Error("the source map has no sources and mappings to read");
  const owners = (sources as string[]).map((source) => moduleOf(source, base, engine));
  const lines = code.split("\n");
  const out = new Map<string, number>();
  let source = 0;
  const rows = mappings.split(";");
  for (let row = 0; row < rows.length; row++) {
    let column = 0;
    const at: number[] = [];
    const whose: (string | null)[] = [];
    for (const segment of (rows[row] as string).split(",")) {
      if (segment === "") continue;
      const fields = vlq(segment);
      column += fields[0] ?? 0;
      if (fields.length >= 4) source += fields[1] ?? 0;
      at.push(column);
      whose.push(fields.length >= 4 ? (owners[source] ?? null) : null);
    }
    const end = (lines[row] ?? "").length;
    for (let i = 0; i < at.length; i++) {
      const module = whose[i];
      const span = (i + 1 < at.length ? (at[i + 1] as number) : end) - (at[i] as number);
      if (module === null || module === undefined || span <= 0) continue;
      out.set(module, (out.get(module) ?? 0) + span);
    }
  }
  return out;
}
/**
 * Bundle one generated entry twice: once for the bytes, and once with a source
 * map for the breakdown. Twice, because an external source map appends a
 * `debugId` comment to the JavaScript, and the number this script prints has to
 * be the bytes a game would actually ship rather than those plus a comment.
 */
export async function weighEntry(name: string, file: string): Promise<Weighed> {
  const code = await only(await build(file, false), "entry-point", name);
  const mapped = await build(file, true);
  const shares = sharesOf(
    await only(mapped, "sourcemap", name),
    await only(mapped, "entry-point", name),
  );
  return { ...sizes(code), shares };
}
/**
 * Every group the door offers, measured, with `FLOOR` first and `WHOLE_DOOR`
 * last. Each entry is written into `dir`, which the caller owns. A group's
 * `pulls` is what its bundle holds beyond its own module and beyond the floor
 * every import of the door pays.
 */
export async function measure(groups: Group[], dir: string): Promise<Cost[]> {
  const all: Group[] = [
    { name: FLOOR, names: [] },
    ...groups,
    { name: WHOLE_DOOR, names: groups.flatMap((group) => group.names) },
  ];
  const out: Cost[] = [];
  let floor = new Map<string, number>();
  for (const group of all) {
    const file = join(dir, `${group.name.replace(/[^a-z]+/g, "-")}.entry.ts`);
    writeFileSync(file, entryFor(group, DOOR, dir));
    const { raw, gzip, shares } = await weighEntry(group.name, file);
    if (group.name === FLOOR) floor = shares;
    out.push({ name: group.name, raw, gzip, pulls: pullsOf(group.name, shares, floor) });
  }
  return out;
}
/**
 * The bytes by which a module already in the floor has to beat the floor before
 * a group is said to have dragged it in. A minifier names identifiers by how
 * often they are used, so the same two lines of `net` come out a byte or two
 * longer in one bundle than in another; that jitter is a few bytes and this is
 * wider than it. A module the floor does not charge at all is counted at any
 * size, because one line of it is still a line a game did not ask for.
 */
export const SLACK = 16;
/**
 * What a bundle brought along: every engine module in it but the group's own,
 * charged more bytes here than the floor charges it. The floor's own row keeps
 * everything, because what it brings along is the whole of what it is.
 */
export function pullsOf(
  name: string,
  shares: Map<string, number>,
  floor: Map<string, number>,
): Pull[] {
  const beyondTheFloor = (module: string, raw: number): boolean => {
    const paid = floor.get(module) ?? 0;
    return raw > paid + (paid === 0 ? 0 : SLACK);
  };
  return [...shares]
    .filter(([module, raw]) => module !== name && (name === FLOOR || beyondTheFloor(module, raw)))
    .map(([module, raw]) => ({ module, raw }))
    .sort((a, b) => b.raw - a.raw || a.module.localeCompare(b.module));
}
/** Measure in a temporary directory of this run's own, removed however it ends. */
export async function costs(source = readFileSync(DOOR, "utf8")): Promise<Cost[]> {
  const dir = mkdtempSync(join(tmpdir(), "cost-"));
  try {
    return await measure(groupsOf(source), dir);
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
}
/**
 * Bytes as the guide writes them: kilobytes of a thousand bytes, one decimal.
 * A tenth of a kilobyte is the resolution of the page, and `TOLERANCE` below is
 * wide enough to cover the rounding this does.
 */
export const kb = (bytes: number): string => `${(bytes / 1000).toFixed(1)} kB`;
/** `and` as a person writes it: `a`, `a and b`, `a, b and c`. */
export function listed(names: readonly string[]): string {
  if (names.length <= 1) return names[0] ?? "";
  return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
}
/**
 * The sentence the guide carries under a group's heading. It is generated here
 * rather than written by hand so that the page and the measurement cannot drift
 * into two different claims; `cost.test.ts` holds today's guide against it.
 */
export function guideLine({ name, raw, gzip, pulls }: Cost): string {
  const tail =
    name === WHOLE_DOOR
      ? "every group at once, which is the most any game can pay"
      : pulls.length === 0
        ? "this module alone"
        : `including ${listed(pulls.map((pull) => pull.module))}, which come${
            pulls.length === 1 ? "s" : ""
          } with it`;
  return `**Weight**: ${kb(raw)} raw, ${kb(gzip)} gzipped — ${tail}.`;
}
/**
 * The guide's heading a measurement belongs under: a group's own section, and
 * for the whole door the section all of them are in. `cost.test.ts` reads the
 * page by these, so the script that prints the lines and the test that checks
 * them cannot disagree about where a line goes.
 */
export const SECTION = "What is behind the door";
export const headingOf = (name: string): string =>
  name === WHOLE_DOOR ? `## ${SECTION}` : `### ${name}`;
/** What the table is a table of, printed under it so a pasted table carries its units. */
export const NOTE = [
  "",
  `Bytes. Every row is one bundle: an entry that imports exactly that group through`,
  `src/engine/index.ts and uses every name in it, bundled the way scripts/build.ts`,
  `bundles a game — browser, minified, esm — and gzipped at level ${GZIP_LEVEL}.`,
  `So a row includes what the group brings with it, and the floor every import of`,
  `the door pays. Run: bun run scripts/cost.ts`,
].join("\n");
/** The whole table, as lines a person reads: one group a row, widest name first. */
export function table(measured: readonly Cost[]): string[] {
  const width = Math.max(...measured.map((cost) => cost.name.length));
  const cell = (text: string, size: number): string => text.padStart(size);
  const rows = measured.map(
    (cost) =>
      `${cost.name.padEnd(width)}  ${cell(String(cost.raw), 7)}  ${cell(String(cost.gzip), 7)}  ` +
      (cost.pulls.length === 0
        ? "—"
        : cost.pulls.map((pull) => `${pull.module} ${pull.raw}`).join(", ")),
  );
  return [
    `${"group".padEnd(width)}  ${cell("raw", 7)}  ${cell(`gzip-${GZIP_LEVEL}`, 7)}  brings with it`,
    `${"-".repeat(width)}  ${"-".repeat(7)}  ${"-".repeat(7)}  ${"-".repeat(14)}`,
    ...rows,
  ];
}
/**
 * Step a seeded world `ticks` times and return each tick's milliseconds. The
 * world is replaced, untimed, whenever a match finishes, so a long sample
 * measures play rather than a `match_over` screen.
 */
export function sampleTicks(opts: Options): Float64Array {
  const rules = rulesFor(opts.rulesName);
  const newWorld = (restart: number) =>
    // The same prime stride scripts/measure.ts uses, so a restart is not a
    // neighbour of the seed it followed.
    createWorld(rules, "cost", "ct", 5, opts.seed + restart * 7919, opts.difficulty);
  let world = newWorld(0);
  let restarts = 0;
  for (let i = 0; i < WARMUP_TICKS; i++) update(world, TICK, NO_INPUT);
  const millis = new Float64Array(opts.ticks);
  for (let i = 0; i < opts.ticks; i++) {
    const before = Bun.nanoseconds();
    update(world, TICK, NO_INPUT);
    millis[i] = (Bun.nanoseconds() - before) / 1e6;
    if (world.match.phase === "match_over") world = newWorld(++restarts);
if (import.meta.main) {
  const measured = await costs();
  if (process.argv.includes("--guide")) {
    for (const cost of measured)
      if (cost.name !== FLOOR) console.log(`${headingOf(cost.name)}\n${guideLine(cost)}\n`);
  } else {
    for (const line of table(measured)) console.log(line);
    console.log(NOTE);
  }
  return millis;
}
function main(): void {
  const opts = parseArgs(process.argv.slice(2));
  console.log(
    `${opts.ticks} ticks of a 10-player ${opts.rulesName.toUpperCase()} world, seed ${opts.seed}, ` +
      `${difficultyLabel(opts.difficulty)} bots, the person idle`,
  );
  const started = Bun.nanoseconds();
  const cost = summarize(sampleTicks(opts));
  const totalSeconds = (Bun.nanoseconds() - started) / 1e9;
  console.log("");
  for (const line of reportLines(cost)) console.log(line);
  console.log("");
  console.log(`${totalSeconds.toFixed(1)}s wall clock, warm-up and sampling both`);
}
if (import.meta.main) main();
@@ -1,37 +0,0 @@
import { expect, test } from "bun:test";
import { parseArgs } from "./duel.ts";
const CARD_SEED = 20260914 + 555;
test("no flags fall back to de_forge, 240 duels, and train.ts's own evaluation seed", () => {
  expect(parseArgs([])).toEqual({ map: "de_forge", duels: 240, seed: CARD_SEED });
});
test("map, duels and seed are read off the command line", () => {
  expect(parseArgs(["--map", "de_cinder", "--duels", "500", "--seed", "7"])).toEqual({
    map: "de_cinder", duels: 500, seed: 7,
  });
});
// The whole point of the flag is comparing two maps on one seed; a typo that
// silently measured the default map again would read as the new map's numbers.
test("a map that is not in the catalogue falls back to the default rather than a name nothing holds", () => {
  expect(parseArgs(["--map", "de_nothing"]).map).toBe("de_forge");
  expect(parseArgs(["--map"]).map).toBe("de_forge");
  expect(parseArgs(["--map", "DE_CINDER"]).map).toBe("de_forge");
  expect(parseArgs(["--map", "../../etc/passwd"]).map).toBe("de_forge");
});
test("a malformed or missing value falls back to the default rather than NaN", () => {
  expect(parseArgs(["--duels", "nope"]).duels).toBe(240);
  expect(parseArgs(["--duels", "-5"]).duels).toBe(240);
  expect(parseArgs(["--duels"]).duels).toBe(240);
  expect(parseArgs(["--seed", "abc"]).seed).toBe(CARD_SEED);
  expect(parseArgs(["--seed"]).seed).toBe(CARD_SEED);
});
test("a negative or non-integer seed falls back the same way a non-positive duel count does", () => {
  expect(parseArgs(["--seed", "-3"]).seed).toBe(CARD_SEED);
  expect(parseArgs(["--seed", "1.5"]).seed).toBe(CARD_SEED);
  expect(parseArgs(["--seed", "0"]).seed).toBe(0); // zero is a fine seed, not a falsy one
});
@@ -1,52 +0,0 @@
/**
 * Measures the shipped policy — and the scripted baseline it is measured
 * against — over the same fixed duels `scripts/train.ts` plays to write
 * `CARD`, on a map of your choosing. It does not retrain: the weights come
 * from `weights.ts` exactly as the game ships them, and `--map` only changes
 * which arena they are dropped into.
 *
 *   bun run scripts/duel.ts                    # de_forge, what CARD was measured on
 *   bun run scripts/duel.ts --map de_cinder    # the other map, same seeds, same duels
 *   bun run scripts/duel.ts --duels 500 --seed 7
 */
import { policy } from "../src/client/bots.ts";
import { DEFAULT_MAP, MAP_NAMES, mapFor, type MapName } from "../src/client/map.ts";
import { flagValue } from "./args.ts";
import { evaluate, greedyDriver, type Outcome } from "./train.ts";
// train.ts's own default seed (20260914) plus the offset its evaluations are
// always called with, so a duel here lines up with the number on the card.
const CARD_SEED = 20260914 + 555;
type Options = { map: MapName; duels: number; seed: number };
const isMapName = (value: string | null): value is MapName =>
  (MAP_NAMES as readonly string[]).includes(value as string);
/** A missing or malformed value keeps the default rather than guessing at it. */
export function parseArgs(argv: string[]): Options {
  const value = (name: string): string | null => flagValue(argv, name);
  const mapArg = value("map");
  const duels = value("duels") === null ? NaN : Number(value("duels"));
  const seed = value("seed") === null ? NaN : Number(value("seed"));
  return {
    map: isMapName(mapArg) ? mapArg : DEFAULT_MAP,
    duels: Number.isFinite(duels) && duels > 0 ? Math.round(duels) : 240,
    seed: Number.isInteger(seed) && seed >= 0 ? seed : CARD_SEED,
  };
}
const rate = (o: Outcome): number => Math.round((o.won / (o.won + o.lost + o.draw)) * 100);
function main(): void {
  const opts = parseArgs(process.argv.slice(2));
  const map = mapFor(opts.map);
  console.log(`${opts.duels} seeded duels on ${opts.map}, seed ${opts.seed}`);
  const shipped = evaluate(greedyDriver(policy()), opts.duels, opts.seed, map);
  const baseline = evaluate("scripted", opts.duels, opts.seed, map);
  console.log(`shipped  ${shipped.won}/${shipped.lost}/${shipped.draw} (${rate(shipped)}% won)`);
  console.log(`scripted ${baseline.won}/${baseline.lost}/${baseline.draw} (${rate(baseline)}% won)`);
}
if (import.meta.main) main();
@@ -1,46 +0,0 @@
import { expect, test } from "bun:test";
import { parseArgs, rulesFor } from "./measure.ts";
import { COMPETITIVE, SHORT } from "../src/client/match.ts";
test("no flags fall back to a short, quick, seeded default", () => {
  expect(parseArgs([])).toEqual({
    matches: 12, seed: 20260917, rulesName: "short", difficulty: "normal", map: "de_forge",
  });
});
test("matches, seed, rules, difficulty and map are read off the command line", () => {
  expect(parseArgs(
    ["--matches", "40", "--seed", "7", "--rules", "long", "--difficulty", "hard", "--map", "de_cinder"],
  )).toEqual({
    matches: 40, seed: 7, rulesName: "long", difficulty: "hard", map: "de_cinder",
  });
});
// The whole point of the flag is comparing two maps on one seed; a typo that
// silently measured the default map again would read as the new map's numbers.
test("a map that is not in the catalogue falls back to the default rather than a name nothing holds", () => {
  expect(parseArgs(["--map", "de_nothing"]).map).toBe("de_forge");
  expect(parseArgs(["--map"]).map).toBe("de_forge");
  expect(parseArgs(["--map", "DE_CINDER"]).map).toBe("de_forge");
});
test("a malformed or missing value falls back to the default rather than NaN", () => {
  expect(parseArgs(["--matches", "nope"]).matches).toBe(12);
  expect(parseArgs(["--matches", "-3"]).matches).toBe(12);
  expect(parseArgs(["--rules", "medium"]).rulesName).toBe("short");
  expect(parseArgs(["--seed"]).seed).toBe(20260917);
  expect(parseArgs(["--difficulty", "extreme"]).difficulty).toBe("normal");
  expect(parseArgs(["--difficulty"]).difficulty).toBe("normal");
});
test("a negative or non-integer seed falls back the same way a negative matches count does", () => {
  expect(parseArgs(["--seed", "-3"]).seed).toBe(20260917);
  expect(parseArgs(["--seed", "1.5"]).seed).toBe(20260917);
  expect(parseArgs(["--seed", "nope"]).seed).toBe(20260917);
  expect(parseArgs(["--seed", "0"]).seed).toBe(0); // zero is a fine seed, not a falsy one
});
test("rulesFor maps the two names to the rule sets main.ts already uses", () => {
  expect(rulesFor("short")).toBe(SHORT);
  expect(rulesFor("long")).toBe(COMPETITIVE);
});
@@ -1,130 +0,0 @@
/**
 * Measures what the bots' rounds are actually like: how often the bomb goes
 * down, how rounds end, how long they take. Plays N seeded matches headless
 * through `world.update`, the person idle (`NO_INPUT`) the whole way, and
 * prints one table — the arithmetic itself lives in `src/client/rounds.ts`
 * and is what the tests check.
 *
 *   bun run scripts/measure.ts                       # 12 seeded SHORT matches
 *   bun run scripts/measure.ts --matches 40 --seed 7  # more matches, a different seed
 *   bun run scripts/measure.ts --rules long           # COMPETITIVE rules instead
 *   bun run scripts/measure.ts --difficulty hard      # harder bots instead of normal
 *   bun run scripts/measure.ts --map de_cinder        # a map from the catalogue, not the default one
 *
 * Nothing here is imported by the game or the server. A round is recorded as
 * plain numbers as it finishes — never a whole `World` held onto for later —
 * so a hundred rounds cost a hundred small objects, not a hundred worlds.
 */
import { COMPETITIVE, SHORT, type Rules } from "../src/client/match.ts";
import {
  DEFAULT_DIFFICULTY, DIFFICULTIES, NO_INPUT, createWorld, difficultyLabel, update, type Difficulty,
} from "../src/client/world.ts";
import { DEFAULT_MAP, MAP_NAMES, mapFor, type MapName } from "../src/client/map.ts";
import { reportLines, summarize, type RoundRecord } from "../src/client/rounds.ts";
import { flagValue } from "./args.ts";
export type RulesName = "short" | "long";
export type Options = {
  matches: number; seed: number; rulesName: RulesName; difficulty: Difficulty; map: MapName;
};
const DEFAULTS: Options = {
  matches: 12, seed: 20260917, rulesName: "short", difficulty: DEFAULT_DIFFICULTY, map: DEFAULT_MAP,
};
/**
 * `--matches 40 --seed 7 --rules long --difficulty hard --map de_cinder`; a
 * missing or malformed value keeps the default rather than guessing at it.
 */
export function parseArgs(argv: string[]): Options {
  const value = (name: string): string | null => flagValue(argv, name);
  const matches = value("matches") === null ? NaN : Number(value("matches"));
  const seed = value("seed") === null ? NaN : Number(value("seed"));
  const rulesArg = value("rules");
  const difficultyArg = value("difficulty");
  const mapArg = value("map");
  return {
    matches: Number.isFinite(matches) && matches > 0 ? Math.round(matches) : DEFAULTS.matches,
    seed: Number.isInteger(seed) && seed >= 0 ? seed : DEFAULTS.seed,
    rulesName: rulesArg === "long" ? "long" : rulesArg === "short" ? "short" : DEFAULTS.rulesName,
    difficulty: isDifficulty(difficultyArg) ? difficultyArg : DEFAULTS.difficulty,
    map: isMapName(mapArg) ? mapArg : DEFAULTS.map,
  };
}
export const rulesFor = (name: RulesName): Rules => (name === "long" ? COMPETITIVE : SHORT);
const isDifficulty = (value: string | null): value is Difficulty =>
  DIFFICULTIES.includes(value as Difficulty);
const isMapName = (value: string | null): value is MapName =>
  (MAP_NAMES as readonly string[]).includes(value as string);
const TICK = 1 / 64;
/**
 * The longest a match can honestly take, with room to spare: every round at
 * its worst (freeze, the full round clock, the bomb's full fuse, the delay
 * after), times the most rounds a best-of-`2 * winScore - 1` can ask for.
 * A guard against a bug turning this into an infinite loop rather than a bad
 * table, not a budget anyone is expected to spend.
 */
function maxTicksFor(rules: Rules): number {
  const worstRound = rules.freezeTime + rules.roundTime + rules.bombTime + rules.endDelay;
  const worstRounds = 2 * rules.winScore - 1;
  return Math.ceil((worstRound * worstRounds * 1.5) / TICK);
}
/** Play one seeded match to its end, the person idle, and return its rounds. */
function playMatch(rules: Rules, seed: number, difficulty: Difficulty, map: MapName): RoundRecord[] {
  const world = createWorld(rules, "measure", "ct", 5, seed, difficulty, mapFor(map));
  const rounds: RoundRecord[] = [];
  let roundStart = 0; // world.time at the freeze that started the round in play
  let prevPhase = world.match.phase;
  const maxTicks = maxTicksFor(rules);
  for (let tick = 0; tick < maxTicks && world.match.phase !== "match_over"; tick++) {
    update(world, TICK, NO_INPUT);
    const phase = world.match.phase;
    if (phase === "over" && prevPhase !== "over") {
      const { reason, winner } = world.match;
      if (reason === null || winner === null) throw new Error("a round went over with no winner or reason set");
      rounds.push({ winner, reason, planted: world.bombPlanted, seconds: world.time - roundStart });
    }
    if (phase === "freeze" && prevPhase === "over") roundStart = world.time;
    prevPhase = phase;
  }
  if (world.match.phase !== "match_over") {
    throw new Error(`match seeded ${seed} did not finish inside ${maxTicks} ticks`);
  }
  return rounds;
}
function main(): void {
  const opts = parseArgs(process.argv.slice(2));
  const rules = rulesFor(opts.rulesName);
  console.log(
    `${opts.matches} seeded ${opts.rulesName.toUpperCase()} matches on ${opts.map}, seed ${opts.seed}, ` +
      `${difficultyLabel(opts.difficulty)} bots, the person idle`,
  );
  const rounds: RoundRecord[] = [];
  const started = Bun.nanoseconds();
  for (let i = 0; i < opts.matches; i++) {
    const before = Bun.nanoseconds();
    // Spread out the same way scripts/train.ts spreads its duels: a prime
    // stride so nearby matches do not share a seed's low bits.
    const matchRounds = playMatch(rules, opts.seed + i * 7919, opts.difficulty, opts.map);
    rounds.push(...matchRounds);
    const seconds = (Bun.nanoseconds() - before) / 1e9;
    console.log(`  match ${String(i + 1).padStart(3)}/${opts.matches}  ${matchRounds.length} rounds  ${seconds.toFixed(1)}s`);
  }
  const totalSeconds = (Bun.nanoseconds() - started) / 1e9;
  console.log("");
  for (const line of reportLines(summarize(rounds))) console.log(line);
  console.log("");
  console.log(`${totalSeconds.toFixed(1)}s wall clock for ${opts.matches} matches (${(totalSeconds / opts.matches).toFixed(1)}s a match)`);
}
if (import.meta.main) main();
@@ -0,0 +1,128 @@
/**
 * A test that stays green when the rule it tests is deleted is not a test.
 * This runs `src/result.test.ts` against a copy of the gate a match comes in
 * through, with one rule broken at a time, and reports which test caught it.
 * Every mutant must die; a survivor is a rule nothing pins.
 *
 *   bun run scripts/mutate-result.ts
 *
 * The gate is two files, not one: `src/result.ts` says what a match is, and
 * `src/gate.ts` holds the two primitives every posted score is checked with —
 * a counted number and a printable name — because the range posts scores too.
 * A mutant names the file it breaks, defaulting to `src/result.ts`; both are
 * put back afterwards whatever happens.
 *
 * It is not part of `bun test`: it spawns one test run per mutant, which takes
 * seconds rather than milliseconds. Run it when you change either file.
 */
import { copyFileSync, unlinkSync, writeFileSync } from "node:fs";
const RESULT = "src/result.ts";
const GATE = "src/gate.ts";
const backupOf = (file: string): string => `${file}.original`;
/**
 * Each mutant: a name, the text to find, and what to put in its place — in
 * `file`, or in `src/result.ts` when it does not say. `redundant` marks a line
 * no test can kill because another rule already refuses everything it would —
 * defence in depth rather than behaviour. Those are expected to survive, and a
 * mutant that stops matching its note (dies when it should survive, or the
 * reverse) fails this run.
 */
const MUTANTS: { rule: string; find: string; replace: string; file?: string; redundant?: string }[] = [
  { rule: "a body must be an object", find: `if (typeof value !== "object" || value === null) return null;`, replace: "" },
  // The id's own shape lives in `src/matchid.ts` now; what this file can still
  // break is asking it at all.
  { rule: "matchId goes through the one door", find: "if (!isMatchId(matchId)) return null;", replace: "" },
  { rule: "a map that is not a map is refused", find: "const map = body.map === undefined ? DEFAULT_MAP : playedOn(body.map);", replace: "const map = playedOn(body.map) ?? DEFAULT_MAP;" },
  { rule: "a refused map refuses the result", find: "if (map === null) return null;", replace: "" },
  { rule: "a number must be a number", find: `if (typeof value !== "number" || !Number.isFinite(value)) return null;`, replace: "", file: GATE },
  { rule: "a number must be finite", find: "!Number.isFinite(value)", replace: "false", file: GATE },
  { rule: "a float is floored", find: "const n = Math.floor(value);", replace: "const n = value;", file: GATE },
  { rule: "negative zero is refused", find: "if (Object.is(n, -0)) return null;", replace: "", file: GATE },
  { rule: "a negative is refused", find: "n < 0 || n > max", replace: "n > max", file: GATE },
  { rule: "a number over its ceiling is refused", find: "n < 0 || n > max", replace: "n < 0", file: GATE },
  { rule: "the rounds ceiling", find: "const rounds = integer(body.rounds, MAX_ROUNDS);", replace: "const rounds = integer(body.rounds, Infinity);" },
  {
    rule: "the score ceilings", find: "const scoreMine = integer(body.scoreMine, MAX_ROUNDS);",
    replace: "const scoreMine = integer(body.scoreMine, Infinity);",
    redundant: "both scores are non-negative and sum to rounds, so neither can pass 30 anyway",
  },
  {
    rule: "the kills ceiling", find: "const kills = integer(body.kills, MAX_ROUNDS * KILLS_PER_ROUND);",
    replace: "const kills = integer(body.kills, Infinity);",
    redundant: "kills > rounds * 5 refuses everything over 150 already",
  },
  {
    rule: "the deaths ceiling", find: "const deaths = integer(body.deaths, MAX_ROUNDS);",
    replace: "const deaths = integer(body.deaths, Infinity);",
    redundant: "deaths > rounds refuses everything over 30 already",
  },
  {
    rule: "the headshots ceiling", find: "const headshots = integer(body.headshots, MAX_ROUNDS * KILLS_PER_ROUND);",
    replace: "const headshots = integer(body.headshots, Infinity);",
    redundant: "headshots > kills refuses everything over 150 already",
  },
  { rule: "the damage ceiling", find: "const damage = integer(body.damage, MAX_ROUNDS * KILLS_PER_ROUND * 200);", replace: "const damage = integer(body.damage, Infinity);" },
  { rule: "the seconds ceiling", find: "const seconds = integer(body.seconds, MAX_ROUNDS * SECONDS_PER_ROUND);", replace: "const seconds = integer(body.seconds, Infinity);" },
  { rule: "a missing number is not a zero", find: "deaths === null || headshots === null || damage === null || seconds === null", replace: "false" },
  { rule: "the scores are the rounds", find: "if (scoreMine + scoreTheirs !== rounds) return null;", replace: "" },
  { rule: "headshots are kills", find: "if (headshots > kills) return null;", replace: "" },
  { rule: "deaths are bounded by rounds", find: "if (deaths > rounds) return null;", replace: "" },
  { rule: "kills are bounded by the enemies there were", find: "if (kills > rounds * KILLS_PER_ROUND) return null;", replace: "" },
  { rule: "the clock is bounded by the rounds", find: "if (seconds > (rounds + 1) * SECONDS_PER_ROUND) return null;", replace: "" },
  { rule: "finished is exactly true", find: "finished: body.finished === true,", replace: "finished: !!body.finished," },
  { rule: "a name must be a string", find: `if (typeof value !== "string") return "anon";`, replace: `if (typeof value !== "string") return String(value);`, file: GATE },
  { rule: "control characters become spaces", find: `.replace(/[\\u0000-\\u001f\\u007f]/g, " ")`, replace: "", file: GATE },
  { rule: "a name is trimmed", find: ".trim().slice(0, 24)", replace: ".slice(0, 24)", file: GATE },
  { rule: "a name is cut to 24", find: ".slice(0, 24)", replace: "", file: GATE },
  { rule: "an empty name is anon", find: `return stripped.length === 0 ? "anon" : stripped;`, replace: "return stripped;", file: GATE },
  { rule: "a win is finished", find: "result.finished && result.scoreMine > result.scoreTheirs", replace: "result.scoreMine > result.scoreTheirs" },
  { rule: "a draw is not a win", find: "result.scoreMine > result.scoreTheirs", replace: "result.scoreMine >= result.scoreTheirs" },
];
const originals = new Map<string, string>();
for (const file of [RESULT, GATE]) {
  originals.set(file, await Bun.file(file).text());
  copyFileSync(file, backupOf(file));
}
let wrong = 0;
try {
  for (const { rule, find, replace, file = RESULT, redundant } of MUTANTS) {
    const original = originals.get(file) as string;
    if (!original.includes(find)) {
      console.log(`?         ${rule}: no longer in ${file} — the mutant needs rewriting`);
      wrong++;
      continue;
    }
    writeFileSync(file, original.replace(find, replace));
    const run = Bun.spawnSync(["bun", "test", "src/result.test.ts"], { stderr: "pipe", stdout: "pipe" });
    const log = run.stderr.toString() + run.stdout.toString();
    const killers = [...log.matchAll(/\(fail\) (.*?)(?: \[[\d.]+m?s\])?$/gm)].map((m) => m[1]?.trim());
    const died = run.exitCode !== 0;
    if (died) console.log(`killed    ${rule}\n          by: ${killers.join("\n          by: ")}`);
    else console.log(`survived  ${rule}${redundant === undefined ? "" : `\n          expected: ${redundant}`}`);
    if (died === (redundant !== undefined)) {
      console.log(died
        ? `          UNEXPECTED: a line called redundant is not: a test can tell the difference`
        : `          UNEXPECTED: nothing catches this line being deleted`);
      wrong++;
    }
    // Put this mutant's file back before the next one is broken, so only ever
    // one rule is missing at a time.
    writeFileSync(file, original);
  }
} finally {
  for (const file of [RESULT, GATE]) {
    copyFileSync(backupOf(file), file);
    unlinkSync(backupOf(file));
  }
}
const expected = MUTANTS.filter((m) => m.redundant !== undefined).length;
console.log(wrong === 0
  ? `\nall ${MUTANTS.length - expected} mutants died; the ${expected} noted as redundant survived, as noted`
  : `\n${wrong} of ${MUTANTS.length} mutants did not do what the list says`);
process.exit(wrong === 0 ? 0 : 1);
@@ -0,0 +1,206 @@
/**
 * The pack, measured. `scripts/pack.ts` claims the engine is a package: one
 * door, a name, no dependencies, and complete enough that a game builds on it
 * with nothing else on disk. A claim like that is only worth what proves it, so
 * this file takes the package out of the repository for real — into a
 * directory it makes under the OS temp and removes afterwards, so a failure
 * never leaves bytes behind for the next run to read — and then builds the
 * sample against the copy.
 *
 * The proof is where the modules came from. The build runs with a plugin that
 * reads every `.ts` the bundler asks for and records the path it read it from;
 * if one of them resolved back into this repository, the path says so. A build
 * that merely *succeeded* would prove nothing, because this repository is
 * sitting right there.
 *
 * The second proof is the surface: the packed door is imported from the temp
 * copy and its keys are held against the door here, and the names it re-exports
 * against `SURFACE` in `src/engine/boundary.test.ts` — the one written-down
 * copy of the engine's API. A pack that dropped a file fails on this line
 * rather than in somebody else's repository.
 */
import { expect, test } from "bun:test";
import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, relative, resolve } from "node:path";
import { pathToFileURL } from "node:url";
import { DEFAULT_OUT, GUIDE, NAME, SAMPLE, VERSION, isModule, line, manifest, pack, target } from "./pack.ts";
import { SURFACE, reExportedNames } from "../src/engine/boundary.test.ts";
/**
 * A directory of this test's own, removed however the body ends. Everything
 * that writes in this file writes in one of these and nowhere else.
 */
async function inTemp<T>(body: (dir: string) => T | Promise<T>): Promise<T> {
  const dir = mkdtempSync(join(tmpdir(), "pack-"));
  try {
    return await body(dir);
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
}
/** Is `path` inside `dir` — the whole question this file exists to ask? */
export function inside(dir: string, path: string): boolean {
  const within = relative(resolve(dir), resolve(path));
  return within !== "" && !within.startsWith("..");
}
test("a path is inside the copy or it is not, and `..` is not a way in", () => {
  expect(inside("/tmp/pack-1", "/tmp/pack-1/math.ts")).toBe(true);
  expect(inside("/tmp/pack-1", "/tmp/pack-1/sub/deep.ts")).toBe(true);
  expect(inside("/tmp/pack-1", "/tmp/pack-1/../repo/src/engine/math.ts")).toBe(false);
  expect(inside("/tmp/pack-1", "/tmp/pack-10/math.ts")).toBe(false);
  expect(inside("/tmp/pack-1", "/tmp/pack-1")).toBe(false);
});
test("the manifest is a name, a version, an ES module, one door and no dependencies", () => {
  expect(manifest()).toEqual({
    name: NAME,
    version: VERSION,
    type: "module",
    exports: { ".": "./index.ts" },
  });
  // Not "dependencies": {} — there is no such key, because there is nothing to
  // install and nothing that could quietly grow a first entry.
  expect(Object.keys(manifest()).filter((key) => /dependencies/i.test(key))).toEqual([]);
  expect(VERSION).toMatch(/^\d+\.\d+\.\d+$/);
});
test("a module of the package is a module; a test, a probe and the sample are not", () => {
  expect(isModule("index.ts")).toBe(true);
  expect(isModule("renderer.ts")).toBe(true);
  expect(isModule("sub/deep.ts")).toBe(true);
  expect(isModule("boundary.test.ts")).toBe(false);
  expect(isModule("purity.probe.ts")).toBe(false);
  expect(isModule(SAMPLE)).toBe(false);
  expect(isModule(GUIDE)).toBe(false);
});
test("the directory is the one argument, resolved, and the default is under dist/", () => {
  expect(target(undefined)).toBe(DEFAULT_OUT);
  expect(DEFAULT_OUT.endsWith(join("dist", "engine"))).toBe(true);
  expect(target("dist/elsewhere")).toBe(resolve(import.meta.dir, "..", "dist", "elsewhere"));
  expect(target("/tmp/pack-fixed")).toBe("/tmp/pack-fixed");
  expect(() => target("")).toThrow(/cannot be empty/);
  expect(() => target("   ")).toThrow(/cannot be empty/);
});
test("the pack is every shipping module, the guide, the sample and a manifest — and nothing else", async () => {
  await inTemp(async (tmp) => {
    const dir = join(tmp, "made", "here");
    const packed = pack(dir);
    // It makes the directory it was given, however deep, and writes only there.
    expect(readdirSync(tmp)).toEqual(["made"]);
    expect(packed.dir).toBe(dir);
    expect(readdirSync(dir).sort()).toEqual([...packed.files].sort());
    for (const file of packed.files) expect(existsSync(join(dir, file))).toBe(true);
    expect(packed.files).toContain("index.ts");
    expect(packed.files).toContain("renderer.ts");
    expect(packed.files).toContain(GUIDE);
    expect(packed.files).toContain(SAMPLE);
    expect(packed.files).toContain("package.json");
    // Nothing that is not the package came along.
    for (const file of packed.files) {
      expect(file.endsWith(".test.ts")).toBe(false);
      expect(file.endsWith(".probe.ts")).toBe(false);
    }
    expect(packed.modules).not.toContain(SAMPLE);
    expect(packed.modules.length).toBeGreaterThan(15);
    // The manifest on disk is the manifest, parsed rather than trusted.
    expect(JSON.parse(readFileSync(join(dir, "package.json"), "utf8"))).toEqual(manifest());
    // The guide is the guide, not a stub.
    expect(readFileSync(join(dir, GUIDE), "utf8")).toBe(
      readFileSync(join(import.meta.dir, "..", "src", "engine", GUIDE), "utf8"),
    );
  });
});
test("packing into a directory that exists leaves what is already there alone", async () => {
  await inTemp(async (tmp) => {
    mkdirSync(tmp, { recursive: true });
    writeFileSync(join(tmp, "notes.txt"), "mine");
    const packed = pack(tmp);
    expect(readdirSync(tmp)).toContain("notes.txt");
    expect(readFileSync(join(tmp, "notes.txt"), "utf8")).toBe("mine");
    // And packing twice over itself is the same bytes, not a second copy.
    const again = pack(tmp);
    expect(again.files).toEqual(packed.files);
  });
});
test("the sample builds against the packed door, and every module came out of the copy", async () => {
  await inTemp(async (dir) => {
    const packed = pack(dir);
    const loaded: string[] = [];
    const out = await Bun.build({
      entrypoints: [join(dir, SAMPLE)],
      target: "browser",
      format: "esm",
      plugins: [
        {
          name: "where-it-came-from",
          setup(build): void {
            build.onLoad({ filter: /\.ts$/ }, async (args) => {
              loaded.push(args.path);
              return { contents: await Bun.file(args.path).text(), loader: "ts" };
            });
          },
        },
      ],
    });
    expect(out.logs.map(String)).toEqual([]);
    expect(out.success).toBe(true);
    // The whole point: no path leads back into this repository.
    const astray = loaded.filter((path) => !inside(dir, path));
    expect(astray).toEqual([]);
    // And it really pulled the package: the sample, the door, and the modules
    // behind it — the renderer included, which is the fattest thing in there
    // and is exactly what a game importing the door gets.
    const seen = new Set(loaded.map((path) => relative(dir, path)));
    expect(seen).toContain(SAMPLE);
    expect(seen).toContain("index.ts");
    expect(seen).toContain("renderer.ts");
    expect([...seen].sort()).toEqual([...packed.modules, SAMPLE].sort());
    const code = await (out.outputs[0] as (typeof out.outputs)[number]).text();
    expect(code.length).toBeGreaterThan(1000);
  });
}, 60_000);
test("the packed door offers exactly the names this repository's door offers", async () => {
  await inTemp(async (dir) => {
    pack(dir);
    const packedDoor = (await import(pathToFileURL(join(dir, "index.ts")).href)) as Record<string, unknown>;
    const door = (await import("../src/engine/index.ts")) as Record<string, unknown>;
    // Every value the door here hands out, the copy hands out too, under the
    // same name: a module that failed to come along is a missing key.
    expect(Object.keys(packedDoor).sort()).toEqual(Object.keys(door).sort());
    // A runtime key is a name that is written down; the types are the rest.
    for (const name of Object.keys(packedDoor)) expect(SURFACE).toContain(name);
    // The written surface, types and all, read off the packed door itself.
    expect(reExportedNames(readFileSync(join(dir, "index.ts"), "utf8")).sort()).toEqual([...SURFACE].sort());
    // And the copy is a second engine, not a re-export of this one: the same
    // names, its own function objects, loaded from its own files.
    expect(typeof packedDoor.clamp).toBe("function");
    expect(packedDoor.clamp).not.toBe(door.clamp);
    expect((packedDoor.clamp as (x: number, lo: number, hi: number) => number)(5, 0, 1)).toBe(1);
  });
}, 30_000);
test("the run prints where the package went and what went into it", () => {
  const printed = line({ dir: DEFAULT_OUT, modules: ["index.ts", "math.ts"], files: [] });
  expect(printed).toContain(`${NAME} ${VERSION}`);
  expect(printed).toContain(join("dist", "engine"));
  expect(printed).toContain("2 modules");
});
@@ -0,0 +1,157 @@
/**
 * The pack: `src/engine/` written out as a package somebody else could install,
 * into a directory that holds nothing of this repository but the engine.
 *
 *   bun run scripts/pack.ts [directory]        # default dist/engine
 *
 * `boundary.test.ts` proves the engine imports nothing outside itself and
 * `purity.test.ts` proves it needs no browser to load. This script is the third
 * claim a package has to make — that it is *complete on its own*, behind one
 * door, with a name and nothing to install — and `pack.test.ts` beside it is
 * the measurement: it packs into a directory of its own, builds the sample
 * against the packed door and asserts every module the bundler loaded came out
 * of that directory. A path that led back here would fail there rather than in
 * somebody else's repository.
 *
 * What is written, and nothing else:
 *
 * - every shipping module under `src/engine/`, with the directory shape it has
 *   here — not a `.test.ts`, which is in no bundle, and not a `.probe.ts`,
 *   which is tooling a test spawns;
 * - `GUIDE.md`, because a package whose how is in another repository is not one;
 * - `package.json`, generated below: a name, `VERSION`, an ES module, one entry
 *   point and no dependencies, because the engine has none;
 * - `example.ts`, the guide's game, beside the modules rather than as one of
 *   them. It goes through the door on purpose — it is the sample a reader
 *   builds first, not a module of the package, which is why `index.ts` does not
 *   offer it and why this script does not count it as one.
 *
 * It is a script and not the app: it runs when a person runs it, it never runs
 * at request time, and it writes only under the directory it was given — which
 * it creates if it is missing and otherwise leaves alone. Nothing here reads or
 * writes `FORGE_APP_DATA`. Anything already in the target that this pack does
 * not write is left where it is; the copy is the files below, not the
 * directory's whole contents.
 */
import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
import { dirname, join, relative, resolve } from "node:path";
import { VERSION } from "./surface.ts";
const ROOT = join(import.meta.dir, "..");
/** Where the package is taken from: the engine, and only the engine. */
export const ENGINE = join(ROOT, "src", "engine");
/** Where it lands when nobody says: under `dist/`, which `.gitignore` covers. */
export const DEFAULT_OUT = join(ROOT, "dist", "engine");
/** The package's name. It is the repository's, because it is its point. */
export const NAME = "cs-engine";
/**
 * The version written into the generated `package.json`. It means the engine's
 * surface — the names `index.ts` offers — and it moves when one of them
 * arrives, leaves or is renamed. This repository keeps no other version and
 * does not otherwise number its releases: the commit is the real identity of a
 * pack, and this is what a reader of the package can compare against the guide.
 *
 * It is not a constant here, because a number that means a surface and sits
 * nowhere near one goes stale in the first pull that widens the door. It lives
 * in `src/engine/surface.json`, committed *with* the sorted list of names it
 * belongs to; `scripts/surface.ts` reads that record, `scripts/surface.test.ts`
 * holds today's door against it and says which part of this number to move, and
 * `src/engine/GUIDE.md` says what a move of it promises a game that packed an
 * older copy.
 */
export { VERSION };
/** The guide, which ships: a package whose how lives elsewhere is not one. */
export const GUIDE = "GUIDE.md";
/** The sample, which ships beside the package rather than as a module of it. */
export const SAMPLE = "example.ts";
/** Every `.ts` under `dir`, recursively, as paths relative to it, sorted. */
export function sources(dir: string, from = dir): string[] {
  const out: string[] = [];
  for (const entry of readdirSync(dir, { withFileTypes: true })) {
    const path = join(dir, entry.name);
    if (entry.isDirectory()) out.push(...sources(path, from));
    else if (entry.name.endsWith(".ts")) out.push(relative(from, path));
  }
  return out.sort();
}
/**
 * Is this file a module of the package? The same three exceptions
 * `src/engine/boundary.test.ts` knows about, read from this side: a test and a
 * probe are not code that ships, and the sample is a game written *on* the
 * package rather than a part of it.
 */
export function isModule(file: string): boolean {
  return (
    file.endsWith(".ts") &&
    !file.endsWith(".test.ts") &&
    !file.endsWith(".probe.ts") &&
    file !== SAMPLE
  );
}
/** The generated `package.json`, as plain data: no dependencies key, none to name. */
export function manifest(): Record<string, unknown> {
  return {
    name: NAME,
    version: VERSION,
    type: "module",
    exports: { ".": "./index.ts" },
  };
}
/** Where a pack goes: the one argument, resolved against the repository root. */
export function target(arg: string | undefined): string {
  if (arg === undefined) return DEFAULT_OUT;
  if (arg.trim() === "") throw new Error("the directory to pack into cannot be empty");
  return resolve(ROOT, arg);
}
/** What one pack wrote: the directory, the modules in it, and every file in it. */
export type Packed = { dir: string; modules: string[]; files: string[] };
/**
 * Write the package into `dir`, making it if it is missing, and hand back what
 * was written. Every path is joined onto `dir`; nothing above it is touched.
 */
export function pack(dir: string = DEFAULT_OUT, from: string = ENGINE): Packed {
  const modules = sources(from).filter(isModule);
  if (!modules.includes("index.ts")) throw new Error(`${from} has no index.ts; there is no door to pack`);
  const files: string[] = [];
  const put = (name: string, text: string): void => {
    const path = join(dir, name);
    mkdirSync(dirname(path), { recursive: true });
    writeFileSync(path, text);
    files.push(name);
  };
  mkdirSync(dir, { recursive: true });
  for (const module of modules) put(module, readFileSync(join(from, module), "utf8"));
  put(GUIDE, readFileSync(join(from, GUIDE), "utf8"));
  put(SAMPLE, readFileSync(join(from, SAMPLE), "utf8"));
  put("package.json", `${JSON.stringify(manifest(), null, 2)}\n`);
  return { dir, modules, files };
}
/** `cs-engine 0.1.0 → dist/engine  (21 modules, the guide, the sample)`. */
export function line({ dir, modules }: Packed): string {
  const where = relative(ROOT, dir) === "" ? dir : relative(ROOT, dir);
  return `${NAME} ${VERSION} → ${where}  (${modules.length} modules, the guide, the sample)`;
}
if (import.meta.main) {
  const args = process.argv.slice(2);
  if (args.length > 1) throw new Error("usage: bun run scripts/pack.ts [directory]");
  const packed = pack(target(args[0]));
  console.log(line(packed));
  console.log(`  bun build ${join(relative(ROOT, packed.dir), SAMPLE)}   # the sample, against the packed door`);
}
@@ -0,0 +1,135 @@
/**
 * The room bench, held to the two things a bench can be wrong about that a
 * reader would never see: its **arithmetic** and its **subject**.
 *
 * The timings themselves are not asserted here and must not be — a number from
 * a shared box is not a number from production, which is why `scripts/room.ts`
 * prints the machine it ran on and why the suite's only assertion about speed
 * is the ceiling in `src/budget.test.ts`. What is asserted is everything
 * around them:
 *
 * - The flags are read or refused with a sentence, so nobody measures a window
 *   of `NaN` seconds and writes the answer in a pull.
 * - Rooms per core is the division it claims to be, floored, and a margin
 *   narrows it.
 * - The JSON candidate carries the **same round** the packed one does — ten
 *   bodies with their health and their guns, the grenades, the smoke, the bomb
 *   and the clock — because a comparison between a packed snapshot and a
 *   smaller idea of one would flatter the winner and settle #304 on a lie.
 * - And the three encodings are measured over a real stepped room, packed
 *   smallest, JSON largest.
 */
import { expect, test } from "bun:test";
import { GZIP_LEVEL } from "../src/compress.ts";
import { useShipped } from "../src/client/shipped.ts";
import { createRoom, stepRoom, SNAPSHOT_HZ } from "../src/rooms/room.ts";
import { SNAPSHOT_MAX } from "../src/rooms/wire.ts";
import {
  DEFAULTS, RATES, encodings, jsonSnapshot, machine, parseOptions, perMemberPerSecond, roomsPerCore,
} from "./room.ts";
import type { Player } from "../src/client/world.ts";
// --- the flags ------------------------------------------------------------
test("the flags are read, and anything that is not a run is a sentence", () => {
  expect(parseOptions([])).toEqual(DEFAULTS);
  expect(parseOptions(["--seconds", "2.5"]).seconds).toBe(2.5);
  expect(parseOptions(["--members", "4"]).members).toBe(4);
  expect(parseOptions(["--margin", "0.25"]).margin).toBe(0.25);
  expect(() => parseOptions(["--fast"])).toThrow(/not a flag this script knows/);
  expect(() => parseOptions(["seconds", "2"])).toThrow(/is not a flag/);
  expect(() => parseOptions(["--seconds"])).toThrow(/needs a value/);
  expect(() => parseOptions(["--seconds", "--members"])).toThrow(/needs a value/);
  expect(() => parseOptions(["--seconds", "soon"])).toThrow(/takes a number/);
  expect(() => parseOptions(["--seconds", "0"])).toThrow(/above zero/);
  expect(() => parseOptions(["--members", "11"])).toThrow(/1…10/);
  expect(() => parseOptions(["--members", "2.5"])).toThrow(/1…10/);
  expect(() => parseOptions(["--margin", "2"])).toThrow(/share of one core/);
  expect(() => parseOptions(["--margin", "0"])).toThrow(/share of one core/);
});
// --- the arithmetic -------------------------------------------------------
test("rooms per core is the division it says it is, floored, and the margin narrows it", () => {
  // A second of one core is 1000 ms of CPU: a room costing 10 ms of it a second
  // is a hundredth of a core, so a hundred of them is the core and fifty is
  // half of it.
  expect(roomsPerCore(10, 1)).toBe(100);
  expect(roomsPerCore(10, 0.5)).toBe(50);
  // Half a room is no room.
  expect(roomsPerCore(30, 1)).toBe(33);
  // And a cost nobody measured is not an infinite number of rooms.
  expect(roomsPerCore(0, 1)).toBe(0);
  expect(roomsPerCore(-1, 1)).toBe(0);
});
test("bytes a member a second is the frame at the rate, and the rates include the shipped one", () => {
  expect(perMemberPerSecond(544, 16)).toBe(8704);
  expect(perMemberPerSecond(544, 32)).toBe(17408);
  expect(RATES).toEqual([8, SNAPSHOT_HZ, 32]);
  expect(RATES).toContain(SNAPSHOT_HZ);
});
test("the machine is named, because a number from a laptop is not a number from production", () => {
  expect(machine()).toContain(`bun ${Bun.version}`);
  expect(machine()).toContain(process.platform);
});
// --- the subject ----------------------------------------------------------
/** A room with a few seconds of a live round played into it. */
function played(seconds: number) {
  useShipped();
  const room = createRoom("TESTRM", { map: "de_forge", seed: 9, length: "short", now: 0 });
  room.world.match.phase = "live";
  room.world.match.timer = room.rules.roundTime;
  for (let i = 0; i < 64 * seconds; i++) stepRoom(room);
  return room;
}
test("the JSON candidate carries the same round the packed one does", () => {
  const room = played(3);
  room.world.bomb.state = "planted";
  room.world.bomb.site = "A";
  room.world.clouds.push({ pos: [500, 500, 40], born: room.world.time - 1, owner: 3 });
  const snapshot = jsonSnapshot(room.world, room.tick, 0) as Record<string, unknown>;
  expect(snapshot.t).toBe(room.tick);
  expect(snapshot.phase).toBe("live");
  const bomb = snapshot.bomb as Record<string, unknown>;
  expect(bomb.state).toBe("planted");
  expect(bomb.site).toBe("A");
  expect((snapshot.clouds as unknown[]).length).toBe(1);
  const bodies = snapshot.players as Record<string, unknown>[];
  expect(bodies.length).toBe(room.world.players.length);
  bodies.forEach((body, i) => {
    const p = room.world.players[i] as Player;
    // Every body, to the hundredth of a unit a JSON wire would round to.
    expect((body.pos as number[])[0]).toBeCloseTo(p.pos[0], 1);
    expect(body.health).toBe(Math.round(p.health));
    expect(body.weapon).toBe(p.weapon);
    expect(body.alive).toBe(p.alive);
    expect(body.money).toBe(Math.round(p.money));
  });
});
test("the three encodings are measured over a real round, and the packed one is the smallest", () => {
  const room = played(3);
  const frame = encodings(room.world, room.tick, 0, new Uint8Array(SNAPSHOT_MAX));
  expect(frame.packed).toBeGreaterThan(0);
  expect(frame.packed).toBeLessThan(frame.gzip);
  expect(frame.gzip).toBeLessThan(frame.json);
  // The packed frame is the one the wire sends, so it is the one pinned by
  // `src/rooms/wire.test.ts`; this only holds the ordering the pull reports.
  expect(frame.json).toBeGreaterThan(2000);
  // And the gzip is really gzip at the level this server compresses at: a
  // different level would be a different number in the table.
  const text = JSON.stringify(jsonSnapshot(room.world, room.tick, 0));
  expect(frame.gzip).toBe(Bun.gzipSync(Buffer.from(text, "utf8"), { level: GZIP_LEVEL }).byteLength);
  expect(frame.json).toBe(Buffer.byteLength(text, "utf8"));
});
@@ -0,0 +1,506 @@
/**
 * What one room costs, measured:
 *
 *   bun run scripts/room.ts                 # the table
 *   bun run scripts/room.ts --seconds 30    # a longer window of play
 *   bun run scripts/room.ts --members 4     # snapshots for four people, not ten
 *   bun run scripts/room.ts --margin 0.25   # a quarter of a core for rooms
 *
 * `src/rooms/hub.ts` holds `ROOM_CAP` rooms in this process and the argument for
 * where that cap is is arithmetic on two numbers: what a world-second of the
 * simulation costs this process, and what a snapshot of that world weighs on a
 * wire. This script measures both rather than asserting them, because every
 * question multiplayer asks after it — how many rooms a deployment holds, how
 * often a snapshot can go out, whether this process can be the truth at all —
 * is those two numbers and nothing else.
 *
 * It measures a **real room**: `createRoom` from `src/rooms/room.ts`, ten
 * bodies on de_forge, `stepRoom` at the game's own 64 Hz with the shipped
 * policy thinking, and `writeSnapshot` on the round that leaves. Nothing here
 * is a stub and nothing is a model of the game; the only thing it does that a
 * deployment does not is skip the freeze at the top of the round, because eight
 * seconds of ten bodies standing still is eight seconds of a tick that is not
 * the tick anybody is asking about.
 *
 * **What it excludes**, said plainly because a bench that hides its edges is
 * worse than none: the socket. No WebSocket is opened, nothing is written to a
 * file descriptor, and the kernel's share of sending 8.7 kB a second to ten
 * members is not in any number below. What is in them is everything this
 * process computes — the simulation, the input frames off the wire, and the
 * encoding of every snapshot.
 *
 * **It is not a ceiling.** `src/budget.test.ts` holds the ceiling and fails
 * when a room-second gets dearer; this prints numbers for a person reading
 * them, and the two are kept apart for the reason that file's header gives.
 *
 * It ships in no bundle and the server never imports it: this is a script a
 * person runs and `room.test.ts` runs the pure parts of. It writes nothing,
 * anywhere.
 */
import { cpus } from "node:os";
import { GZIP_LEVEL } from "../src/compress.ts";
import { useShipped } from "../src/client/shipped.ts";
import { createRoom, drive, join, stepRoom, TICK, SNAPSHOT_HZ, type Room } from "../src/rooms/room.ts";
import { writeInput, writeSnapshot, SNAPSHOT_MAX } from "../src/rooms/wire.ts";
import { NO_INPUT, type Effect, type Player, type World } from "../src/client/world.ts";
// --- the options ----------------------------------------------------------
export type Options = {
  /** How many simulated seconds one batch of the step is. */
  seconds: number;
  /** How many members' snapshots a full room is costed for. */
  members: number;
  /** What share of one core rooms are allowed, for the "how many" arithmetic. */
  margin: number;
};
export const DEFAULTS: Options = { seconds: 10, members: 10, margin: 0.5 };
const KNOWN = ["--seconds", "--members", "--margin"];
export const USAGE = `usage: bun run scripts/room.ts [${KNOWN.join("] [")}]`;
/**
 * argv (what comes after the script name) in, options out. Anything that is not
 * a run — an unknown flag, a value that is not a number, a window of zero
 * seconds, a margin outside 0…1 — throws a sentence naming the flag and what it
 * got, because a table of numbers measured over `NaN` seconds is worse than an
 * error.
 */
export function parseOptions(argv: readonly string[]): Options {
  const options: Options = { ...DEFAULTS };
  for (let i = 0; i < argv.length; i++) {
    const flag = argv[i] as string;
    if (!flag.startsWith("--")) throw new Error(`${JSON.stringify(flag)} is not a flag; ${USAGE}`);
    if (!KNOWN.includes(flag)) throw new Error(`${flag} is not a flag this script knows; ${USAGE}`);
    const text = argv[++i];
    if (text === undefined || text.startsWith("--")) throw new Error(`${flag} needs a value`);
    const n = Number(text);
    if (!Number.isFinite(n)) throw new Error(`${flag} takes a number, and got ${JSON.stringify(text)}`);
    if (flag === "--seconds") {
      if (n <= 0) throw new Error(`--seconds is a window of play, so it is above zero, and got ${n}`);
      options.seconds = n;
    } else if (flag === "--members") {
      if (!Number.isInteger(n) || n < 1 || n > 10) throw new Error(`--members is 1…10, and got ${JSON.stringify(text)}`);
      options.members = n;
    } else {
      if (n <= 0 || n > 1) throw new Error(`--margin is a share of one core, above 0 and at most 1, and got ${n}`);
      options.margin = n;
    }
  }
  return options;
}
// --- the arithmetic the numbers are read through --------------------------
/**
 * How many rooms one core holds, given what a room-second of CPU costs and the
 * share of that core rooms may have. A thousand milliseconds of CPU is a second
 * of one core; a room that costs `each` milliseconds a simulated second takes
 * that much of it, and the floor is taken because half a room is no room.
 *
 * The margin is not conservatism for its own sake: this process also serves
 * pages, encodes snapshots for everybody, and runs a garbage collector, and a
 * room that is late does not drop a frame — it judders for ten people.
 */
export const roomsPerCore = (each: number, margin: number): number =>
  each <= 0 ? 0 : Math.floor((1000 * margin) / each);
/** What one member is sent a second, in bytes, at a rate of `hz` snapshots. */
export const perMemberPerSecond = (bytes: number, hz: number): number => bytes * hz;
/** The rates this script costs every encoding at. */
export const RATES = [8, SNAPSHOT_HZ, 32] as const;
// --- the two clocks -------------------------------------------------------
/**
 * Milliseconds of CPU this process has burned, user and system together.
 *
 * Every batch below is timed by this **and** by the wall clock, and the
 * measurement is the smaller of the two: interference only ever pushes one of
 * them up — a descheduled process reads a long wall clock, a GC thread on
 * another core reads a long CPU clock — so the smaller is the tightest bound
 * the pair honestly supports. It is the same argument `src/budget.test.ts`
 * makes at length, and the fifteen lines are here rather than imported from
 * there because a script that imports a test file to run is a worse trade than
 * fifteen lines that say the same thing.
 */
const cpuMs = (): number => {
  const used = process.cpuUsage();
  return (used.user + used.system) / 1000;
};
const median = (xs: number[]): number =>
  [...xs].sort((a, b) => a - b)[(xs.length - 1) >> 1] as number;
/** Batches thrown away before any are kept, so nothing measured is cold. */
const WARM = 2;
/** Batches kept, of which the median is the answer. Odd, so there is one. */
const BATCHES = 7;
export type Measured = { label: string; each: number; wall: number; cpu: number };
/** One batch's worth of world-seconds, timed one at a time. */
const secondsOf = (ticks: number, step: () => void): number[] => {
  const out: number[] = [];
  for (let i = 0; i < ticks; i += 64) {
    const wall = performance.now();
    const cpu = cpuMs();
    for (let j = 0; j < Math.min(64, ticks - i); j++) step();
    out.push(Math.min(performance.now() - wall, cpuMs() - cpu));
  }
  return out;
};
/**
 * The cost of a world-second across a round rather than averaged over one: a
 * room's first second is ten bots walking out of spawn and its fifth is a
 * firefight, and a deployment is sized by the dear second and not the cheap
 * one. `make` hands back a fresh room per batch; `step` takes one tick of it.
 */
export function profile(ticks: number, make: () => () => void): { mean: number; peak: number; at: number } {
  const means: number[] = [];
  const peaks: number[] = [];
  const ats: number[] = [];
  for (let b = 0; b < WARM + BATCHES; b++) {
    const each = secondsOf(ticks, make());
    if (b < WARM) continue;
    means.push(each.reduce((a, c) => a + c, 0) / each.length);
    const peak = Math.max(...each);
    peaks.push(peak);
    ats.push(each.indexOf(peak) + 1);
  }
  return { mean: median(means), peak: median(peaks), at: median(ats) };
}
/**
 * `runs` of something, warmed and repeated, in milliseconds each. `batch` does
 * `runs` operations and is called once per batch; the answer is the median of
 * `BATCHES` kept batches on the tighter of the two clocks.
 */
function measure(label: string, runs: number, batch: () => void): Measured {
  const walls: number[] = [];
  const cpus_: number[] = [];
  for (let i = 0; i < WARM + BATCHES; i++) {
    const wall = performance.now();
    const cpu = cpuMs();
    batch();
    if (i < WARM) continue;
    walls.push((performance.now() - wall) / runs);
    cpus_.push((cpuMs() - cpu) / runs);
  }
  const wall = median(walls);
  const cpu = median(cpus_);
  return { label, each: Math.min(wall, cpu), wall, cpu };
}
// --- the room being measured ----------------------------------------------
/** How many bodies a room has. Ten, like the game. */
const BODIES = 10;
/**
 * A room with its round already under way: the same fixed map and seed every
 * time, and the freeze set aside for the reason in the header. Fresh per batch,
 * because a world played for thousands of ticks is a world where people have
 * died and a dead body does not think — the measurement would drift downwards
 * into a number about nothing.
 */
function liveRoom(seed = 9): Room {
  const room = createRoom("BENCH1", { map: "de_forge", seed, length: "short", now: 0 });
  room.world.match.phase = "live";
  room.world.match.timer = room.rules.roundTime;
  return room;
}
/** The same room with every seat held by a member, so no body is left to think. */
function heldRoom(seed = 9): { room: Room; ids: string[] } {
  const room = liveRoom(seed);
  const ids: string[] = [];
  for (let i = 0; i < BODIES; i++) {
    const id = `member-${i}`;
    if (join(room, id, id, 0) !== null) ids.push(id);
  }
  return { room, ids };
}
/** One input frame per member per tick, the way a page sends them: keys down. */
function driveAll(room: Room, ids: readonly string[], frames: Uint8Array<ArrayBuffer>[]): void {
  ids.forEach((id, i) => {
    writeInput(
      { tick: room.tick, input: { ...NO_INPUT, forward: 1 }, yaw: 90, pitch: 0, switchCode: 0, buy: null },
      frames[i] as Uint8Array<ArrayBuffer>,
    );
    drive(room, id, frames[i] as Uint8Array);
  });
}
// --- the three encodings a wire could use ---------------------------------
/**
 * The same snapshot as plain data: every field `writeSnapshot` packs, in the
 * shape a JSON wire would send it. It exists so the comparison below is between
 * two encodings of *one* frame rather than between a packed snapshot and a
 * smaller idea of one — the ten bodies, the grenades in the air, the smoke
 * standing, the bomb, the clock, and the events since the member's last beat.
 *
 * Nothing chooses an encoding here. This measures three candidates; the choice
 * and its reasons are `src/rooms/wire.ts`'s, and a reader comparing the numbers
 * should read that file's header for what the packed one buys.
 *
 * Numbers are rounded the way an honest JSON wire would round them — positions
 * to a hundredth of a unit, angles to a tenth of a degree — because
 * `JSON.stringify` of an f32 writes seventeen significant digits and charging
 * JSON for those would be measuring a strawman.
 */
export function jsonSnapshot(world: World, tick: number, since: number): unknown {
  const r2 = (v: number): number => Math.round(v * 100) / 100;
  const r1 = (v: number): number => Math.round(v * 10) / 10;
  const m = world.match;
  return {
    t: tick,
    time: r2(world.time),
    phase: m.phase,
    round: m.round,
    score: [m.score.t, m.score.ct],
    timer: r2(m.timer),
    winner: m.matchWinner,
    bomb: {
      state: world.bomb.state,
      pos: world.bomb.pos.map(r2),
      plant: r2(world.bomb.plantProgress),
      defuse: r2(world.bomb.defuseProgress),
      site: world.bomb.site,
    },
    players: world.players.map((p: Player) => ({
      pos: p.pos.map(r2),
      vel: p.vel.map(r2),
      yaw: r1(p.yaw),
      pitch: r1(p.pitch),
      health: Math.round(p.health),
      armor: Math.round(p.armor),
      alive: p.alive,
      team: p.team,
      onGround: p.onGround,
      ducking: p.ducking,
      duck: r2(p.duckAmount),
      bomb: p.hasBomb,
      helmet: p.helmet,
      kit: p.defuseKit,
      scoped: p.scoped,
      weapon: p.weapon,
      primary: p.primary,
      secondary: p.secondary,
      mag: p.ammo[p.weapon]?.mag ?? 0,
      reserve: p.ammo[p.weapon]?.reserve ?? 0,
      money: Math.round(p.money),
      blind: r2(p.blind),
      pocket: [p.pocket.he, p.pocket.flash, p.pocket.smoke],
      kills: p.kills,
      deaths: p.deaths,
      damage: Math.round(p.damage),
    })),
    grenades: world.grenades.map((g) => ({
      pos: g.pos.map(r2), weapon: g.weapon, owner: g.owner, team: g.team, fuse: r2(g.fuse),
    })),
    clouds: world.clouds.map((s) => ({ pos: s.pos.map(r2), age: r2(world.time - s.born), owner: s.owner })),
    events: eventsSince(world, since).map((e) => ({ ...e, at: r2(e.at) })),
  };
}
/** Everything in the world's effect ring younger than `since`, oldest first. */
function eventsSince(world: World, since: number): Effect[] {
  const out: Effect[] = [];
  const ring = world.effects;
  for (let i = 0; i < ring.count; i++) {
    const e = ring.events[i];
    if (e !== undefined && e.at > since) out.push(e);
  }
  return out;
}
export type Frame = { packed: number; json: number; gzip: number };
/** What one beat weighs in each of the three encodings, in bytes. */
export function encodings(world: World, tick: number, since: number, into: Uint8Array): Frame {
  const packed = writeSnapshot(world, tick, since, into).byteLength;
  const text = JSON.stringify(jsonSnapshot(world, tick, since));
  const bytes = Buffer.byteLength(text, "utf8");
  return { packed, json: bytes, gzip: Bun.gzipSync(Buffer.from(text, "utf8"), { level: GZIP_LEVEL }).byteLength };
}
// --- printing -------------------------------------------------------------
const ms = (v: number): string => `${v.toFixed(v < 1 ? 3 : 2)} ms`;
const kb = (v: number): string => (v < 1000 ? `${Math.round(v)} B` : `${(v / 1000).toFixed(1)} kB`);
const pad = (text: string, width: number): string => text.padEnd(width);
const rpad = (text: string, width: number): string => text.padStart(width);
/** Which machine this ran on, because a number from a laptop is not production. */
export const machine = (): string =>
  `${cpus()[0]?.model.trim() ?? "unknown CPU"} × ${cpus().length}` +
  `, bun ${Bun.version}, ${process.platform}/${process.arch}`;
async function main(options: Options): Promise<void> {
  useShipped(); // a bot with no policy does not think, and would not be measured
  const ticks = Math.round(options.seconds * 64);
  const seconds = ticks * TICK;
  const buffer = new Uint8Array(SNAPSHOT_MAX);
  console.log(`what a room costs — ten bodies on de_forge at 64 Hz, ${seconds.toFixed(2)} simulated seconds a batch`);
  console.log(`  ${machine()}`);
  console.log(`  median of ${BATCHES} batches after ${WARM}, on the tighter of the wall and CPU clocks\n`);
  // --- the step ---
  // The rooms of every batch are kept so the round each measurement really
  // played can be asked afterwards how many bodies were still standing in it.
  const played: Room[] = [];
  const thinking = profile(ticks, () => {
    const room = liveRoom();
    played.push(room);
    return () => stepRoom(room);
  });
  const aliveAfter = (played[played.length - 1] as Room).world.players.filter((p) => p.alive).length;
  // The other half of the pair, and the only way this game has of stepping a
  // world with no policy in the loop: a bot without one does not think, it
  // throws (`policy()` in `src/client/bots.ts`), so "the policy unloaded" is a
  // room whose every seat is held by a member sending keys.
  const frames = Array.from({ length: BODIES }, () => new Uint8Array(14));
  const idle = profile(ticks, () => {
    const { room, ids } = heldRoom();
    return () => {
      driveAll(room, ids, frames);
      stepRoom(room);
    };
  });
  // What the wire itself costs inside that number: ten input frames written and
  // read every tick, which the thinking room above does not pay at all.
  const wire = measure("  of which the input frames off the wire", seconds, () => {
    const { room, ids } = heldRoom();
    for (let i = 0; i < ticks; i++) driveAll(room, ids, frames);
  });
  console.log("CPU per simulated world-second");
  console.log(`  ${pad("", 40)}${rpad("average", 10)}${rpad("dearest second", 18)}`);
  const step = (label: string, m: { mean: number; peak: number; at: number }): void =>
    console.log(`  ${pad(label, 40)}${rpad(ms(m.mean), 10)}${rpad(`${ms(m.peak)} (no. ${m.at})`, 18)}`);
  step("ten bots thinking, the shipped policy", thinking);
  step("ten seats driven, nothing thinking", idle);
  console.log(`  ${pad(wire.label, 40)}${rpad(ms(wire.each), 10)}`);
  // Ten bodies are stepped either way; what the first row has and the second
  // does not is ten policies thinking, and what the second has and the first
  // does not is the wire. So the policy's share is the difference, with the
  // wire handed back — which is an estimate and is called one: bots that think
  // also shoot, throw and die, and a body walking forward into a wall does not.
  const share = thinking.mean - (idle.mean - wire.each);
  console.log(
    `  ${pad("so the ten policies cost about", 40)}${rpad(ms(share), 10)}` +
      `  (${((share / thinking.mean) * 100).toFixed(0)}% of a thinking room)`,
  );
  console.log(
    `  ${aliveAfter} of ${BODIES} bodies were still alive after ${seconds.toFixed(1)}s` +
      ` of the thinking round, which is what the numbers above are seconds of\n`,
  );
  // --- the snapshot, over a real round ---
  const beats: Frame[] = [];
  {
    const room = liveRoom();
    const every = Math.max(1, Math.round(64 / SNAPSHOT_HZ));
    let since = 0;
    for (let i = 0; i < ticks; i++) {
      stepRoom(room);
      if (i % every !== 0) continue;
      beats.push(encodings(room.world, room.tick, since, buffer));
      since = room.world.time;
    }
  }
  const pick = (of: (f: Frame) => number): { med: number; max: number } => ({
    med: median(beats.map(of)),
    max: Math.max(...beats.map(of)),
  });
  const sizes = {
    "packed binary": pick((f) => f.packed),
    "JSON": pick((f) => f.json),
    [`JSON gzipped (level ${GZIP_LEVEL})`]: pick((f) => f.gzip),
  };
  console.log(`a snapshot of this round, over ${beats.length} beats at ${SNAPSHOT_HZ} Hz`);
  for (const [name, size] of Object.entries(sizes))
    console.log(`  ${pad(name, 30)} median ${rpad(kb(size.med), 8)}   widest ${rpad(kb(size.max), 8)}`);
  console.log();
  console.log(`bytes a member a second, at the median beat`);
  console.log(`  ${pad("", 30)}${RATES.map((hz) => rpad(`${hz} Hz`, 12)).join("")}`);
  for (const [name, size] of Object.entries(sizes))
    console.log(
      `  ${pad(name, 30)}` +
        RATES.map((hz) => rpad(`${kb(perMemberPerSecond(size.med, hz))}/s`, 12)).join(""),
    );
  console.log();
  // --- what encoding a beat costs this process ---
  const busy = liveRoom();
  for (let i = 0; i < ticks; i++) stepRoom(busy);
  // One beat's worth of "since", not the whole ring: what a member is sent
  // sixteen times a second is the round plus what happened in the last
  // sixteenth of it, and costing them the whole ring would be costing a frame
  // nobody is ever sent.
  const since = busy.world.time - 1 / SNAPSHOT_HZ;
  const runs = 200;
  const encode = [
    measure("packed binary", runs, () => {
      for (let i = 0; i < runs; i++) writeSnapshot(busy.world, busy.tick, since, buffer);
    }),
    measure("JSON", runs, () => {
      for (let i = 0; i < runs; i++) JSON.stringify(jsonSnapshot(busy.world, busy.tick, since));
    }),
    measure(`JSON gzipped (level ${GZIP_LEVEL})`, runs, () => {
      for (let i = 0; i < runs; i++)
        Bun.gzipSync(Buffer.from(JSON.stringify(jsonSnapshot(busy.world, busy.tick, since)), "utf8"), { level: GZIP_LEVEL });
    }),
  ];
  console.log("CPU to encode one beat, and what that is a world-second for a full room");
  for (const m of encode)
    console.log(
      `  ${pad(m.label, 30)} ${rpad(ms(m.each), 9)} a beat` +
        `   ${rpad(ms(m.each * SNAPSHOT_HZ * options.members), 9)} a world-second` +
        ` (${options.members} members at ${SNAPSHOT_HZ} Hz)`,
    );
  console.log();
  // --- the answer ---
  const packedCost = (encode[0] as Measured).each * SNAPSHOT_HZ * options.members;
  const whole = thinking.mean + packedCost;
  const dearest = thinking.peak + packedCost;
  const row = (label: string, each: number): void =>
    console.log(
      `  ${pad(label, 46)} ${rpad(String(roomsPerCore(each, options.margin)), 4)} rooms` +
        `   (${roomsPerCore(each, 1)} flat out, at ${ms(each)} a room-second)`,
    );
  console.log(`rooms one core holds at 64 Hz, with ${((1 - options.margin) * 100).toFixed(0)}% of it left for everything else`);
  row("the step alone, bots thinking", thinking.mean);
  row("the step alone, nobody thinking", idle.mean);
  row(`a whole room: step and ${options.members} packed snapshots`, whole);
  row("the same, priced at the round's dearest second", dearest);
  console.log(
    `\none room costs ${ms(whole)} of CPU a second — the step ${ms(thinking.mean)}` +
      ` and ${options.members} snapshots ${ms(packedCost)} — so one core holds ${roomsPerCore(whole, options.margin)}` +
      ` of them at ${SNAPSHOT_HZ} Hz with ${((1 - options.margin) * 100).toFixed(0)}% of the core to spare,` +
      ` or ${roomsPerCore(dearest, options.margin)} if every one of them is having its dearest second at once.`,
  );
}
if (import.meta.main) {
  try {
    await main(parseOptions(process.argv.slice(2)));
  } catch (error) {
    console.error(error instanceof Error ? error.message : String(error));
    process.exit(1);
  }
}
@@ -0,0 +1,213 @@
/**
 * The version, enforced. `src/engine/surface.json` says which names the door
 * offered when the version in it was set, and `scripts/pack.ts` stamps that
 * version into every pack. This file is what makes the number true: it reads
 * today's door, holds it against the record, and fails when the surface moved
 * and the number did not — naming the names that arrived or left, saying which
 * part of the version that moves, and printing the one step that records it.
 *
 * The rest of this file is that message and that arithmetic, tested on made-up
 * surfaces rather than on the real one, so the promises hold for a change that
 * has not happened yet.
 */
import { expect, test } from "bun:test";
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import {
  COMMAND,
  DOOR,
  RECORD,
  VERSION,
  bump,
  changed,
  doorNames,
  isVersion,
  line,
  moved,
  parse,
  read,
  render,
  today,
  verdict,
  write,
} from "./surface.ts";
import { manifest } from "./pack.ts";
import { SURFACE, reExportedNames } from "../src/engine/boundary.test.ts";
/** A record of this test's own, removed however the body ends. */
function inTemp<T>(body: (path: string) => T): T {
  const dir = mkdtempSync(join(tmpdir(), "surface-"));
  try {
    return body(join(dir, "surface.json"));
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
}
const seed = (path: string, version: string, names: string[]): string => {
  writeFileSync(path, render({ version, names }));
  return path;
};
// --- the record on disk ---------------------------------------------------
test("today's door is the surface the recorded version belongs to", () => {
  const record = read();
  const why = verdict(today(), record);
  // Thrown rather than asserted, the way a pinned run's complaint is thrown in
  // `src/range/pin.test.ts`: the message is the whole point of this file, so a
  // failure here prints it entire rather than as a diff of two hundred names.
  if (why !== null) throw new Error(why);
  expect(today()).toEqual(record.names);
  expect(record.names.length).toBeGreaterThan(50);
});
test("the version a pack is stamped with is the version the record pins", () => {
  expect(VERSION).toBe(read().version);
  expect(manifest().version).toBe(read().version);
  expect(isVersion(VERSION)).toBe(true);
});
test("the record is exactly the bytes a write produces, so a diff is the names", () => {
  const text = readFileSync(RECORD, "utf8");
  expect(text).toBe(render(read()));
  // Data, not prose: two keys, and a name to a line.
  expect(Object.keys(JSON.parse(text) as object).sort()).toEqual(["names", "version"]);
  // One name to a line: the two keys, the brackets, the braces and the names.
  expect(text.trimEnd().split("\n").length).toBe(read().names.length + 5);
  expect(text.endsWith("]\n}\n")).toBe(true);
});
test("the surface the record holds is the surface the engine's own test pins", () => {
  // `boundary.test.ts` reads this record for `SURFACE` — one written-down copy
  // of the API — and reads the door with its own regular expression, which may
  // not import this one. Both readings, on the real door, agree here or never.
  expect(SURFACE).toEqual(read().names);
  expect(doorNames(readFileSync(DOOR, "utf8"))).toEqual(
    reExportedNames(readFileSync(DOOR, "utf8")).sort(),
  );
});
test("a type-only export is in the record, because a game imports types too", () => {
  const record = read().names;
  // `Body` and `Hull` are types; `move` is a function. All three are promises.
  expect(record).toContain("Body");
  expect(record).toContain("Hull");
  expect(record).toContain("move");
});
// --- reading the record ---------------------------------------------------
test("the record is checked rather than trusted", () => {
  expect(parse(`{"version":"1.2.3","names":["a","b"]}`)).toEqual({ version: "1.2.3", names: ["a", "b"] });
  expect(() => parse("{")).toThrow(/is not JSON/);
  expect(() => parse("[]")).toThrow(/is not an object/);
  expect(() => parse(`{"names":["a"]}`)).toThrow(/a version and a list of names/);
  expect(() => parse(`{"version":"1.0.0","names":["a"],"note":"why"}`)).toThrow(/a version and a list of names/);
  expect(() => parse(`{"version":"1.0","names":["a"]}`)).toThrow(/three numbers/);
  expect(() => parse(`{"version":"1.0.0","names":[]}`)).toThrow(/no names/);
  expect(() => parse(`{"version":"1.0.0","names":[3]}`)).toThrow(/not a name/);
  expect(() => parse(`{"version":"1.0.0","names":["a","a"]}`)).toThrow(/twice/);
  expect(() => parse(`{"version":"1.0.0","names":["b","a"]}`)).toThrow(/not sorted/);
});
test("a version is three numbers and two dots", () => {
  expect(isVersion("0.1.0")).toBe(true);
  expect(isVersion("10.20.30")).toBe(true);
  expect(isVersion("1.0")).toBe(false);
  expect(isVersion("v1.0.0")).toBe(false);
  expect(isVersion("1.0.0-beta")).toBe(false);
});
// --- what moved, and what that asks of the number -------------------------
test("what arrived and what left, and a rename is both", () => {
  expect(changed(["a", "b"], ["a", "b"])).toEqual({ added: [], removed: [] });
  expect(changed(["a"], ["a", "b"])).toEqual({ added: ["b"], removed: [] });
  expect(changed(["a", "b"], ["a"])).toEqual({ added: [], removed: ["b"] });
  expect(changed(["move"], ["walk"])).toEqual({ added: ["walk"], removed: ["move"] });
  expect(moved(changed(["a"], ["a"]))).toBe(false);
  expect(moved(changed(["a"], ["a", "b"]))).toBe(true);
});
test("a name that arrived moves the middle number; one that left moves the first", () => {
  expect(bump("0.1.0", { added: ["b"], removed: [] })).toBe("0.2.0");
  expect(bump("1.4.2", { added: ["b"], removed: [] })).toBe("1.5.0");
  expect(bump("0.1.0", { added: [], removed: ["a"] })).toBe("1.0.0");
  // A rename is a removal wearing an arrival, and the removal decides.
  expect(bump("0.1.0", { added: ["walk"], removed: ["move"] })).toBe("1.0.0");
  expect(bump("0.1.0", { added: [], removed: [] })).toBe("0.1.0");
  expect(() => bump("0.1", { added: [], removed: [] })).toThrow(/not a version/);
});
// --- the message ----------------------------------------------------------
test("a surface that did not move says nothing at all", () => {
  expect(verdict(["a", "b"], { version: "0.1.0", names: ["a", "b"] })).toBeNull();
});
test("a name that arrived is named, with the middle number and the step to take", () => {
  const why = verdict(["a", "b", "sway"], { version: "0.1.0", names: ["a", "b"] }) as string;
  expect(why).toContain("1 name arrived: `sway`.");
  expect(why).not.toContain("left:");
  expect(why).toContain("still builds");
  expect(why).toContain("the middle number moves: 0.1.0 → 0.2.0");
  expect(why).toContain(`${COMMAND} 0.2.0`);
  expect(why).toContain("src/engine/surface.json");
  expect(why).toContain("src/engine/GUIDE.md");
});
test("a name that left is named, with the first number and the step to take", () => {
  const why = verdict(["a"], { version: "0.1.0", names: ["a", "b"] }) as string;
  expect(why).toContain("1 name left: `b`.");
  expect(why).toContain("stop a game that packed an older copy from building");
  expect(why).toContain("the first number moves: 0.1.0 → 1.0.0");
  expect(why).toContain(`${COMMAND} 1.0.0`);
});
test("a rename says both halves, and the removal decides the number", () => {
  const why = verdict(["walk"], { version: "2.3.4", names: ["move"] }) as string;
  expect(why).toContain("1 name arrived: `walk`.");
  expect(why).toContain("1 name left: `move`.");
  expect(why).toContain("2.3.4 → 3.0.0");
  expect(why).toContain(`${COMMAND} 3.0.0`);
});
test("several names read as a sentence, not as a diff", () => {
  const why = verdict(["a", "b", "c", "d"], { version: "0.1.0", names: ["a"] }) as string;
  expect(why).toContain("3 names arrived: `b`, `c` and `d`.");
});
// --- the one step ---------------------------------------------------------
test("the write records today's names, sorted, against the version it was given", () => {
  inTemp((path) => {
    seed(path, "0.1.0", ["a", "b"]);
    const written = write(["sway", "a", "b"], "0.2.0", path);
    expect(written).toEqual({ version: "0.2.0", names: ["a", "b", "sway"] });
    expect(read(path)).toEqual(written);
    expect(readFileSync(path, "utf8")).toBe(render(written));
    expect(verdict(["a", "b", "sway"], read(path))).toBeNull();
  });
});
test("a write that leaves the number where it was when the surface moved is refused", () => {
  inTemp((path) => {
    seed(path, "0.1.0", ["a", "b"]);
    expect(() => write(["a", "b", "sway"], "0.1.0", path)).toThrow(/asks for 0\.2\.0/);
    expect(() => write(["a"], "0.1.0", path)).toThrow(/asks for 1\.0\.0/);
    expect(() => write(["a", "b"], "0.1", path)).toThrow(/not a version/);
    // The refusals left the record alone.
    expect(read(path)).toEqual({ version: "0.1.0", names: ["a", "b"] });
    // A surface that did not move may be rewritten at the same version.
    expect(write(["a", "b"], "0.1.0", path).version).toBe("0.1.0");
  });
});
test("the run prints the version and how many names it covers", () => {
  expect(line({ version: "0.1.0", names: ["a", "b"] }, "src/engine/surface.json")).toBe(
    "0.1.0 — 2 names behind the door, recorded in src/engine/surface.json",
  );
});
@@ -0,0 +1,241 @@
/**
 * The engine's surface, recorded against the version it belongs to.
 *
 *   bun run scripts/surface.ts                 # is today's door the recorded one?
 *   bun run scripts/surface.ts --write 0.2.0   # record today's door as that version
 *
 * `scripts/pack.ts` writes a version into the `package.json` it generates, and
 * that number means one thing: the names `src/engine/index.ts` offers. A number
 * like that is a promise to somebody who packed an older copy, and a promise
 * nothing checks is a lie waiting for the first pull that widens the door. So
 * the surface and the version are committed *together*, as one record —
 * `src/engine/surface.json`, the sorted list of names and the version they
 * belong to, and nothing else — and `scripts/surface.test.ts` holds today's
 * door against it on every run of the tests.
 *
 * The rule the record enforces, in one line each, and written out for a reader
 * of the package in `src/engine/GUIDE.md`:
 *
 * - a name arrives and none leaves → the middle number moves. A game that
 *   packed an older copy still builds: every name it imported is still here;
 * - a name leaves or is renamed → the first number moves. A game that packed an
 *   older copy may stop building, and the number is the warning;
 * - the surface stands still → so does the version, however much behaviour
 *   moved underneath it. The commit is the real identity of a pack.
 *
 * Type-only exports are in the record, because a game that imports a type from
 * this door is a game the surface is a promise to — the same list, types and
 * all, that `src/engine/boundary.test.ts` has always pinned the door against.
 * That file reads this record for its `SURFACE`, so there is one written-down
 * copy of the engine's API in this repository rather than two that drift.
 *
 * It is a script and not the app: it runs when a person runs it, it never runs
 * at request time, it reads two files in the repository and writes exactly one
 * — the record — and only when told to. Nothing here reads or writes
 * `FORGE_APP_DATA`.
 */
import { readFileSync, writeFileSync } from "node:fs";
import { join, relative } from "node:path";
const ROOT = join(import.meta.dir, "..");
/** The door the surface is read off: the engine's one entry point. */
export const DOOR = join(ROOT, "src", "engine", "index.ts");
/** The committed record. Data, beside the door whose names it holds. */
export const RECORD = join(ROOT, "src", "engine", "surface.json");
/** The step a builder takes when the surface moves, as it is typed. */
export const COMMAND = "bun run scripts/surface.ts --write";
/** A surface, pinned: the names, sorted, and the version they belong to. */
export type Surface = { version: string; names: string[] };
/** Three numbers and two dots. This repository numbers nothing else. */
export const isVersion = (version: string): boolean => /^\d+\.\d+\.\d+$/.test(version);
/**
 * The record, parsed and checked rather than trusted: a version of the right
 * shape, a non-empty list of distinct names in sorted order, and no third key,
 * because a record that grows prose stops being readable in a diff.
 */
export function parse(text: string, where = RECORD): Surface {
  let data: unknown;
  try {
    data = JSON.parse(text);
  } catch (error) {
    throw new Error(`${where} is not JSON: ${(error as Error).message}`);
  }
  if (data === null || typeof data !== "object" || Array.isArray(data))
    throw new Error(`${where} is not an object`);
  const record = data as Record<string, unknown>;
  const keys = Object.keys(record).sort();
  if (keys.join(",") !== "names,version")
    throw new Error(`${where} holds ${keys.join(", ") || "nothing"}; a record is a version and a list of names`);
  const { version, names } = record;
  if (typeof version !== "string" || !isVersion(version))
    throw new Error(`${where} has version ${JSON.stringify(version)}; a version is three numbers, like 0.1.0`);
  if (!Array.isArray(names) || names.length === 0)
    throw new Error(`${where} has no names; the door offers some`);
  for (const name of names)
    if (typeof name !== "string" || name === "")
      throw new Error(`${where} holds ${JSON.stringify(name)}, which is not a name`);
  const list = names as string[];
  if (new Set(list).size !== list.length) throw new Error(`${where} names something twice`);
  if ([...list].sort().join(",") !== list.join(","))
    throw new Error(`${where} is not sorted; the record is a sorted list so a diff reads as one`);
  return { version, names: list };
}
/** The record as it is committed. Read once: a stale one helps nobody. */
export function read(path = RECORD): Surface {
  return parse(readFileSync(path, "utf8"), path);
}
/**
 * The version a pack is stamped with, read from the record rather than typed
 * beside it. `scripts/pack.ts` re-exports this as its own.
 */
export const VERSION: string = read().version;
/**
 * The names a door offers: everything inside the braces of an `export { … }
 * from` or `export type { … } from`, under the name it leaves by, sorted.
 *
 * `src/engine/boundary.test.ts` reads the door the same way and may not import
 * this file — a module in the engine imports nothing outside the engine, and
 * that boundary is the point of it. So the reading is written twice on purpose,
 * and `scripts/surface.test.ts` holds the two readings against each other on
 * the real door, where a difference between them would matter.
 */
export function doorNames(source: string): string[] {
  const out: string[] = [];
  const pattern = /\bexport\s+(?:type\s+)?\{([^}]*)\}\s*from\s*["'][^"']+["']/g;
  for (let m = pattern.exec(source); m !== null; m = pattern.exec(source))
    for (const clause of (m[1] as string).split(",")) {
      const name = clause.trim().replace(/^type\s+/, "").split(/\s+as\s+/).pop()?.trim();
      if (name !== undefined && name !== "") out.push(name);
    }
  return out.sort();
}
/** Today's surface, read off the door. */
export function today(path = DOOR): string[] {
  return doorNames(readFileSync(path, "utf8"));
}
/** What moved between a recorded surface and today's: names, not counts. */
export type Change = { added: string[]; removed: string[] };
/** Which names arrived and which left, sorted, between `was` and `now`. */
export function changed(was: readonly string[], now: readonly string[]): Change {
  const before = new Set(was);
  const after = new Set(now);
  return {
    added: now.filter((name) => !before.has(name)).sort(),
    removed: was.filter((name) => !after.has(name)).sort(),
  };
}
/** Did anything move at all? A rename is both halves of one. */
export const moved = (change: Change): boolean => change.added.length + change.removed.length > 0;
/**
 * The version that change asks for. A name that left — which is half of every
 * rename — can break a game that packed an older copy, so the first number
 * moves; a name that only arrived cannot, so the middle one does. Nothing moved
 * means nothing moves.
 */
export function bump(version: string, change: Change): string {
  if (!isVersion(version)) throw new Error(`${version} is not a version`);
  const [major = 0, minor = 0] = version.split(".").map(Number);
  if (change.removed.length > 0) return `${major + 1}.0.0`;
  if (change.added.length > 0) return `${major}.${minor + 1}.0`;
  return version;
}
/** `` `a`, `b` and `c` `` — names in a sentence, quoted the way a message is. */
const names = (list: readonly string[]): string => {
  const quoted = list.map((name) => `\`${name}\``);
  if (quoted.length <= 1) return quoted.join("");
  return `${quoted.slice(0, -1).join(", ")} and ${quoted[quoted.length - 1] as string}`;
};
/**
 * Why today's door and the record disagree, or null if they do not. A test that
 * only says "no" sends a reader to a diff of two hundred names: this one names
 * what arrived and what left, says which part of the version that moves and
 * why, and prints the one step that records today's surface against it.
 */
export function verdict(now: readonly string[], record: Surface, where = relative(ROOT, RECORD)): string | null {
  const change = changed(record.names, now);
  if (!moved(change)) return null;
  const next = bump(record.version, change);
  const lines = [
    `The engine's door no longer offers the surface recorded in ${where}, which version ${record.version} belongs to.`,
  ];
  if (change.added.length > 0)
    lines.push(`${change.added.length} name${change.added.length === 1 ? "" : "s"} arrived: ${names(change.added)}.`);
  if (change.removed.length > 0)
    lines.push(`${change.removed.length} name${change.removed.length === 1 ? "" : "s"} left: ${names(change.removed)}.`);
  lines.push(
    change.removed.length > 0
      ? `A name that left or was renamed can stop a game that packed an older copy from building, ` +
        `so the first number moves: ${record.version} → ${next}.`
      : `Nothing left, so a game that packed an older copy still builds, ` +
        `and the middle number moves: ${record.version} → ${next}.`,
    `If that is what this pull means to do, record today's surface against that version in one step:`,
    ``,
    `    ${COMMAND} ${next}`,
    ``,
    `That rewrites ${where}. ${relative(ROOT, join(ROOT, "src", "engine", "GUIDE.md"))} says what the move promises.`,
  );
  return lines.join("\n");
}
/** The record as bytes: sorted names, one to a line, and a trailing newline. */
export function render(surface: Surface): string {
  return `${JSON.stringify({ version: surface.version, names: [...surface.names].sort() }, null, 2)}\n`;
}
/**
 * Write the record: today's names against the version the builder named. The
 * version has to move when the surface did — that is the whole promise — so a
 * write that leaves it where it was is refused with the number it should be.
 */
export function write(now: readonly string[], version: string, path = RECORD): Surface {
  if (!isVersion(version)) throw new Error(`${version} is not a version: three numbers, like 0.2.0`);
  const was = read(path);
  const change = changed(was.names, now);
  if (moved(change) && version === was.version)
    throw new Error(
      `the surface moved and ${version} is where it already was; ` +
        `this change asks for ${bump(was.version, change)}`,
    );
  const surface: Surface = { version, names: [...now].sort() };
  writeFileSync(path, render(surface));
  return surface;
}
/** `cs-engine 0.1.0 — 184 names behind the door, recorded in src/engine/surface.json`. */
export function line(surface: Surface, where = relative(ROOT, RECORD)): string {
  return `${surface.version} — ${surface.names.length} names behind the door, recorded in ${where}`;
}
if (import.meta.main) {
  const args = process.argv.slice(2);
  const now = today();
  if (args.length === 0) {
    const why = verdict(now, read());
    if (why !== null) {
      console.error(why);
      process.exit(1);
    }
    console.log(line(read()));
  } else if (args[0] === "--write" && args.length === 2) {
    console.log(line(write(now, args[1] as string)));
  } else {
    throw new Error(`usage: bun run scripts/surface.ts [--write <version>]`);
  }
}
@@ -0,0 +1,162 @@
/**
 * The trainer's two ends, checked as data in and data out: the flags a run is
 * asked for, and the module a run writes. Nothing here trains — the twelve
 * minutes between the two is not a thing a test suite should spend, and the
 * duels that grade the shipped weights are `src/rl/learned.test.ts`'s.
 *
 * The test that matters is the last one: `cardModule` handed what
 * `src/client/weights.ts` exports today gives that file back character for
 * character. It says at once that the generator's formatting is what is in the
 * tree, that the file in the tree was written by this generator and not by
 * hand, and that a retrain writes a file shaped exactly like the one it
 * replaces. `src/client/weights.test.ts` is the other half: it holds the file
 * that is actually in the tree to the numbers it claims.
 *
 * `../src/client/packed.ts` is imported before `./train.ts` on purpose, and
 * the order is load-bearing until somebody breaks the cycle it works around:
 * `packed.ts` reads `OBS_SIZE` out of `observe.ts` while it is initialising,
 * and `observe.ts` → `world.ts` → `bots.ts` → `packed.ts` closes the ring, so
 * a graph entered at the `observe.ts` end — which is what `./train.ts` is, one
 * import further on — runs `packed.ts`'s body before that constant exists and
 * throws `Cannot access 'OBS_SIZE' before initialization`. Entered here, this
 * file loads on its own as well as in a suite. Not this pull's to fix.
 */
import { expect, test } from "bun:test";
import { mkdtempSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, resolve } from "node:path";
import { parsePacked } from "../src/client/packed.ts";
import { cardModule, DEFAULTS, parseOptions, policyDocument, POLICY, USAGE, WEIGHTS, type Options } from "./train.ts";
import { PACKED } from "../src/client/shipped.ts";
import { CARD } from "../src/client/weights.ts";
const SOURCE = join(import.meta.dir, "..", "src", "client", "weights.ts");
/** What `parseOptions` gives back for these flags, as a difference from the defaults. */
const options = (...argv: string[]): Options => parseOptions(argv);
test("no flags is the run the README documents, writing the file the game ships", () => {
  expect(options()).toEqual(DEFAULTS);
  expect(DEFAULTS.out).toBe(WEIGHTS);
  expect(WEIGHTS).toBe(SOURCE);
  // The defaults are a real run, not placeholders.
  expect(DEFAULTS.iters).toBeGreaterThan(0);
  expect(DEFAULTS.envs).toBeGreaterThan(0);
  expect(DEFAULTS.maps).toBeGreaterThan(1);
  expect(DEFAULTS.holdout).toBeGreaterThan(0);
  expect(DEFAULTS.foe).toBe("mixed");
  expect(DEFAULTS.bench).toBe(false);
  expect(DEFAULTS.dry).toBe(false);
});
test("every flag the trainer takes lands on the option it names", () => {
  expect(options("--bench")).toEqual({ ...DEFAULTS, bench: true });
  expect(options("--dry")).toEqual({ ...DEFAULTS, dry: true });
  expect(options("--iters", "300")).toEqual({ ...DEFAULTS, iters: 300 });
  expect(options("--envs", "8", "--steps", "4")).toEqual({ ...DEFAULTS, envs: 8, steps: 4 });
  expect(options("--maps", "1")).toEqual({ ...DEFAULTS, maps: 1 });
  expect(options("--holdout", "3")).toEqual({ ...DEFAULTS, holdout: 3 });
  expect(options("--foe", "scripted")).toEqual({ ...DEFAULTS, foe: "scripted" });
  expect(options("--foe", "still")).toEqual({ ...DEFAULTS, foe: "still" });
  // A seed is a label, not a size, so zero is one.
  expect(options("--seed", "0")).toEqual({ ...DEFAULTS, seed: 0 });
  // The order they are written in is not a meaning, and the last one wins.
  expect(options("--dry", "--iters", "7")).toEqual(options("--iters", "7", "--dry"));
  expect(options("--iters", "7", "--iters", "9").iters).toBe(9);
});
test("a count that is not a count is a sentence and not a twelve-minute run on NaN", () => {
  expect(() => options("--iters", "abc")).toThrow(`--iters wants a whole number greater than 0, and got "abc"`);
  expect(() => options("--iters", "NaN")).toThrow("--iters wants a whole number");
  expect(() => options("--envs", "-4")).toThrow("--envs wants a whole number");
  expect(() => options("--envs", "0")).toThrow("--envs wants a whole number");
  expect(() => options("--steps", "2.5")).toThrow("--steps wants a whole number");
  expect(() => options("--maps", "")).toThrow("--maps wants a whole number");
  expect(() => options("--maps", "1e400")).toThrow("--maps wants a whole number");
  // A seed of 0 is fine; a seed below it is not a seed.
  expect(() => options("--seed", "-1")).toThrow("--seed wants a whole number of 0 or more");
});
test("a flag with nothing after it is refused rather than swallowing the next flag", () => {
  expect(() => options("--iters")).toThrow("--iters needs a value");
  expect(() => options("--iters", "--dry")).toThrow("--iters needs a value");
  expect(() => options("--foe")).toThrow("--foe needs a value");
  expect(() => options("--out")).toThrow("--out needs a value");
  expect(() => options("--out", " ")).toThrow("--out cannot be empty");
});
test("a flag nobody knows, and a word that is not a flag, stop the run and say so", () => {
  const unknown = (): Options => options("--iter", "300");
  expect(unknown).toThrow("unknown flag --iter");
  // The complaint lists what there is, so the typo is one line from its fix.
  expect(unknown).toThrow("--iters");
  expect(() => options("300")).toThrow(`"300" is not a flag`);
  expect(() => options("--foe", "friendly")).toThrow(`--foe is one of mixed, still, scripted, and got "friendly"`);
  expect(USAGE).toContain("bun run scripts/train.ts");
  for (const flag of ["--bench", "--dry", "--envs", "--foe", "--holdout", "--iters", "--maps", "--out", "--seed", "--steps"])
    expect(USAGE).toContain(flag);
});
test("--out and --policy are the two paths a run writes, resolved against where it was run", () => {
  expect(options("--out", "/tmp/weights.ts").out).toBe("/tmp/weights.ts");
  expect(options("--out", "elsewhere/w.ts").out).toBe(resolve("elsewhere/w.ts"));
  expect(options("--out", "/tmp/w.ts").out).not.toBe(WEIGHTS);
  // Since #214 the weights are their own file: the card is one write and the
  // packed policy the build copies into static/ is the other.
  expect(DEFAULTS.policy).toBe(POLICY);
  expect(POLICY.endsWith("src/client/weights.json")).toBe(true);
  expect(options("--policy", "/tmp/w.json").policy).toBe("/tmp/w.json");
  expect(options("--policy", "elsewhere/w.json").policy).toBe(resolve("elsewhere/w.json"));
  expect(options("--policy", "/tmp/w.json").out).toBe(WEIGHTS);
});
test("the policy document it writes is what the page's reader accepts, and is the file in the tree", async () => {
  const text = policyDocument(PACKED);
  expect(text.endsWith("\n")).toBe(true);
  // One line of JSON: these bytes are copied into static/ verbatim and are
  // what a browser downloads, so `parsePacked` is the other end of this.
  expect(parsePacked(text)).toEqual(PACKED);
  expect(policyDocument(PACKED)).toBe(await Bun.file(POLICY).text());
});
test("the generated module says not to edit it, and says it first", () => {
  const text = cardModule(CARD);
  expect(text.startsWith("/**")).toBe(true);
  expect(text).toContain("scripts/train.ts. Do not edit by hand.");
  expect(text.indexOf("Do not edit by hand")).toBeLessThan(text.indexOf("export const CARD"));
  expect(text.endsWith("\n")).toBe(true);
});
test("the same card and the same weights write the same text, every time", () => {
  expect(cardModule(CARD)).toBe(cardModule(CARD));
  // And a different card is a different file in exactly one place: its numbers.
  const other = cardModule({ ...CARD, winRate: 3 });
  expect(other).not.toBe(cardModule(CARD));
  expect(other).toContain(`"winRate": 3`);
  expect(other.replace(`"winRate": 3`, `"winRate": ${CARD.winRate}`)).toBe(cardModule(CARD));
});
test("what it emits parses, and exports what src/client/weights.ts exports today", async () => {
  // Transpiled rather than imported as TypeScript: the generated module has no
  // imports at all, so what is left is a module with nothing of this repository
  // in it.
  const js = new Bun.Transpiler({ loader: "ts" }).transformSync(cardModule(CARD));
  const file = join(mkdtempSync(join(tmpdir(), "train-")), "weights.js");
  writeFileSync(file, js);
  const generated = (await import(file)) as { CARD: typeof CARD };
  const shipped = await import("../src/client/weights.ts");
  expect(Object.keys(generated).sort()).toEqual(Object.keys(shipped).sort());
  expect(generated.CARD).toEqual(CARD);
  // And the weights are not in it any more: they are the JSON beside it.
  expect(Object.keys(generated)).not.toContain("PACKED");
});
test("the file in the tree is this generator's output, character for character", async () => {
  // If this fails, either somebody edited `src/client/weights.ts` by hand or
  // the generator's formatting moved under it. Both are worth a failure: the
  // page reads the file in the tree, and every other test here reads the
  // generator.
  expect(cardModule(CARD)).toBe(await Bun.file(SOURCE).text());
});
@@ -1,109 +1,169 @@
/**
 * Training. Runs a few hundred PPO updates over a batch of duels and writes
 * the result to src/client/weights.ts, which is what the game ships.
 * two files the game ships: src/client/weights.json, which is the packed
 * policy and is copied into static/ under its own content hash by
 * `bun run scripts/build.ts`, and src/client/weights.ts, which is the card the
 * page boasts about it. A run that writes them is followed by a build and a
 * commit of both, and of what static/ then holds.
 *
 *   bun run scripts/train.ts --bench            # how fast the arena steps
 *   bun run scripts/train.ts --iters 300        # train and write the weights
 *   bun run scripts/train.ts --iters 300 --dry  # train without writing
 *   bun run scripts/train.ts --workers 0        # on this thread, for debugging
 *   bun run scripts/train.ts --maps 1           # one map, the way it used to train
 *   bun run scripts/train.ts --out /tmp/w.ts    # write the card somewhere else
 *   bun run scripts/train.ts --policy /tmp/w.json  # and the weights somewhere else
 *
 * Nothing here is imported by the server or the page: this file runs on a
 * machine with a few minutes to spare, and its only output is a table of
 * numbers and about eight kilobytes of int8.
 *
 * The PPO is the engine's, reached through the door like everything else it
 * offers; what is the shooter's is the arena it collects from, the observation
 * it fills, the heads it decodes and the curriculum below.
 *
 * The two ends of the run are plain functions, so `train.test.ts` can check
 * both in milliseconds without training for twelve minutes: `parseOptions`
 * (argv in, options out, a sentence for anything that is not one) and
 * `weightsModule` (a card and packed weights in, the source text out). What is
 * between them is the twelve minutes, and no test runs it.
 */
import { writeFileSync } from "node:fs";
import { join } from "node:path";
import { join, resolve } from "node:path";
import { HEADS, decode } from "../src/client/action.ts";
import { botThink, makeBrain } from "../src/client/bots.ts";
import { rng } from "../src/client/math.ts";
import { DE_FORGE, type MapDef } from "../src/client/map.ts";
import {
  computeAdvantages, copyPolicy, createAdam, createPolicy, createRollout, forward,
  newActivations, pack, rng, sample, unpack, update, DEFAULT_HYPER,
  type Hyper, type Packed,
} from "../src/engine/index.ts";
import { OBS_SIZE } from "../src/client/observe.ts";
import { SHAPE } from "../src/client/packed.ts";
import {
  createPolicy, forward, greedy, newActivations, pack, policyBytes, policyOver, sample,
  tensorsOf, unpack, type Policy, type Shape,
} from "../src/client/policy.ts";
import {
  createArena, EPISODE_TICKS, observeLearner, reset, scriptedFoe, SKIP,
  step, stepInput, type Arena,
  createArena, observeFoe, observeLearner, policyFoe, relevel, reset, scriptedFoe, SKIP,
  step, stillFoe, type Arena,
} from "../src/rl/arena.ts";
import { cores } from "../src/rl/cores.ts";
import { addTotals, createPool, noTotals, updateStep } from "../src/rl/pool.ts";
import { LEAGUE, type Curriculum } from "../src/rl/shard.ts";
import { createAdam, rolloutOver, DEFAULT_HYPER, type Hyper } from "../src/rl/ppo.ts";
export const SHAPE: Shape = { obs: OBS_SIZE, hidden: 64, heads: HEADS };
const arg = (name: string, fallback: number): number => {
  const at = process.argv.indexOf(`--${name}`);
  if (at < 0) return fallback;
  const value = Number(process.argv[at + 1]);
  return Number.isFinite(value) ? value : fallback;
};
const flag = (name: string): boolean => process.argv.includes(`--${name}`);
const ENVS = arg("envs", 64);
const STEPS = arg("steps", 32);
const ITERS = arg("iters", 240);
const SEED = arg("seed", 20260914);
// One worker a shard, defaulting to the cores this process is allowed. Zero
// runs the whole thing on this thread, which is the reference the parallel path
// is tested against and the way to debug it.
const WORKERS = arg("workers", cores());
// --- evaluation -----------------------------------------------------------
export type Outcome = { won: number; lost: number; draw: number; damage: number };
import { drawPercent, evaluate, greedyDriver, wonPercent } from "../src/rl/evaluate.ts";
import { holdoutLevels, trainingLevels } from "../src/rl/maps.ts";
import type { Level } from "../src/client/level.ts";
import type { Card } from "../src/client/weights.ts";
/**
 * Play `duels` fixed duels against the scripted bots. Both drivers get the
 * same seeds, so the same spawns, the same distances and the same opponent
 * skills: the difference in the result is the difference in the driver.
 * `map` defaults to de_forge — the arena the shipped weights were trained
 * and are still measured in — and takes any other map to measure the same
 * fixed duels on it instead, without retraining anything.
 * The shape trained here, which is the shape the game asks for: it is
 * `src/client/packed.ts`'s constant and not a second copy, because the browser
 * refuses a downloaded policy of any other shape and a trainer that disagreed
 * with it would write eight kilobytes nobody can run.
 */
export function evaluate(
  drive: ((arena: Arena) => void) | "scripted",
  duels: number,
  seed: number,
  map: MapDef = DE_FORGE,
): Outcome {
  const out: Outcome = { won: 0, lost: 0, draw: 0, damage: 0 };
  for (let i = 0; i < duels; i++) {
    const arena = createArena(seed + i * 7919, scriptedFoe, map);
    if (drive === "scripted") arena.learner.brain = makeBrain(0.65, seed + i, false);
    // Both drivers get the same six seconds; the scripted brain turns its own
    // view every tick, the policy decides once every SKIP ticks.
    while (arena.ticks < EPISODE_TICKS && arena.learner.alive && arena.foe.alive) {
      if (drive === "scripted") stepInput(arena, botThink(arena.world, arena.learner, 1 / 64));
      else drive(arena);
    }
    out.damage += arena.learner.damage;
    if (!arena.foe.alive) out.won += 1;
    else if (!arena.learner.alive) out.lost += 1;
    else out.draw += 1;
  }
  return out;
}
export { SHAPE };
/** A driver that plays the policy greedily — no sampling, so it is repeatable. */
export function greedyDriver(policy: Policy): (arena: Arena) => void {
  const obs = new Float32Array(OBS_SIZE);
  const act = newActivations(policy.shape);
  const actions = new Int32Array(HEADS.length);
  return (arena) => {
    observeLearner(arena, obs);
    forward(policy, obs, act);
    greedy(policy.shape, act.logits, actions);
    step(arena, decode(actions));
// --- the boundary ---------------------------------------------------------
/** Where the card lands when nobody says otherwise: the file the page reads. */
export const WEIGHTS = join(import.meta.dir, "..", "src", "client", "weights.ts");
/** And where the weights themselves land: the document the build copies to static/. */
export const POLICY = join(import.meta.dir, "..", "src", "client", "weights.json");
/** Who a run practises against: the curriculum, or one opponent all the way. */
export type Foe = "mixed" | "still" | "scripted";
/** One run, as plain data. Everything the loop below reads comes from here. */
export type Options = {
  /** Step the arena and print a throughput, instead of training. */
  bench: boolean;
  /** Train and print the table, but write no module. */
  dry: boolean;
  envs: number;
  steps: number;
  iters: number;
  seed: number;
  /** How many layouts a run learns on: de_forge and the rest carved from seeds. */
  maps: number;
  /** How many layouts it is graded on, none of which it trained on. */
  holdout: number;
  foe: Foe;
  /** Where the card is written. Absolute, resolved against the cwd. */
  out: string;
  /** Where the packed weights are written. Absolute, resolved against the cwd. */
  policy: string;
};
export const DEFAULTS: Options = {
  bench: false,
  dry: false,
  envs: 64,
  steps: 32,
  iters: 240,
  seed: 20260914,
  maps: 96,
  holdout: 24,
  foe: "mixed",
  out: WEIGHTS,
  policy: POLICY,
};
/** The flags that take a whole number, and the smallest one each will accept. */
const NUMBERS = {
  envs: 1, steps: 1, iters: 1, maps: 1, holdout: 1,
  // A seed is a label, not a size: zero is a seed like any other.
  seed: 0,
} as const;
const FOES: readonly Foe[] = ["mixed", "still", "scripted"];
const KNOWN = ["--bench", "--dry", "--foe", "--out", "--policy", ...Object.keys(NUMBERS).map((k) => `--${k}`)].sort();
/** What the usage line says, printed under any complaint below. */
export const USAGE = `usage: bun run scripts/train.ts [${KNOWN.join("] [")}]`;
/**
 * argv (what comes after the script name) in, options out. Anything that is
 * not a run — a flag nobody knows, a value that is not a number, a count of
 * zero, a missing value, a bare word — throws a sentence saying which flag and
 * what it got, because training for twelve minutes on `NaN` and writing the
 * result over the shipped weights is the failure this stands in front of.
 */
export function parseOptions(argv: readonly string[]): Options {
  const options: Options = { ...DEFAULTS };
  const value = (flag: string, next: string | undefined): string => {
    if (next === undefined || next.startsWith("--")) throw new Error(`${flag} needs a value`);
    return next;
  };
  for (let i = 0; i < argv.length; i++) {
    const flag = argv[i] as string;
    if (!flag.startsWith("--")) throw new Error(`${JSON.stringify(flag)} is not a flag; ${USAGE}`);
    const name = flag.slice(2);
    if (flag === "--bench") options.bench = true;
    else if (flag === "--dry") options.dry = true;
    else if (flag === "--foe") {
      const foe = value(flag, argv[++i]);
      if (!FOES.includes(foe as Foe)) throw new Error(`--foe is one of ${FOES.join(", ")}, and got ${JSON.stringify(foe)}`);
      options.foe = foe as Foe;
    } else if (flag === "--out" || flag === "--policy") {
      const where = value(flag, argv[++i]);
      if (where.trim() === "") throw new Error(`${flag} cannot be empty`);
      if (flag === "--out") options.out = resolve(where);
      else options.policy = resolve(where);
    } else if (Object.hasOwn(NUMBERS, name)) {
      const key = name as keyof typeof NUMBERS;
      const text = value(flag, argv[++i]);
      const n = Number(text);
      if (!Number.isInteger(n) || n < NUMBERS[key])
        throw new Error(
          `${flag} wants a whole number ${NUMBERS[key] === 0 ? "of 0 or more" : "greater than 0"}, ` +
          `and got ${JSON.stringify(text)}`,
        );
      options[key] = n;
    } else throw new Error(`unknown flag ${flag}; known flags are ${KNOWN.join(" ")}`);
  }
  return options;
}
// --- the loop -------------------------------------------------------------
function benchmark(): void {
  const arenas = Array.from({ length: 64 }, (_, i) => createArena(SEED + i));
function benchmark({ maps, seed }: Options): void {
  const levels = trainingLevels(maps);
  const arenas = Array.from({ length: 64 }, (_, i) =>
    createArena(seed + i, scriptedFoe, levels[i % levels.length] as Level));
  const obs = new Float32Array(OBS_SIZE);
  const policy = createPolicy(SHAPE, rng(1));
  const act = newActivations(SHAPE);
@@ -124,138 +184,213 @@
function benchmark(): void {
  console.log(`${steps} steps in ${seconds.toFixed(2)}s = ${(steps / seconds / 1000).toFixed(0)}k steps/s (observe + policy + arena)`);
}
async function train(): Promise<void> {
async function train(options: Options): Promise<void> {
  const { envs: ENVS, steps: STEPS, iters: ITERS, seed: SEED, maps: MAPS, holdout: HOLDOUT } = options;
  const hyper: Hyper = { ...DEFAULT_HYPER, minibatch: Math.max(256, (ENVS * STEPS) / 4) };
  const random = rng(SEED);
  const pool = createPool({
    shape: SHAPE, envs: ENVS, steps: STEPS, seed: SEED, hyper,
    shards: Math.max(1, WORKERS), threaded: WORKERS > 0,
  });
  // The weights live in the shared buffer every shard reads, so there is no
  // broadcast: the Adam step below is visible to the workers the moment it lands.
  const policy = policyOver(SHAPE, pool.weights);
  const initial = createPolicy(SHAPE, random);
  tensorsOf(policy).forEach((t, i) => t.set(tensorsOf(initial)[i] as Float32Array));
  const policy = createPolicy(SHAPE, random);
  const adam = createAdam(policy, hyper);
  const rollout = rolloutOver(SHAPE, ENVS, STEPS, pool.rollout);
  const league = Array.from({ length: LEAGUE }, (_, k) => policyOver(SHAPE, pool.league, k * policyBytes(SHAPE)));
  const freezeEvery = Math.max(1, Math.floor(ITERS / (LEAGUE * 6)));
  let filled = 0;
  let slot = 0;
  const rollout = createRollout(SHAPE, ENVS, STEPS);
  const act = newActivations(SHAPE);
  const foeObs = new Float32Array(OBS_SIZE);
  const foeAct = newActivations(SHAPE);
  const foeActions = new Int32Array(HEADS.length);
  const actions = new Int32Array(HEADS.length);
  const tail = new Float32Array(OBS_SIZE);
  let snapshot = copyPolicy(policy);
  const selfPlay = policyFoe((arena) => {
    observeFoe(arena, foeObs);
    forward(snapshot, foeObs, foeAct);
    sample(SHAPE, foeAct.logits, random, foeActions);
    return decode(foeActions);
  });
  // Who a bot practises against, and how hard, both move with the run: it
  // starts mostly against targets that do not shoot back, and ends mostly
  // against the scripted bots at full skill and against itself. Handed a hard
  // opponent from the first step, the policy learns to hide instead of to
  // shoot, and never comes back from it.
  const opponentFor = (e: number, progress: number): Arena["opponent"] => {
    if (options.foe === "still") return stillFoe;
    if (options.foe === "scripted") return scriptedFoe;
    const still = Math.max(0.1, 0.6 - progress * 0.5);
    const scripted = 0.3 + progress * 0.3;
    const u = (e % 10) / 10;
    return u < still ? stillFoe : u < still + scripted ? scriptedFoe : selfPlay;
  };
  // The maps. Every arena starts on one of them and rolls onto another every
  // time its duel ends, so a run of this length fights on all of them many
  // times over and none of them long enough to learn its corners. There is no
  // curriculum on the map on purpose: what the policy sees is egocentric, so a
  // corridor is a corridor, and mixing the layouts from the first step is what
  // stops "the enemy went left" from meaning a particular left.
  const levels = trainingLevels(MAPS);
  const holdout = holdoutLevels(HOLDOUT);
  let rolled = 0;
  const nextLevel = (): Level => levels[rolled++ % levels.length] as Level;
  const arenas = Array.from({ length: ENVS }, (_, e) =>
    createArena(SEED + e * 104729, opponentFor(e, 0), nextLevel()));
  const baseline = evaluate("scripted", 120, SEED + 555);
  const baselineUnseen = evaluate("scripted", 120, SEED + 777, holdout);
  console.log(`${levels.length} maps to learn on (de_forge and ${levels.length - 1} carved from seeds), ` +
    `${holdout.length} held back to be graded on`);
  console.log(
    `${pool.shards} shard${pool.shards === 1 ? "" : "s"}, ${ENVS} environments, ` +
    `${ENVS * STEPS} decisions an update, minibatch ${hyper.minibatch}`,
  );
  console.log(
    `baseline (scripted brain in the same duels): ${baseline.won} won / ${baseline.lost} lost / ${baseline.draw} drawn`,
    `baseline (scripted brain in the same duels): ${baseline.won} won / ${baseline.lost} lost / ${baseline.draw} drawn` +
    `, and on maps it has never seen ${baselineUnseen.won}/${baselineUnseen.lost}/${baselineUnseen.draw}`,
  );
  const n = ENVS * STEPS;
  const episodeReturn = new Float64Array(ENVS);
  let returns: number[] = [];
  let wins = 0, losses = 0, finished = 0;
  let aimSum = 0, aimN = 0, fireSum = 0, fireN = 0;
  const started = Bun.nanoseconds();
  let envSteps = 0;
  let sinceLog = noTotals();
  for (let iter = 1; iter <= ITERS; iter++) {
    // Two curricula, both stretched over the first half of the run: how far
    // apart a duel starts, and who it is against. Learning to shoot across the
    // map before learning to shoot at all is the sort of thing that eats a run,
    // and handed a good opponent from the first step the policy learns to hide.
    // A curriculum on distance: near the start every duel is close enough that
    // the enemy is a wide target, and it widens to the full range by halfway.
    // Learning to shoot across the map before learning to shoot at all is the
    // sort of thing that eats a training run.
    const progress = Math.min(1, iter / (ITERS * 0.5));
    const curriculum: Curriculum = {
      maxRange: 600 + progress * 900,
      maxSkill: 0.45 + progress * 0.55,
      still: Math.max(0.1, 0.6 - progress * 0.5),
      scripted: 0.3 + progress * 0.3,
      filled,
    };
    const { totals: t, gradNorm } = await updateStep(pool, policy, adam, rollout, curriculum, random);
    envSteps += n;
    // The league: a copy of the policy is frozen into the next slot every so
    // often, and self-play duels draw from the ones that are filled. Practising
    // only against your newest self is how a policy learns to beat one opponent
    // and forgets the rest; a handful of older selves keeps it honest.
    if (iter % freezeEvery === 0) {
      const into = league[slot % LEAGUE] as Policy;
      tensorsOf(into).forEach((tensor, i) => tensor.set(tensorsOf(policy)[i] as Float32Array));
      slot += 1;
      filled = Math.min(LEAGUE, filled + 1);
    for (const arena of arenas) {
      arena.maxRange = 600 + progress * 900;
      arena.maxSkill = 0.45 + progress * 0.55;
    }
    for (let t = 0; t < STEPS; t++) {
      for (let e = 0; e < ENVS; e++) {
        const arena = arenas[e] as Arena;
        const i = t * ENVS + e;
        observeLearner(arena, rollout.obs, i * OBS_SIZE);
        forward(policy, rollout.obs, act, i * OBS_SIZE);
        rollout.values[i] = act.value;
        rollout.logProbs[i] = sample(SHAPE, act.logits, random, actions);
        for (let h = 0; h < HEADS.length; h++) rollout.actions[i * HEADS.length + h] = actions[h] as number;
        if ((rollout.obs[i * OBS_SIZE + 2] as number) > 0.5) {
          aimSum += rollout.obs[i * OBS_SIZE + 4] as number; // cos of the aim error
          aimN += 1;
          fireSum += actions[4] === 1 ? 1 : 0;
          fireN += 1;
        }
        const result = step(arena, decode(actions));
        rollout.rewards[i] = result.reward;
        rollout.dones[i] = result.done ? 1 : 0;
        episodeReturn[e] = (episodeReturn[e] as number) + result.reward;
        envSteps += 1;
        if (result.done) {
          returns.push(episodeReturn[e] as number);
          episodeReturn[e] = 0;
          finished += 1;
          if (result.won) wins += 1;
          if (result.lost) losses += 1;
          relevel(arena, nextLevel());
          arena.opponent = opponentFor(e, progress);
        }
      }
    }
    // Bootstrap: what the policy thinks the unfinished episodes are still worth.
    for (let e = 0; e < ENVS; e++) {
      observeLearner(arenas[e] as Arena, tail);
      forward(policy, tail, act);
      rollout.lastValues[e] = act.value;
    }
    computeAdvantages(rollout, hyper.gamma, hyper.lambda);
    const stats = update(policy, rollout, adam, random);
    if (iter % 10 === 0) snapshot = copyPolicy(policy);
    sinceLog = addTotals(sinceLog, t);
    if (iter % 10 === 0 || iter === 1) {
      const mean = returns.length === 0 ? 0 : returns.reduce((a, b) => a + b, 0) / returns.length;
      const seconds = (Bun.nanoseconds() - started) / 1e9;
      const s = sinceLog;
      const rate = (x: number, of: number): string => (of === 0 ? "0" : Math.round((x / of) * 100).toString());
      console.log(
        `${String(iter).padStart(4)} ${((envSteps * SKIP) / 1000).toFixed(0).padStart(7)}k ticks ` +
        `${((envSteps * SKIP) / seconds / 1000).toFixed(0).padStart(4)}k/s  ` +
        `return ${(s.episodes === 0 ? 0 : s.returns / s.episodes).toFixed(2).padStart(6)}  ` +
        `won ${rate(s.wins, s.episodes)}% lost ${rate(s.losses, s.episodes)}%  ` +
        `aim ${(s.aimN === 0 ? 0 : s.aim / s.aimN).toFixed(2)} fire ${(s.fireN === 0 ? 0 : s.fire / s.fireN).toFixed(2)} ` +
        `ent ${(s.entropy / Math.max(1, s.samples)).toFixed(2)} ` +
        `vloss ${(s.valueLoss / Math.max(1, s.samples)).toFixed(3)} ` +
        `clip ${(s.clipped / Math.max(1, s.samples)).toFixed(2)} gn ${gradNorm.toFixed(2)}`,
        `${String(iter).padStart(4)} ${((envSteps * SKIP) / 1000).toFixed(0).padStart(6)}k ticks ` +
        `${((envSteps * SKIP) / seconds / 1000).toFixed(0).padStart(4)}k/s  return ${mean.toFixed(2).padStart(6)}  ` +
        `won ${finished === 0 ? 0 : Math.round((wins / finished) * 100)}% lost ${finished === 0 ? 0 : Math.round((losses / finished) * 100)}%  ` +
        `aim ${(aimN === 0 ? 0 : aimSum / aimN).toFixed(2)} fire ${(fireN === 0 ? 0 : fireSum / fireN).toFixed(2)} ` +
        `ent ${stats.entropy.toFixed(2)} vloss ${stats.valueLoss.toFixed(3)} clip ${stats.clipFraction.toFixed(2)}`,
      );
      sinceLog = noTotals();
      returns = [];
      wins = 0; losses = 0; finished = 0;
      aimSum = 0; aimN = 0; fireSum = 0; fireN = 0;
    }
  }
  const seconds = (Bun.nanoseconds() - started) / 1e9;
  pool.close();
  const packed = pack(policy);
  const quantised = unpack(packed);
  const trained = evaluate(greedyDriver(policy), 240, SEED + 555);
  const shipped = evaluate(greedyDriver(quantised), 240, SEED + 555);
  const baselineAgain = evaluate("scripted", 240, SEED + 555);
  const rate = (o: typeof trained): number => Math.round((o.won / (o.won + o.lost + o.draw)) * 100);
  console.log(`\ntrained  ${trained.won}/${trained.lost}/${trained.draw} (${rate(trained)}% won)`);
  console.log(`shipped  ${shipped.won}/${shipped.lost}/${shipped.draw} (${rate(shipped)}% won) after int8 packing`);
  console.log(`scripted ${baselineAgain.won}/${baselineAgain.lost}/${baselineAgain.draw} (${rate(baselineAgain)}% won)`);
  // The same duels again on the maps no arena in this run was ever put on:
  // what the policy does on a layout it has never seen is the number the whole
  // map curriculum is for, and a draw there is the bot that got confused.
  const unseen = evaluate(greedyDriver(quantised), 240, SEED + 777, holdout);
  const unseenBaseline = evaluate("scripted", 240, SEED + 777, holdout);
  console.log(`\nde_forge, the map it has always been measured on:`);
  console.log(`  trained  ${trained.won}/${trained.lost}/${trained.draw} (${wonPercent(trained)}% won)`);
  console.log(`  shipped  ${shipped.won}/${shipped.lost}/${shipped.draw} (${wonPercent(shipped)}% won) after int8 packing`);
  console.log(`  scripted ${baselineAgain.won}/${baselineAgain.lost}/${baselineAgain.draw} (${wonPercent(baselineAgain)}% won)`);
  console.log(`${holdout.length} maps it has never seen:`);
  console.log(`  shipped  ${unseen.won}/${unseen.lost}/${unseen.draw} (${wonPercent(unseen)}% won, ${drawPercent(unseen)}% drawn)`);
  console.log(`  scripted ${unseenBaseline.won}/${unseenBaseline.lost}/${unseenBaseline.draw} ` +
    `(${wonPercent(unseenBaseline)}% won, ${drawPercent(unseenBaseline)}% drawn)`);
  if (flag("dry")) return;
  const out = join(import.meta.dir, "..", "src", "client", "weights.ts");
  writeFileSync(out, weightsModule(packed, {
  if (options.dry) return;
  // The two writes this script does, each to the path the options name: the
  // weights themselves, and the card that says what they measured.
  const out = options.out;
  writeFileSync(options.policy, policyDocument(packed));
  writeFileSync(out, cardModule({
    trainedAt: new Date().toISOString().slice(0, 10),
    decisions: envSteps,
    envSteps: envSteps * SKIP,
    updates: ITERS,
    stepsPerSecond: Math.round((envSteps * SKIP) / seconds),
    minutes: Math.round(seconds / 6) / 10,
    workers: pool.shards,
    duels: 240,
    winRate: rate(shipped),
    baselineWinRate: rate(baselineAgain),
    winRate: wonPercent(shipped),
    baselineWinRate: wonPercent(baselineAgain),
    maps: levels.length,
    unseenMaps: holdout.length,
    unseenWinRate: wonPercent(unseen),
    unseenBaselineWinRate: wonPercent(unseenBaseline),
    unseenDrawRate: drawPercent(unseen),
  }));
  console.log(`\nwrote ${out} (${packed.bytes.length} base64 chars)`);
  console.log(`\nwrote ${options.policy} (${packed.bytes.length} base64 chars) and ${out}`);
  console.log("now run `bun run scripts/build.ts` and commit both files with what it writes into static/");
}
type Card = {
  trainedAt: string;
  decisions: number;
  envSteps: number;
  updates: number;
  stepsPerSecond: number;
  minutes: number;
  workers: number;
  duels: number;
  winRate: number;
  baselineWinRate: number;
};
function weightsModule(packed: ReturnType<typeof pack>, card: Card): string {
  return `/**
 * The trained policy, written by scripts/train.ts. Do not edit by hand.
/**
 * The packed weights as they are written to disk and as they travel: one
 * compact JSON document, newline-ended like any other file here. Compact
 * because these bytes are what a browser downloads — this file is copied into
 * static/ verbatim — and nobody reads eight kilobytes of base64 by eye.
 *
 * Weights are int8 with one scale per tensor — about eight kilobytes instead of
 * thirty — and are dequantised once when the page loads. CARD is what the run
 * that produced them measured, and it is what the page and the terminal show.
 * `src/client/packed.ts` is the other end of it and the only reader: what this
 * writes, that accepts, and `train.test.ts` holds the pair to it.
 */
export const policyDocument = (packed: Packed): string => `${JSON.stringify(packed)}\n`;
import type { Packed } from "./policy.ts";
/**
 * The generated module, as text: the header that says not to edit it, the type
 * the card is, and the card this run measured. It is a pure function of its one
 * argument and formats the same way every time, so `train.test.ts` can hand it
 * what `src/client/weights.ts` exports today and get that file back character
 * for character.
 */
export function cardModule(card: Card): string {
  return `/**
 * The card for the weights in \`weights.json\` beside this file, written by
 * scripts/train.ts. Do not edit by hand.
 *
 * The weights themselves are that JSON document and not a literal in here:
 * int8 with one scale per tensor, about eight kilobytes, shipped as this
 * game's own asset (\`src/games.ts\`) and fetched at boot rather than bundled
 * into the entry a player downloads first. CARD is what the run that produced
 * them measured, and it is what the page and the terminal show — a hundred
 * bytes of prose numbers, which is why it is still a module the first paint
 * can read.
 */
export type Card = {
  trainedAt: string;
@@ -264,24 +399,34 @@
export type Card = {
  updates: number;
  stepsPerSecond: number;
  minutes: number;
  workers: number;
  /** Duels evaluated on de_forge, for \`winRate\` and \`baselineWinRate\`. */
  duels: number;
  winRate: number;
  baselineWinRate: number;
  /** Layouts the run learned on: de_forge and the rest carved from seeds. */
  maps: number;
  /** Layouts it was graded on and never trained on, from the other seed stream. */
  unseenMaps: number;
  unseenWinRate: number;
  unseenBaselineWinRate: number;
  /** Duels on those maps that ran the six seconds out without a kill. */
  unseenDrawRate: number;
};
export const CARD: Card = ${JSON.stringify(card, null, 2)};
export const PACKED: Packed = {
  shape: ${JSON.stringify(packed.shape)},
  scales: ${JSON.stringify(packed.scales)},
  bytes:
    "${packed.bytes}",
};
`;
}
if (import.meta.main) {
  if (flag("bench")) benchmark();
  else await train();
  let options: Options;
  try {
    options = parseOptions(process.argv.slice(2));
  } catch (error) {
    // A sentence and a non-zero exit, rather than twelve minutes on nonsense.
    console.error(error instanceof Error ? error.message : String(error));
    console.error(USAGE);
    process.exit(2);
  }
  if (options.bench) benchmark(options);
  else await train(options);
}
@@ -0,0 +1,35 @@
/**
 * What the server binds, given an environment. The case that matters is a
 * shell's ambient `HOST`: a machine name is not an address, and the app starts
 * on the loopback rather than failing to resolve it.
 */
import { expect, test } from "bun:test";
import { bind, isAddress } from "./bind.ts";
test("the forge's HOST and PORT are taken as they are", () => {
  expect(bind({ HOST: "0.0.0.0", PORT: "8080" })).toEqual({ hostname: "0.0.0.0", port: 8080 });
  expect(bind({ HOST: "::", PORT: "3000" })).toEqual({ hostname: "::", port: 3000 });
  expect(bind({ HOST: "127.0.0.1", PORT: "0" })).toEqual({ hostname: "127.0.0.1", port: 0 });
  expect(bind({ HOST: "localhost", PORT: "65535" })).toEqual({ hostname: "localhost", port: 65535 });
});
test("an ambient HOST is not an address, and is ignored rather than bound", () => {
  const listen = bind({ HOST: "vespers-laptop.local", PORT: "8080" });
  expect(listen.hostname).toBe("127.0.0.1");
  expect(listen.port).toBe(8080);
  expect(listen.unusable).toBe("vespers-laptop.local");
  for (const host of ["example.com", "999.1.1.1", "0.0.0.0 ", "", "-", "10.0.0"])
    expect(bind({ HOST: host }).hostname).toBe("127.0.0.1");
  expect(isAddress("vespers-laptop.local")).toBe(false);
  expect(isAddress("fe80::1")).toBe(true);
});
test("no HOST is the loopback, quietly: nothing was ignored", () => {
  expect(bind({})).toEqual({ hostname: "127.0.0.1", port: 8080 });
  expect(bind({ PORT: "9000" }).unusable).toBeUndefined();
});
test("a port that is not a port falls back rather than binding something else", () => {
  for (const port of ["", "  ", "eighty", "-1", "70000", "80.5"]) expect(bind({ PORT: port }).port).toBe(8080);
});
@@ -0,0 +1,35 @@
/**
 * The socket the server listens on. `PORT` and `HOST` are the forge's, but
 * `HOST` is also an ambient variable a shell hands out — zsh and csh set it to
 * the machine's name — and binding to a name that does not resolve here is a
 * start-up that fails for no reason a person can see. So only an address is
 * taken: an IPv4 or IPv6 literal, or `localhost`. Anything else is not
 * something the forge set, and the loopback default stands.
 */
export const DEFAULT_HOSTNAME = "127.0.0.1";
export const DEFAULT_PORT = 8080;
const IPV4 = /^\d{1,3}(\.\d{1,3}){3}$/;
const IPV6 = /^[0-9a-fA-F:]{2,45}$/; // "::", "::1", a full address — colons and hex digits only
/** True when a string is an address to bind, rather than a name to resolve. */
export const isAddress = (host: string): boolean =>
  host === "localhost" ||
  (IPV4.test(host) && host.split(".").every((part) => Number(part) <= 255)) ||
  (IPV6.test(host) && host.includes(":"));
/** What to bind, given the environment. `unusable` is what was ignored, for the log. */
export function bind(env: Record<string, string | undefined>): {
  hostname: string;
  port: number;
  unusable?: string;
} {
  const host = env.HOST;
  const port = env.PORT ?? "";
  const listen = {
    hostname: host !== undefined && isAddress(host) ? host : DEFAULT_HOSTNAME,
    port: /^\d{1,5}$/.test(port) && Number(port) <= 65535 ? Number(port) : DEFAULT_PORT,
  };
  return host === undefined || isAddress(host) ? listen : { ...listen, unusable: host };
}
@@ -0,0 +1,433 @@
/**
 * A frame has a budget, and this is where the suite holds it. Sixty-four frames
 * a second is **15.625 ms** a frame for everything — the simulation, the scene
 * and the drawing — so the things measured here, the 64 Hz tick and the scene
 * built from it, have to stay a small fraction of it on a laptop and stay one
 * on a phone. `src/frames.test.ts` proves a frame allocates nothing after
 * the first; this proves a frame is *cheap*, and the two sit beside each other
 * for the same reason: both claims are about the two games at once, and neither
 * game may import the other.
 *
 * **This is not a bench.** #20 is a script a person runs to read numbers, and
 * `bun run scripts/room.ts` is the one for the room below. This is a ceiling
 * the suite enforces on every push, and nothing here is meant to be read as
 * "how fast is it": for that, run the bench. Merging the two would lose the
 * only thing this file is for — failing.
 *
 * ## What is measured
 *
 * - One tick of the shooter at 64 Hz on a live round: ten bodies on de_forge,
 *   nine of them bots running the shipped policy, plus the grenades, the bomb
 *   and the rules clock. This is the whole simulation a playing frame steps.
 * - **A world-second of a room**, which is the same simulation stepped by this
 *   process instead of by a browser: `createRoom` and sixty-four `stepRoom`s,
 *   ten bots thinking, which is what a deployment pays per room per second of
 *   play. A frame's budget is a person's patience; a room-second's budget is a
 *   core, and `ROOM_CAP` in `src/rooms/hub.ts` is one divided by the other, so
 *   this is the number that decides how many rooms one box holds.
 * - `buildScene` on the world that tick left, with a firefight's worth of
 *   effects in the ring — bodies, the bomb, tracers, sparks and blood — which
 *   is a hungry frame rather than a quiet one.
 * - `buildRangeScene` on a live run: the room, the plates standing in it and a
 *   tracer still fading. The range's frame is a thirtieth of the shooter's and
 *   is measured anyway, because a game with no ceiling is where the cost goes.
 * - And a frame deliberately made dearer, which must fail the same ceiling: a
 *   guard nothing can trip is not a guard, and the last test here proves this
 *   one trips.
 *
 * ## Why the ceilings are where they are
 *
 * Measured on the machine that wrote this, idle: a tick **0.078 ms**, the
 * shooter's hungry frame **0.0096 ms**, the range's **0.0003 ms**. The ceilings
 * below are not those numbers — a test pinned to today's number fails the first
 * time CI is busy — they are **1.0 ms**, **0.15 ms** and **0.02 ms**: thirteen,
 * sixteen and sixty-six times today's cost, and each still a small slice of the
 * 15.625 ms a frame has. A radar, a gait, a grenade trail, footsteps or a
 * damage indicator that made one of these an order of magnitude dearer trips
 * the ceiling. A box a few times slower than this one does not: with all eighty
 * cores of this machine saturated by other work the three measured 0.27 ms,
 * 0.022 ms and 0.0010 ms — still under their ceilings by four, seven and twenty
 * times over.
 *
 * The room-second is the same argument at a different scale, and it is worth
 * saying exactly which second it is: the **first** of a live round, which is
 * ten bots walking out of spawn, and which reads about **4.6 ms** here. A round
 * gets dearer as it meets itself — `bun run scripts/room.ts` measures an
 * eight-second window on the forge's box, eighty cores at a load average of
 * twenty, and reads 5.4–8.1 ms an average second with 10–24 ms in the dearest
 * one — so the ceiling is set against the bench's numbers and not against this
 * test's own. It is **40 ms**: roughly five times an average second of play,
 * four per cent of the second a room has to be stepped inside, and still above
 * the dearest second this box has produced. What it catches is a change that
 * makes the simulation *several* times dearer, not one that makes it a fifth
 * dearer — a tighter ceiling on a shared box is a red build about somebody
 * else's job, which nobody would read twice.
 *
 * The multiple is deliberately larger where the number is smaller. Clock
 * resolution and scheduler jitter are absolute, not proportional: ten times
 * 0.3 µs is inside the noise of any machine, so the range's ceiling is sixty
 * times its cost and still a seven-hundredth of a frame, which is what makes it
 * worth asserting at all rather than not asserting it.
 *
 * ## Why it does not flake
 *
 * Three things, and the file is worth little without all of them.
 *
 * Every measurement **warms up first** — two batches thrown away, so the JIT
 * has compiled and the shapes have settled — and then takes the **median of
 * seven batches** rather than the mean of one, so a batch that lands on a GC
 * pause is one of seven and the median steps over it.
 *
 * And every batch is timed by **two clocks**: the wall clock, and this
 * process's own CPU time (`process.cpuUsage`). Both are upper bounds on the
 * work a frame does, and interference only ever pushes one of them up — a
 * descheduled process reads a long wall clock, and Bun's GC and JIT threads
 * burning a second core read a long CPU clock — so the measurement is the
 * **smaller of the two medians**, which is the tightest bound the pair can
 * honestly support. It matters: measured against 160 spinning processes on 80
 * cores, the wall clock put a tick at 7.8 ms — a hundred times its real cost,
 * and past any ceiling worth having — while the CPU clock put it at 0.43 ms and
 * every ceiling here held. That is the difference between a test that fails
 * when the code got slower and one that fails when CI got busy.
 *
 * The whole file costs about six tenths of a second — a thirty-fifth of the
 * twenty-second suite it joined — which is the price of batches big enough for
 * a clock to resolve.
 */
import { expect, test } from "bun:test";
import { pushEffect, resetEffects, type Camera } from "./engine/index.ts";
import { DE_FORGE } from "./client/map.ts";
import { SHORT } from "./client/match.ts";
import { buildScene, createScene } from "./client/scene.ts";
import { useShipped } from "./client/shipped.ts";
import { NO_INPUT, createWorld, update, type Effect, type World } from "./client/world.ts";
import { buildRangeScene, createRangeScene } from "./range/scene.ts";
import { EYE, createRun, start, step } from "./range/targets.ts";
import { createRoom, stepRoom, type Room } from "./rooms/room.ts";
/** The fixed simulation step, and the wall clock a frame of it has to fit in. */
const TICK = 1 / 64;
const FRAME_BUDGET = 1000 * TICK;
/** One tick of ten bodies, nine of them thinking. Today: 0.078 ms. */
const TICK_CEILING = 1.0;
/** The shooter's scene, a hungry frame of it. Today: 0.0096 ms. */
const SCENE_CEILING = 0.15;
/** The range's scene. Today: 0.0003 ms — see the note on small numbers above. */
const RANGE_SCENE_CEILING = 0.02;
/**
 * One second of play in one room, stepped here. Today: 4.6 ms for the second
 * this test takes, 5.4–8.1 ms for an average one on the forge's box under load
 * — see the note above, and `bun run scripts/room.ts` for where the numbers
 * come from and what a deployment does with them.
 */
const ROOM_SECOND_CEILING = 40;
/** Batches thrown away before any are kept, so nothing measured is cold. */
const WARM = 2;
/** Batches kept, of which the median is the answer. Odd, so there is one. */
const BATCHES = 7;
/**
 * Milliseconds of CPU this process has burned, user and system together. The
 * clock every batch below is timed by, for the reason in the header: it counts
 * work done and not time spent waiting for a core.
 */
const cpuMs = (): number => {
  const used = process.cpuUsage();
  return (used.user + used.system) / 1000;
};
const median = (xs: number[]): number =>
  [...xs].sort((a, b) => a - b)[(xs.length - 1) >> 1] as number;
/** One batch of operations, in milliseconds each, read off both clocks. */
type Batch = { wall: number; cpu: number };
/** `runs` operations of `work`, timed by both clocks and divided by `runs`. */
function timed(runs: number, work: () => void): Batch {
  const wall = performance.now();
  const cpu = cpuMs();
  work();
  return { wall: (performance.now() - wall) / runs, cpu: (cpuMs() - cpu) / runs };
}
/**
 * Long enough that a machine under real contention finishes rather than fails:
 * the measurement itself is immune to load, but the wall clock the runner holds
 * a test to is not, and a timeout is a flake by another name.
 */
const PATIENCE = 60_000;
/**
 * What a ceiling here is a slice of. A frame has 15.625 ms of a person's
 * patience; a room-second has a second of a core, which is the same sentence
 * about a different clock, and the printed line says which one it meant.
 */
const FRAME = { ms: FRAME_BUDGET, name: "frame" };
const ROOM_SECOND = { ms: 1000, name: "second a room has" };
/**
 * Run `batch` — which times some number of operations and hands back the
 * milliseconds one of them cost — until it is warm, then seven more times, and
 * return the median. The number is printed, because a green run should still
 * tell a person what a frame costs today.
 */
function measure(label: string, ceiling: number, batch: () => Batch, within = FRAME): number {
  for (let i = 0; i < WARM; i++) batch();
  const kept: Batch[] = [];
  for (let i = 0; i < BATCHES; i++) kept.push(batch());
  const wall = median(kept.map((b) => b.wall));
  const cpu = median(kept.map((b) => b.cpu));
  const cost = Math.min(wall, cpu);
  console.log(
    `  ${label}: ${cost.toFixed(4)} ms` +
      ` (median of ${BATCHES}: wall ${wall.toFixed(4)}, cpu ${cpu.toFixed(4)};` +
      ` ceiling ${ceiling} ms of a ${within.ms.toFixed(3)} ms ${within.name})`,
  );
  return cost;
}
/**
 * A round of the shooter already under way: ten bodies on de_forge, the freeze
 * over. The phase is set rather than played through, because eight seconds of
 * freeze is eight seconds of the same tick and this file has a second to spend.
 */
function liveRound(seed: number): World {
  const world = createWorld(DE_FORGE, SHORT, "you", "ct", 5, seed);
  world.match.phase = "live";
  world.match.timer = SHORT.roundTime;
  return world;
}
/** How many ticks one batch of the simulation is: a second of play. */
const TICKS = 64;
test("a 64 Hz tick with ten bodies stays well inside the frame budget", () => {
  useShipped(); // a bot with no policy does not think, and would not be measured
  let alive = 0;
  const each = measure("a 64 Hz tick, ten bodies, nine of them thinking", TICK_CEILING, () => {
    // A fresh round per batch: a world played for thousands of ticks is a world
    // where people have died, and a dead bot does not think — the measurement
    // would drift downwards into meaninglessness.
    const world = liveRound(7);
    const batch = timed(TICKS, () => {
      for (let i = 0; i < TICKS; i++) update(world, TICK, NO_INPUT);
    });
    alive = world.players.filter((p) => p.alive).length;
    return batch;
  });
  expect(each).toBeLessThan(TICK_CEILING);
  // And the ticks that were measured really did have ten bodies in them: if the
  // round had emptied out, the number above would be a number about nothing.
  expect(alive).toBe(10);
}, PATIENCE);
/**
 * The same tick with smoke standing in the round: ten clouds, one per body,
 * which is the most this game can have at once and far more than a round ever
 * does. It is measured against the *same* ceiling as the plain tick, because
 * what #165 promised is that a cloud does not buy a sight test a second price:
 * `canSee` traces the level's fifty-odd boxes first, as it always has, and then
 * runs `segmentSphere` over the clouds — a dot product and at most one square
 * root each, with no allocation — and in a round nobody smoked the loop is a
 * length check on an empty array and costs nothing measurable at all.
 *
 * Measured on the machine that wrote this, idle: a plain tick 0.102 ms, this
 * one 0.107 ms. Ten clouds cost about **0.005 ms a tick** — three hundredths of
 * one per cent of the 15.625 ms a frame has, and a twentieth of what a tick
 * already cost — and both are nearly ten times under the 1.0 ms ceiling, which
 * did not move for any of this.
 */
test("a tick with ten clouds of smoke standing is still well inside the budget", () => {
  useShipped();
  let clouds = 0;
  const each = measure("a 64 Hz tick with ten clouds standing", TICK_CEILING, () => {
    const world = liveRound(7);
    // One cloud on each body, opened a moment ago so every one of them is at
    // its full radius for the whole batch rather than growing out of nothing.
    for (const p of world.players)
      world.clouds.push({ pos: [p.pos[0], p.pos[1], p.pos[2] + 58], born: world.time - 2, owner: p.id });
    const batch = timed(TICKS, () => {
      for (let i = 0; i < TICKS; i++) update(world, TICK, NO_INPUT);
    });
    clouds = world.clouds.length;
    return batch;
  });
  expect(each).toBeLessThan(TICK_CEILING);
  // The ticks that were measured really did have ten clouds standing in them.
  expect(clouds).toBe(10);
}, PATIENCE);
/**
 * A room's own round, whose freeze is set aside the way `liveRound` sets it
 * aside and for the same reason. Every one of the ten bodies is a bot here —
 * `createRoom` makes `world.me` one too, because a room has seats and not a
 * person — so this is ten policies thinking and not nine.
 */
function liveRoom(seed: number): Room {
  const room = createRoom("BUDGET", { map: "de_forge", seed, length: "short", now: 0 });
  room.world.match.phase = "live";
  room.world.match.timer = room.rules.roundTime;
  return room;
}
/**
 * What this process pays to *be* one room for one second of play. It is the
 * number `ROOM_CAP` is divided out of, so the day the simulation gets several
 * times dearer this is where it is read — before twenty rooms full of people
 * find out for themselves.
 *
 * The snapshots are not in here: what they weigh is pinned in
 * `src/rooms/wire.test.ts` and what they cost is printed by
 * `bun run scripts/room.ts`, and this holds the one number that is the room
 * whether anybody is watching it or not.
 */
test("a second of play in one room costs a small fraction of the second it had", () => {
  useShipped(); // a bot with no policy does not think, and would not be measured
  let alive = 0;
  const each = measure(
    "a room-second: 64 steps of ten bodies, all ten thinking",
    ROOM_SECOND_CEILING,
    () => {
      // A fresh round per batch, for the reason the tick above takes one.
      const room = liveRoom(7);
      const batch = timed(1, () => {
        for (let i = 0; i < TICKS; i++) stepRoom(room);
      });
      alive = room.world.players.filter((p) => p.alive).length;
      return batch;
    },
    ROOM_SECOND,
  );
  expect(each).toBeLessThan(ROOM_SECOND_CEILING);
  // And the second that was measured really was ten bodies thinking: a room
  // that had emptied out would be a cheap number about nothing.
  expect(alive).toBe(10);
}, PATIENCE);
/**
 * And the room's ceiling bites too, for the reason the frame's does. Sixteen
 * seconds of play charged as one is a simulation sixteen times dearer — nothing
 * about the room changed, it is simply asked for sixteen times the work inside
 * the second it had — and the measurement notices and the ceiling refuses it.
 * Sixteen and not two, for the same reason the frame's proof is written at
 * sixty-four substeps and not at ten: the margin between the ceiling and
 * today's cost is what keeps a busy box from turning this file red, and a proof
 * has to clear that margin on a machine slower than this one as well.
 */
test("a room-second that got several times dearer is past the ceiling", () => {
  useShipped();
  const dearer = 16;
  const each = measure(
    `a room-second asked to step ${dearer} of them, to prove the ceiling bites`,
    ROOM_SECOND_CEILING,
    () => {
      const room = liveRoom(7);
      return timed(1, () => {
        for (let i = 0; i < TICKS * dearer; i++) stepRoom(room);
      });
    },
    ROOM_SECOND,
  );
  expect(each).toBeGreaterThan(ROOM_SECOND_CEILING);
}, PATIENCE);
/**
 * The guard's own guard. A ceiling nothing can reach is a green light wired to
 * nothing: a loop the JIT lifted out, a clock read twice in a row, a batch that
 * timed an empty function would all pass every assertion above and say so
 * cheerfully forever. So here is a frame that really did get dearer — the same
 * 1/64 s of play, stepped in sixty-four substeps instead of one — and the
 * measurement notices it and the ceiling refuses it.
 *
 * Sixty-four substeps is not sixty-four times the cost: some of a tick is
 * per-call work that does not multiply, and it measures about 35× a plain one,
 * 2.6–3.8 ms against a 1.0 ms ceiling. That margin is the point of the number.
 * A tenfold regression would land just under the ceiling on *this* machine and
 * over it on any machine slower — which is the price of a ceiling that never
 * flakes, and the reason this proof is not written at ten.
 */
test("a frame that got an order of magnitude dearer is past the ceiling", () => {
  useShipped();
  const dearer = 64;
  const ops = 4;
  const each = measure(`a 64 Hz tick cut into ${dearer} substeps, to prove the ceiling bites`, TICK_CEILING, () => {
    const world = liveRound(7);
    return timed(ops, () => {
      for (let i = 0; i < ops; i++)
        for (let j = 0; j < dearer; j++) update(world, TICK / dearer, NO_INPUT);
    });
  });
  expect(each).toBeGreaterThan(TICK_CEILING);
}, PATIENCE);
test("the shooter's scene is built in a fraction of what a tick costs", () => {
  useShipped();
  const world = liveRound(11);
  for (let i = 0; i < 64; i++) update(world, TICK, NO_INPUT);
  // A hungry frame: the bomb down and a firefight's worth of effects still in
  // the ring, so the line buffer is being filled and not just the instances.
  resetEffects(world.effects);
  world.bomb.state = "planted";
  world.bomb.pos = [500, 600, 20];
  for (let i = 0; i < 64; i++) {
    const at = world.time - 0.02;
    const effect: Effect =
      i % 3 === 0
        ? { kind: "tracer", from: [i, 0, 40], to: [i, 200, 45], at }
        : i % 3 === 1
          ? { kind: "impact", at, pos: [i, 2, 3], normal: [0, 0, 1] }
          : { kind: "blood", at, pos: [i, 2, 3] };
    pushEffect(world.effects, effect, effect.at);
  }
  const camera: Camera = {
    pos: [world.me.pos[0], world.me.pos[1], world.me.pos[2] + 64],
    yaw: world.me.yaw, pitch: world.me.pitch, fov: 90,
  };
  const scene = createScene();
  const runs = 1000;
  const each = measure("buildScene, a firefight frame", SCENE_CEILING, () =>
    timed(runs, () => {
      for (let i = 0; i < runs; i++) buildScene(world, camera, scene);
    }),
  );
  expect(each).toBeLessThan(SCENE_CEILING);
  // The frame that was timed was the hungry one it claims to be: bodies drawn
  // and a few hundred line vertices, not an empty scene measured very fast.
  expect(scene.instanceCount).toBeGreaterThan(5);
  expect(scene.lineCount).toBeGreaterThan(100);
}, PATIENCE);
test("the range's scene is built in a fraction of what a tick costs", () => {
  const run = createRun(1);
  start(run);
  // Five seconds in, so the lane is as full as this drill ever makes it.
  for (let i = 0; i < 64 * 5; i++) step(run, TICK);
  const scene = createRangeScene();
  const view = { eye: EYE, yaw: 3, pitch: -1 };
  const trail = { from: EYE, to: [900, 0, 60] as [number, number, number], at: 0 };
  const runs = 10000;
  const each = measure("buildRangeScene, plates and a tracer", RANGE_SCENE_CEILING, () =>
    timed(runs, () => {
      for (let i = 0; i < runs; i++) buildRangeScene(run, view, trail, 0.02, scene);
    }),
  );
  expect(each).toBeLessThan(RANGE_SCENE_CEILING);
  // The room, the plates standing in it, and the tracer still fading — which is
  // one line, and a line is two vertices, which is what `lineCount` counts.
  expect(run.targets.length).toBeGreaterThan(0);
  expect(scene.instanceCount).toBe(1 + run.targets.length);
  expect(scene.lineCount).toBe(2);
}, PATIENCE);
@@ -1,23 +0,0 @@
/**
 * The client bundle: one file, named by the hash of its own bytes, so a
 * source change is a new URL and a stale cache is impossible.
 */
import { join } from "node:path";
const ENTRY = join(import.meta.dir, "client", "main.ts");
export async function bundle(): Promise<{ name: string; code: string }> {
  const built = await Bun.build({
    entrypoints: [ENTRY],
    target: "browser",
    minify: true,
    format: "esm",
  });
  if (!built.success) throw new Error(built.logs.map(String).join("\n"));
  const output = built.outputs[0];
  if (output === undefined) throw new Error("the bundle produced no output");
  const code = await output.text();
  const hash = new Bun.CryptoHasher("sha256").update(code).digest("hex").slice(0, 10);
  return { name: `app.${hash}.js`, code };
}
@@ -0,0 +1,61 @@
/**
 * Where this deployment's bundles are, and the build that puts them there.
 *
 * They are generated files, so they are generated: `src/server.ts` calls
 * `buildBundles()` before it binds, into `FORGE_APP_DATA/static`, and serves
 * what came out. Nothing built is committed — three outages in three days were
 * one cause, two branches each rebuilding `static/app.<hash>.js` and git
 * keeping both, and an artifact that is never in git cannot collide in it.
 *
 * It is also why a preview can never be stale: the process that answers a
 * request built the files it answers with, from the tree it was deployed from,
 * this boot.
 *
 * The build itself is `scripts/build.ts` — one bundler call per game and one
 * copy per asset, with the naming, the sweeping and the ceilings — and this
 * module is only the two things the server adds to it: which directory, and
 * what a failure says. A build that fails throws here, naming the directory,
 * and the process stops on it exactly as a missing bundle stopped it before:
 * a deploy that cannot build is a failed deploy, not a server listening with
 * nothing to serve.
 */
import { join } from "node:path";
import { type Built, ENTRIES, sizes, write } from "../scripts/build.ts";
import { kB } from "./bytes.ts";
/**
 * The directory the bundles are built into and served from: `static/` under
 * this deployment's data directory, which production and every preview each
 * have their own of. The default is `./data` like the database's, so a checkout
 * with no forge around it still runs.
 *
 * It is a subdirectory rather than the data directory itself because the
 * database lives there too, and the server holds every file in this one in
 * memory at start-up.
 */
export const bundlesDir = (data = process.env.FORGE_APP_DATA ?? "./data"): string => join(data, "static");
/**
 * Build every game's bundle and every declared asset into `dir`, and hand back
 * what was written. A failure — an unwritable directory, a source that does not
 * compile — is re-thrown with the directory named, because the message a
 * deploy's log shows should say where it was trying to write.
 */
export async function buildBundles(dir = bundlesDir()): Promise<Built[]> {
  try {
    return await write(ENTRIES, dir);
  } catch (cause) {
    const why = cause instanceof Error ? cause.message : String(cause);
    throw new Error(`the bundles could not be built into ${dir}: ${why}`, { cause });
  }
}
/**
 * What the build cost this boot, for the log: how many files, what they weigh
 * on disk, and the milliseconds it took. The gzip of them is weighed separately
 * when they are held, and `src/server.ts` prints that line beside this one.
 */
export const buildSummary = (built: readonly Built[], ms: number, dir = bundlesDir()): string =>
  `${built.length} files built into ${dir}, ` +
  `${kB(built.reduce((total, { code }) => total + sizes(code).raw, 0))} raw, in ${ms.toFixed(1)} ms`;
@@ -0,0 +1,31 @@
import { expect, test } from "bun:test";
import { bytes, kB } from "./bytes.ts";
test("an exact count is grouped in threes, from either side of a thousand", () => {
  expect(bytes(0)).toBe("0");
  expect(bytes(7)).toBe("7");
  expect(bytes(999)).toBe("999");
  expect(bytes(1000)).toBe("1,000");
  expect(bytes(9735)).toBe("9,735");
  expect(bytes(93_714)).toBe("93,714");
  expect(bytes(1_234_567)).toBe("1,234,567");
});
test("a kilobyte is 1,024 bytes, to a tenth, with the unit on it", () => {
  // The number the issue this came from wrote by hand: 4,229 over the wire is
  // 4.1 kB. It is 1,024 and not 1,000, and that is the whole difference.
  expect(kB(4229)).toBe("4.1 kB");
  expect(kB(4619)).toBe("4.5 kB");
  expect(kB(1024)).toBe("1.0 kB");
  expect(kB(512)).toBe("0.5 kB");
  expect(kB(0)).toBe("0.0 kB");
  expect(kB(42_539)).toBe("41.5 kB");
});
test("a number that is not a count of bytes is a throw, not a sentence with NaN in it", () => {
  expect(() => bytes(-1)).toThrow(/whole number of bytes/);
  expect(() => bytes(1.5)).toThrow(/whole number of bytes/);
  expect(() => bytes(Number.NaN)).toThrow(/whole number of bytes/);
  expect(() => kB(-1)).toThrow(/whole number of bytes/);
  expect(() => kB(Number.POSITIVE_INFINITY)).toThrow(/whole number of bytes/);
});
@@ -0,0 +1,27 @@
/**
 * A byte count, written the way a sentence says one. Two shapes and nothing
 * else: `9735` is `9,735` when the exact figure is the claim, and `4619` is
 * `4.5 kB` when what a reader wants is the feel of the download.
 *
 * It is a module of its own because the alternative is arithmetic inside a
 * template, where no test can reach it: a page interpolates `bytes(n)` and the
 * rounding, the grouping and the unit are decided here, once, with a test
 * beside them.
 *
 * The unit is stated rather than assumed: a kB here is 1,024 bytes, which is
 * what makes 4,619 read as 4.5 kB. That is the ruler `scripts/build.ts`
 * measures with too — a gzip figure at level 9 — and the pages that print these
 * numbers say so next to them.
 */
/** A count this module will print: a whole number of bytes, and not a negative one. */
const whole = (n: number, kind: string): number => {
  if (!Number.isInteger(n) || n < 0) throw new Error(`${kind} wants a whole number of bytes, not ${n}`);
  return n;
};
/** `9735` → `9,735`: the exact count, in groups of three. */
export const bytes = (n: number): string => String(whole(n, "bytes")).replace(/\B(?=(\d{3})+$)/g, ",");
/** `4619` → `4.5 kB`: the same count rounded to a tenth of a kibibyte, with its unit. */
export const kB = (n: number): string => `${(whole(n, "kB") / 1024).toFixed(1)} kB`;
@@ -1,94 +1,223 @@
/**
 * `action.ts` decodes the bins the shipped policy was trained against — a
 * bin renumbered or reordered here does not fail to compile, it just makes
 * the weights mean something else. So the bin tables are pinned by value,
 * and `decode`/`toInput` are pinned end to end: an index in, the exact
 * `Intent`/`Input` it is supposed to mean out.
 * What a sample from the policy means, which is this game's and not the
 * engine's: the engine hands back one integer per head and knows nothing about
 * what any of them says. These tests moved out of `policy.test.ts` when the
 * network itself went behind the door in #106 — the arithmetic went with it as
 * `src/engine/net.test.ts`, and the bins stayed here, where the bins are.
 *
 * The bins are a contract with weights that were trained against them, so the
 * expectations below are written as literals rather than as `decode`'s own
 * arithmetic said twice: a table of what each index means, walked over the
 * whole 9·7·3·3·2·3. A test that recomputed the index would agree with any
 * future mistake made the same way, and the first sign of one is a bot standing
 * still on the map.
 */
import { expect, test } from "bun:test";
import { AXIS_BINS, decode, HEADS, PITCH_BINS, STILL, toInput, YAW_BINS } from "./action.ts";
import {
  ACTION_SIZE, AXIS_BINS, decode, HEADS, PITCH_BINS, STILL, toInput, YAW_BINS, type Intent,
} from "./action.ts";
import { forward, greedy, newActivations, rng, sample, unpack } from "../engine/index.ts";
import { OBS_SIZE } from "./observe.ts";
import { PACKED } from "./shipped.ts";
import { NO_INPUT } from "./world.ts";
test("the bin tables are odd-length, sorted, and centred on zero", () => {
  for (const bins of [YAW_BINS, PITCH_BINS, AXIS_BINS]) {
    expect(bins.length % 2).toBe(1); // an odd count so there is a middle bin
    const middle = (bins.length - 1) / 2;
    expect(bins[middle]).toBe(0);
    const sorted = [...bins].sort((a, b) => a - b);
    expect(bins).toEqual(sorted); // strictly increasing, so index order is bin order
/** The bins, written out again by hand. If these two lists ever disagree, one of them moved. */
const YAW = [-720, -240, -80, -25, 0, 25, 80, 240, 720];
const PITCH = [-240, -80, -25, 0, 25, 80, 240];
const AXIS = [-1, 0, 1];
/** The posture head: index 0 is neither, 1 is walking, 2 is ducking. */
const POSTURE = [
  { walk: false, duck: false },
  { walk: true, duck: false },
  { walk: false, duck: true },
];
test("the bins are the ones the shipped policy was trained on", () => {
  // Spread because the bins are a readonly tuple and these lists are plain.
  expect([...YAW_BINS]).toEqual(YAW);
  expect([...PITCH_BINS]).toEqual(PITCH);
  expect([...AXIS_BINS]).toEqual(AXIS);
  expect(HEADS).toEqual([9, 7, 3, 3, 2, 3]);
  expect(ACTION_SIZE).toBe(6);
  expect(ACTION_SIZE).toBe(HEADS.length);
});
/**
 * The one failure that could pass every other test in this repository: weights
 * quantised against a different action or observation space than the one the
 * game hands them. `weights.test.ts` asks the same of the unpacked policy; this
 * asks it of the shape the file declares, which is what `unpack` reads.
 */
test("the shipped weights and the spaces they were trained on agree", () => {
  expect(PACKED.shape.heads).toEqual(HEADS);
  expect(PACKED.shape.obs).toBe(OBS_SIZE);
  expect(unpack(PACKED).shape.heads).toEqual(HEADS);
});
test("every index of every head decodes to the bin it names", () => {
  const actions = new Int32Array(ACTION_SIZE);
  let seen = 0;
  for (let y = 0; y < YAW.length; y++) {
    for (let p = 0; p < PITCH.length; p++) {
      for (let f = 0; f < AXIS.length; f++) {
        for (let s = 0; s < AXIS.length; s++) {
          for (let b = 0; b < 2; b++) {
            for (let t = 0; t < POSTURE.length; t++) {
              actions.set([y, p, f, s, b, t]);
              expect(decode(actions)).toEqual({
                yawRate: YAW[y]!,
                pitchRate: PITCH[p]!,
                forward: AXIS[f]!,
                side: AXIS[s]!,
                fire: b === 1,
                walk: POSTURE[t]!.walk,
                duck: POSTURE[t]!.duck,
              });
              seen += 1;
            }
          }
        }
      }
    }
  }
  expect(YAW_BINS[0]).toBe(-720);
  expect(YAW_BINS[YAW_BINS.length - 1]).toBe(720);
  expect(PITCH_BINS[0]).toBe(-240);
  expect(PITCH_BINS[PITCH_BINS.length - 1]).toBe(240);
  expect(AXIS_BINS).toEqual([-1, 0, 1]);
  expect(seen).toBe(9 * 7 * 3 * 3 * 2 * 3);
  expect(seen).toBe(3402);
});
test("HEADS lists each head's bin count, in the order decode reads them", () => {
  expect(HEADS).toEqual([YAW_BINS.length, PITCH_BINS.length, AXIS_BINS.length, AXIS_BINS.length, 2, 3]);
test("a head is read from its own index and not its neighbour's", () => {
  // Six heads whose indices are all different, so reading one along shows.
  const actions = new Int32Array([1, 2, 0, 2, 1, 2]);
  expect(decode(actions)).toEqual({
    yawRate: -240, pitchRate: -25, forward: -1, side: 1, fire: true, walk: false, duck: true,
  });
});
test("decoding the middle of every bin head is the still intent", () => {
  const yawMid = (YAW_BINS.length - 1) / 2;
  const pitchMid = (PITCH_BINS.length - 1) / 2;
  const axisMid = (AXIS_BINS.length - 1) / 2;
  const intent = decode(Int32Array.from([yawMid, pitchMid, axisMid, axisMid, 0, 0]));
  expect(intent).toEqual(STILL);
/**
 * An index a head does not have is a sample from somewhere else — short, or
 * from a net trained against different heads. `decode` clamps it to the nearest
 * bin, because the nearest bin is a bot that turns too far while `undefined` is
 * a view angle of NaN that never comes back. The expectations are the ends of
 * the tables above, written out.
 */
test("a bin the head does not have is clamped to the nearest one it does", () => {
  const past = decode(new Int32Array([YAW.length + 3, -2, 99, -1, 0, 0]));
  expect(past).toEqual({
    yawRate: 720, // the last yaw bin, not undefined
    pitchRate: -240, // the first pitch bin: a negative index clamps to 0
    forward: 1,
    side: -1,
    fire: false,
    walk: false,
    duck: false,
  });
  for (const v of [past.yawRate, past.pitchRate, past.forward, past.side])
    expect(Number.isNaN(v)).toBe(false);
  // A sample that stops short of the six heads asks the same question of a
  // missing index, and answers with the first bin rather than undefined.
  expect(decode(new Int32Array([1]))).toEqual({
    yawRate: -240, pitchRate: -240, forward: -1, side: -1, fire: false, walk: false, duck: false,
  });
});
test("the extreme yaw bins turn at 720 deg/s, one way and the other", () => {
  const actions = Int32Array.from([0, 3, 1, 1, 0, 0]);
  expect(decode(actions).yawRate).toBe(-720);
  actions[0] = YAW_BINS.length - 1;
  expect(decode(actions).yawRate).toBe(720);
test("`at` reads one sample out of a buffer of many", () => {
  const buffer = new Int32Array([
    8, 0, 2, 0, 0, 1, // a sample at 0: hard right, nose down, forward, walking
    0, 6, 0, 2, 1, 2, // a sample at 6: hard left, nose up, back, right, firing, ducking
  ]);
  expect(decode(buffer, 0)).toEqual({
    yawRate: 720, pitchRate: -240, forward: 1, side: -1, fire: false, walk: true, duck: false,
  });
  expect(decode(buffer, 6)).toEqual({
    yawRate: -720, pitchRate: 240, forward: -1, side: 1, fire: true, walk: false, duck: true,
  });
});
test("decode reads fire and posture as the flags they are, at a given offset", () => {
  const walking = decode(Int32Array.from([4, 3, 1, 1, 1, 1]));
  expect(walking.fire).toBe(true);
  expect(walking.walk).toBe(true);
  expect(walking.duck).toBe(false);
  const ducking = decode(Int32Array.from([4, 3, 1, 1, 0, 2]));
  expect(ducking.fire).toBe(false);
  expect(ducking.walk).toBe(false);
  expect(ducking.duck).toBe(true);
  // and at a non-zero offset, into a batch of several samples
  const batch = Int32Array.from([0, 0, 0, 0, 0, 0, 4, 3, 2, 0, 1, 1]);
  const second = decode(batch, 6);
  expect(second.forward).toBe(1);
  expect(second.side).toBe(-1);
  expect(second.fire).toBe(true);
  expect(second.walk).toBe(true);
test("the middle bin of every axis is standing still, and that is STILL", () => {
  const middle = new Int32Array([4, 3, 1, 1, 0, 0]);
  expect(decode(middle)).toEqual({
    yawRate: 0, pitchRate: 0, forward: 0, side: 0, fire: false, walk: false, duck: false,
  });
  expect(STILL).toEqual({
    yawRate: 0, pitchRate: 0, forward: 0, side: 0, fire: false, walk: false, duck: false,
  });
  expect(decode(middle)).toEqual(STILL);
});
test("an out-of-range index is clamped, never undefined in an Input", () => {
  const tooHigh = decode(Int32Array.from([YAW_BINS.length + 5, PITCH_BINS.length + 5, 9, 9, 9, 9]));
  for (const value of Object.values(tooHigh)) expect(value).not.toBeUndefined();
  expect(Number.isFinite(tooHigh.yawRate)).toBe(true);
  expect(Number.isFinite(tooHigh.pitchRate)).toBe(true);
const INTENT: Intent = {
  yawRate: 240, pitchRate: -80, forward: 1, side: -1, fire: true, walk: true, duck: false,
};
  const negative = decode(Int32Array.from([-1, -1, -1, -1, -1, -1]));
  for (const value of Object.values(negative)) expect(value).not.toBeUndefined();
test("an intent becomes an input the game can apply, field by field", () => {
  expect(toInput(INTENT, false)).toEqual({
    forward: 1,
    side: -1,
    jump: false,
    duck: false,
    walk: true,
    fire: true,
    reload: false,
    use: false,
    scope: false,
    throwing: null,
    switchTo: null,
  });
  // Turning is not an Input: the caller moves the view, the way a mouse does.
  // `toEqual` above already refuses an extra field; this names the one meant.
  expect(toInput(INTENT, false)).not.toHaveProperty("yawRate");
  expect(toInput(INTENT, false)).not.toHaveProperty("pitchRate");
});
test("toInput carries the intent's own fields and takes turning from nobody", () => {
  const intent = decode(Int32Array.from([0, 0, 2, 0, 1, 1]));
  const input = toInput(intent, true, "ak47");
  expect(input.forward).toBe(intent.forward);
  expect(input.side).toBe(intent.side);
  expect(input.fire).toBe(intent.fire);
  expect(input.walk).toBe(intent.walk);
  expect(input.duck).toBe(intent.duck);
  expect(input.reload).toBe(true);
  expect(input.switchTo).toBe("ak47");
  expect(input.jump).toBe(false); // a bot never jumps through this path
  expect(input.use).toBe(false);
  expect(input.scope).toBe(false);
  expect("yawRate" in input).toBe(false); // turning is the caller's mouse, not Input
test("reload and a weapon switch are carried, and the other posture too", () => {
  const ducking: Intent = { ...INTENT, walk: false, duck: true, fire: false, forward: -1, side: 1 };
  expect(toInput(ducking, true, "ak47")).toEqual({
    forward: -1,
    side: 1,
    jump: false,
    duck: true,
    walk: false,
    fire: false,
    reload: true,
    use: false,
    scope: false,
    throwing: null,
    switchTo: "ak47",
  });
});
test("toInput defaults to no weapon switch", () => {
  expect(toInput(STILL, false).switchTo).toBeNull();
test("a still intent is the world's own no-input", () => {
  expect(toInput(STILL, false)).toEqual(NO_INPUT);
});
/**
 * And the end to end: whatever the shipped weights say about an observation,
 * greedily or sampled, is an intent the game can act on.
 */
test("the shipped policy decodes to a valid intent on a seeded sweep", () => {
  const net = unpack(PACKED);
  const act = newActivations(net.shape);
  const actions = new Int32Array(ACTION_SIZE);
  const obs = new Float32Array(OBS_SIZE);
  const random = rng(20108);
  const check = (intent: Intent): void => {
    expect(YAW).toContain(intent.yawRate);
    expect(PITCH).toContain(intent.pitchRate);
    expect(AXIS).toContain(intent.forward);
    expect(AXIS).toContain(intent.side);
    expect(typeof intent.fire).toBe("boolean");
    // Walking and ducking come from one head, so a bot never asks for both.
    expect(intent.walk && intent.duck).toBe(false);
    for (const v of [intent.yawRate, intent.pitchRate, intent.forward, intent.side])
      expect(Number.isNaN(v)).toBe(false);
  };
  for (let i = 0; i < 200; i++) {
    for (let j = 0; j < OBS_SIZE; j++) obs[j] = random() * 2 - 1; // the trained range
    forward(net, obs, act);
    for (const v of act.logits) expect(Number.isFinite(v)).toBe(true);
    greedy(net.shape, act.logits, actions);
    check(decode(actions));
    sample(net.shape, act.logits, random, actions);
    check(decode(actions));
  }
});
@@ -13,9 +13,12 @@
import type { WeaponId } from "./weapons.ts";
import type { Input } from "./world.ts";
export const YAW_BINS = [-720, -240, -80, -25, 0, 25, 80, 240, 720];
export const PITCH_BINS = [-240, -80, -25, 0, 25, 80, 240];
export const AXIS_BINS = [-1, 0, 1];
/** A head's bins: at least one, so there is always a bin to fall back on. */
export type Bins = readonly [number, ...number[]];
export const YAW_BINS: Bins = [-720, -240, -80, -25, 0, 25, 80, 240, 720];
export const PITCH_BINS: Bins = [-240, -80, -25, 0, 25, 80, 240];
export const AXIS_BINS: Bins = [-1, 0, 1];
/** The heads, in the order the policy writes them. */
export const HEADS = [YAW_BINS.length, PITCH_BINS.length, AXIS_BINS.length, AXIS_BINS.length, 2, 3];
@@ -36,18 +39,24 @@
export const STILL: Intent = {
  yawRate: 0, pitchRate: 0, forward: 0, side: 0, fire: false, walk: false, duck: false,
};
/** An index into a bin table, clamped so a stray sample never reads past it. */
const clampBin = (i: number, bins: readonly number[]): number =>
  bins[Math.max(0, Math.min(bins.length - 1, i))] as number;
/**
 * The bin an index names, clamped to the head it belongs to. A policy of the
 * right shape only ever names one of its own bins; a sample that is short, or
 * that came from a net trained against different heads, names one that is not
 * there — and the nearest bin is a bot that turns too far, while `undefined`
 * is a yaw of NaN that never comes back.
 */
const bin = (bins: Bins, index: number | undefined): number =>
  bins[Math.min(Math.max(index ?? 0, 0), bins.length - 1)] ?? bins[0];
/** Turn one sample from the policy into an intent. */
export function decode(actions: Int32Array, at = 0): Intent {
  const posture = actions[at + 5] as number;
  const posture = actions[at + 5];
  return {
    yawRate: clampBin(actions[at] as number, YAW_BINS),
    pitchRate: clampBin(actions[at + 1] as number, PITCH_BINS),
    forward: clampBin(actions[at + 2] as number, AXIS_BINS),
    side: clampBin(actions[at + 3] as number, AXIS_BINS),
    yawRate: bin(YAW_BINS, actions[at]),
    pitchRate: bin(PITCH_BINS, actions[at + 1]),
    forward: bin(AXIS_BINS, actions[at + 2]),
    side: bin(AXIS_BINS, actions[at + 3]),
    fire: actions[at + 4] === 1,
    walk: posture === 1,
    duck: posture === 2,
@@ -69,6 +78,9 @@
export function toInput(intent: Intent, reload: boolean, switchTo: WeaponId | nu
    reload,
    use: false,
    scope: false,
    // A bot throws nothing: it buys neither grenade, and `null` here is the
    // field's own "neither", which `applyInput` reads as no press at all.
    throwing: null,
    switchTo,
  };
}
@@ -1,361 +1,287 @@
/**
 * `audio.ts` against a recording `AudioContext`: no browser, no speaker, just
 * the graph it would have built — the same trick `renderer.test.ts` plays on
 * WebGL2, one level down. `createAudio` takes its context constructor as an
 * argument, so the fake below stands in for `window.AudioContext`.
 */
import { expect, test } from "bun:test";
import { createAudio, type WorldSoundName } from "./audio.ts";
import { ears } from "./ears.ts";
import type { Vec3 } from "./math.ts";
import { readFileSync } from "node:fs";
import { join } from "node:path";
import { LOUDEST_INSTANT, createAudio, loudness, shotTone, type Audio } from "./audio.ts";
import type { Burst, SoundDevice, Tone, Vec3 } from "../engine/index.ts";
import type { Sound } from "./world.ts";
type Event = { method: string; value: number; time: number };
/**
 * Every noise a round can make, which is the whole of `Sound`: the five a
 * grenade makes and the five the round does. Written once, because three tests
 * here walk all of them and a name missing from one of those lists is a recipe
 * nobody checks — `smoke` was exactly that until the budget below wanted it.
 */
const SOUNDS: Sound[] = [
  "step", "beep", "plant", "defuse", "death", "throw", "bounce", "blast", "flash", "smoke",
];
/** A minimal AudioParam: `.value` sets and the two ramps `audio.ts` schedules
 * are both logged, in order, so a test can tell a sound's starting loudness
 * (its first event) from where the ramp leaves it (its `.value`). */
class FakeParam {
  #value: number;
  readonly events: Event[] = [];
  constructor(initial: number) {
    this.#value = initial;
  }
  get value(): number {
    return this.#value;
  }
  set value(v: number) {
    this.#value = v;
    this.events.push({ method: "value", value: v, time: NaN });
  }
  setValueAtTime(value: number, time: number): FakeParam {
    this.#value = value;
    this.events.push({ method: "setValueAtTime", value, time });
    return this;
  }
  exponentialRampToValueAtTime(value: number, time: number): FakeParam {
    this.#value = value;
    this.events.push({ method: "exponentialRampToValueAtTime", value, time });
    return this;
  }
/** A device that plays nothing and writes down everything. */
function recorder(): SoundDevice & { bursts: Burst[]; tones: Tone[]; resumes: number } {
  const device = {
    muted: false,
    bursts: [] as Burst[],
    tones: [] as Tone[],
    resumes: 0,
    resume() { device.resumes += 1; },
    noiseBurst(burst: Burst) { if (!device.muted) device.bursts.push(burst); },
    tone(tone: Tone) { if (!device.muted) device.tones.push(tone); },
  };
  return device;
}
type Edge = { from: number; to: number };
test("a shot is a burst plus a thump, coloured by the weapon", () => {
  const device = recorder();
  const audio = createAudio(device);
  audio.shot("ak47", [0, 0, 0], [0, 0, 0]);
  expect(device.bursts.length).toBe(1);
  expect(device.tones.length).toBe(1);
  const burst = device.bursts[0] as Burst;
  const thump = device.tones[0] as Tone;
  expect(burst.frequency).toBe(shotTone("ak47").cut);
  expect(burst.length).toBe(shotTone("ak47").length);
  expect(thump.slideTo).toBeLessThan(thump.frequency);
class FakeNode {
  readonly id: number;
  readonly kind: string;
  #onConnect: (edge: Edge) => void;
  constructor(id: number, kind: string, onConnect: (edge: Edge) => void) {
    this.id = id;
    this.kind = kind;
    this.#onConnect = onConnect;
  }
  connect(dest: FakeNode): FakeNode {
    this.#onConnect({ from: this.id, to: dest.id });
    return dest;
  audio.shot("awp", [0, 0, 0], [0, 0, 0]);
  const sniper = device.bursts[1] as Burst;
  // The sniper is lower and rings longer than the rifle.
  expect(sniper.frequency).toBeLessThan(burst.frequency);
  expect(sniper.length).toBeGreaterThan(burst.length);
});
test("a shot across the map is quieter than one at your feet", () => {
  const device = recorder();
  const audio = createAudio(device);
  audio.shot("ak47", [0, 0, 0], [0, 0, 0]);
  audio.shot("ak47", [4000, 0, 0], [0, 0, 0]);
  const near = device.bursts[0] as Burst, far = device.bursts[1] as Burst;
  expect(far.gain).toBeLessThan(near.gain / 2);
  expect(near.gain).toBeCloseTo(0.35, 6);
  expect(loudness([100, 0, 0], [0, 0, 0])).toBe(1);
  expect(loudness([4000, 0, 0], [0, 0, 0])).toBeLessThan(0.3);
});
/**
 * The gain the recipe asks for at a distance, by hand: `attenuate` is
 * `min(1, earshot / distance)`, so a footstep's 256-unit earshot is full gain
 * at 256 units and a quarter of it at 1,024 — four times the distance, a
 * quarter the volume. The numbers on the right are written out rather than
 * computed from the constants, because a test that recomputes the code proves
 * nothing about what a player hears.
 */
test("a footstep is full gain at 256 Source units and a quarter of that at 1,024", () => {
  const device = recorder();
  const audio = createAudio(device);
  audio.play("step", [0, 0, 0], [256, 0, 0]);
  audio.play("step", [1024, 0, 0], [0, 0, 0]);
  const near = device.bursts[0] as Burst, far = device.bursts[1] as Burst;
  expect(near.gain).toBeCloseTo(0.3, 10); // 0.3 × min(1, 256/256)
  expect(far.gain).toBeCloseTo(0.075, 10); // 0.3 × 256/1024
  // Past a site and a half it is under a tenth of what it was: an enemy across
  // the map is not information, and this is the distance that says so.
  audio.play("step", [2560, 0, 0], [0, 0, 0]);
  expect((device.bursts[2] as Burst).gain).toBeCloseTo(0.03, 10); // 0.3 × 256/2560
});
test("your own boots are quieter than somebody else's taken in the same place", () => {
  const device = recorder();
  const audio = createAudio(device);
  audio.play("step", [0, 0, 0], [0, 0, 0], true);
  audio.play("step", [0, 0, 0], [0, 0, 0], false);
  const mine = device.bursts[0] as Burst, theirs = device.bursts[1] as Burst;
  expect(mine.gain).toBeCloseTo(0.105, 10); // 0.3 × 0.35, and no distance at all
  expect(theirs.gain).toBeCloseTo(0.3, 10);
  expect(mine.gain).toBeLessThan(theirs.gain / 2);
});
test("every noise a round makes has a recipe, and a far one is quieter than a near one", () => {
  for (const name of SOUNDS) {
    const device = recorder();
    const audio = createAudio(device);
    audio.play(name, [0, 0, 0], [0, 0, 0]);
    const bursts = [...device.bursts], tones = [...device.tones];
    expect(bursts.length + tones.length).toBeGreaterThan(0);
    expect([...bursts, ...tones].every((node) => node.gain > 0)).toBe(true);
    // The same noise three thousand units away, node for node: every one of
    // them is quieter, and none of them went missing on the way.
    audio.play(name, [3000, 0, 0], [0, 0, 0]);
    const far = [...device.bursts.slice(bursts.length), ...device.tones.slice(tones.length)];
    const near = [...bursts, ...tones];
    expect(far.length).toBe(near.length);
    for (let i = 0; i < far.length; i++)
      expect((far[i] as Burst).gain).toBeLessThan((near[i] as Burst).gain);
  }
});
// --- the budget -----------------------------------------------------------
/** What one recipe asks for at zero distance: the peak gain of every voice in it. */
function peak(play: (audio: Audio) => void): number {
  const device = recorder();
  play(createAudio(device));
  return [...device.bursts, ...device.tones].reduce((sum, voice) => sum + voice.gain, 0);
}
class FakeGain extends FakeNode {
  readonly gain = new FakeParam(1);
  constructor(id: number, onConnect: (edge: Edge) => void) {
    super(id, "gain", onConnect);
  }
}
/**
 * The headroom, measured rather than asserted. This adds the recipes up from
 * the recipes — not from a table of numbers copied beside them — and holds the
 * total against `LOUDEST_INSTANT`, which is the number `src/engine/sound.ts`
 * sized the master bus and its limiter from. A recipe that grows, or a new loud
 * name, fails here and is read there.
 *
 * The instant is the issue's own: five guns in one room, and the three loudest
 * other noises a tick can carry in with them. Which three is not written down —
 * it is whichever three are loudest today — so a new noise louder than a body
 * falling joins the sum on its own rather than waiting for somebody to notice.
 */
test("the recipes fit the headroom the engine's bus was sized for", () => {
  const here: Vec3 = [0, 0, 0];
  const shot = peak((audio) => audio.shot("ak47", here, here));
  expect(shot).toBeCloseTo(0.65, 9); // 0.35 of noise, 0.30 of thump
class FakeStereoPanner extends FakeNode {
  readonly pan = new FakeParam(0);
  constructor(id: number, onConnect: (edge: Edge) => void) {
    super(id, "panner", onConnect);
  }
}
  const others = SOUNDS
    .map((name) => ({ name, gain: peak((audio) => audio.play(name, here, here)) }))
    .sort((a, b) => b.gain - a.gain);
  expect(others.slice(0, 3)).toEqual([
    { name: "blast", gain: expect.closeTo(1.25, 9) },
    { name: "flash", gain: expect.closeTo(0.85, 9) },
    { name: "death", gain: expect.closeTo(0.58, 9) },
  ]);
class FakeBiquadFilter extends FakeNode {
  type = "lowpass";
  readonly frequency = new FakeParam(350);
  readonly Q = new FakeParam(1);
  constructor(id: number, onConnect: (edge: Edge) => void) {
    super(id, "filter", onConnect);
  }
}
  const worst = 5 * shot + others.slice(0, 3).reduce((sum, one) => sum + one.gain, 0);
  expect(worst).toBeCloseTo(5.93, 9);
  // A nanogain of slack, because this is a sum of floats and the budget is a
  // statement about a firefight rather than about the last bit of a double.
  expect(worst).toBeLessThanOrEqual(LOUDEST_INSTANT + 1e-9);
class FakeBufferSource extends FakeNode {
  buffer: AudioBuffer | null = null;
  readonly playbackRate = new FakeParam(1);
  #onStart: (id: number) => void;
  #onStop: (id: number) => void;
  constructor(id: number, onConnect: (edge: Edge) => void, onStart: (id: number) => void, onStop: (id: number) => void) {
    super(id, "bufferSource", onConnect);
    this.#onStart = onStart;
    this.#onStop = onStop;
  }
  start(_time: number): void {
    this.#onStart(this.id);
  }
  stop(_time: number): void {
    this.#onStop(this.id);
  }
}
class FakeOscillator extends FakeNode {
  type = "sine";
  readonly frequency = new FakeParam(440);
  #onStart: (id: number) => void;
  #onStop: (id: number) => void;
  constructor(id: number, onConnect: (edge: Edge) => void, onStart: (id: number) => void, onStop: (id: number) => void) {
    super(id, "oscillator", onConnect);
    this.#onStart = onStart;
    this.#onStop = onStop;
  }
  start(_time: number): void {
    this.#onStart(this.id);
  }
  stop(_time: number): void {
    this.#onStop(this.id);
  }
}
class FakeAudioContext {
  readonly sampleRate = 44100;
  currentTime = 0;
  state: "running" | "suspended" = "suspended";
  readonly destination: FakeNode;
  readonly nodes: FakeNode[] = [];
  readonly edges: Edge[] = [];
  readonly started: number[] = [];
  readonly stopped: number[] = [];
  #seq = 0;
  constructor() {
    this.destination = new FakeNode(this.#next(), "destination", (e) => this.edges.push(e));
  }
  #next(): number {
    this.#seq += 1;
    return this.#seq;
  }
  #register<T extends FakeNode>(node: T): T {
    this.nodes.push(node);
    return node;
  }
  createBuffer(channels: number, length: number, sampleRate: number): AudioBuffer {
    const data = new Float32Array(length);
    return { getChannelData: () => data, length, sampleRate, numberOfChannels: channels } as unknown as AudioBuffer;
  }
  createGain(): FakeGain {
    return this.#register(new FakeGain(this.#next(), (e) => this.edges.push(e)));
  }
  createStereoPanner(): FakeStereoPanner {
    return this.#register(new FakeStereoPanner(this.#next(), (e) => this.edges.push(e)));
  }
  createBiquadFilter(): FakeBiquadFilter {
    return this.#register(new FakeBiquadFilter(this.#next(), (e) => this.edges.push(e)));
  }
  createBufferSource(): FakeBufferSource {
    return this.#register(
      new FakeBufferSource(this.#next(), (e) => this.edges.push(e), (id) => this.started.push(id), (id) => this.stopped.push(id)),
    );
  }
  createOscillator(): FakeOscillator {
    return this.#register(
      new FakeOscillator(this.#next(), (e) => this.edges.push(e), (id) => this.started.push(id), (id) => this.stopped.push(id)),
    );
  }
  resume(): Promise<void> {
    this.state = "running";
    return Promise.resolve();
  }
}
/** A constructor `createAudio` can call with `new`, plus every instance it built. */
function recorder(): { Ctor: typeof AudioContext; instances: FakeAudioContext[] } {
  const instances: FakeAudioContext[] = [];
  class Ctor extends FakeAudioContext {
    constructor() {
      super();
      instances.push(this);
    }
  }
  return { Ctor: Ctor as unknown as typeof AudioContext, instances };
}
const last = (ctx: FakeAudioContext, kind: string): FakeNode =>
  ctx.nodes.filter((n) => n.kind === kind).at(-1) as FakeNode;
const LISTENER: Vec3 = [0, 0, 0];
test("nothing is created before the first sound or resume()", () => {
  const { Ctor, instances } = recorder();
  createAudio(Ctor);
  expect(instances.length).toBe(0);
  // And the same line of addition is the reason the bus multiplies by what it
  // multiplies by, so the docstring that does the arithmetic has to hold this
  // number: read out of the file rather than trusted to stay true.
  const device = readFileSync(join(import.meta.dir, "..", "engine", "sound.ts"), "utf8");
  expect(device).toContain(`= ${LOUDEST_INSTANT}`);
});
test("resume() is what creates a context built at page load would otherwise need", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  audio.resume();
  expect(instances.length).toBe(1);
  expect(instances[0]?.state).toBe("running");
test("the bomb counting is a square tone, and the plant climbs where the defuse falls", () => {
  const device = recorder();
  const audio = createAudio(device);
  audio.play("beep", [0, 0, 0], [0, 0, 0]);
  const beep = device.tones[0] as Tone;
  expect(beep.type).toBe("square");
  expect(device.bursts.length).toBe(0); // nothing under it: it has to cut through
  audio.play("plant", [0, 0, 0], [0, 0, 0]);
  audio.play("defuse", [0, 0, 0], [0, 0, 0]);
  const plant = device.tones[1] as Tone, defuse = device.tones[2] as Tone;
  expect(plant.slideTo as number).toBeGreaterThan(plant.frequency);
  expect(defuse.slideTo as number).toBeLessThan(defuse.frequency);
});
test("the first sound creates the context lazily, exactly once", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  audio.beep(900);
  expect(instances.length).toBe(1);
  audio.beep(900);
  audio.shot("ak47", [10, 0, 0], LISTENER, 0);
  expect(instances.length).toBe(1);
test("a headshot beeps higher than a body hit", () => {
  const device = recorder();
  const audio = createAudio(device);
  audio.hit(true);
  audio.hit(false);
  const head = device.tones[0] as Tone, body = device.tones[1] as Tone;
  expect(head.frequency).toBeGreaterThan(body.frequency);
  expect(head.type).toBe("square");
});
test("muted creates no nodes at all, and setMuted(false) brings the sound back", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  audio.setMuted(true);
  audio.shot("ak47", [10, 0, 0], LISTENER, 0);
  audio.step([10, 0, 0], LISTENER, 0);
  audio.beep(900);
  audio.pain(20);
  audio.world("beep", [10, 0, 0], LISTENER, 0);
  expect(instances.length).toBe(0);
  audio.setMuted(false);
  audio.beep(900);
  expect(instances.length).toBe(1);
  expect(instances[0]?.nodes.length).toBeGreaterThan(0);
test("muting the voice mutes the device under it", () => {
  const device = recorder();
  const audio = createAudio(device);
  audio.muted = true;
  expect(device.muted).toBe(true);
  audio.shot("ak47", [0, 0, 0], [0, 0, 0]);
  audio.play("step", [0, 0, 0], [0, 0, 0]);
  audio.beep(700);
  expect(device.bursts).toEqual([]);
  expect(device.tones).toEqual([]);
  audio.muted = false;
  audio.beep(700);
  expect(device.tones.length).toBe(1);
});
test("a volume set before the first sound is applied once master exists", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  audio.setVolume(0.4);
  audio.beep(900);
  const master = instances[0]?.nodes[0] as FakeGain;
  expect(master.kind).toBe("gain");
  expect(master.gain.value).toBeCloseTo(0.4, 6);
test("resuming the voice resumes the device", () => {
  const device = recorder();
  createAudio(device).resume();
  expect(device.resumes).toBe(1);
});
test("setVolume(NaN) keeps the previous volume", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  audio.setVolume(0.7);
  audio.setVolume(NaN);
  audio.beep(900);
  const master = instances[0]?.nodes[0] as FakeGain;
  expect(master.gain.value).toBeCloseTo(0.7, 6);
// --- which side it came from ----------------------------------------------
/**
 * North is +Y, so an ear facing north is at yaw 90, and from there west (−X) is
 * its left and east (+X) is its right. 300 units is well past the engine's
 * softening radius, so these are the full swing: a step that far to one side
 * comes out of that speaker and nowhere near the other.
 */
const NORTH = 90;
test("a footstep to the left of a facing ear is negative, to the right positive, ahead zero", () => {
  const device = recorder();
  const audio = createAudio(device);
  audio.play("step", [-300, 0, 0], [0, 0, 0], false, NORTH);
  audio.play("step", [300, 0, 0], [0, 0, 0], false, NORTH);
  audio.play("step", [0, 300, 0], [0, 0, 0], false, NORTH);
  const [left, right, ahead] = device.bursts as [Burst, Burst, Burst];
  expect(left.pan).toBeLessThan(0);
  expect(right.pan).toBeGreaterThan(0);
  expect(ahead.pan).toBeCloseTo(0, 12);
  // Hard over, both of them, and mirrored: 300 units is a long way past a head.
  expect(left.pan).toBeCloseTo(-1, 12);
  expect(right.pan).toBeCloseTo(1, 12);
  // The thump under the step is placed with it, or the two halves of one
  // footstep come out of different speakers.
  expect((device.tones[0] as Tone).pan).toBe(left.pan);
});
test("volume is clamped to 0..1", () => {
  const above = recorder();
  const audioAbove = createAudio(above.Ctor);
  audioAbove.setVolume(5);
  audioAbove.beep(900);
  expect((above.instances[0]?.nodes[0] as FakeGain).gain.value).toBe(1);
  const below = recorder();
  const audioBelow = createAudio(below.Ctor);
  audioBelow.setVolume(-3);
  audioBelow.beep(900);
  expect((below.instances[0]?.nodes[0] as FakeGain).gain.value).toBe(0);
test("turning to face the sound brings it to the middle, and turning past it swaps sides", () => {
  const device = recorder();
  const audio = createAudio(device);
  // The same step due east of the ear, heard while facing east, north and south.
  for (const yaw of [0, 90, -90]) audio.play("step", [300, 0, 0], [0, 0, 0], false, yaw);
  const [facing, backTo, turnedAway] = device.bursts as [Burst, Burst, Burst];
  expect(facing.pan).toBeCloseTo(0, 12); // straight at it
  expect(backTo.pan).toBeCloseTo(1, 12); // right shoulder
  expect(turnedAway.pan).toBeCloseTo(-1, 12); // left shoulder
});
test("a shot to the left pans negative and to the right positive, agreeing with ears()", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  const yaw = 0;
  const leftPos: Vec3 = [100, 100, 0];
  const rightPos: Vec3 = [100, -100, 0];
test("a shot is placed the same way, and every node of a noise carries one pan", () => {
  const device = recorder();
  const audio = createAudio(device);
  audio.shot("ak47", [-800, 0, 0], [0, 0, 0], NORTH);
  expect((device.bursts[0] as Burst).pan).toBeCloseTo(-1, 12);
  expect((device.tones[0] as Tone).pan).toBeCloseTo(-1, 12);
  audio.shot("ak47", leftPos, LISTENER, yaw);
  const leftPan = (last(instances[0] as FakeAudioContext, "panner") as FakeStereoPanner).pan.value;
  expect(Math.sign(leftPan)).toBe(Math.sign(ears(leftPos, LISTENER, yaw).pan));
  audio.shot("ak47", rightPos, LISTENER, yaw);
  const rightPan = (last(instances[0] as FakeAudioContext, "panner") as FakeStereoPanner).pan.value;
  expect(Math.sign(rightPan)).toBe(Math.sign(ears(rightPos, LISTENER, yaw).pan));
  expect(Math.sign(leftPan)).not.toBe(Math.sign(rightPan));
});
test("a distant shot's gain is below a near one's", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  const ctx = () => instances[0] as FakeAudioContext;
  const yaw = 0;
  audio.shot("ak47", [50, 0, 0], LISTENER, yaw);
  const nearGain = (last(ctx(), "gain") as FakeGain).gain.events[0]?.value as number;
  audio.shot("ak47", [3000, 0, 0], LISTENER, yaw);
  const farGain = (last(ctx(), "gain") as FakeGain).gain.events[0]?.value as number;
  expect(farGain).toBeLessThan(nearGain);
});
test("pain twice inside 140ms plays once, and after the window it plays again", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  audio.pain(20);
  const ctx = instances[0] as FakeAudioContext;
  const afterFirst = ctx.nodes.length;
  expect(afterFirst).toBeGreaterThan(0);
  ctx.currentTime = 0.1; // inside the 140ms window
  audio.pain(20);
  expect(ctx.nodes.length).toBe(afterFirst); // nothing new
  ctx.currentTime = 0.3; // outside it
  audio.pain(20);
  expect(ctx.nodes.length).toBeGreaterThan(afterFirst);
});
test('world("beep", …, pitch) uses the pitch it is given, and the table\'s frequency when it is not', () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  const ctx = () => instances[0] as FakeAudioContext;
  audio.world("beep", [10, 0, 0], LISTENER, 0, 1200);
  expect((last(ctx(), "oscillator") as FakeOscillator).frequency.events[0]?.value).toBe(1200);
  audio.world("beep", [10, 0, 0], LISTENER, 0);
  expect((last(ctx(), "oscillator") as FakeOscillator).frequency.events[0]?.value).toBe(900); // WORLD_TONE.beep.freq
});
test("explode and blast take the same path, and ignore the pitch a beep would use", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  const ctx = () => instances[0] as FakeAudioContext;
  for (const name of ["explode", "blast"] as const) {
    audio.world(name, [10, 0, 0], LISTENER, 0, 5000);
    const boom = last(ctx(), "oscillator") as FakeOscillator;
    expect(boom.frequency.events[0]?.value).toBe(140);
    const tail = last(ctx(), "bufferSource") as FakeBufferSource;
    expect(tail.buffer).not.toBeNull();
  // Every recipe places every voice it builds: a name that forgot would leave
  // half a noise in the middle while the other half is off to one side.
  for (const name of SOUNDS) {
    const one = recorder();
    createAudio(one).play(name, [900, 0, 0], [0, 0, 0], false, NORTH);
    const voices = [...one.bursts, ...one.tones];
    expect(voices.length).toBeGreaterThan(0);
    for (const voice of voices) expect([name, voice.pan]).toEqual([name, expect.closeTo(1, 12)]);
  }
});
test("a name with no tone and no special case creates nothing but the panner", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  audio.beep(900); // gets the context and its master gain out of the way
  const ctx = instances[0] as FakeAudioContext;
  const before = ctx.nodes.length;
  audio.world("nope" as unknown as WorldSoundName, [10, 0, 0], LISTENER, 0);
  expect(ctx.nodes.length).toBe(before + 1);
  expect(ctx.nodes[ctx.nodes.length - 1]?.kind).toBe("panner");
test("your own boots and your own gun stay in the middle", () => {
  const device = recorder();
  const audio = createAudio(device);
  // A noise you made is passed no pan at all: there is no side for it.
  audio.play("step", [0, 0, 0], [0, 0, 0], true, NORTH);
  expect((device.bursts[0] as Burst).pan).toBeUndefined();
  expect((device.tones[0] as Tone).pan).toBeUndefined();
  // Your own gun fires from the ear it is heard with, so it works out centred
  // without a special case.
  audio.shot("ak47", [0, 0, 0], [0, 0, 0], NORTH);
  expect((device.bursts[1] as Burst).pan).toBe(0);
});
test("a hundred shots cost a fixed number of nodes, and every source and oscillator that starts is stopped", () => {
  const { Ctor, instances } = recorder();
  const audio = createAudio(Ctor);
  for (let i = 0; i < 100; i += 1) audio.shot("ak47", [i, 0, 0], LISTENER, 0);
  const ctx = instances[0] as FakeAudioContext;
  // One master gain, plus a panner, a source, a filter, a gain, an
  // oscillator and its own gain per shot: 1 + 100 * 6, not one node more.
  expect(ctx.nodes.length).toBe(1 + 100 * 6);
  expect(ctx.started.length).toBe(200); // the noise burst and the thump, per shot
  expect(ctx.stopped.length).toBe(ctx.started.length);
  expect(new Set(ctx.stopped)).toEqual(new Set(ctx.started));
test("a caller that names no heading is the game as it was: every sound ahead-and-centre of due east", () => {
  const device = recorder();
  const audio = createAudio(device);
  // No yaw given is yaw 0 — facing +X — which is the old behaviour for anything
  // directly in front, and still a real pan for anything off to a side.
  audio.play("blast", [1000, 0, 0], [0, 0, 0]);
  expect((device.bursts[0] as Burst).pan).toBeCloseTo(0, 12);
});
@@ -1,36 +1,53 @@
/**
 * Sound, synthesised. A gunshot is a noise burst through a resonant filter
 * plus a low thump; the rest are short tones. Nothing is downloaded, and the
 * context is only created once the person has clicked something.
 * The game's voice. A gunshot is a noise burst through a resonant filter plus a
 * low thump, and each weapon kind gets its own colour, length and thump; a hit
 * and a buy are short tones. Nothing is downloaded, and the engine's device
 * only opens a context once the person has clicked something.
 *
 * Everything the round itself makes — a foot landing, the bomb's beep, the
 * plant, the cut wire, a body going down — is one recipe per name under `play`,
 * positioned through the engine's `attenuate` and `panOf` from the ear the
 * frame is listening with: how far away it is sets the gain, and which side of
 * the ear's heading it is on sets the pan. Front and back are not distinguished
 * and cannot be with two speakers — a step ahead and a step behind are both
 * centre, and that is the whole of what this device claims.
 *
 * The distances are in Source units (1 unit ≈ 1.9 cm) and are
 * the numbers below: a sound is at its recipe's full gain inside its earshot
 * and falls as `earshot / distance` past it, so a footstep at 256 units is as
 * loud as a footstep can be and the same one at 1,024 is a quarter of that.
 */
import { ears } from "./ears.ts";
import type { Vec3 } from "./math.ts";
import { attenuate, createSoundDevice, dist, panOf, type SoundDevice, type Vec3 } from "../engine/index.ts";
import { WEAPONS, type WeaponId } from "./weapons.ts";
import type { SoundName } from "./world.ts";
/** Every named world sound `world()` below knows how to play — everything but a footstep, which keeps its own dedicated `step`. */
export type WorldSoundName = Exclude<SoundName, "step">;
import type { Sound } from "./world.ts";
export type Audio = {
  shot(weapon: WeaponId, at: Vec3, listener: Vec3, listenerYaw: number): void;
  step(at: Vec3, listener: Vec3, listenerYaw: number): void;
  hit(headshot: boolean): void;
  pain(amount: number): void;
  beep(pitch: number, gain?: number): void;
  /**
   * One named world sound — the bomb's own beep, a plant, a defuse, the
   * blast that ends it, a grenade's bounce and its own blast, a dry trigger
   * — panned and attenuated through `ears` exactly like `shot` and `step`.
   * Each name has its own timbre; `pitch` overrides the default for
   * `"beep"`, which climbs as the fuse runs down.
   * A weapon going off at `at`, heard from `listener` facing `yaw` degrees.
   * Your own gun needs no special case: it is fired from the ear it is heard
   * with, so `panOf` softens it to dead centre on its own.
   */
  world(name: WorldSoundName, at: Vec3, listener: Vec3, listenerYaw: number, pitch?: number): void;
  shot(weapon: WeaponId, at: Vec3, listener: Vec3, yaw?: number): void;
  /**
   * One noise of the round, by name, placed where it happened and heard from
   * `listener`. `own` is true when the body that made it is the body these ears
   * belong to, which is the whole of why your own boots are quieter than
   * somebody else's standing where you are.
   *
   * One path widened by a name rather than a voice per noise: a grenade leaving
   * the hand and a foot landing are the same two nodes with different numbers
   * in them, and the day a sixth round noise is wanted it is a `case` here.
   *
   * `yaw` is the ear's heading in degrees; a noise you made yourself is passed
   * no pan at all, because your own boots come from where you are standing and
   * a panner on them is a node that does nothing.
   */
  play(sound: Sound, at: Vec3, listener: Vec3, own?: boolean, yaw?: number): void;
  hit(headshot: boolean): void;
  beep(pitch: number, gain?: number): void;
  resume(): void;
  /** Mute is silence at the one node everything goes through, not a per-sound skip. */
  setMuted(muted: boolean): void;
  setVolume(volume: number): void;
  readonly muted: boolean;
  muted: boolean;
};
const TONE: Record<string, { cut: number; thump: number; length: number }> = {
@@ -39,278 +56,204 @@
const TONE: Record<string, { cut: number; thump: number; length: number }> = {
  rifle: { cut: 1500, thump: 110, length: 0.24 },
  sniper: { cut: 1000, thump: 80, length: 0.5 },
  knife: { cut: 4200, thump: 400, length: 0.08 },
  // Never heard: a grenade is thrown rather than fired, and its three noises
  // are below. It is here so the table covers every kind a weapon can be.
  grenade: { cut: 2600, thump: 300, length: 0.1 },
};
/** One tone per named world sound: a square blip for the bomb's own beep,
 * two-note chirps for the plant and the defuse, a click for a dry trigger.
 * `explode`, `blast` and `bounce` are noise, not a tone, and have no entry
 * here — `world()` below synthesises those directly. */
const WORLD_TONE: Partial<Record<WorldSoundName, { freq: number; type: OscillatorType; length: number }>> = {
  beep: { freq: 900, type: "square", length: 0.08 },
  plant: { freq: 420, type: "sine", length: 0.22 },
  defuse: { freq: 900, type: "sine", length: 0.3 },
  empty: { freq: 220, type: "square", length: 0.04 },
};
type Live = { ctx: AudioContext; noise: AudioBuffer; master: GainNode };
/** The browser default: `webkitAudioContext` is Safari's old name for it. */
const defaultContext = (): typeof AudioContext | undefined =>
  window.AudioContext ?? (window as unknown as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;
/** Full volume within 120 units, and audible across the map after that. */
const EARSHOT = 900;
const CLOSE = 120;
/**
 * `Ctor` is the seam a test supplies a recording `AudioContext` through — the
 * same trick `renderer.test.ts` plays on `getContext`. Nothing calls it
 * before the first sound or `resume()`, since a context built at page load is
 * one the browser suspends anyway.
 * A blast carries much further than a gunshot and is loud over a much wider
 * circle: full volume out to 300 units and still worth hearing at 2,400.
 */
export function createAudio(Ctor: typeof AudioContext | undefined = defaultContext()): Audio {
  let live: Live | null = null;
  let lastPain = -1;
  let volume = 1;
  let muted = false;
const BLAST_EARSHOT = 2400;
const BLAST_CLOSE = 300;
  const applyGain = (): void => {
    if (live !== null) live.master.gain.value = muted ? 0 : volume;
  };
/**
 * A footstep, in Source units: full gain inside 256 (about five metres, a room)
 * and `256 / distance` past it, so a body at 1,024 units — the far side of a
 * site — is heard at a quarter of that, and one at 2,560 at a tenth, which is
 * under the noise of a round being fought. That is the distance the game
 * intends: an enemy crossing a site is information, an enemy across the map is
 * not.
 */
const STEP_EARSHOT = 256;
const STEP_CLOSE = 48;
const STEP_GAIN = 0.3;
  // The one node the whole of this file plays into: a volume set before the
  // first click just waits here for `master` to exist to apply itself to.
  const ensure = (): Live | null => {
    if (live === null) {
      if (Ctor === undefined) return null;
      const ctx = new Ctor();
      const noise = ctx.createBuffer(1, ctx.sampleRate * 0.5, ctx.sampleRate);
      const data = noise.getChannelData(0);
      for (let i = 0; i < data.length; i++) data[i] = Math.random() * 2 - 1;
      const master = ctx.createGain();
      master.connect(ctx.destination);
      live = { ctx, noise, master };
      applyGain();
    }
    if (live.ctx.state === "suspended") void live.ctx.resume();
    return live;
  };
/**
 * What your own boots are worth beside somebody else's: a little over a third.
 * They are the only footsteps in the game that are always at zero distance, so
 * without this they would be the loudest thing in every round — and the whole
 * point of the sound is hearing the other one.
 */
const OWN_STEP = 0.35;
/**
 * The bomb: the beep, the plant and the cut wire. 600 units of full gain is the
 * site and the ways on to it — a defuse behind you is meant to be heard from
 * where you are holding — and it falls off from there like everything else.
 */
const BOMB_EARSHOT = 600;
const BOMB_CLOSE = 64;
/** A body going down: heard across the room it fell in, not across the map. */
const DEATH_EARSHOT = 400;
const DEATH_CLOSE = 64;
/**
 * The loudest instant these recipes can ask a device for, as peak gains summed:
 * a grenade landing in a five-man crossfire. Five gunshots (0.35 of noise and
 * 0.30 of thump each), the blast (0.70 + 0.55), the flash that came with it
 * (0.55 + 0.30) and a body hitting the floor (0.34 + 0.24) — every one of them
 * inside its own full-volume radius, and every voice of it starting at the same
 * instant, because a frame plays everything that happened since the last frame
 * at one `currentTime`:
 *
 *     5 × 0.65 + 1.25 + 0.85 + 0.58 = 5.93
 *
 * Nearly six times the 1.0 a sample can hold, which is what a firefight sounded
 * like before #211: not a firefight, a crackle. The number lives here because it
 * is a fact about these recipes and about nothing else, and it is what the
 * engine's master bus was sized against — `MASTER_GAIN` in `src/engine/sound.ts`
 * multiplies it down and the limiter on the end of that bus catches the rest.
 * `audio.test.ts` adds the recipes up from the recipes themselves, fails when a
 * new one grows past this, and holds this number against the arithmetic written
 * in `sound.ts` so that the two cannot drift apart.
 */
export const LOUDEST_INSTANT = 5.93;
/** The shot a weapon makes: its filter colour, its thump and how long it rings. */
export const shotTone = (weapon: WeaponId): { cut: number; thump: number; length: number } =>
  TONE[WEAPONS[weapon]?.kind ?? "rifle"] ?? (TONE.rifle as { cut: number; thump: number; length: number });
/** How loud a shot fired at `at` is to someone standing at `listener`. */
export const loudness = (at: Vec3, listener: Vec3): number =>
  attenuate(dist(at, listener), EARSHOT, CLOSE);
export function createAudio(device: SoundDevice = createSoundDevice()): Audio {
  const audio: Audio = {
    get muted() {
      return muted;
      return device.muted;
    },
    setMuted(next) {
      muted = next;
      applyGain();
    set muted(value: boolean) {
      device.muted = value;
    },
    setVolume(next) {
      volume = Number.isFinite(next) ? Math.min(1, Math.max(0, next)) : volume;
      applyGain();
    resume: () => device.resume(),
    shot(weapon, at, listener, yaw = 0) {
      const tone = shotTone(weapon);
      const volume = loudness(at, listener);
      const pan = panOf(at, listener, yaw);
      device.noiseBurst({
        frequency: tone.cut,
        gain: 0.35 * volume,
        length: tone.length,
        q: 0.9,
        rate: 1 + Math.random() * 0.15,
        pan,
      });
      device.tone({
        frequency: tone.thump,
        slideTo: tone.thump * 0.4,
        gain: 0.3 * volume,
        length: tone.length,
        pan,
      });
    },
    resume: () => void ensure(),
    shot(weapon, at, listener, listenerYaw) {
      if (muted) return;
      const live = ensure();
      if (live === null) return;
      const { ctx: context, noise, master } = live;
      const kind = WEAPONS[weapon]?.kind ?? "rifle";
      const tone = TONE[kind] ?? TONE.rifle;
      const { pan, volume } = ears(at, listener, listenerYaw);
      const now = context.currentTime;
      const panner = context.createStereoPanner();
      panner.pan.value = pan;
      panner.connect(master);
      const source = context.createBufferSource();
      source.buffer = noise;
      source.playbackRate.value = 1 + Math.random() * 0.15;
      const filter = context.createBiquadFilter();
      filter.type = "bandpass";
      filter.frequency.value = tone.cut;
      filter.Q.value = 0.9;
      const gain = context.createGain();
      gain.gain.setValueAtTime(0.35 * volume, now);
      gain.gain.exponentialRampToValueAtTime(0.0008, now + tone.length);
      source.connect(filter).connect(gain).connect(panner);
      source.start(now);
      source.stop(now + tone.length);
      const thump = context.createOscillator();
      thump.frequency.setValueAtTime(tone.thump, now);
      thump.frequency.exponentialRampToValueAtTime(tone.thump * 0.4, now + tone.length);
      const thumpGain = context.createGain();
      thumpGain.gain.setValueAtTime(0.3 * volume, now);
      thumpGain.gain.exponentialRampToValueAtTime(0.0008, now + tone.length);
      thump.connect(thumpGain).connect(panner);
      thump.start(now);
      thump.stop(now + tone.length);
    },
    /** A footstep: a short low tap, panned and faded the same way a shot is. */
    step(at, listener, listenerYaw) {
      if (muted) return;
      const live = ensure();
      if (live === null) return;
      const { ctx: context, noise, master } = live;
      const { pan, volume } = ears(at, listener, listenerYaw);
      const now = context.currentTime;
      const length = 0.09;
      const source = context.createBufferSource();
      source.buffer = noise;
      source.playbackRate.value = 0.5 + Math.random() * 0.15;
      const filter = context.createBiquadFilter();
      filter.type = "lowpass";
      filter.frequency.value = 320;
      const gain = context.createGain();
      gain.gain.setValueAtTime(0.14 * volume, now);
      gain.gain.exponentialRampToValueAtTime(0.0008, now + length);
      const panner = context.createStereoPanner();
      panner.pan.value = pan;
      source.connect(filter).connect(gain).connect(panner).connect(master);
      source.start(now);
      source.stop(now + length);
    play(sound, at, listener, own = false, yaw = 0) {
      const far = dist(at, listener);
      // Your own noise is not placed: it happens at the ear, so there is no
      // side for it to be on and no panner worth building for it.
      const pan = own ? undefined : panOf(at, listener, yaw);
      if (sound === "step") {
        // A foot landing: a scuff of grit through a wide filter with a soft
        // thump under it. The rate is jittered so a body at a dead run is a
        // walk and not one sample played twelve times.
        const volume = attenuate(far, STEP_EARSHOT, STEP_CLOSE) * (own ? OWN_STEP : 1);
        device.noiseBurst({ frequency: 520, gain: STEP_GAIN * volume, length: 0.1, q: 1.1, rate: 0.85 + Math.random() * 0.3, pan });
        device.tone({ frequency: 95, slideTo: 55, gain: 0.16 * volume, length: 0.09, pan });
        return;
      }
      if (sound === "beep") {
        // The bomb, counting. A square tone and nothing under it: it has to cut
        // through a firefight, and it is the one sound here that repeats.
        const volume = attenuate(far, BOMB_EARSHOT, BOMB_CLOSE);
        device.tone({ frequency: 2200, gain: 0.2 * volume, length: 0.07, type: "square", floor: 0.0005, tail: 0.01, pan });
        return;
      }
      if (sound === "plant") {
        // The bomb going down: the clunk of it landing, and a tone that climbs
        // — the round just turned over, and it turned the terrorists' way.
        const volume = attenuate(far, BOMB_EARSHOT, BOMB_CLOSE);
        device.noiseBurst({ frequency: 1400, gain: 0.3 * volume, length: 0.09, q: 5, rate: 1, pan });
        device.tone({ frequency: 300, slideTo: 900, gain: 0.26 * volume, length: 0.3, pan });
        return;
      }
      if (sound === "defuse") {
        // The wire, cut: a bright snip and a tone that falls away under it. It
        // is the plant's noise backwards on purpose — the same event, undone.
        const volume = attenuate(far, BOMB_EARSHOT, BOMB_CLOSE);
        device.noiseBurst({ frequency: 2600, gain: 0.26 * volume, length: 0.07, q: 6, rate: 1, pan });
        device.tone({ frequency: 900, slideTo: 300, gain: 0.26 * volume, length: 0.3, pan });
        return;
      }
      if (sound === "death") {
        // A body hitting the floor: low, wide, short, with a thump that falls
        // away. No cry — the game has no voices, and a fall carries further.
        const volume = attenuate(far, DEATH_EARSHOT, DEATH_CLOSE);
        device.noiseBurst({ frequency: 240, gain: 0.34 * volume, length: 0.35, q: 0.8, rate: 0.8, pan });
        device.tone({ frequency: 110, slideTo: 50, gain: 0.24 * volume, length: 0.3, pan });
        return;
      }
      if (sound === "throw") {
        // A short upward whoosh of air: quiet, and only near you.
        device.noiseBurst({ frequency: 2400, gain: 0.14 * loudness(at, listener), length: 0.16, q: 0.7, rate: 1.4, pan });
        return;
      }
      if (sound === "bounce") {
        // A hard tap: the shell against concrete, tight and short.
        const volume = loudness(at, listener);
        device.noiseBurst({ frequency: 1200, gain: 0.22 * volume, length: 0.07, q: 4, rate: 1, pan });
        device.tone({ frequency: 260, slideTo: 150, gain: 0.16 * volume, length: 0.08, pan });
        return;
      }
      if (sound === "smoke") {
        // The canister opening: no bang at all. A long, soft, wide hiss that
        // fades away rather than cracks — it is the one grenade noise in this
        // game that is a *process* and not an event, and it is quiet, because
        // what a smoke costs you is what you can see and never what you hear.
        // It carries like a footstep does and not like a blast: a cloud across
        // the map is not information anybody should get for free.
        const soft = attenuate(far, BOMB_EARSHOT, BOMB_CLOSE);
        device.noiseBurst({ frequency: 3200, gain: 0.2 * soft, length: 1.4, q: 0.5, rate: 0.9, pan });
        device.tone({ frequency: 420, slideTo: 210, gain: 0.1 * soft, length: 0.9, pan });
        return;
      }
      if (sound === "flash") {
        // The flash: the opposite noise to the blast in every way. A bright,
        // tight crack with no body under it and a ring above it that climbs
        // rather than falls — what a very loud, very short bang leaves in your
        // ears. It carries as far as the blast does, and it matters over a
        // wider circle than one, because so does the light.
        const bright = attenuate(far, BLAST_EARSHOT, BLAST_CLOSE);
        device.noiseBurst({ frequency: 5200, gain: 0.55 * bright, length: 0.28, q: 1.2, rate: 1.5, pan });
        device.tone({ frequency: 2600, slideTo: 4200, gain: 0.3 * bright, length: 0.5, pan });
        return;
      }
      // The blast: a wide, low body of noise with a thump under it that falls
      // an octave and a half as it goes.
      const volume = attenuate(far, BLAST_EARSHOT, BLAST_CLOSE);
      device.noiseBurst({ frequency: 360, gain: 0.7 * volume, length: 1.1, q: 0.35, rate: 0.6, pan });
      device.tone({ frequency: 130, slideTo: 42, gain: 0.55 * volume, length: 0.85, pan });
    },
    hit(headshot) {
      audio.beep(headshot ? 1400 : 900, 0.08);
    },
    /**
     * Taking damage: a low grunt sliding down, nothing like the square-wave
     * beep the shooter hears. A rifle burst lands four of these inside a
     * quarter of a second, so one every 140ms is all that is let through —
     * the rest would be noise on top of a sound already playing.
     */
    pain(amount) {
      if (muted) return;
      const live = ensure();
      if (live === null) return;
      const { ctx: context, noise, master } = live;
      const now = context.currentTime;
      if (now - lastPain < 0.14) return;
      lastPain = now;
      const hurt = Math.min(1, Math.max(0.15, amount / 50));
      const length = 0.18 + hurt * 0.12;
      const osc = context.createOscillator();
      osc.type = "sawtooth";
      osc.frequency.setValueAtTime(240 + hurt * 90, now);
      osc.frequency.exponentialRampToValueAtTime(110, now + length);
      const shape = context.createBiquadFilter();
      shape.type = "lowpass";
      shape.frequency.value = 900;
      const gain = context.createGain();
      gain.gain.setValueAtTime(0.0001, now);
      gain.gain.exponentialRampToValueAtTime(0.16 * hurt, now + 0.02);
      gain.gain.exponentialRampToValueAtTime(0.0005, now + length);
      osc.connect(shape).connect(gain).connect(master);
      osc.start(now);
      osc.stop(now + length + 0.02);
      // A breath of noise under it, so it reads as a body and not a synth.
      const breath = context.createBufferSource();
      breath.buffer = noise;
      breath.playbackRate.value = 0.6;
      const band = context.createBiquadFilter();
      band.type = "bandpass";
      band.frequency.value = 500;
      band.Q.value = 1.2;
      const breathGain = context.createGain();
      breathGain.gain.setValueAtTime(0.07 * hurt, now);
      breathGain.gain.exponentialRampToValueAtTime(0.0005, now + length * 0.8);
      breath.connect(band).connect(breathGain).connect(master);
      breath.start(now);
      breath.stop(now + length);
    },
    beep(pitch, gain = 0.06) {
      if (muted) return;
      const live = ensure();
      if (live === null) return;
      const { ctx: context, master } = live;
      const now = context.currentTime;
      const osc = context.createOscillator();
      osc.type = "square";
      osc.frequency.value = pitch;
      const gainNode = context.createGain();
      gainNode.gain.setValueAtTime(gain, now);
      gainNode.gain.exponentialRampToValueAtTime(0.0005, now + 0.09);
      osc.connect(gainNode).connect(master);
      osc.start(now);
      osc.stop(now + 0.1);
    },
    world(name, at, listener, listenerYaw, pitch) {
      if (muted) return;
      const live = ensure();
      if (live === null) return;
      const { ctx: context, noise, master } = live;
      const { pan, volume } = ears(at, listener, listenerYaw);
      const now = context.currentTime;
      const panner = context.createStereoPanner();
      panner.pan.value = pan;
      panner.connect(master);
      // An explosion, whichever set it off: a sine falling through octaves
      // for the punch in the chest, and a long low-passed tail of noise over
      // it for the debris. The bomb and a thrown HE are the same event to an
      // ear a hundred units away, so they are the same code.
      if (name === "explode" || name === "blast") {
        const length = 0.9;
        const tail = context.createBufferSource();
        tail.buffer = noise;
        tail.playbackRate.value = 0.35;
        const filter = context.createBiquadFilter();
        filter.type = "lowpass";
        filter.frequency.setValueAtTime(3200, now);
        filter.frequency.exponentialRampToValueAtTime(220, now + length);
        const tailGain = context.createGain();
        tailGain.gain.setValueAtTime(0.45 * volume, now);
        tailGain.gain.exponentialRampToValueAtTime(0.0008, now + length);
        tail.connect(filter).connect(tailGain).connect(panner);
        tail.start(now);
        tail.stop(now + length);
        const boom = context.createOscillator();
        boom.type = "sine";
        boom.frequency.setValueAtTime(140, now);
        boom.frequency.exponentialRampToValueAtTime(30, now + length * 0.7);
        const boomGain = context.createGain();
        boomGain.gain.setValueAtTime(0.5 * volume, now);
        boomGain.gain.exponentialRampToValueAtTime(0.0008, now + length);
        boom.connect(boomGain).connect(panner);
        boom.start(now);
        boom.stop(now + length);
        return;
      }
      // A grenade off a wall: a tick of filtered noise, shorter than a footstep.
      if (name === "bounce") {
        const length = 0.07;
        const source = context.createBufferSource();
        source.buffer = noise;
        source.playbackRate.value = 1.4 + Math.random() * 0.3;
        const filter = context.createBiquadFilter();
        filter.type = "bandpass";
        filter.frequency.value = 1700;
        filter.Q.value = 2.4;
        const gain = context.createGain();
        gain.gain.setValueAtTime(0.11 * volume, now);
        gain.gain.exponentialRampToValueAtTime(0.0008, now + length);
        source.connect(filter).connect(gain).connect(panner);
        source.start(now);
        source.stop(now + length);
        return;
      }
      const tone = WORLD_TONE[name];
      if (tone === undefined) return;
      const osc = context.createOscillator();
      osc.type = tone.type;
      const start = pitch ?? tone.freq;
      osc.frequency.setValueAtTime(start, now);
      // A plant climbs like it is arming; a defuse settles like it is done.
      if (name === "plant") osc.frequency.exponentialRampToValueAtTime(start * 1.7, now + tone.length);
      else if (name === "defuse") osc.frequency.exponentialRampToValueAtTime(start * 0.7, now + tone.length);
      const gain = context.createGain();
      gain.gain.setValueAtTime((name === "empty" ? 0.1 : 0.16) * volume, now);
      gain.gain.exponentialRampToValueAtTime(0.0005, now + tone.length);
      osc.connect(gain).connect(panner);
      osc.start(now);
      osc.stop(now + tone.length + 0.02);
      device.tone({ frequency: pitch, gain, length: 0.09, type: "square", floor: 0.0005, tail: 0.01 });
    },
  };
  return audio;
@@ -1,62 +0,0 @@
import { expect, test } from "bun:test";
import { ACTION_LABELS, decideBind, labelForCode } from "./bind.ts";
import { ACTIONS, DEFAULT_BINDINGS } from "./input.ts";
test("a fresh code nothing else holds is accepted, and only that action moves", () => {
  const outcome = decideBind("forward", "KeyG", DEFAULT_BINDINGS);
  expect(outcome).toEqual({ ok: true, bindings: { ...DEFAULT_BINDINGS, forward: "KeyG" } });
});
test("a reserved code — the movement and crouch fallback — is refused, and says why", () => {
  for (const code of ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "KeyC"]) {
    const outcome = decideBind("jump", code, DEFAULT_BINDINGS);
    expect(outcome.ok).toBe(false);
    expect(outcome).toMatchObject({ reason: expect.stringContaining("reserved") });
  }
});
test("a code another action already holds is refused, naming that action", () => {
  const outcome = decideBind("jump", DEFAULT_BINDINGS.forward, DEFAULT_BINDINGS);
  expect(outcome.ok).toBe(false);
  expect(outcome).toMatchObject({ reason: expect.stringContaining("Move forward") });
});
test("rebinding an action to the code it already has is a no-op success, not a self-conflict", () => {
  const outcome = decideBind("forward", DEFAULT_BINDINGS.forward, DEFAULT_BINDINGS);
  expect(outcome).toEqual({ ok: true, bindings: DEFAULT_BINDINGS });
});
test("a refusal never changes the map: the caller still holds the bindings it started with", () => {
  const outcome = decideBind("jump", "KeyC", DEFAULT_BINDINGS);
  expect(outcome.ok).toBe(false);
  // decideBind returns no bindings at all on refusal — there is nothing for
  // a caller to accidentally apply.
  expect((outcome as { bindings?: unknown }).bindings).toBeUndefined();
});
test("labelForCode reads a code the way a player would say it", () => {
  expect(labelForCode("KeyW")).toBe("W");
  expect(labelForCode("Digit1")).toBe("1");
  expect(labelForCode("Space")).toBe("Space");
  expect(labelForCode("ControlLeft")).toBe("Left Ctrl");
  expect(labelForCode("ArrowUp")).toBe("Arrow Up");
  expect(labelForCode("Numpad5")).toBe("Numpad 5");
});
test("labelForCode never throws on a code it does not recognise — it just shows the code", () => {
  expect(labelForCode("IntlBackslash")).toBe("IntlBackslash");
});
test("the radio is one of the bindable actions: a default key, a label, and rebindable", () => {
  // It reaches the Controls panel the same way every other action does — the
  // panel is built from ACTIONS — so being on that list is the whole wiring.
  expect(ACTIONS).toContain("radio");
  expect(DEFAULT_BINDINGS.radio).toBe("KeyZ");
  expect(ACTION_LABELS.radio).toBe("Radio");
  const outcome = decideBind("radio", "KeyG", DEFAULT_BINDINGS);
  expect(outcome).toEqual({ ok: true, bindings: { ...DEFAULT_BINDINGS, radio: "KeyG" } });
  // And it takes part in the collision rule rather than sitting outside it.
  expect(decideBind("buy", "KeyZ", DEFAULT_BINDINGS)).toEqual({
    ok: false, reason: "Z is already bound to Radio.",
  });
});
@@ -1,55 +0,0 @@
/**
 * The rebind panel's rules: what a captured key does to a binding map, and
 * what a key or an action is called on the screen. Pure data in, plain data
 * out — nothing here touches the DOM, so main.ts is free to paint it however
 * a click or a screen reader needs, the way buy.ts already keeps the buy
 * panel's rules out of main.ts.
 */
import { ACTIONS, RESERVED_CODES, type Action } from "./input.ts";
export const ACTION_LABELS: Record<Action, string> = {
  forward: "Move forward", back: "Move back", left: "Strafe left", right: "Strafe right",
  jump: "Jump", duck: "Crouch", walk: "Walk",
  reload: "Reload", use: "Use / plant / defuse", buy: "Buy menu", radio: "Radio",
  scoreboard: "Scoreboard", scope: "Scope",
  slot1: "Slot 1 — rifle", slot2: "Slot 2 — pistol", slot3: "Slot 3 — knife", slot4: "Slot 4 — grenade",
};
const CODE_LABELS: Record<string, string> = {
  Space: "Space", Tab: "Tab", Escape: "Escape", CapsLock: "Caps Lock", Enter: "Enter", Backspace: "Backspace",
  ControlLeft: "Left Ctrl", ControlRight: "Right Ctrl", ShiftLeft: "Left Shift", ShiftRight: "Right Shift",
  AltLeft: "Left Alt", AltRight: "Right Alt", Backquote: "`", Minus: "-", Equal: "=",
  BracketLeft: "[", BracketRight: "]", Semicolon: ";", Quote: "'", Comma: ",", Period: ".",
  Slash: "/", Backslash: "\\",
};
/** A key code, as a player reads it — not as the DOM names it. */
export function labelForCode(code: string): string {
  if (code.startsWith("Key")) return code.slice(3);
  if (code.startsWith("Digit")) return code.slice(5);
  if (code.startsWith("Numpad")) return `Numpad ${code.slice(6)}`;
  if (code.startsWith("Arrow")) return `Arrow ${code.slice(5)}`;
  return CODE_LABELS[code] ?? code;
}
export type BindOutcome =
  | { ok: true; bindings: Record<Action, string> }
  | { ok: false; reason: string };
/**
 * What a captured key does to `action`'s binding: reserved codes (the
 * movement/crouch fallback) are refused outright, a code another action
 * already holds is refused with which one, and otherwise the map gets the
 * one change asked for and nothing else moves.
 */
export function decideBind(action: Action, code: string, bindings: Record<Action, string>): BindOutcome {
  if (RESERVED_CODES.has(code)) {
    return { ok: false, reason: `${labelForCode(code)} is reserved for movement and can't be bound.` };
  }
  const takenBy = ACTIONS.find((other) => other !== action && bindings[other] === code);
  if (takenBy !== undefined) {
    return { ok: false, reason: `${labelForCode(code)} is already bound to ${ACTION_LABELS[takenBy]}.` };
  }
  return { ok: true, bindings: { ...bindings, [action]: code } };
}
@@ -0,0 +1,139 @@
import { expect, test } from "bun:test";
import { CS_KEYS, CS_MOUSE, CS_TAP, CS_WHEEL, NUMBER_ROW, readIntent, slotAction, slotIndex } from "./binding.ts";
const NONE = { x: 0, y: 0 };
const intent = (actions: string[], stick = NONE) => readIntent(new Set(actions), stick);
test("the bindings are the ones the keyboard has always had", () => {
  expect(CS_KEYS.KeyW).toBe("forward");
  expect(CS_KEYS.KeyS).toBe("back");
  expect(CS_KEYS.KeyA).toBe("left");
  expect(CS_KEYS.KeyD).toBe("right");
  expect(CS_KEYS.ArrowUp).toBe("forward");
  expect(CS_KEYS.Space).toBe("jump");
  expect(CS_KEYS.ControlLeft).toBe("duck");
  expect(CS_KEYS.KeyC).toBe("duck");
  expect(CS_KEYS.ShiftLeft).toBe("walk");
  expect(CS_KEYS.KeyR).toBe("reload");
  expect(CS_KEYS.KeyE).toBe("use");
  expect(CS_KEYS.KeyB).toBe("buy");
  expect(CS_KEYS.KeyG).toBe("grenade");
  expect(CS_KEYS.KeyT).toBe("flash");
  expect(CS_KEYS.KeyV).toBe("smoke");
  expect(CS_KEYS.Tab).toBe("scoreboard");
  expect(CS_KEYS.Digit1).toBe("slot1");
  expect(CS_KEYS.Digit3).toBe("slot3");
  expect(CS_MOUSE[0]).toBe("fire");
  expect(CS_MOUSE[2]).toBe("scope");
  // The whole mouse, because an unbound button is one the browser keeps: 3 and
  // 4 are Back and Forward on Windows, and the wheel pressed is the quick knife.
  expect(CS_MOUSE[1]).toBe("knife");
  expect(CS_MOUSE[3]).toBe("use");
  expect(CS_MOUSE[4]).toBe("grenade");
  // The wheel jumps whichever way it is turned, which is how half of this
  // game's players jump at all.
  expect(CS_WHEEL.up).toBe("jump");
  expect(CS_WHEEL.down).toBe("jump");
  expect(intent(["jump"]).input.jump).toBe(true);
  expect([...CS_TAP]).toEqual(["jump", "reload", "buy", "grenade", "flash", "smoke"]);
  // F is the page's, not the world's: `main.ts` hears it on `onAction` and asks
  // the browser for the screen, and nothing about an `Input` changes for it.
  expect(CS_KEYS.KeyF).toBe("fullscreen");
  expect(intent(["fullscreen"])).toEqual(intent([]));
  // P is the page's in the same way: it pauses, which is what Escape means too,
  // and no browser has a meaning of its own for it to take the window back with.
  expect(CS_KEYS.KeyP).toBe("pause");
  expect(intent(["pause"])).toEqual(intent([]));
  // X is the page's too: it buys last round's loadout again, which is money and
  // not movement, so nothing about an `Input` changes for it either.
  expect(CS_KEYS.KeyX).toBe("rebuy");
  expect(intent(["rebuy"])).toEqual(intent([]));
});
test("the number row is one row of keys, bound in the order it is printed", () => {
  // Eleven keys, left to right, and the code of each is what a browser calls
  // that key: the buy panel prints them on its tiles in this order.
  expect([...NUMBER_ROW]).toEqual(["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "-"]);
  const codes = ["Digit1", "Digit2", "Digit3", "Digit4", "Digit5", "Digit6", "Digit7", "Digit8", "Digit9", "Digit0", "Minus"];
  expect(codes.map((code) => CS_KEYS[code])).toEqual(NUMBER_ROW.map((_, i) => slotAction(i)));
  // And the way back, which is how `main.ts` turns a press into the tile under
  // it: every one of them, and nothing else.
  expect(codes.map((code) => slotIndex(CS_KEYS[code] ?? ""))).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  expect(slotIndex("forward")).toBeNull();
  expect(slotIndex("slot12")).toBeNull();
  expect(slotIndex("slot")).toBeNull();
});
test("only the first three of the row are pockets: the rest are the panel's and the world has never heard of them", () => {
  expect(intent(["slot1"]).slotWanted).toBe(1);
  expect(intent(["slot2"]).slotWanted).toBe(2);
  expect(intent(["slot3"]).slotWanted).toBe(3);
  for (const action of ["slot4", "slot9", "slot10", "slot11"]) {
    expect(intent([action]).slotWanted).toBeNull();
    expect(intent([action])).toEqual(intent([]));
  }
});
test("the wheel pressed is the knife pocket, and it is not a tile of the buy panel", () => {
  // The same pocket `3` is, by a name no tile is printed with: with the shop
  // open a key of the number row buys, and a thumb on the wheel means the knife
  // rather than whatever the third tile happens to be.
  expect(intent(["knife"]).slotWanted).toBe(3);
  expect(slotIndex("knife")).toBeNull();
  expect(intent(["knife"]).input).toEqual(intent([]).input);
});
test("nothing held is nothing asked for", () => {
  const { input, scoreboard, slotWanted } = intent([]);
  expect(input.forward).toBe(0);
  expect(input.side).toBe(0);
  expect(input.jump).toBe(false);
  expect(input.fire).toBe(false);
  expect(input.switchTo).toBeNull();
  expect(scoreboard).toBe(false);
  expect(slotWanted).toBeNull();
});
test("the movement keys sum and opposites cancel", () => {
  expect(intent(["forward"]).input.forward).toBe(1);
  expect(intent(["back"]).input.forward).toBe(-1);
  expect(intent(["forward", "back"]).input.forward).toBe(0);
  expect(intent(["right"]).input.side).toBe(1);
  expect(intent(["left"]).input.side).toBe(-1);
  expect(intent(["left", "right"]).input.side).toBe(0);
});
test("the stick adds to the keys and the sum clamps to ±1", () => {
  expect(intent([], { x: -0.5, y: 0.25 }).input.side).toBeCloseTo(-0.5, 10);
  expect(intent([], { x: -0.5, y: 0.25 }).input.forward).toBeCloseTo(0.25, 10);
  expect(intent(["forward"], { x: 0, y: 0.9 }).input.forward).toBe(1);
  expect(intent(["left"], { x: -0.9, y: 0 }).input.side).toBe(-1);
});
test("every held action lands on its field", () => {
  const { input } = intent(["jump", "duck", "walk", "reload", "use", "fire", "scope"]);
  expect(input.jump).toBe(true);
  expect(input.duck).toBe(true);
  expect(input.walk).toBe(true);
  expect(input.reload).toBe(true);
  expect(input.use).toBe(true);
  expect(input.fire).toBe(true);
  expect(input.scope).toBe(true);
});
test("the scoreboard is not an input to the world", () => {
  expect(intent(["scoreboard"]).scoreboard).toBe(true);
  expect(intent(["scoreboard"]).input).toEqual(intent([]).input);
});
test("three beats two beats one", () => {
  expect(intent(["slot1"]).slotWanted).toBe(1);
  expect(intent(["slot2"]).slotWanted).toBe(2);
  expect(intent(["slot3"]).slotWanted).toBe(3);
  expect(intent(["slot1", "slot2"]).slotWanted).toBe(2);
  expect(intent(["slot1", "slot2", "slot3"]).slotWanted).toBe(3);
});
test("an action the game does not know is not an input", () => {
  expect(intent(["buy", "nonsense"]).input).toEqual(intent([]).input);
});
@@ -0,0 +1,129 @@
/**
 * The game's half of input: which keys mean what, and what a held action does
 * to an `Input`. The engine's controls collect names — "forward", "slot2" —
 * and know nothing else; this is where a name becomes the same struct a bot
 * hands the simulation, so a person and a bot are the same kind of player.
 */
import { clamp } from "../engine/index.ts";
import { NO_INPUT, type Input } from "./world.ts";
/**
 * The number row, left to right, printed as the key prints itself. It is one
 * list because it is one row of keys with two meanings, and which one is meant
 * is the frame's question rather than the keyboard's: with the buy panel open
 * every key of it presses the tile it is printed on, and with the panel closed
 * the first three are the weapon pockets and the rest do nothing.
 *
 * Eleven, because a CT's shelf is eleven tiles — five guns, three grenades, the
 * vest, the vest and helmet, and the kit — and a tile with no key on it is a
 * tile you need the mouse for, which is the whole of what #153 was about.
 * `src/client/buy.ts` prints these on the tiles and `src/client/main.ts` reads
 * one back to an index in the same list, so the number on the screen and the
 * key that buys it cannot drift.
 */
export const NUMBER_ROW = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "-"] as const;
/** The `KeyboardEvent.code` of each of those keys, in the same order. */
const NUMBER_CODES = [
  "Digit1", "Digit2", "Digit3", "Digit4", "Digit5",
  "Digit6", "Digit7", "Digit8", "Digit9", "Digit0", "Minus",
] as const;
/** What the nth key of the number row presses: `slot1` is the first of them. */
export const slotAction = (index: number): string => `slot${index + 1}`;
/** Which key of the number row an action is, or null for anything else. */
export function slotIndex(action: string): number | null {
  const at = NUMBER_ROW.findIndex((_, index) => slotAction(index) === action);
  return at === -1 ? null : at;
}
/** `KeyboardEvent.code` to action. Today's bindings, moved rather than tuned. */
export const CS_KEYS: Record<string, string> = {
  KeyW: "forward", KeyS: "back", KeyA: "left", KeyD: "right",
  ArrowUp: "forward", ArrowDown: "back", ArrowLeft: "left", ArrowRight: "right",
  Space: "jump", ControlLeft: "duck", KeyC: "duck", ShiftLeft: "walk",
  KeyR: "reload", KeyE: "use", KeyG: "grenade", KeyT: "flash", KeyV: "smoke",
  KeyB: "buy", Tab: "scoreboard",
  ...Object.fromEntries(NUMBER_CODES.map((code, index) => [code, slotAction(index)])),
  // Neither of these is a thing the world knows about: `main.ts` hears them on
  // `onAction`, and `readIntent` below never sees either. F asks the browser for
  // the screen; P pauses, which is what Escape means too — and P is a key no
  // browser has its own meaning for, so it pauses without also handing the
  // window back, which is what Escape does on a Mac.
  KeyF: "fullscreen",
  KeyP: "pause",
  // Nor is this one: X buys last round's loadout again, which is money and not
  // movement, so `main.ts` hears it and `readIntent` never does.
  KeyX: "rebuy",
};
/**
 * Left fires, right scopes, and the three buttons a five-button mouse has as
 * well — all of them, because a bound button is a button the engine takes the
 * browser's meaning away from and an unbound one is left alone.
 *
 * That matters most for the two under the thumb: to a browser on Windows they
 * are Back and Forward, so a thumb that finds one mid-round in Edge leaves the
 * page and takes the match with it. Bound here, they are the game's. Which
 * actions they get is the pair a thumb reaches for: plant-or-defuse, and the HE.
 *
 * The wheel pressed is the quick knife every other shooter puts there — it is
 * `knife` rather than `slot3` on purpose, because the number row is also the
 * buy panel's and a middle click with the shop open would otherwise spend the
 * money on whatever tile is printed with a 3.
 */
export const CS_MOUSE: Record<number, string> = {
  0: "fire", 1: "knife", 2: "scope", 3: "use", 4: "grenade",
};
/** The wheel jumps, both ways, which is the bind half this game plays with. */
export const CS_WHEEL: Record<string, string> = { up: "jump", down: "jump" };
/** On-screen buttons that are a tap, not a hold. */
export const CS_TAP = ["jump", "reload", "buy", "grenade", "flash", "smoke"] as const;
export type Intent = {
  input: Input;
  scoreboard: boolean;
  /** 1 primary, 2 pistol, 3 knife — `main` knows which weapon each is. */
  slotWanted: 1 | 2 | 3 | null;
};
/**
 * What the held actions and the thumb stick add up to this frame. `switchTo`
 * stays null: only the world knows what is in slot 1, so `main` fills it from
 * `slotWanted`.
 */
export function readIntent(held: ReadonlySet<string>, stick: { x: number; y: number }): Intent {
  const down = (action: string): boolean => held.has(action);
  const input: Input = {
    ...NO_INPUT,
    forward: clamp((down("forward") ? 1 : 0) - (down("back") ? 1 : 0) + stick.y, -1, 1),
    side: clamp((down("right") ? 1 : 0) - (down("left") ? 1 : 0) + stick.x, -1, 1),
    jump: down("jump"),
    duck: down("duck"),
    walk: down("walk"),
    reload: down("reload"),
    use: down("use"),
    fire: down("fire"),
    scope: down("scope"),
    // Three pockets, three keys, read newest-reach-first: the one nearest the
    // front of this list wins while more than one is held, because the one you
    // just reached for is the one you meant, and releasing it throws whichever
    // of the others is still down.
    throwing: down("smoke") ? "smoke" : down("flash") ? "flash" : down("grenade") ? "he" : null,
    switchTo: null,
  };
  return {
    input,
    scoreboard: down("scoreboard"),
    // Three pockets, and only three: the rest of the number row belongs to the
    // buy panel, and a world that has never heard of `slot4` cannot be steered
    // by the key that buys the fourth tile. `knife` is the third pocket by
    // another name — the wheel pressed, which no tile is printed with.
    slotWanted:
      down("slot3") || down("knife") ? 3 : down("slot2") ? 2 : down("slot1") ? 1 : null,
  };
}
@@ -1,114 +0,0 @@
import { expect, test } from "bun:test";
import { addBody, MAX_BODIES, type Corpse } from "./bodies.ts";
import { traceBullet } from "./combat.ts";
import { WEAPONS } from "./weapons.ts";
import { SHORT } from "./match.ts";
import { move, MOVE, type Body, type Wish } from "./physics.ts";
import {
  aimAt, bodyCentre, createWorld, shoot, startRound, type Player, type World,
} from "./world.ts";
/** Put a shooter in front of the person on an empty map, rifle up and aimed. */
function faceOff(world: World, shooter: Player, apart = 200): void {
  world.boxes = [];
  world.match.phase = "live";
  for (const p of world.players) if (p !== shooter && p !== world.me) p.alive = false;
  world.bodies.length = 0;
  world.me.pos = [0, 0, 0];
  world.me.vel = [0, 0, 0];
  world.me.yaw = 180;
  shooter.pos = [apart, 0, 0];
  shooter.vel = [0, 0, 0];
  shooter.onGround = true;
  shooter.primary = "ak47";
  shooter.weapon = "ak47";
  shooter.ammo.ak47 = { mag: 30, reserve: 90 };
  shooter.nextShotAt = 0;
  shooter.reloadUntil = 0;
  shooter.shotIndex = 0;
  const aim = aimAt(shooter, bodyCentre(world.me));
  shooter.yaw = aim.yaw;
  shooter.pitch = aim.pitch;
  world.effects.length = 0;
}
/** Kill the person where they stand, and hand back the shooter. */
function killMe(world: World): Player {
  const shooter = world.players.find((p) => p.team === "t") as Player;
  faceOff(world, shooter);
  world.me.health = 1;
  world.me.armor = 0;
  expect(shoot(world, shooter)).toBe(true);
  expect(world.me.alive).toBe(false);
  return shooter;
}
test("a kill leaves one body where and how the player fell", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 211);
  killMe(world);
  expect(world.bodies.length).toBe(1);
  const body = world.bodies[0] as Corpse;
  expect(body.id).toBe(world.me.id);
  expect(body.team).toBe("ct");
  expect(body.yaw).toBe(world.me.yaw);
  expect(body.at).toBe(world.time);
  expect(body.pos).toEqual([0, 0, 0]);
  // A copy, not the player: the corpse does not follow them to the next round.
  expect(body.pos).not.toBe(world.me.pos);
});
test("the next round clears the bodies", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 223);
  killMe(world);
  expect(world.bodies.length).toBe(1);
  startRound(world);
  expect(world.bodies.length).toBe(0);
  expect(world.me.alive).toBe(true);
});
test("the list of bodies is bounded however long the world is stepped", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 227);
  const shooter = world.players.find((p) => p.team === "t") as Player;
  faceOff(world, shooter);
  for (let i = 0; i < 400; i++) {
    world.me.alive = true;
    world.me.health = 1;
    world.me.armor = 0;
    shooter.nextShotAt = 0;
    shooter.shotIndex = 0; // the first bullet of a spray, every time: it lands
    shooter.ammo.ak47 = { mag: 30, reserve: 90 };
    world.time += 1;
    shoot(world, shooter);
  }
  expect(world.bodies.length).toBe(MAX_BODIES);
  // The oldest went first: what is left is the last MAX_BODIES kills.
  expect((world.bodies[0] as Corpse).at).toBeLessThan((world.bodies[MAX_BODIES - 1] as Corpse).at);
});
test("someone killed in the air is put down on the floor under them", () => {
  const bodies: Corpse[] = [];
  const boxes = [{ min: [-200, -200, -64] as [number, number, number], max: [200, 200, 0] as [number, number, number], mat: 0 }];
  addBody(bodies, { id: 3, team: "t", pos: [0, 0, 180], yaw: 45 }, boxes, 9);
  expect((bodies[0] as Corpse).pos).toEqual([0, 0, 0]);
  // Nothing under them at all — a hole in the world — leaves them where they died.
  addBody(bodies, { id: 4, team: "t", pos: [0, 0, 180], yaw: 0 }, [], 9);
  expect((bodies[1] as Corpse).pos[2]).toBe(180);
});
test("a body is decoration: nobody collides with it and no bullet stops on it", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 229);
  const shooter = killMe(world);
  expect(world.bodies.length).toBe(1);
  // `move` only ever collides with `world.boxes`, and a body is never one: the
  // only box in this world is the floor the body is lying on.
  world.boxes = [{ min: [-400, -400, -64], max: [400, 400, 0], mat: 0 }];
  expect(world.boxes.length).toBe(1);
  const walker: Body = { pos: [0, -100, 0], vel: [0, 0, 0], onGround: true, ducking: false, duckAmount: 0, landSpeed: 0 };
  const wish: Wish = { forward: 1, side: 0, yaw: 90, jump: false, duck: false, walk: false, maxSpeed: MOVE.maxSpeed };
  for (let i = 0; i < 128; i++) move(walker, wish, 1 / 64, world.boxes);
  expect(walker.pos[1]).toBeGreaterThan(0); // straight over where the body lies
  // A bullet along the same line finds nothing: only living players are actors.
  const hit = traceBullet([0, -300, 20], [0, 300, 20], world.boxes, world.players, shooter.id, WEAPONS.ak47);
  expect(hit.kind).toBe("none");
});
@@ -1,53 +0,0 @@
/**
 * The dead, left where they fell. A body is a copy of four numbers taken at the
 * moment of the kill — never a reference to the player, who stands up again at
 * the next `startRound` — and it is decoration and nothing else: bullets go
 * through it, `move` never collides with it, and no bot has ever seen one.
 *
 * It lives in `world.bodies` rather than `world.effects` because the effects
 * list is trimmed to the last two seconds and a body lasts the round.
 */
import type { Box } from "./map.ts";
import type { Team } from "./match.ts";
import type { Vec3 } from "./math.ts";
import { HULL, groundUnder } from "./physics.ts";
export type Corpse = {
  id: number; // the player who fell, so the HUD or a camera could find them
  team: Team; // the tint, kept here because half time swaps the player's side
  pos: Vec3; // the feet, on the floor under where they died
  yaw: number; // the way they were facing: the body lies along it
  at: number; // world time of the kill
};
/**
 * Ten a side is the ceiling for a round, but a world can be stepped for as long
 * as anyone likes, so the list has a hard end and the oldest body goes first.
 */
export const MAX_BODIES = 20;
/** How far below a player killed in the air the floor is looked for. */
export const FALL_REACH = 512;
/** What a body needs from the player it was; every field is copied out. */
export type Fallen = { id: number; team: Team; pos: Vec3; yaw: number };
/**
 * Add the body of `p` to `bodies`. Someone shot mid-jump is put down on the
 * floor under them — the only work here, and it happens once per kill, never
 * in a tick where nobody dies.
 */
export function addBody(bodies: Corpse[], p: Fallen, boxes: Box[], time: number): Corpse {
  const floor = groundUnder(p.pos, HULL.stand, boxes, FALL_REACH);
  const body: Corpse = {
    id: p.id,
    team: p.team,
    pos: [p.pos[0], p.pos[1], floor ?? p.pos[2]],
    yaw: p.yaw,
    at: time,
  };
  bodies.push(body);
  if (bodies.length > MAX_BODIES) bodies.shift();
  return body;
}
@@ -0,0 +1,214 @@
/**
 * The objective's own tests, on a round made of three plain objects: the bomb,
 * the match clock and a level. No world, no players, no bots — `updateBomb`
 * takes a carrier and gives back at most one thing for the world to do, which
 * is exactly what can be checked here without any of that.
 *
 * `world.test.ts` keeps the two that are the world's rather than the bomb's: a
 * plant that keeps the round alive past the clock, and a defuse that wins it and
 * pays ten people.
 */
import { expect, test } from "bun:test";
import {
  BEEP_FAST, BEEP_SLOW, beepDue, beepInterval, defuseTime, dropBomb, giveBomb, newBomb, updateBomb,
  useProgress, type BombState, type Carrier, type Round,
} from "./bomb.ts";
import { DE_FORGE } from "./map.ts";
import { newMatch, PLANT_REWARD, SHORT, type Phase } from "./match.ts";
const TICK = 1 / 64;
const at = (site: "A" | "B"): [number, number, number] =>
  [DE_FORGE.sites[site][0], DE_FORGE.sites[site][1], 2];
/** A round mid-play, with the bomb wherever this test wants it. */
const round = (phase: Phase = "live"): Round => {
  const match = newMatch(SHORT, "t");
  match.phase = phase;
  return { bomb: newBomb(), match, level: DE_FORGE };
};
const carrier = (over: Partial<Carrier> = {}): Carrier => ({
  team: "t", pos: at("A"), onGround: true, money: 1000, defuseKit: false, hasBomb: false, ...over,
});
/** Hold use (or not) for `seconds`, and hand back whatever the bomb said. */
function hold(r: Round, p: Carrier, seconds: number, use = true): ReturnType<typeof updateBomb> {
  let last: ReturnType<typeof updateBomb> = null;
  for (let t = 0; t < seconds; t += TICK) last = updateBomb(r, p, use, TICK) ?? last;
  return last;
}
test("a plant needs the site and not just the bomb", () => {
  const r = round();
  const p = carrier({ hasBomb: true, pos: [0, 0, 2] }); // holding it, standing nowhere
  expect(hold(r, p, SHORT.plantTime + 0.2)).toBe(null);
  expect(r.bomb.state).toBe("carried");
  expect(r.bomb.plantProgress).toBe(0);
  // The same key, the same seconds, on the site.
  p.pos = at("A");
  const event = hold(r, p, SHORT.plantTime + 0.2);
  expect(event).toEqual({ type: "planted", site: "A" });
  expect(r.bomb.state).toBe("planted");
  expect(r.bomb.site).toBe("A");
});
test("a plant needs the bomb and not just the site, and needs the round live", () => {
  const empty = round();
  expect(hold(empty, carrier({ hasBomb: false }), SHORT.plantTime + 0.2)).toBe(null);
  expect(empty.bomb.state).toBe("carried");
  const frozen = round("freeze");
  expect(hold(frozen, carrier({ hasBomb: true }), SHORT.plantTime + 0.2)).toBe(null);
  expect(frozen.bomb.plantProgress).toBe(0);
});
test("a plant pays the planter, empties their hands and puts the clock on the fuse", () => {
  const r = round();
  const p = carrier({ hasBomb: true, pos: at("B") });
  expect(hold(r, p, SHORT.plantTime + 0.2)?.type).toBe("planted");
  expect(p.money).toBe(1000 + PLANT_REWARD);
  expect(p.hasBomb).toBe(false);
  expect(r.match.phase).toBe("planted");
  expect(r.match.timer).toBe(SHORT.bombTime);
  expect(r.bomb.pos[2]).toBe(4); // on the floor at their feet, not inside them
});
test("a plant interrupted by letting go starts again from nothing", () => {
  const r = round();
  const p = carrier({ hasBomb: true });
  hold(r, p, SHORT.plantTime / 2);
  expect(r.bomb.plantProgress).toBeGreaterThan(0);
  expect(useProgress(r, p)).toEqual({ label: "Planting", fraction: expect.any(Number) });
  hold(r, p, TICK, false);
  expect(r.bomb.plantProgress).toBe(0);
  expect(useProgress(r, p)).toBe(null);
});
test("the bomb the carrier dropped is picked up by the next terrorist past it", () => {
  const r = round();
  const dead = carrier({ hasBomb: true, pos: [100, 100, 2] });
  dropBomb(r.bomb, dead);
  expect(r.bomb.state).toBe("dropped");
  expect(dead.hasBomb).toBe(false);
  const ct = carrier({ team: "ct", pos: [100, 100, 2] });
  updateBomb(r, ct, false, TICK);
  expect(r.bomb.state).toBe("dropped"); // not theirs to carry
  const far = carrier({ pos: [1000, 1000, 2] });
  updateBomb(r, far, false, TICK);
  expect(r.bomb.state).toBe("dropped");
  const near = carrier({ pos: [120, 100, 2] });
  updateBomb(r, near, false, TICK);
  expect(r.bomb.state).toBe("carried");
  expect(near.hasBomb).toBe(true);
});
test("a defuse interrupted goes back to nothing, and resuming starts the wire again", () => {
  const r = round("planted");
  r.bomb.state = "planted";
  r.bomb.pos = at("B");
  const ct = carrier({ team: "ct", pos: at("B") });
  hold(r, ct, SHORT.defuseTime * 0.75);
  expect(r.bomb.defuser).toBe(ct);
  expect(useProgress(r, ct)?.label).toBe("Defusing");
  hold(r, ct, TICK, false); // the key came up
  expect(r.bomb.defuseProgress).toBe(0);
  expect(r.bomb.defuser).toBe(null);
  expect(useProgress(r, ct)).toBe(null);
  // Three quarters of the way was worth nothing: it takes the whole of it again.
  expect(hold(r, ct, SHORT.defuseTime * 0.9)).toBe(null);
  expect(r.bomb.state).toBe("planted");
  expect(hold(r, ct, SHORT.defuseTime * 0.2)).toEqual({ type: "defused" });
  // Asked as a `BombState`: the checker last saw this field assigned, and
  // does not know that `hold` moved it on.
  expect<BombState>(r.bomb.state).toBe("defused");
});
test("a defuse needs to be stood next to, and is the CT's alone", () => {
  const r = round("planted");
  r.bomb.state = "planted";
  r.bomb.pos = at("A");
  const far = carrier({ team: "ct", pos: [DE_FORGE.sites.A[0] + 200, DE_FORGE.sites.A[1], 2] });
  expect(hold(r, far, SHORT.defuseTime + 0.2)).toBe(null);
  expect(r.bomb.defuseProgress).toBe(0);
  const t = carrier({ team: "t", pos: at("A") });
  expect(hold(r, t, SHORT.defuseTime + 0.2)).toBe(null);
  expect(r.bomb.state).toBe("planted");
});
test("a kit halves the defuse, and the readout says which one it is", () => {
  const withKit = round("planted");
  withKit.bomb.state = "planted";
  withKit.bomb.pos = at("A");
  const kitted = carrier({ team: "ct", pos: at("A"), defuseKit: true });
  expect(defuseTime(withKit, kitted)).toBe(SHORT.defuseTimeWithKit);
  expect(SHORT.defuseTimeWithKit).toBeLessThan(SHORT.defuseTime);
  // The seconds a bare-handed CT would still be cutting at.
  expect(hold(withKit, kitted, SHORT.defuseTimeWithKit - 0.1)).toBe(null);
  expect(useProgress(withKit, kitted)?.label).toBe("Defusing (kit)");
  expect(hold(withKit, kitted, 0.2)).toEqual({ type: "defused" });
  const bare = round("planted");
  bare.bomb.state = "planted";
  bare.bomb.pos = at("A");
  const empty = carrier({ team: "ct", pos: at("A") });
  expect(defuseTime(bare, empty)).toBe(SHORT.defuseTime);
  expect(hold(bare, empty, SHORT.defuseTimeWithKit + 0.1)).toBe(null);
  expect(bare.bomb.state).toBe("planted");
});
test("a defuse pays the hands that did it", () => {
  const r = round("planted");
  r.bomb.state = "planted";
  r.bomb.pos = at("A");
  const ct = carrier({ team: "ct", pos: at("A"), defuseKit: true });
  hold(r, ct, SHORT.defuseTimeWithKit + 0.1);
  expect(ct.money).toBe(1300);
});
test("the bomb starts in the hands of whoever was given it", () => {
  const p = carrier({ pos: [12, 34, 2] });
  const bomb = giveBomb(p);
  expect(p.hasBomb).toBe(true);
  expect(bomb.state).toBe("carried");
  expect(bomb.pos).toEqual([12, 34, 2]);
  p.pos[0] = 999; // a copy, not the player's own array
  expect(bomb.pos[0]).toBe(12);
});
test("the fuse beeps slower at the top than at the bottom, by a straight line", () => {
  // A forty-second fuse: 0.9 s between beeps at the plant, 0.12 + 0.78/2 at
  // half, and 0.12 at the moment it goes off.
  expect(beepInterval(40, 40)).toBeCloseTo(BEEP_SLOW, 10);
  expect(beepInterval(20, 40)).toBeCloseTo(0.51, 10);
  expect(beepInterval(0, 40)).toBeCloseTo(BEEP_FAST, 10);
  // A clock that has run past its own end, or a rule set with no fuse at all,
  // is the fastest beep rather than a division by zero.
  expect(beepInterval(-5, 40)).toBeCloseTo(BEEP_FAST, 10);
  expect(beepInterval(1, 0)).toBeCloseTo(BEEP_FAST, 10);
});
test("a bomb beeps on the tick it is planted, and then on its own clock", () => {
  const bomb = newBomb();
  // The first call is due at once: a bomb that has just gone down says so.
  expect(beepDue(bomb, 40, 40, TICK)).toBe(true);
  let beeps = 0;
  for (let t = 0; t < 0.9 - TICK; t += TICK) if (beepDue(bomb, 40, 40, TICK)) beeps += 1;
  expect(beeps).toBe(0);
  expect(beepDue(bomb, 40, 40, TICK)).toBe(true);
  // With a second of fuse left it beeps seven times a second instead of once:
  // the first of the two below is still the 0.9 s that was set when the fuse
  // was full, and everything after it is 0.12 + 0.78/40 apart.
  let fast = 0;
  for (let t = 0; t < 2; t += TICK) if (beepDue(bomb, 1, 40, TICK)) fast += 1;
  expect(fast).toBeGreaterThan(5);
});
@@ -0,0 +1,178 @@
/**
 * The objective: who is carrying it, where it landed when they died, what
 * pressing use on a site does, and what pressing use on a planted one undoes.
 * The kit lives here too, because the only thing a defuse kit is is half a
 * defuse, and so does the fraction a readout draws a bar from.
 *
 * It knows nothing about the world it is called from. `updateBomb` reads the
 * round's clock and the level's sites, writes the bomb and the one player in
 * front of it, and hands back what the *world* has to do about it — a line on
 * the screen, a round that just ended — because paying ten people for a round
 * needs all ten and this file has one. So it takes a slice of the world named
 * by the members it touches, the way `combat.ts` names an `Actor`, and cannot
 * reach back for `world.ts`.
 */
import { siteAt, type Level } from "./level.ts";
import { clamp, dist, type Vec3 } from "../engine/index.ts";
import { capMoney, plantBomb, DEFUSE_REWARD, PLANT_REWARD, type MatchState, type Team } from "./match.ts";
/** Everything the bomb reads or writes on the person handling it. */
export type Carrier = {
  team: Team;
  pos: Vec3;
  onGround: boolean;
  money: number;
  defuseKit: boolean;
  hasBomb: boolean;
};
/** Where the bomb is in its life, from a T's hands to the crater. */
export type BombState = "carried" | "dropped" | "planted" | "defused" | "detonated";
export type Bomb = {
  state: BombState;
  pos: Vec3;
  site: "A" | "B" | null;
  plantProgress: number;
  defuseProgress: number;
  defuser: Carrier | null;
  /**
   * Seconds until the next beep. It is the bomb's own clock and nothing reads
   * it back — a beep is information, not a rule — so it is here with the fuse
   * rather than in the frame, which would beep at whatever rate the screen runs.
   */
  beepIn: number;
};
/** The round as the bomb sees it: itself, the clock, and the ground it is on. */
export type Round = { bomb: Bomb; match: MatchState; level: Level };
/**
 * What the world must do about a tick of the bomb that it could not do here:
 * say a line about the plant, and end the round on the defuse. The state the
 * bomb owns — the fuse, the site, the money for the hands that did it — is
 * already written by the time one of these comes back.
 */
export type BombEvent = { type: "planted"; site: "A" | "B" } | { type: "defused" };
/** How close a defuser has to stand. Counter-Strike's is generous; so is this. */
export const DEFUSE_RANGE = 64;
/** How close you walk past a dropped bomb before it is in your hands. */
export const PICKUP_RANGE = 48;
/** A fresh bomb, in somebody's hands, at `pos`. */
export const newBomb = (pos: Vec3 = [0, 0, 0]): Bomb => ({
  state: "carried", pos: [pos[0], pos[1], pos[2]],
  site: null, plantProgress: 0, defuseProgress: 0, defuser: null, beepIn: 0,
});
/**
 * How long between two beeps, in seconds, with `left` of a `whole`-second fuse
 * still to run. It is a straight line from `BEEP_SLOW` at the moment of the
 * plant to `BEEP_FAST` at zero, because the beep is how long you have: a
 * defuser who can hear it does not need to see the clock. A forty-second fuse
 * beeps every 0.9 s at the top, every 0.51 s at half, and eight times a second
 * in the last moment of it.
 */
export const BEEP_SLOW = 0.9;
export const BEEP_FAST = 0.12;
export const beepInterval = (left: number, whole: number): number =>
  BEEP_FAST + (BEEP_SLOW - BEEP_FAST) * clamp(whole <= 0 ? 0 : left / whole, 0, 1);
/**
 * One tick of the fuse's clock: true on the tick a beep is due, and the next
 * one is set from how much fuse is left at that moment. Called once a tick for
 * the one bomb — never once per player — and it makes no sound itself: the
 * world turns a true into an effect, the way it does with everything else that
 * can be heard.
 */
export function beepDue(bomb: Bomb, left: number, whole: number, dt: number): boolean {
  bomb.beepIn -= dt;
  if (bomb.beepIn > 0) return false;
  bomb.beepIn = beepInterval(left, whole);
  return true;
}
/** Hand the bomb to this player at the top of a round: it starts where they do. */
export function giveBomb(carrier: Carrier): Bomb {
  carrier.hasBomb = true;
  return newBomb(carrier.pos);
}
/** The carrier died: the bomb is on the floor where the body is, for anyone. */
export function dropBomb(bomb: Bomb, carrier: Carrier): void {
  carrier.hasBomb = false;
  bomb.state = "dropped";
  bomb.pos = [carrier.pos[0], carrier.pos[1], carrier.pos[2] + 4];
}
/** How long this player's defuse takes: a kit is the whole of the difference. */
export const defuseTime = (round: Round, p: Carrier): number =>
  p.defuseKit ? round.match.rules.defuseTimeWithKit : round.match.rules.defuseTime;
/**
 * One tick of the bomb for one player: pick it up, carry it, plant it on a
 * site, or cut the wire on one that is down. Everything a plant or a defuse is
 * — the progress that resets the moment the key comes up or you step off, the
 * reward, the clock going onto the fuse — happens here; what the round does
 * about it comes back to the caller.
 */
export function updateBomb(round: Round, p: Carrier, use: boolean, dt: number): BombEvent | null {
  const { bomb, match } = round;
  let event: BombEvent | null = null;
  if (bomb.state === "carried" && p.hasBomb && match.phase === "live") {
    bomb.pos = [p.pos[0], p.pos[1], p.pos[2]];
    const site = siteAt(round.level, p.pos);
    if (use && site !== null && p.onGround) {
      bomb.plantProgress += dt;
      if (bomb.plantProgress >= match.rules.plantTime) {
        bomb.state = "planted";
        bomb.site = site;
        bomb.pos = [p.pos[0], p.pos[1], p.pos[2] + 2];
        p.hasBomb = false;
        p.money = capMoney(p.money + PLANT_REWARD, match.rules);
        plantBomb(match);
        event = { type: "planted", site };
      }
    } else {
      bomb.plantProgress = 0;
    }
  }
  if (bomb.state === "dropped" && p.team === "t" && dist(p.pos, bomb.pos) < PICKUP_RANGE) {
    bomb.state = "carried";
    p.hasBomb = true;
  }
  if (bomb.state === "planted" && p.team === "ct") {
    const near = dist(p.pos, bomb.pos) < DEFUSE_RANGE;
    if (use && near && p.onGround) {
      bomb.defuser = p;
      bomb.defuseProgress += dt;
      if (bomb.defuseProgress >= defuseTime(round, p)) {
        bomb.state = "defused";
        p.money = capMoney(p.money + DEFUSE_REWARD, match.rules);
        event = { type: "defused" };
      }
    } else if (bomb.defuser === p) {
      bomb.defuser = null;
      bomb.defuseProgress = 0;
    }
  }
  return event;
}
/** How far along the thing this player is doing is, 0..1, for the HUD bar. */
export function useProgress(round: Round, p: Carrier): { label: string; fraction: number } | null {
  const bomb = round.bomb;
  if (p.team === "t" && p.hasBomb && bomb.plantProgress > 0)
    return { label: "Planting", fraction: clamp(bomb.plantProgress / round.match.rules.plantTime, 0, 1) };
  if (p.team === "ct" && bomb.defuser === p && bomb.defuseProgress > 0) {
    return {
      label: p.defuseKit ? "Defusing (kit)" : "Defusing",
      fraction: clamp(bomb.defuseProgress / defuseTime(round, p), 0, 1),
    };
  }
  return null;
}
@@ -1,18 +1,41 @@
import { expect, test } from "bun:test";
import { PACKED, useShipped } from "./shipped.ts";
import { unpack, type Policy } from "../engine/index.ts";
import {
  applyIntent, botThink, CARD, DIFFICULTIES, gunGoal, makeBrain, policy, restyleBrain, skillBand, think,
  applyIntent, blindness, botBuy, botThink, dry, flashed, makeBrain, nextWeapon, NO_POLICY, pathTo, policy,
  ride, roundPlan, think, usePlan, usePolicy,
} from "./bots.ts";
import { DE_FORGE, placeAt, worldOf } from "./map.ts";
import { dist2d } from "./math.ts";
import { COMPETITIVE, SHORT } from "./match.ts";
import { CALL_LIFE, HUNT_AT, otherSite } from "./plan.ts";
import {
  aimAt, bodyCentre, createWorld, NO_INPUT, radioCall, setDifficulty, startRound, update,
  type Player, type World,
} from "./world.ts";
import type { RoundPlan, TeamPlan } from "../plan/plan.ts";
import { grip } from "./spray.ts";
import { colOf, findPath, rowOf, walkable, worldOf } from "./level.ts";
import { dist, type Vec3 } from "../engine/index.ts";
import { OBS_SIZE } from "./observe.ts";
import { FLASH, WEAPONS, type WeaponId } from "./weapons.ts";
import { DE_FORGE } from "./map.ts";
import { COMPETITIVE } from "./match.ts";
import { aimAt, applyInput, bodyCentre, createWorld, deployTicks, type Player } from "./world.ts";
// The bots in here think with the policy this repository ships, handed in the
// way a browser hands in the one it downloaded.
useShipped();
test("a bot with no policy handed to it says so, and one handed a policy uses that one", () => {
  // The seam #214 opened: the weights are data now, so `usePolicy` is the only
  // way a bot gets any — a browser hands it what it downloaded, Bun hands it
  // what `shipped.ts` read. Nobody having handed one in is loud, not a bot
  // quietly aiming at nothing.
  usePolicy(null as unknown as Policy);
  expect(() => policy()).toThrow(NO_POLICY);
  const net = useShipped();
  expect(policy()).toBe(net);
  const other = unpack(PACKED);
  usePolicy(other);
  expect(policy()).toBe(other);
  useShipped();
});
const duel = (seed = 2024): { world: ReturnType<typeof createWorld>; me: Player; bot: Player } => {
  const world = createWorld(COMPETITIVE, "you", "ct", 1, seed);
  const world = createWorld(DE_FORGE, COMPETITIVE, "you", "ct", 1, seed);
  world.match.phase = "live";
  const me = world.me;
  const bot = world.players[1] as Player;
@@ -61,12 +84,47 @@
test("a bot turns towards a target it can see, and shoots at it", () => {
  expect(fired).toBeGreaterThan(0);
});
test("the hands hold the gun down through a spray and give the whole pull back", () => {
  const { world, bot } = duel();
  const brain = bot.brain!;
  bot.weapon = "ak47";
  bot.pitch = 0;
  bot.yaw = 180;
  // Ten rounds into a spray: the pattern has climbed and the hands are on it.
  bot.shotIndex = 10;
  for (let t = 0; t < 32; t++) ride(bot, brain, brain.grip, 1 / 64);
  expect(bot.pitch).toBeGreaterThan(1); // pointing below where it was aiming
  expect(brain.pull[1]).toBeCloseTo(bot.pitch, 9);
  expect(brain.pull[0]).toBeCloseTo(bot.yaw - 180, 9);
  // The world puts shotIndex back a third of a second after the trigger comes
  // up, and the pull unwinds with it: nothing of it outlives the burst.
  bot.shotIndex = 0;
  for (let t = 0; t < 64; t++) ride(bot, brain, brain.grip, 1 / 64);
  expect(bot.pitch).toBeCloseTo(0, 2);
  expect(bot.yaw).toBeCloseTo(180, 2);
  expect(Math.hypot(brain.pull[0], brain.pull[1])).toBeLessThan(0.01);
  // And the scripted brain never rides at all: it is the baseline the policy is
  // measured against, and a baseline that moves measures nothing.
  const scripted = duel();
  scripted.bot.brain = makeBrain(1, 99, false);
  scripted.bot.weapon = "ak47";
  scripted.bot.shotIndex = 10;
  for (let t = 0; t < 32; t++) botThink(scripted.world, scripted.bot, 1 / 64);
  expect(scripted.bot.brain.pull).toEqual([0, 0]);
});
test("skill is a handicap on the hands, not on the policy", () => {
  const fast = makeBrain(1, 7);
  const slow = makeBrain(0, 7);
  expect(slow.aimSpeed).toBeLessThan(fast.aimSpeed);
  expect(slow.aimError).toBeGreaterThan(fast.aimError);
  expect(slow.reaction).toBeGreaterThan(fast.reaction);
  // Spray control is on the same ladder: fodder holds a fifth of the pattern
  // and chases it slowly, the best hands in the game hold nine tenths.
  expect(slow.grip).toBeLessThan(fast.grip);
  expect(fast.grip).toBeCloseTo(grip(1), 12);
  expect(slow.gripRate).toBeLessThan(fast.gripRate);
  // The same intent, asked of both: the slow one cannot turn as far.
  const { world, bot } = duel();
@@ -88,643 +146,312 @@
test("a bot that has only just seen you does not shoot yet", () => {
  expect(immediate.fire).toBe(false);
});
// --- hearing --------------------------------------------------------------
test("a goal nothing can walk to is nudged to a cell something can", () => {
  // A crate is solid to the search and standing on it is not: a bomb dropped
  // up there is a point A* answers nothing about.
  const crate = worldOf(DE_FORGE, 21, 18, 0); // one of de_forge's jumpable crates
  expect(walkable(DE_FORGE, colOf(DE_FORGE, crate[0]), rowOf(DE_FORGE, crate[1]))).toBe(false);
  const from = DE_FORGE.spawns.t[0] as Vec3;
  expect(findPath(DE_FORGE, from, crate)).toHaveLength(0);
/**
 * A bot standing in ct mid with its back to b link, and the person 512 units
 * away through the wall between the two. The person moves for `seconds` —
 * running, walking or ducking — and what comes back is what the bot made of
 * the noise. Nothing here is pushed by hand: the footsteps are the ones
 * `world.ts` pushes for a person who is actually moving.
 */
function behindTheWall(seconds: number, how: Partial<typeof NO_INPUT>): Player {
  const world = createWorld(COMPETITIVE, "you", "ct", 1, 4242);
  const path = pathTo(DE_FORGE, from, crate);
  expect(path.length).toBeGreaterThan(0);
  const end = path[path.length - 1] as Vec3;
  expect(Math.hypot(end[0] - crate[0], end[1] - crate[1])).toBeLessThan(3 * 128 * 1.5);
});
test("a bot whose objective sits on a crate walks to it rather than standing still", () => {
  const world = createWorld(DE_FORGE, COMPETITIVE, "you", "ct", 1, 4242);
  world.match.phase = "live";
  const bot = world.players[1] as Player;
  world.me.pos = [-448, 1856, 2]; // b link
  world.me.yaw = 90; // running up the room, not into the wall
  bot.pos = [64, 1856, 2]; // ct mid, one wall away
  bot.yaw = 0; // looking the other way entirely
  bot.brain = makeBrain(1, 99);
  bot.brain.reset = false;
  bot.brain.heardAt = world.time;
  for (let t = 0; t < 64 * seconds; t++) update(world, 1 / 64, { ...NO_INPUT, forward: 1, ...how });
  return bot;
}
test("a bot turns towards a running enemy it cannot see", () => {
  const bot = behindTheWall(1, {});
  const suspect = bot.brain!.suspect;
  expect(suspect).not.toBeNull();
  // It believes the noise is roughly where it was made: west of it, in b link.
  expect(suspect![0]).toBeLessThan(bot.pos[0]);
  const towards = aimAt(bot, suspect!).yaw;
  expect(Math.abs(((towards - bot.yaw + 540) % 360) - 180)).toBeLessThan(45);
  expect(Math.abs(bot.yaw)).toBeGreaterThan(45); // it started out looking the other way
});
test("the same enemy walking or ducking is not heard at all", () => {
  expect(behindTheWall(1, { walk: true }).brain!.suspect).toBeNull();
  expect(behindTheWall(1, { duck: true }).brain!.suspect).toBeNull();
});
test("a bot never hears itself walking about", () => {
  const world = createWorld(RULES, "you", "ct", 1, 606);
  world.match.phase = "live";
  const bot = world.players[1] as Player;
  // The person stands still and silent at the far end of the map; the only
  // footsteps in this round are the bot's own.
  world.me.pos = [DE_FORGE.sites.A[0], DE_FORGE.sites.A[1], 2];
  let steps = 0;
  for (let t = 0; t < 64 * 3; t++) {
    update(world, 1 / 64, NO_INPUT);
    steps += world.effects.filter((e) => e.kind === "sound" && e.name === "step" && e.by === bot.id).length;
    expect(bot.brain?.suspect ?? null).toBeNull();
  }
  expect(steps).toBeGreaterThan(0); // it really was making a noise
});
// --- difficulty -----------------------------------------------------------
test("easy hands are strictly slower and shakier than hard's", () => {
  const easy = createWorld(SHORT, "you", "ct", 5, 999, "easy");
  const hard = createWorld(SHORT, "you", "ct", 5, 999, "hard");
  for (const easyBot of easy.players) {
    if (!easyBot.bot) continue;
    const hardBot = hard.players.find((p) => p.id === easyBot.id)!;
    const easyBrain = easyBot.brain!;
    const hardBrain = hardBot.brain!;
    expect(easyBrain.aimSpeed).toBeLessThan(hardBrain.aimSpeed);
    expect(easyBrain.aimError).toBeGreaterThan(hardBrain.aimError);
    expect(easyBrain.reaction).toBeGreaterThan(hardBrain.reaction);
  }
});
test("createWorld gives every bot a skill inside its difficulty's band", () => {
  for (const difficulty of DIFFICULTIES) {
    const { lo, hi } = skillBand(difficulty);
    const world = createWorld(SHORT, "you", "ct", 5, 555, difficulty);
    const bots = world.players.filter((p) => p.bot);
    expect(bots.length).toBeGreaterThan(0);
    for (const bot of bots) {
      expect(bot.brain).toBeDefined();
      expect(bot.brain!.skill).toBeGreaterThanOrEqual(lo);
      expect(bot.brain!.skill).toBeLessThanOrEqual(hi);
    }
  }
});
test("a difficulty change waits for the next startRound", () => {
  const world = createWorld(SHORT, "you", "ct", 5, 777, "normal");
  const bot = world.players.find((p) => p.bot)!;
  const before = bot.brain!.skill;
  setDifficulty(world, "hard");
  // Queued, not applied: the round already running keeps the hands it started with.
  expect(world.difficulty).toBe("normal");
  expect(bot.brain!.skill).toBe(before);
  startRound(world);
  expect(world.difficulty).toBe("hard");
  const { lo, hi } = skillBand("hard");
  expect(bot.brain!.skill).toBeGreaterThanOrEqual(lo);
  expect(bot.brain!.skill).toBeLessThanOrEqual(hi);
});
test("restyleBrain changes the hands but keeps the plan it already made", () => {
  const brain = makeBrain(0.9, 5);
  brain.path = [[100, 200, 0]];
  brain.step = 1;
  brain.site = "B";
  brain.targetId = 4;
  restyleBrain(brain, 3, "easy");
  const { lo, hi } = skillBand("easy");
  expect(brain.skill).toBeGreaterThanOrEqual(lo);
  expect(brain.skill).toBeLessThanOrEqual(hi);
  expect(brain.path).toEqual([[100, 200, 0]]);
  expect(brain.step).toBe(1);
  expect(brain.site).toBe("B");
  expect(brain.targetId).toBe(4);
});
test("the card describes a real training run", () => {
  expect(CARD.envSteps).toBeGreaterThan(1_000_000);
  expect(CARD.updates).toBeGreaterThan(0);
  expect(CARD.duels).toBeGreaterThan(0);
  expect(CARD.winRate).toBeGreaterThanOrEqual(0);
  expect(CARD.winRate).toBeLessThanOrEqual(100);
  expect(CARD.trainedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
});
// --- the round's plan -----------------------------------------------------
/**
 * A round played out headlessly: every player, the person's slot included, is
 * driven by the same bot code, so this is a real round with nobody watching.
 * Three a side and a half-minute clock: the whole suite is a few seconds, and
 * a full 1:55 round with ten players in it is most of one on its own.
 */
const RULES = { ...SHORT, freezeTime: 0.5, roundTime: 30 };
function playRound(seed: number, teamSize = 3): { planted: boolean; left: number } {
  const world = createWorld(RULES, "you", "ct", teamSize, seed);
  for (let t = 0; t < 64 * 70; t++) {
    update(world, 1 / 64, botThink(world, world.me, 1 / 64));
    if (world.bomb.state === "planted") return { planted: true, left: world.match.timer };
    if (world.match.phase === "over" || world.match.phase === "match_over") break;
  }
  return { planted: false, left: 0 };
}
test("a side walks in together: every terrorist reads the round's own site", () => {
  const world = createWorld(SHORT, "you", "ct", 5, 20240);
  for (let t = 0; t < 4; t++) for (const p of world.players) if (p.bot) botThink(world, p, 1 / 64);
  const ts = world.players.filter((p) => p.team === "t" && p.bot);
  expect(ts.length).toBe(5);
  for (const t of ts) expect(t.brain?.site).toBe(world.plan.push);
  // And the defence covers both sites rather than all standing on one.
  const cts = world.players.filter((p) => p.team === "ct" && p.bot).map((p) => p.brain?.site);
  expect(new Set(cts).size).toBe(2);
});
test("the carrier gets the bomb down inside the round clock", () => {
  const seeds = [11, 23, 37, 51, 67, 83, 97, 113, 131, 149];
  const planted = seeds.filter((seed) => playRound(seed).planted);
  // Not every round: a carrier that loses the fight on the way is a round the
  // terrorists lost, and that is allowed to happen. Half of them, though —
  // where the code this replaced planted in none of these, because a bot that
  // rolled its own site never arrived anywhere with anybody. Ten seeds rather
  // than five because the rate this is asking about is only about 54% (that is
  // `scripts/measure.ts` over 177 rounds, before and after the bots could
  // hear), and five rounds cannot tell 54% from a bad afternoon.
  expect(planted.length).toBeGreaterThanOrEqual(5);
}, 10_000); // ten rounds played out headlessly, twice the default timeout for a slower box
test("a bomb on the floor is still picked up by a living terrorist", () => {
  const world = createWorld(RULES, "you", "ct", 1, 4242);
  world.match.phase = "live";
  const bot = world.players.find((p) => p.team === "t") as Player;
  world.me.pos = [DE_FORGE.sites.A[0], DE_FORGE.sites.A[1], 2]; // out of the way, and out of sight
  bot.team = "t";
  bot.hasBomb = false;
  world.bomb = { ...world.bomb, state: "dropped", pos: [bot.pos[0] + 240, bot.pos[1], bot.pos[2] + 4] };
  for (let t = 0; t < 64 * 6 && world.bomb.state === "dropped"; t++) update(world, 1 / 64, NO_INPUT);
  expect(world.bomb.state).toBe("carried");
  expect(bot.hasBomb).toBe(true);
});
// --- picking a gun up off the floor ----------------------------------------
test("a bot with an empty primary slot detours to a rifle a few steps off its path", () => {
  const world = createWorld(RULES, "you", "t", 1, 4242);
  world.match.phase = "live";
  const bot = world.players.find((p) => p.team === "ct") as Player;
  world.me.alive = false; // nothing for it to fight, nothing to flee
  expect(bot.primary).toBeNull(); // an eco round: too little money to have bought one
  world.pickups.push({
    weapon: "m4a4", pos: [bot.pos[0] + 80, bot.pos[1], bot.pos[2] + 4], ammo: { mag: 30, reserve: 90 },
  });
  for (let t = 0; t < 64 * 6 && bot.primary === null; t++) update(world, 1 / 64, NO_INPUT);
  expect(bot.primary).toBe("m4a4");
});
test("a bot already holding a primary never diverts for one on the floor", () => {
  const world = createWorld(SHORT, "you", "ct", 1, 1);
  const bot = world.players[1] as Player;
  bot.primary = "ak47";
  world.pickups.push({
    weapon: "m4a4", pos: [bot.pos[0] + 10, bot.pos[1], bot.pos[2]], ammo: { mag: 30, reserve: 90 },
  });
  const goal: [number, number, number] = [123, 456, 0];
  expect(gunGoal(world, bot, goal)).toBe(goal);
});
test("a rifle across the map is not worth crossing for", () => {
  const world = createWorld(SHORT, "you", "ct", 1, 1);
  const bot = world.players[1] as Player;
  bot.primary = null;
  bot.pos = [0, 0, 2];
  world.pickups.push({ weapon: "ak47", pos: [4000, 4000, 2], ammo: { mag: 30, reserve: 90 } });
  const goal: [number, number, number] = [100, 0, 2];
  expect(gunGoal(world, bot, goal)).toBe(goal);
});
test("an empty pickups list leaves the goal it was given untouched", () => {
  const world = createWorld(SHORT, "you", "ct", 1, 1);
  const bot = world.players[1] as Player;
  bot.primary = null;
  const goal: [number, number, number] = [123, 456, 0];
  expect(world.pickups.length).toBe(0);
  expect(gunGoal(world, bot, goal)).toBe(goal); // same reference: nothing was computed
});
// --- the radio ------------------------------------------------------------
/**
 * A side thinking with nobody to shoot at: the enemy is taken out of the world
 * so every bot takes the walking branch, which is the one that reads the plan.
 * The person is a terrorist here, so the terrorists are the side that hears.
 */
function quietSide(seed: number): { world: ReturnType<typeof createWorld>; carrier: Player } {
  const world = createWorld(SHORT, "you", "t", 5, seed);
  world.match.phase = "live";
  for (const p of world.players) {
    if (p.team === "ct") p.alive = false;
    p.hasBomb = false;
  }
  const carrier = world.players.find((p) => p.team === "t" && p.bot) as Player;
  carrier.hasBomb = true;
  return { world, carrier };
}
const thinkAll = (world: ReturnType<typeof createWorld>): void => {
  for (const p of world.players) if (p.bot && p.alive) botThink(world, p, 1 / 64);
};
test("a bot carrying the bomb obeys a call exactly as it obeys the plan", () => {
  const { world, carrier } = quietSide(20240);
  thinkAll(world);
  expect(carrier.brain?.site).toBe(world.plan.push);
  expect(carrier.brain?.goal).toEqual(DE_FORGE.sites[world.plan.push]);
  const called = otherSite(world.plan.push);
  world.time += 1;
  radioCall(world, called);
  thinkAll(world); // the next tick, and the bomb is already walking the other way
  expect(carrier.brain?.site).toBe(called);
  expect(carrier.brain?.goal).toEqual(DE_FORGE.sites[called]);
});
test("the four teammates turn round on the call, and the other side never hears it", () => {
  const { world } = quietSide(4242);
  thinkAll(world);
  const called = otherSite(world.plan.push);
  world.time += 1;
  radioCall(world, called);
  thinkAll(world);
  const ts = world.players.filter((p) => p.team === "t" && p.bot);
  expect(ts.length).toBe(4);
  for (const t of ts) expect(t.brain?.site).toBe(called);
  // The counter-terrorists were never told anything: their brains still read
  // the roll, split across the two sites exactly as they were.
  for (const ct of world.players.filter((p) => p.team === "ct")) ct.alive = true;
  thinkAll(world);
  const cts = world.players.filter((p) => p.team === "ct").map((p) => p.brain?.site);
  expect(new Set(cts).size).toBe(2);
});
test("a call expires and the side goes back to the plan it rolled", () => {
  const { world, carrier } = quietSide(1234);
  const called = otherSite(world.plan.push);
  radioCall(world, called);
  thinkAll(world);
  expect(carrier.brain?.site).toBe(called);
  world.time += CALL_LIFE + 1;
  thinkAll(world);
  expect(carrier.brain?.site).toBe(world.plan.push);
});
test("hold stops the push and leaves nobody standing still in the open", () => {
  const { world, carrier } = quietSide(777);
  thinkAll(world);
  const site = DE_FORGE.sites[world.plan.push];
  expect(dist2d(carrier.pos, carrier.brain?.goal ?? [0, 0, 0])).toBeGreaterThan(600);
  world.time += 1;
  radioCall(world, "hold");
  thinkAll(world);
  for (const t of world.players.filter((p) => p.team === "t" && p.bot)) {
    const goal = t.brain?.goal as [number, number, number];
    // Where it stands, not where the plan was taking it — and a goal it can
    // still walk to, so a held bot repositions rather than freezing.
    expect(t.brain?.site).toBe(world.plan.push); // hold does not move the site
    expect(dist2d(t.pos, goal)).toBeLessThanOrEqual(360);
    expect(dist2d(goal, site)).toBeGreaterThan(600);
    expect(t.brain?.path.length).toBeGreaterThan(0);
  }
});
test("a call outranks the rotation a counter-terrorist would have made on its own", () => {
  // The person is a counter-terrorist — the side the menu picks by default —
  // and one of their teammates has just died at B. That is the contact the
  // defence rotates to on its own, and it is exactly what a person who has
  // seen something at A is calling against.
  const world = createWorld(SHORT, "you", "ct", 5, 31);
  world.match.phase = "live";
  for (const p of world.players) if (p.team === "t") p.alive = false;
  const cts = world.players.filter((p) => p.team === "ct" && p.bot);
  const fallen = cts[0] as Player;
  fallen.alive = false;
  fallen.pos = [...DE_FORGE.sites.B] as [number, number, number];
  world.feed.push({
    at: world.time, killer: "them", killerId: 9, victim: fallen.name, victimId: fallen.id,
    weapon: "ak47", headshot: false, killerTeam: "t",
  });
  const standing = cts.filter((p) => p.alive);
  const near = (p: Player, site: "A" | "B"): number =>
    dist2d(p.brain?.goal ?? [0, 0, 0], DE_FORGE.sites[site]);
  thinkAll(world);
  // Without a word said, every one of them is on its way to the contact.
  for (const ct of standing) expect(near(ct, "B")).toBeLessThan(400);
  world.time += 1;
  radioCall(world, "A");
  thinkAll(world);
  for (const ct of standing) {
    expect(ct.brain?.site).toBe("A");
    expect(near(ct, "A")).toBeLessThan(400);
  }
  // And when the call runs out, the side reads the round for itself again.
  world.time += CALL_LIFE + 1;
  thinkAll(world);
  for (const ct of standing) expect(near(ct, "B")).toBeLessThan(400);
});
// --- the clock ------------------------------------------------------------
/**
 * The terrorists walking in with the bomb and the clock wherever the test puts
 * it, with one counter-terrorist standing in front of the carrier so that the
 * branch every terrorist is in is the fight — the one that trades ground for a
 * duel. Nothing is planted, and the person is a terrorist so that their side
 * is the one the radio reaches.
 */
function underFire(secondsLeft: number, seed = 20240): {
  world: ReturnType<typeof createWorld>; carrier: Player; enemy: Player;
} {
  const world = createWorld(SHORT, "you", "t", 3, seed);
  world.match.phase = "live";
  world.match.timer = secondsLeft;
  const carrier = world.players.find((p) => p.team === "t" && p.bot && p.hasBomb) as Player;
  const enemy = world.players.find((p) => p.team === "ct") as Player;
  for (const p of world.players) if (p.team === "ct" && p.id !== enemy.id) p.alive = false;
  // Close enough to be unmissable, and the carrier already looking at it.
  enemy.pos = [carrier.pos[0] + 160, carrier.pos[1], carrier.pos[2]];
  carrier.yaw = aimAt(carrier, bodyCentre(enemy)).yaw;
  return { world, carrier, enemy };
}
test("with the clock low and no plant, a terrorist's feet go to the site", () => {
  const { world, carrier } = underFire(25);
  botThink(world, carrier, 1 / 64);
  expect(carrier.brain?.targetId).not.toBeNull(); // it really is in a fight
  // The policy still has the gun; the plan has taken the feet, and they are
  // walking to the site the round rolled.
  expect(carrier.brain?.goal).toEqual(DE_FORGE.sites[carrier.brain!.site]);
  expect(carrier.brain?.path.length).toBeGreaterThan(0);
});
test("with the clock high the same fight is the policy's to move", () => {
  const { world, carrier } = underFire(110);
  botThink(world, carrier, 1 / 64);
  expect(carrier.brain?.targetId).not.toBeNull(); // the same fight, one number apart
  expect(carrier.brain?.goal).toBeNull(); // nothing asked the plan for a path
});
test("the escort feels the clock too, not just the bot holding the bomb", () => {
  const { world, carrier } = underFire(25);
  const escort = world.players.find((p) => p.team === "t" && p.bot && p.id !== carrier.id) as Player;
  escort.pos = [...carrier.pos] as [number, number, number];
  escort.yaw = carrier.yaw;
  botThink(world, escort, 1 / 64);
  expect(escort.brain?.targetId).not.toBeNull();
  expect(dist2d(escort.brain?.goal ?? [0, 0, 0], DE_FORGE.sites[escort.brain!.site])).toBeLessThan(400);
});
test("a call is answered on a hard push: the push goes where the person said", () => {
  const { world, carrier } = underFire(25);
  const called = otherSite(world.plan.push);
  world.time += 1;
  radioCall(world, called);
  botThink(world, carrier, 1 / 64);
  expect(carrier.brain?.site).toBe(called);
  expect(carrier.brain?.goal).toEqual(DE_FORGE.sites[called]);
});
test("hold outranks the clock: a bot told to stand still is not dragged off", () => {
  const { world, carrier } = underFire(25);
  world.time += 1;
  radioCall(world, "hold");
  botThink(world, carrier, 1 / 64);
  expect(carrier.brain?.holding).toBe(true);
  // It fights where it was told to stand: nothing asked the plan for a path
  // to the site, which is what the same clock does to a bot nobody called.
  expect(carrier.brain?.goal).toBeNull();
});
test("once the bomb is down the clock stops moving the terrorists' feet", () => {
  const { world, carrier } = underFire(25);
  // The same round one moment later: the bomb is on the floor at the site and
  // the carrier is in the fight it was already in.
  world.bomb = {
    ...world.bomb,
    state: "planted",
    pos: [...DE_FORGE.sites[carrier.brain?.site ?? "A"]] as [number, number, number],
  };
  carrier.hasBomb = false;
  botThink(world, carrier, 1 / 64);
  expect(carrier.brain?.targetId).not.toBeNull();
  // There is nothing left to be late for. Time pressure is off, so nothing
  // walks a terrorist at the bomb in the middle of a duel it is having —
  // holding near a planted bomb is not the same thing as standing on it.
  expect(carrier.brain?.goal).toBeNull();
});
/** The defence with nothing to shoot at and nothing on the floor to defend. */
function quietDefence(secondsLeft: number, seed = 31): ReturnType<typeof createWorld> {
  const world = createWorld(SHORT, "you", "ct", 3, seed);
  world.match.phase = "live";
  world.match.timer = secondsLeft;
  for (const p of world.players) if (p.team === "t") p.alive = false;
  return world;
}
const defenders = (world: ReturnType<typeof createWorld>): Player[] =>
  world.players.filter((p) => p.team === "ct" && p.bot);
test("with the clock low and no plant, the defence stops holding and goes looking", () => {
  const late = quietDefence(HUNT_AT - 1);
  thinkAll(late);
  for (const ct of defenders(late)) {
    const goal = ct.brain?.goal ?? [0, 0, 0];
    // Nobody has come to the corner it was sitting in, so it walks at the half
    // of the map the terrorists came from — and it walks, rather than teleports.
    expect(dist2d(goal, DE_FORGE.muster.t)).toBeLessThan(1000);
    expect(dist2d(goal, DE_FORGE.sites[ct.brain!.site])).toBeGreaterThan(2000);
    expect(ct.brain?.path.length).toBeGreaterThan(0);
  }
  const early = quietDefence(HUNT_AT + 1);
  thinkAll(early);
  for (const ct of defenders(early)) {
    expect(dist2d(ct.brain?.goal ?? [0, 0, 0], DE_FORGE.sites[ct.brain!.site])).toBeLessThan(400);
  }
});
test("the defence leaves its angle the tick the clock says so, not at the next repath", () => {
  const world = quietDefence(HUNT_AT + 10);
  thinkAll(world);
  const holding = defenders(world).map((ct) => {
    const brain = ct.brain as NonNullable<Player["brain"]>;
    // A path it is part-way through and a repath it is nowhere near due for:
    // nothing about this bot is stale, which is the whole point of the test.
    expect(dist2d(brain.goal ?? [0, 0, 0], DE_FORGE.sites[brain.site])).toBeLessThan(400);
    expect(brain.path.length).toBeGreaterThan(0);
    expect(brain.step).toBeLessThan(brain.path.length);
    expect(world.time).toBeLessThan(brain.repathAt);
    return { ct, brain, plannedFor: brain.plannedFor };
  });
  expect(holding.length).toBeGreaterThan(0);
  // Eleven seconds of clock and not a tick of anything else. The objective it
  // planned for has to say it is hunting, or the defence sits on its angle for
  // the rest of its repath window with the round running out.
  world.match.timer = HUNT_AT - 1;
  thinkAll(world);
  for (const { brain, plannedFor } of holding) {
    expect(brain.plannedFor).not.toBe(plannedFor);
    expect(dist2d(brain.goal ?? [0, 0, 0], DE_FORGE.muster.t)).toBeLessThan(1000);
  }
});
test("a call turns a rotating defender round inside its repath window", () => {
  // The person is a counter-terrorist, a teammate has just died at B, and the
  // side is rotating there on its own. The person calls A — which is the site
  // this bot was rolled onto anyway, so nothing about its orders changes
  // except that a person said them.
  const world = quietDefence(SHORT.roundTime); // nothing hunting at this clock
  const fallen = defenders(world)[0] as Player;
  fallen.alive = false;
  fallen.pos = [...DE_FORGE.sites.B] as [number, number, number];
  world.feed.push({
    at: world.time, killer: "them", killerId: 9, victim: fallen.name, victimId: fallen.id,
    weapon: "ak47", headshot: false, killerTeam: "t",
  });
  thinkAll(world);
  const rotated = defenders(world).filter((p) => p.alive && p.brain?.site === "A");
  expect(rotated.length).toBeGreaterThan(0);
  for (const ct of rotated) {
    expect(dist2d(ct.brain?.goal ?? [0, 0, 0], DE_FORGE.sites.B)).toBeLessThan(400);
    expect(world.time).toBeLessThan(ct.brain!.repathAt); // the path is fresh
  }
  radioCall(world, "A");
  thinkAll(world);
  for (const ct of rotated) {
    expect(ct.brain?.site).toBe("A"); // the call named the site it already had
    expect(dist2d(ct.brain?.goal ?? [0, 0, 0], DE_FORGE.sites.A)).toBeLessThan(400);
  }
});
test("a bomb on the floor is what the defence is for: no hunt once it is planted", () => {
  const world = quietDefence(HUNT_AT - 1);
  world.bomb = { ...world.bomb, state: "planted", pos: [...DE_FORGE.sites.A] as [number, number, number] };
  thinkAll(world);
  for (const ct of defenders(world)) {
    expect(dist2d(ct.brain?.goal ?? [0, 0, 0], DE_FORGE.sites.A)).toBeLessThan(200);
  }
});
test("a defender told to hold keeps holding however low the clock is", () => {
  const world = quietDefence(HUNT_AT - 1);
  world.time += 1;
  radioCall(world, "hold");
  thinkAll(world);
  for (const ct of defenders(world)) {
    expect(ct.brain?.holding).toBe(true);
    expect(dist2d(ct.pos, ct.brain?.goal ?? [0, 0, 0])).toBeLessThanOrEqual(360);
  }
});
// --- callouts -------------------------------------------------------------
/**
 * One teammate and one enemy, six cells apart down mid with nothing between
 * them, and two more players parked out of the way at the far end of the map.
 * The teammate is looking straight at the enemy, so `pickTarget`'s own trace
 * is what decides whether it can see anything — nothing here is handed to it.
 */
function squad(seed = 4114): { world: World; mate: Player; foe: Player } {
  const world = createWorld(COMPETITIVE, "you", "ct", 2, seed);
  world.match.phase = "live";
  const mate = world.players.find((p) => p.bot && p.team === "ct") as Player;
  const foe = world.players.find((p) => p.team === "t") as Player;
  for (const p of world.players) {
    if (p === mate || p === foe) continue;
    p.pos = [DE_FORGE.sites.B[0], DE_FORGE.sites.B[1], 2];
  }
  mate.pos = [...worldOf(DE_FORGE, 22, 14, 2)];
  foe.pos = [...worldOf(DE_FORGE, 22, 20, 2)];
  mate.brain = makeBrain(1, 99);
  mate.brain.reset = false;
  mate.yaw = aimAt(mate, bodyCentre(foe)).yaw;
  return { world, mate, foe };
}
const callouts = (world: World): string[] =>
  world.messages.filter((m) => m.by !== undefined).map((m) => m.text);
/** Let `bot` think for `seconds` of ticks, the way a round would. */
const thinkFor = (world: World, bot: Player, seconds: number): void => {
  for (let t = 0; t < 64 * seconds; t++) {
    botThink(world, bot, 1 / 64);
  world.me.alive = false; // nothing to fight: this is about the walking
  // The bomb, dropped on top of a crate in mid.
  world.bomb.state = "dropped";
  world.bomb.pos = worldOf(DE_FORGE, 21, 18, 0);
  const before = dist(bot.pos, world.bomb.pos);
  for (let tick = 0; tick < 64 * 3; tick++) {
    world.time += 1 / 64;
    applyInput(world, bot, botThink(world, bot, 1 / 64), 1 / 64);
  }
  expect(dist(bot.pos, world.bomb.pos)).toBeLessThan(before - 200);
});
test("a flashed bot keeps its policy and loses its hands: slower, wilder, later, blinder", () => {
  const { world, me, bot } = duel();
  const brain = bot.brain!;
  const clear = flashed(bot, brain);
  // Unflashed it is exactly the skill it always was — the same numbers, to the
  // bit, which is why every pinned run in this repository is untouched by this.
  expect(blindness(bot)).toBe(0);
  expect(clear.aimSpeed).toBe(brain.aimSpeed);
  expect(clear.aimError).toBe(brain.aimError);
  expect(clear.reaction).toBe(brain.reaction);
  expect(clear.grip).toBe(brain.grip);
  bot.blind = FLASH.flash.maxBlind;
  const hit = flashed(bot, brain);
  expect(blindness(bot)).toBe(1);
  expect(hit.aimSpeed).toBeCloseTo(brain.aimSpeed * 0.2, 6);
  expect(hit.aimError).toBeCloseTo(brain.aimError * 7, 6);
  expect(hit.reaction).toBeCloseTo(brain.reaction * 4, 6);
  expect(hit.sight).toBeLessThan(clear.sight);
  // And it holds none of its spray: a pair of hands that cannot see the gun
  // cannot ride the pattern either.
  expect(hit.grip).toBe(0);
  // Half way through the flash it is half of each: the number in the world is
  // the only thing that decides, and it is the same one the HUD paints.
  bot.blind = FLASH.flash.maxBlind / 2;
  expect(flashed(bot, brain).aimSpeed).toBeCloseTo(brain.aimSpeed * 0.6, 6);
  // Its head is untouched: the observation, the heads and the weights know
  // nothing about any of this.
  expect(OBS_SIZE).toBe(33);
  expect(brain.obs.length).toBe(OBS_SIZE);
});
test("a flashed bot turns slower and shoots later than the same bot unflashed", () => {
  const turn = (blind: number): number => {
    const { world, me, bot } = duel();
    bot.blind = blind;
    bot.yaw = 90; // ninety degrees off the target
    let fired = 0;
    for (let t = 0; t < 64; t++) {
      const input = botThink(world, bot, 1 / 64);
      world.time += 1 / 64;
      if (input.fire) fired += 1;
    }
    return Math.abs(bot.yaw - 90) - fired * 1e-6;
  };
  // A second of the same duel, from the same seed, with and without a flash on
  // it: the blinded one has come nowhere near as far round towards the shot.
  expect(turn(FLASH.flash.maxBlind)).toBeLessThan(turn(0));
  // And a bot blinded at the far end of the map does not pick a fight it cannot
  // see: its sight shrinks with the blindness.
  const blinded = duel();
  blinded.bot.blind = FLASH.flash.maxBlind;
  botThink(blinded.world, blinded.bot, 1 / 64);
  expect(flashed(blinded.bot, blinded.bot.brain!).sight).toBeLessThan(500);
  expect(blinded.bot.brain!.targetId).toBe(null);
  // The same bot, the same room, the same enemy five hundred units away, with
  // its eyes working: it picks the fight it just could not see.
  const seeing = duel();
  botThink(seeing.world, seeing.bot, 1 / 64);
  expect(seeing.bot.brain!.targetId).toBe(seeing.me.id);
});
/**
 * A duel where both of them are standing somewhere de_forge actually has a
 * floor, five hundred units apart down a clear line. The tests below step the
 * movement as well as the thinking, so where they stand has to be real.
 */
const standoff = (): ReturnType<typeof duel> => {
  const d = duel();
  d.me.pos = [-448, 2496, 2];
  d.bot.pos = [64, 2496, 2];
  d.bot.yaw = aimAt(d.bot, bodyCentre(d.me)).yaw;
  return d;
};
test("a teammate that can see an enemy says where it is", () => {
  const { world, mate, foe } = squad();
  botThink(world, mate, 1 / 64);
  expect(callouts(world)).toEqual([`${mate.name}: enemy — ${placeAt(DE_FORGE, foe.pos)}`]);
  expect(world.messages[world.messages.length - 1]?.by).toBe(mate.id);
/** Step a duel for `ticks`, counting the shots the bot actually got out. */
const fight = (d: ReturnType<typeof duel>, ticks: number): number => {
  let shots = 0;
  for (let t = 0; t < ticks; t++) {
    const input = botThink(d.world, d.bot, 1 / 64);
    const before = d.bot.lastShotAt;
    applyInput(d.world, d.bot, input, 1 / 64);
    if (d.bot.lastShotAt !== before) shots += 1;
    d.world.time += 1 / 64;
  }
  return shots;
};
test("a gun is dry only with nothing behind it, and a knife never is", () => {
  const { bot } = duel();
  bot.primary = "ak47";
  bot.weapon = "ak47";
  bot.ammo.ak47 = { mag: 30, reserve: 90 };
  expect(dry(bot, "ak47")).toBe(false);
  expect(nextWeapon(bot)).toBe(null);
  // An empty magazine with a spare behind it is a reload, not a swap.
  bot.ammo.ak47 = { mag: 0, reserve: 90 };
  expect(dry(bot, "ak47")).toBe(false);
  expect(nextWeapon(bot)).toBe(null);
  // Nothing anywhere: the pistol, then the knife, and then nothing more.
  bot.ammo.ak47 = { mag: 0, reserve: 0 };
  expect(dry(bot, "ak47")).toBe(true);
  expect(nextWeapon(bot)).toBe(bot.secondary);
  bot.ammo[bot.secondary] = { mag: 0, reserve: 0 };
  expect(nextWeapon(bot)).toBe("knife");
  bot.weapon = "knife";
  expect(dry(bot, "knife")).toBe(false);
  expect(nextWeapon(bot)).toBe(null);
});
test("a teammate with nothing in view says nothing", () => {
  const { world, mate, foe } = squad();
  // The same two players, with the whole map between them: b site cannot be
  // seen from mid, and `pickTarget` is the thing that finds that out.
  foe.pos = [DE_FORGE.sites.B[0], DE_FORGE.sites.B[1], 2];
  thinkFor(world, mate, 3);
  expect(callouts(world)).toEqual([]);
test("a bot that has fired its rifle dry draws its pistol and keeps fighting", () => {
  const d = standoff();
  d.bot.primary = "ak47";
  d.bot.weapon = "ak47";
  d.bot.ammo.ak47 = { mag: 0, reserve: 0 }; // it spent the round's ammunition
  const shots = fight(d, 192);
  // Before this it held the trigger down on an empty rifle for the rest of the
  // round: `shoot` refuses without a round in the magazine and `reload` refuses
  // with nothing to reload from, so nobody was ever hit.
  expect<WeaponId>(d.bot.weapon).toBe(d.bot.secondary);
  expect(shots).toBeGreaterThan(0);
  expect(d.me.health).toBeLessThan(100);
});
test("a teammate does not say the same thing twice in a row", () => {
  const { world, mate } = squad();
  botThink(world, mate, 1 / 64);
  expect(callouts(world).length).toBe(1);
  // Half a minute of staring down the same corridor at the same enemy: the
  // sighting was news once, and the rate limit and the contact edge between
  // them keep it at once.
  thinkFor(world, mate, 30);
  expect(callouts(world).length).toBe(1);
test("a bot with nothing left to fire closes the distance and knifes", () => {
  const d = standoff();
  d.bot.primary = "ak47";
  d.bot.weapon = "ak47";
  d.bot.ammo.ak47 = { mag: 0, reserve: 0 };
  d.bot.ammo[d.bot.secondary] = { mag: 0, reserve: 0 };
  const started = dist(d.bot.pos, d.me.pos);
  const shots = fight(d, 384);
  expect<WeaponId>(d.bot.weapon).toBe("knife");
  expect(dist(d.bot.pos, d.me.pos)).toBeLessThan(started); // it walked in
  expect(shots).toBeGreaterThan(0);
  expect(d.me.health).toBeLessThan(100);
});
test("nothing the other side's bots know ever reaches the person's feed", () => {
  const { world, mate, foe } = squad();
  // The enemy looking straight back down the same corridor, for as long as
  // the teammate looked down it.
  foe.brain = makeBrain(1, 77);
  foe.brain.reset = false;
  foe.yaw = aimAt(foe, bodyCentre(mate)).yaw;
  mate.pos = [DE_FORGE.sites.B[0], DE_FORGE.sites.B[1], 2]; // and the teammate out of it
  thinkFor(world, foe, 30);
  expect(callouts(world)).toEqual([]);
test("a bot pays the deploy time too: no bot bypasses the timer", () => {
  const d = standoff();
  d.bot.primary = "ak47";
  d.bot.weapon = "ak47";
  d.bot.ammo.ak47 = { mag: 0, reserve: 0 };
  // A bot switches the way a person does — `input.switchTo` into `applyInput`
  // — so it goes through exactly the same clock. Its pistol is a Glock (it is
  // a T here) and CS's 0.7 s is 45 whole ticks at 64 Hz.
  let swappedAt = -1;
  let firstShot = -1;
  for (let t = 0; t < 192; t++) {
    const input = botThink(d.world, d.bot, 1 / 64);
    const holding: WeaponId = d.bot.weapon;
    const before = d.bot.lastShotAt;
    applyInput(d.world, d.bot, input, 1 / 64);
    if (swappedAt < 0 && d.bot.weapon !== holding) swappedAt = t;
    if (firstShot < 0 && d.bot.lastShotAt !== before) firstShot = t;
    d.world.time += 1 / 64;
  }
  expect<WeaponId>(d.bot.weapon).toBe(d.bot.secondary);
  expect(swappedAt).toBeGreaterThanOrEqual(0);
  expect(firstShot).toBeGreaterThan(swappedAt);
  expect(deployTicks(WEAPONS[d.bot.secondary], 1 / 64)).toBe(45);
  // The empty rifle's trigger sent nothing before the swap either, so the first
  // shot of the round is the pistol's, and it is not one tick earlier than 45.
  expect(firstShot - swappedAt).toBeGreaterThanOrEqual(45);
});
test("a round restart clears the callouts and leaves the round's own line", () => {
  const { world, mate, foe } = squad();
  botThink(world, mate, 1 / 64);
  expect(callouts(world).length).toBe(1);
  world.messages.push({ at: world.time, text: "Terrorists win — detonated the bomb" });
  startRound(world);
  expect(callouts(world)).toEqual([]);
  expect(world.messages.map((m) => m.text)).toEqual(["Terrorists win — detonated the bomb"]);
  // And the side starts the round with nothing already said, so the first
  // sighting of it is news again.
test("a bot with bullets left plays exactly as it did: no swap, no knife", () => {
  const d = standoff();
  d.bot.primary = "ak47";
  d.bot.weapon = "ak47";
  d.bot.ammo.ak47 = { mag: 30, reserve: 90 };
  const shots = fight(d, 192);
  expect(d.bot.weapon).toBe("ak47");
  expect(shots).toBeGreaterThan(0);
});
// --- the round's plan -------------------------------------------------------
const planned = (over: Partial<TeamPlan> = {}): RoundPlan => ({
  round: 1,
  source: "typesafe",
  model: "jev-1",
  t: { site: "A", shape: "stack", tempo: 2, save: false, ...over },
  ct: { site: "A", shape: "stack", tempo: 2, save: false, ...over },
});
/** A full ten-bot round, frozen on the first tick, with every brain made. */
const round = (seed = 77): ReturnType<typeof createWorld> => {
  const world = createWorld(DE_FORGE, COMPETITIVE, "you", "ct", 5, seed);
  world.match.phase = "freeze";
  return world;
};
const bots = (world: ReturnType<typeof createWorld>, team: "t" | "ct"): Player[] =>
  world.players.filter((p) => p.team === team && p !== world.me);
test("with no plan a bot is what it always was: its own coin flip, no wait", () => {
  const world = round();
  const bot = bots(world, "t")[0] as Player;
  botThink(world, bot, 1 / 64);
  expect(roundPlan(world)).toBeNull();
  expect(bot.brain?.job.role).toBe("support");
  expect(bot.brain?.job.delay).toBe(0);
  expect(["A", "B"]).toContain(bot.brain?.job.site ?? "");
});
test("a plan makes a team a team: one site between them, and one of them first", () => {
  const world = round();
  usePlan(world, planned({ site: "B" }));
  for (const bot of world.players) if (bot !== world.me) botThink(world, bot, 1 / 64);
  const attackers = bots(world, "t");
  expect(attackers.every((bot) => bot.brain?.job.site === "B")).toBe(true);
  expect(attackers.filter((bot) => bot.brain?.job.role === "entry")).toHaveLength(1);
  // The entry goes now and the rest give it its beat: that is the coordination.
  const entry = attackers.find((bot) => bot.brain?.job.role === "entry") as Player;
  expect(entry.brain?.job.delay).toBe(0);
  expect(attackers.some((bot) => (bot.brain?.job.delay ?? 0) > 0)).toBe(true);
});
test("a split sends the attackers to both sites at once", () => {
  const world = round();
  usePlan(world, planned({ site: "A", shape: "split" }));
  for (const bot of world.players) if (bot !== world.me) botThink(world, bot, 1 / 64);
  const sites = bots(world, "t").map((bot) => bot.brain?.job.site);
  expect(sites.filter((site) => site === "A").length).toBeGreaterThan(0);
  expect(sites.filter((site) => site === "B").length).toBeGreaterThan(0);
});
test("a bot waiting for its beat stands still, and goes when the beat comes", () => {
  const world = round();
  usePlan(world, planned());
  world.match.phase = "freeze";
  for (const bot of world.players) if (bot !== world.me) botThink(world, bot, 1 / 64);
  const waiting = bots(world, "t").find((bot) => (bot.brain?.job.delay ?? 0) > 0) as Player;
  waiting.hasBomb = false;
  world.match.phase = "live";
  mate.pos = [...worldOf(DE_FORGE, 22, 14, 2)];
  foe.pos = [...worldOf(DE_FORGE, 22, 20, 2)];
  mate.yaw = aimAt(mate, bodyCentre(foe)).yaw;
  botThink(world, mate, 1 / 64); // `reset` and all: this is the round's first tick
  expect(callouts(world).length).toBe(1);
  world.time += 0.5;
  const held = botThink(world, waiting, 1 / 64);
  expect(held.forward).toBe(0);
  expect(held.side).toBe(0);
  // Past the wait it moves off towards the site like any other bot.
  world.time = (waiting.brain?.pushAt ?? 0) + 0.1;
  const moving = botThink(world, waiting, 1 / 64);
  expect(Math.abs(moving.forward) + Math.abs(moving.side)).toBeGreaterThan(0);
});
test("a plan that says save is a round nothing is spent on a rifle", () => {
  const world = round();
  const bot = bots(world, "t")[0] as Player;
  bot.money = 2400;
  usePlan(world, planned({ save: true }));
  botBuy(world, bot);
  expect(bot.primary).toBeNull();
  expect(bot.money).toBe(2400);
  // The same money with the same plan, on a side that is not saving: it buys.
  const spending = round(78);
  const other = bots(spending, "t")[0] as Player;
  other.money = 2400;
  usePlan(spending, planned({ save: false }));
  botBuy(spending, other);
  expect(other.money).toBeLessThan(2400);
});
test("a plan that lands mid-round re-tasks the team it was cut for", () => {
  const world = round();
  usePlan(world, planned({ site: "A" }));
  for (const bot of world.players) if (bot !== world.me) botThink(world, bot, 1 / 64);
  expect(bots(world, "t").every((bot) => bot.brain?.job.site === "A")).toBe(true);
  usePlan(world, planned({ site: "B" }));
  for (const bot of world.players) if (bot !== world.me) botThink(world, bot, 1 / 64);
  expect(bots(world, "t").every((bot) => bot.brain?.job.site === "B")).toBe(true);
  expect(roundPlan(world)?.t.site).toBe("B");
});
@@ -7,68 +7,107 @@
 * The split is deliberate. The round's objective is a plan (go to a site, plant
 * the bomb, defuse it) and A* already solves it. The fight is a reflex, and a
 * reflex is what reinforcement learning is good at: src/rl trains this policy
 * on millions of duels in the same simulation you are playing, and the weights
 * it produces are in weights.ts.
 * on millions of duels in the same simulation you are playing.
 *
 * Between the two there is now a third thing, and it is the round: `usePlan`
 * hands the bots a `RoundPlan` — a site, a shape, a tempo and a save for each
 * side — and `src/plan/plan.ts` cuts it into one job per bot, so five attackers
 * arrive at one site together, or at two sites in two groups, instead of each
 * flipping its own coin. Where that plan came from is not this file's business:
 * the page asks its own server, and the server asks TypeSafe AI when it has a
 * key and answers with the local plan when it has not. Bots nobody planned for
 * — the arena's, the trainer's — behave exactly as they did before, down to the
 * coin flip, because `usePlan` was never called on them.
 *
 * Smoke is handled in the same layer, and deliberately not in the policy. A bot
 * cannot see through a cloud because `canSee` says so, which is one change in
 * one function and covers the shooting; what it cannot answer is the walking,
 * so `skirt` below bends the next step of a path around a cloud rather than
 * into it. Both are scripted, both are outside the network, and the shipped
 * weights are the same eight kilobytes they were.
 *
 * The weights are not in here and are not imported: they arrive as data. In a
 * browser `src/client/main.ts` downloads `weights.json` as this game's own
 * asset and calls `usePolicy` before Play is pressable; in Bun
 * `src/client/shipped.ts` reads the committed document and calls the same
 * function. So a second game with its own policy — or with none — is a
 * different caller of `usePolicy` and not a different copy of this file.
 */
import { decode, HEADS, STILL, type Intent } from "./action.ts";
import { fromOther, loudness, reported, type HeardName, type Maker } from "./hearing.ts";
import { angleDelta, clamp, dist, dist2d, rng, type Vec3 } from "./math.ts";
import { findPath, siteAt, walkable, colOf, rowOf } from "./map.ts";
import { observe, OBS_SIZE, type Memory } from "./observe.ts";
import { mustHunt, mustPush, ordersFor, worthTheDetour, type Site } from "./plan.ts";
import {
  forward, newActivations, sample, unpack, type Activations, type Policy,
} from "./policy.ts";
import { CARD, PACKED } from "./weights.ts";
import { WEAPONS, type WeaponId } from "./weapons.ts";
  angleDelta, clamp, dist, forward, newActivations, rng, sample,
  type Activations, type Policy, type Vec3,
} from "../engine/index.ts";
import { assign, DEFAULT_JOB, type Job, type RoundPlan } from "../plan/plan.ts";
import { colOf, findPath, rowOf, siteAt, walkable, worldOf, type Level } from "./level.ts";
import { CS_HULL } from "./movement.ts";
import { observe, OBS_SIZE, type Memory } from "./observe.ts";
import { SHAPE } from "./packed.ts";
import { ease, grip, gripRate, sprayPull } from "./spray.ts";
import { cloudRadius } from "./grenade.ts";
import { FLASH, WEAPONS, type WeaponId } from "./weapons.ts";
import { buy } from "./economy.ts";
import type { Input, Player, World } from "./world.ts";
import { aimAt, bodyCentre, buy, callout, canSee, NO_INPUT, pickupSlot } from "./world.ts";
import { aimAt, bodyCentre, canSee, NO_INPUT } from "./world.ts";
import { coverFrom } from "./cover.ts";
export { CARD };
/** The weights are unpacked once, the first time a bot needs to think. */
/**
 * The policy every bot in this process thinks with, put here once by whoever
 * got hold of one. There is one because there is one game: a bot's own skill
 * is what makes it easy or hard, not a network of its own.
 */
let learned: Policy | null = null;
/** What `policy()` says when nobody handed one in. */
export const NO_POLICY = "no policy: nothing has called usePolicy, so a bot has nothing to think with";
/** Hand the bots the policy they think with. `main.ts` at boot, `shipped.ts` in Bun. */
export function usePolicy(net: Policy): void {
  learned = net;
}
/**
 * The policy the bots think with. It throws rather than falling back to the
 * scripted fight: a round played against bots that quietly stopped being the
 * trained ones is the failure nobody would notice, and the browser never
 * reaches here anyway — Play is not pressable until the weights have arrived.
 */
export function policy(): Policy {
  if (learned === null) learned = unpack(PACKED);
  if (learned === null) throw new Error(NO_POLICY);
  return learned;
}
/** The policy decides at 16 Hz and holds it, exactly as it was trained. */
const SKIP = 4;
/**
 * How hard the opposition is. It is a band of skills, not one number — a side
 * still runs from fodder to uncomfortable at every setting, just a different
 * stretch of the same 0..1 scale `makeBrain` turns into hands.
 * Hand one world's bots the round they are playing. `main.ts` does this every
 * round: the local plan the moment the round starts, and the planned one if a
 * better one arrives while it is still that round.
 *
 * It is the world's and not this module's, unlike the policy above, because a
 * plan is one match's round and a policy is the whole game's: a plan in a
 * module would be one match's orders reaching the next match's bots, and the
 * arena's duels and the trainer's rounds — worlds nobody plans for — would be
 * playing whatever the last page happened to ask for.
 */
export type Difficulty = "easy" | "normal" | "hard";
export const DIFFICULTIES: readonly Difficulty[] = ["easy", "normal", "hard"];
export const DEFAULT_DIFFICULTY: Difficulty = "normal";
const DIFFICULTY_LABELS: Record<Difficulty, string> = { easy: "Easy", normal: "Normal", hard: "Hard" };
export const difficultyLabel = (difficulty: Difficulty): string => DIFFICULTY_LABELS[difficulty];
const BANDS: Record<Difficulty, { lo: number; hi: number }> = {
  easy: { lo: 0, hi: 0.35 },
  normal: { lo: 0.25, hi: 1 },
  hard: { lo: 0.55, hi: 1 },
};
/** A bot's place in its band, from its id — the same spread `brainOf` always used. */
function skillFor(id: number, difficulty: Difficulty): number {
  const { lo, hi } = BANDS[difficulty];
  const frac = ((id * 37) % 100) / 100;
  return clamp(lo + frac * (hi - lo), 0, 1);
export function usePlan(world: World, plan: RoundPlan | null): void {
  world.plan = plan;
}
/** The band itself, for anything — a test, a hint on the page — that needs its edges. */
export const skillBand = (difficulty: Difficulty): { lo: number; hi: number } => BANDS[difficulty];
/** The round this world's bots are playing, or null when nobody planned one. */
export const roundPlan = (world: World): RoundPlan | null => world.plan;
/** The policy decides at 16 Hz and holds it, exactly as it was trained. */
const SKIP = 4;
export type BotBrain = {
  skill: number; // 0 = fodder, 1 = uncomfortable
  reaction: number; // seconds between seeing and shooting
  aimSpeed: number; // degrees a second
  aimError: number; // degrees of standing error
  grip: number; // 0..1, the share of the spray pattern these hands pull back
  gripRate: number; // how fast that pull catches up, e-foldings a second
  /** Where the pull is holding the view right now: [yaw, pitch] degrees. */
  pull: [number, number];
  goal: Vec3 | null;
  path: Vec3[];
  step: number;
@@ -80,13 +119,14 @@
export type BotBrain = {
  strafe: number;
  strafeUntil: number;
  suspect: Vec3 | null;
  /** The world clock the last time this bot listened: what came after it is news. */
  heardAt: number;
  plannedFor: string;
  site: Site; // where the side is going: the round's plan, or what was called
  slot: number; // this bot's place in its side's list, counted when the round starts
  holding: boolean; // told to stop and defend where it stands rather than push
  ordered: boolean; // the site came from a person on the radio, not from the roll
  /** This bot's share of the round: a site, a role, a beat to wait, a spread. */
  job: Job;
  /** The plan the job was cut from, and the round it was cut for. */
  jobPlan: RoundPlan | null;
  jobRound: number;
  /** The clock the job's wait is up at. Set while the round is still frozen. */
  pushAt: number;
  reset: boolean;
  random: () => number;
  // What the policy needs to run, one set per bot so nothing is shared.
@@ -101,6 +141,15 @@
export type BotBrain = {
  jitterUntil: number;
  /** False runs the pre-policy fight: the arena's opponent and its baseline. */
  useLearned: boolean;
  /**
   * Where this bot is going to reload out of sight: the path from `coverFrom`,
   * null when there was nowhere to go, cut once per reload — `coverFor` is the
   * `reloadUntil` it was cut for — and `coverLook` is where the threat was.
   */
  cover: Vec3[] | null;
  coverStep: number;
  coverFor: number;
  coverLook: Vec3 | null;
};
export function makeBrain(skill: number, seed: number, useLearned = true): BotBrain {
@@ -109,13 +158,20 @@
export function makeBrain(skill: number, seed: number, useLearned = true): BotBr
    reaction: 0.5 - skill * 0.33,
    aimSpeed: 180 + skill * 620,
    aimError: 4.5 - skill * 3.6,
    grip: grip(skill),
    gripRate: gripRate(skill),
    pull: [0, 0],
    goal: null, path: [], step: 0, repathAt: 0,
    targetId: null, seenAt: 0, burstUntil: 0, restUntil: 0,
    strafe: 0, strafeUntil: 0, suspect: null, heardAt: 0, plannedFor: "",
    site: "A", slot: 0, holding: false, ordered: false, reset: true,
    strafe: 0, strafeUntil: 0, suspect: null, plannedFor: "",
    job: DEFAULT_JOB, jobPlan: null, jobRound: -1, pushAt: 0,
    reset: true,
    random: rng(seed),
    obs: new Float32Array(OBS_SIZE),
    activations: newActivations(PACKED.shape),
    // Sized from the shape the game asks for rather than from a policy: a
    // brain is made before any weights have arrived, and the two agree because
    // `parsePacked` refuses a document of any other shape.
    activations: newActivations(SHAPE),
    actions: new Int32Array(HEADS.length),
    memory: { sinceSeen: 9 },
    intent: { ...STILL },
@@ -124,12 +180,95 @@
export function makeBrain(skill: number, seed: number, useLearned = true): BotBr
    jitterApplied: 0,
    jitterUntil: 0,
    useLearned,
    cover: null,
    coverStep: 0,
    coverFor: -1,
    coverLook: null,
  };
}
// --- blinded --------------------------------------------------------------
/**
 * How badly this bot is flashed, 0 to 1: the seconds of blindness it has left
 * over the ceiling a flash can hand out. A bot does not see a white screen —
 * there is no screen — so what a flash costs it is written here, in the same
 * skill layer its reaction and its shaky hands already live in.
 *
 * Not flashed, this is exactly 0 and every number below is multiplied by
 * exactly 1, which is why an unflashed bot plays the same game to the bit and
 * the training arena's digest does not move for any of this.
 */
export const blindness = (bot: Player): number => clamp(bot.blind / FLASH.flash.maxBlind, 0, 1);
/**
 * What a flash leaves a bot with. Fully blind it turns at a fifth of its usual
 * speed, its hands wander seven times as far off centre, it takes four times as
 * long to decide to shoot at all, it holds none of its spray pattern, and it
 * only notices an enemy inside a twelfth of its usual sight — which is roughly
 * what a person flashed in the face does, and is the whole of the disadvantage.
 * Its policy is untouched: `OBS_SIZE`, the heads and the shipped weights know
 * nothing about this.
 */
export function flashed(
  bot: Player,
  brain: BotBrain,
): { aimSpeed: number; aimError: number; reaction: number; sight: number; grip: number } {
  const b = blindness(bot);
  return {
    aimSpeed: brain.aimSpeed * (1 - 0.8 * b),
    aimError: brain.aimError * (1 + 6 * b),
    reaction: brain.reaction * (1 + 3 * b),
    sight: SIGHT * (1 - 0.92 * b),
    grip: brain.grip * (1 - b),
  };
}
/**
 * One tick of the bot riding its own recoil: the pull eases towards what would
 * cancel the shot it is about to take, and the *change* in it is what moves the
 * view — exactly the way the wobble below is applied, and for the same reason.
 * The view carries the pull, nothing else does, so the bullets that leave the
 * barrel are the ones a person pulling down would have sent.
 *
 * `bot.shotIndex` is where the next round lands in the pattern, and the world
 * puts it back to zero a third of a second after the trigger comes up — so a
 * bot that stops spraying eases back up to where it was aiming, with the whole
 * of the pull given back. Nothing here is a net offset that outlives a burst.
 *
 * The policy sees the pulled view, because the arena it learned in pulls the
 * same way (`src/rl/arena.ts`) and its own grip is one of the 33 numbers it is
 * handed. A policy told nothing about its hands would aim for a recoil nobody
 * was about to make.
 */
export function ride(bot: Player, brain: BotBrain, grip: number, dt: number): void {
  const want = sprayPull(bot.weapon, bot.shotIndex, grip);
  const next = ease(brain.pull, want, brain.gripRate, dt);
  bot.yaw += next[0] - brain.pull[0];
  bot.pitch = clamp(bot.pitch + next[1] - brain.pull[1], -89, 89);
  brain.pull = next;
}
/** How far a bot notices an enemy at all, in units, with its eyes working. */
const SIGHT = 4000;
/**
 * A bot rich enough that a save costs it nothing buys anyway, which is what a
 * person does with a round's worth of money already in the bank.
 */
const FORCE = 5000;
/** What a bot spends its money on, roughly in the order a person would. */
export function botBuy(world: World, bot: Player): void {
  const brain = brainOf(world, bot);
  const job = jobOf(world, bot, brain);
  // The economy half of a plan: a round the side is saving is a round nothing
  // leaves the bank, so the next one is a full buy for five rather than a rifle
  // for two. Armour is still worth it to whoever can spare the change.
  if (job.save && bot.money < FORCE) {
    if (bot.armor < 100 && bot.money >= 2000) buy(world, bot, "armor");
    return;
  }
  const rich = bot.money >= 4000;
  const wants: WeaponId[] = [];
  if (rich && brain.random() < 0.15 && bot.money >= WEAPONS.awp.price + 1000) wants.push("awp");
@@ -141,243 +280,168 @@
export function botBuy(world: World, bot: Player): void {
  if (bot.team === "ct" && !bot.defuseKit && bot.money >= 400 && brain.random() < 0.6) buy(world, bot, "kit");
}
// --- what is left to shoot with -------------------------------------------
/**
 * Is this weapon out of bullets — none in the magazine and none behind it?
 * A weapon with no magazine at all is the knife, and a knife is never dry:
 * that is what makes it the last answer below and why a bot always has one.
 */
export function dry(bot: Player, id: WeaponId): boolean {
  const weapon = WEAPONS[id];
  if (weapon === undefined) return true;
  if (weapon.magazine === 0) return weapon.kind !== "knife";
  const ammo = bot.ammo[id];
  return ammo === undefined || (ammo.mag <= 0 && ammo.reserve <= 0);
}
/**
 * What this bot should have in its hands instead of what it is holding, or
 * null to keep holding it. A gun it can still fire it keeps; an empty one it
 * puts away for the rifle, then the pistol, then the knife.
 *
 * A bot cannot buy mid-round and there is nothing on the floor to pick up, so
 * an empty gun stays empty until the round ends. Before this it kept pulling
 * the trigger on it: `shoot` refuses with no round in the magazine and `reload`
 * refuses with nothing to reload from, so the bot stood in the open holding
 * fire at an enemy it could see and never hurt it — which is what a weird spot
 * where two bots will not shoot each other looks like from the inside.
 */
export function nextWeapon(bot: Player): WeaponId | null {
  if (!dry(bot, bot.weapon)) return null;
  for (const id of [bot.primary, bot.secondary, "knife" as WeaponId]) {
    if (id !== null && id !== bot.weapon && !dry(bot, id)) return id;
  }
  return null;
}
/**
 * How close a knife has to be, centre to centre, to land: `world.ts` traces a
 * knife 64 units from the eye, and the body it is swung at is a hull's radius
 * wide, so the two overlap from here in.
 */
const KNIFE_RANGE = 64 + CS_HULL.radius;
function brainOf(world: World, bot: Player): BotBrain {
  if (bot.brain === undefined) {
    bot.brain = makeBrain(skillFor(bot.id, world.difficulty), 0x1234 + bot.id * 2654435761);
    const skill = clamp(0.25 + ((bot.id * 37) % 100) / 130, 0, 1);
    bot.brain = makeBrain(skill, 0x1234 + bot.id * 2654435761);
  }
  return bot.brain;
}
/**
 * Re-skill a brain for a new difficulty in place: the hands change, but the
 * path, the plan and the memory it already built up this match do not. Called
 * once a round, from `startRound`, so a change queued mid-fight cannot hand a
 * bot new hands between one shot and the next.
 * This bot's job, cut from the round's plan the first time anyone asks for it
 * after that plan arrived. A job belongs to a team and not to a bot — an entry
 * only means anything if somebody else is the support — so asking for one bot's
 * re-tasks its whole side at once, in one `assign`, and the other four find
 * theirs already waiting.
 *
 * With no plan handed in this is whatever `botThink` put there at the start of
 * the round, which is the coin flip these bots have always made. Nothing about
 * the arena or the trainer changes until somebody calls `usePlan`.
 */
export function restyleBrain(brain: BotBrain, id: number, difficulty: Difficulty): void {
  const skill = skillFor(id, difficulty);
  brain.skill = skill;
  brain.reaction = 0.5 - skill * 0.33;
  brain.aimSpeed = 180 + skill * 620;
  brain.aimError = 4.5 - skill * 3.6;
}
/** This bot's place in its side's list, so the plan can hand out two sites. */
function slotOf(world: World, bot: Player): number {
  let slot = 0;
  for (const p of world.players) if (p.team === bot.team && p.id < bot.id) slot += 1;
  return slot;
}
/**
 * Read this side's orders onto the brain: where to be, and whether to push
 * onto it. `plan.ts` answers with the round's roll unless somebody on this
 * side has called something else — which is all this file knows about it. A
 * site that changed under a bot already walking is a new objective, and
 * `repath` notices that on the next tick by itself.
 */
function readOrders(world: World, bot: Player, brain: BotBrain): void {
  const orders = ordersFor(world.plan, world.radio, bot.team, brain.slot, world.time);
  brain.site = orders.site;
  brain.holding = orders.hold;
  brain.ordered = orders.called;
}
/** What is left of the walk this bot has already planned, in map units. */
function pathLeft(brain: BotBrain, from: Vec3): number {
  let total = 0;
  let prev = from;
  for (let i = brain.step; i < brain.path.length; i++) {
    const at = brain.path[i] as Vec3;
    total += dist2d(prev, at);
    prev = at;
  }
  return total;
}
/** A crow flight underestimates a walk around a wall by about this much. */
const DETOUR = 1.3;
/**
 * How far this bot still has to walk to where the round wants it, in seconds
 * of clock: the longer of the crow flight around a wall and what is left of
 * the path it has already planned.
 */
function walkLeft(world: World, bot: Player, brain: BotBrain): number {
  const crow = dist2d(bot.pos, world.map.sites[brain.site]) * DETOUR;
  return Math.max(crow, pathLeft(brain, bot.pos));
}
/**
 * Has a person told this bot to stand still? "Hold" is the one call the clock
 * does not overrule: a teammate that walked off mid-sentence because the timer
 * said so is a teammate you cannot use. The other two calls need no exception
 * — a bot under time pressure walks to `brain.site`, and a call is what
 * `brain.site` says — so somebody who calls A at 0:20 gets the push, at A.
 */
const heldInPlace = (brain: BotBrain): boolean => brain.holding;
/**
 * Time pressure on the terrorists. What is left of the round is no more than
 * the walk to the site, the plant, and `PUSH_WINDOW` seconds of fighting — so
 * a duel on the way is a round lost on the timer. The whole side reads it, not
 * just the carrier: an escort still trading angles in mid is the carrier
 * walking in alone. A bot that reads true keeps its gun — the policy still
 * points it and still fires it — but its feet stop negotiating and take it to
 * the site.
 */
function pushing(world: World, bot: Player, brain: BotBrain): boolean {
  if (bot.team !== "t" || world.match.phase !== "live" || heldInPlace(brain)) return false;
  if (world.bomb.state === "planted") return false;
  return mustPush(world.match.timer, walkLeft(world, bot, brain), world.match.rules.plantTime);
}
/**
 * Time pressure on the counter-terrorists, which is the mirror of it: with the
 * clock this low and no bomb on the floor, the terrorists are not coming to
 * the corner this bot is sitting in — they are somewhere else, running it out.
 * So it stops holding and goes to look, and `chooseGoal` says where.
 */
function hunting(world: World, bot: Player, brain: BotBrain): boolean {
  if (bot.team !== "ct" || world.match.phase !== "live") return false;
  // Both calls outrank this one, and for the same reason: a hunt is a guess
  // about which room the terrorists are in, and a person who has just said
  // "go A" or "hold" has made that guess already, out loud.
  if (heldInPlace(brain) || brain.ordered) return false;
  if (world.bomb.state === "planted") return false;
  return mustHunt(world.match.timer);
}
/**
 * How wide a hunt fans out around the terrorists' own half. Enough that five
 * counter-terrorists sweep it rather than queue down one corridor into the
 * same angle, and not so much that they stop covering each other.
 */
const HUNT_SPREAD = 700;
/** A death this far from a site centre is a fight over that site. */
const CONTACT_RANGE = 1600;
/** Which site a fight at `pos` is a fight over, if it is near enough to be one. */
function contactSite(world: World, pos: Vec3): Site | null {
  const a = dist2d(pos, world.map.sites.A);
  const b = dist2d(pos, world.map.sites.B);
  if (Math.min(a, b) > CONTACT_RANGE) return null;
  return a <= b ? "A" : "B";
}
/**
 * Where the round is being fought, as far as this side can tell: the site the
 * last of them to die fell at. It is only ever this side's own information —
 * who is dead and where they were, which is the kill feed and the radar — and
 * it is the answer to a side that commits to one site together. The first CT
 * down at A is what turns the B players around; without it, five together
 * beats three and two nearly every round.
 */
function rotateTo(world: World, bot: Player): Site | null {
  let site: Site | null = null;
  let freshest = -Infinity;
  for (const entry of world.feed) {
    if (entry.killerTeam === bot.team || entry.at < freshest) continue;
    for (const p of world.players) {
      if (p.id !== entry.victimId || p.team !== bot.team) continue;
      const where = contactSite(world, p.pos);
      if (where === null) continue;
      freshest = entry.at;
      site = where;
    }
  }
  return site;
}
/**
 * `goal`, or a dropped primary if this bot has an empty primary slot and one
 * is close enough to be worth the walk. `worthTheDetour` (plan.ts) is the
 * whole arithmetic; this only finds the candidates and picks the cheapest.
 * The empty floor — every tick of the training arena — costs one comparison.
 */
export function gunGoal(world: World, bot: Player, goal: Vec3): Vec3 {
  if (world.pickups.length === 0 || bot.primary !== null) return goal;
  const toGoal = dist2d(bot.pos, goal);
  let best: Vec3 | null = null;
  let bestDetour = Infinity;
  for (const pickup of world.pickups) {
    if (pickupSlot(pickup.weapon) !== "primary") continue;
    const toGun = dist2d(bot.pos, pickup.pos);
    const gunToGoal = dist2d(pickup.pos, goal);
    if (!worthTheDetour(toGun, gunToGoal, toGoal)) continue;
    const detour = toGun + gunToGoal - toGoal;
    if (detour < bestDetour) {
      bestDetour = detour;
      best = pickup.pos;
    }
  }
  return best ?? goal;
}
/**
 * How many dropped primaries are on the floor right now — the whole gun
 * signature `repath` needs in its objective string: a rifle appearing or
 * getting taken is a floor that changed, whatever else this bot is doing.
 */
function primaryPickupCount(world: World): number {
  let count = 0;
  for (const pickup of world.pickups) if (pickupSlot(pickup.weapon) === "primary") count += 1;
  return count;
function jobOf(world: World, bot: Player, brain: BotBrain): Job {
  const plan = world.plan;
  if (plan === null) return brain.job;
  // The plan itself is the stamp: a new one is a new object, and a bot holding
  // a job cut from another one is a bot with yesterday's orders.
  if (brain.jobPlan === plan && brain.jobRound === world.match.round) return brain.job;
  const mates = world.players.filter((p) => p.team === bot.team);
  const brains = mates.map((mate) => brainOf(world, mate));
  const jobs = assign(plan[bot.team], bot.team, mates.map((mate, at) => ({
    id: mate.id,
    skill: brains[at]?.skill ?? 0,
  })));
  brains.forEach((mate, at) => {
    mate.job = jobs[at] ?? DEFAULT_JOB;
    mate.jobPlan = plan;
    mate.jobRound = world.match.round;
    // The wait runs from the moment the round goes live, and the freeze time is
    // still running: `botThink` pushes this forward on every frozen tick.
    mate.pushAt = world.time + mate.job.delay;
    // A goal cut for the site this bot is no longer going to is not a goal.
    mate.plannedFor = "";
  });
  return brain.job;
}
/** Where this bot is trying to be, given what the round is doing. */
function chooseGoal(world: World, bot: Player, brain: BotBrain): Vec3 {
  const bomb = world.bomb;
  // Told to hold: this is where the round is being fought from now on. The
  // goal is a walkable spot a stride away rather than the bot's own feet —
  // a bot with no path stands still wherever it happened to be, and standing
  // still in the open is how a hold gets a side killed. Once the bomb is on
  // the floor or in the ground it outranks anything anyone said.
  if (brain.holding && bomb.state === "carried") return nearby(world, brain, bot.pos, 250);
  const level = world.level;
  const job = brain.job;
  const site = level.sites[job.site];
  if (bot.team === "t") {
    if (bomb.state === "planted") {
      // Hold near the bomb rather than walk onto it.
      return nearby(world, brain, bomb.pos, 300);
      return nearby(level, brain, bomb.pos, 300);
    }
    // The bomb carrier does not stop for a gun: walking in alone with a rifle
    // costs the round more than walking in with a pistol on time.
    if (bot.hasBomb) return world.map.sites[brain.site];
    if (bot.hasBomb) return site;
    if (bomb.state === "dropped") return bomb.pos;
    return gunGoal(world, bot, nearby(world, brain, world.map.sites[brain.site], 200));
    // An entry walks onto the site; a lurker is happy five hundred units off
    // it, watching the way somebody would come. That is what a role is worth.
    return nearby(level, brain, site, job.spread * 0.8);
  }
  if (bomb.state === "planted") return bomb.pos;
  // The contact rotation is this side reading the round for itself — and it
  // gives way to a person who has just said where to be. Somebody dying at B
  // is why you called A; it is not an argument against the call.
  const contact = brain.ordered ? null : rotateTo(world, bot);
  // Nothing has happened and the clock is nearly out: whatever the terrorists
  // are doing they are not doing it here, or this bot would have seen them by
  // now. So it walks at the half of the map they came from and takes what it
  // meets on the way. A death somewhere is better information than a guess,
  // so a contact still wins.
  if (contact === null && hunting(world, bot, brain)) {
    return gunGoal(world, bot, nearby(world, brain, world.map.muster.t, HUNT_SPREAD));
  }
  return gunGoal(world, bot, nearby(world, brain, world.map.sites[contact ?? brain.site], 250));
  return nearby(level, brain, site, job.spread);
}
const nearby = (world: World, brain: BotBrain, at: Vec3, spread: number): Vec3 => {
const nearby = (level: Level, brain: BotBrain, at: Vec3, spread: number): Vec3 => {
  for (let tries = 0; tries < 8; tries++) {
    const x = at[0] + (brain.random() * 2 - 1) * spread;
    const y = at[1] + (brain.random() * 2 - 1) * spread;
    if (walkable(world.map, colOf(world.map, x), rowOf(world.map, y))) return [x, y, at[2]];
    if (walkable(level, colOf(level, x), rowOf(level, y))) return [x, y, at[2]];
  }
  return at;
};
/** How many cells out a goal nothing walks to may be nudged, and how many tries. */
const NUDGE_RINGS = 3;
const NUDGE_TRIES = 8;
/**
 * A path to `goal`, or to the nearest cell something can walk to.
 *
 * A* aims at a cell, and not every point a round hands a bot is one: a bomb
 * dropped on top of a jumpable crate stands on a cell the search calls solid,
 * and so does a body that fell into a corner of a map carved from a seed. The
 * search then comes back with nothing, and a bot with no path stands exactly
 * where it is until it asks again three seconds later — the standing about
 * that looks, from the other end of a corridor, like a bot that has forgotten
 * what it was doing. So a goal nothing walks to is nudged outwards in rings
 * until a cell answers, at most `NUDGE_TRIES` searches deep, and only a goal
 * walled off entirely leaves the bot without a plan.
 */
export function pathTo(level: Level, from: Vec3, goal: Vec3): Vec3[] {
  const direct = findPath(level, from, goal);
  if (direct.length > 0) return direct;
  const col = colOf(level, goal[0]);
  const row = rowOf(level, goal[1]);
  let tries = 0;
  for (let ring = 1; ring <= NUDGE_RINGS; ring++) {
    for (let dr = -ring; dr <= ring; dr++)
      for (let dc = -ring; dc <= ring; dc++) {
        if (Math.max(Math.abs(dc), Math.abs(dr)) !== ring) continue;
        if (!walkable(level, col + dc, row + dr)) continue;
        if (tries++ >= NUDGE_TRIES) return [];
        const path = findPath(level, from, worldOf(level, col + dc, row + dr, goal[2]));
        if (path.length > 0) return path;
      }
  }
  return [];
}
function pickTarget(world: World, bot: Player, brain: BotBrain): Player | null {
  let best: Player | null = null;
  let bestScore = Infinity;
  // Flashed, a bot picks its fights out of a much smaller room: this is the
  // "choice" half of what a flash costs it, and the aim below is the other.
  const sight = flashed(bot, brain).sight;
  for (const other of world.players) {
    if (!other.alive || other.team === bot.team) continue;
    const d = dist(bot.pos, other.pos);
    if (d > 4000) continue;
    if (d > sight) continue;
    if (!canSee(world, bot, other)) continue;
    const aim = aimAt(bot, bodyCentre(other));
    const off = Math.abs(angleDelta(bot.yaw, aim.yaw));
@@ -388,60 +452,82 @@
function pickTarget(world: World, bot: Player, brain: BotBrain): Player | null {
  return best;
}
/** The player an effect's `by` names, if it names one. Ids are the slot they sit in. */
function makerOf(world: World, by: number | undefined): Maker {
  if (by === undefined) return undefined;
  const at = world.players[by];
  return at !== undefined && at.id === by ? at : world.players.find((p) => p.id === by);
}
// --- smoke ----------------------------------------------------------------
/**
 * Hearing. Every noise the world made since this bot last listened is looked
 * at once — no list built and nothing allocated until something is actually
 * heard — and the loudest of them, if it arrives above `AUDIBLE`, becomes the
 * place the bot thinks someone is.
 *
 * It is the sounds themselves, not the players making them: a gunshot through
 * two walls is quieter than one down the corridor, a sprint carries and a walk
 * makes no sound at all, and where the bot ends up looking is off by more the
 * further away it was. `hearing.ts` owns all of that arithmetic.
 *
 * The bomb's own beep is skipped on purpose. It repeats every half-second from
 * a place both sides already know, so acting on it would drown out every
 * footstep near a planted site — what a CT should do about it is #46's retake.
 * How far outside a cloud a bot aims to walk, in units. A hull's width, so it
 * skirts the fringe of one rather than clipping through it — and so that a
 * diversion is a visible step around something and not a shuffle along its
 * edge.
 */
function listen(world: World, bot: Player, brain: BotBrain): void {
  const since = brain.heardAt;
  brain.heardAt = world.time;
  let loudest = 0;
  let from: Vec3 | null = null;
  // Backwards, and out at the first stale one: `world.effects` is only ever
  // appended to and only ever filtered, so what is new is the tail of it. The
  // list is two seconds deep and a firefight fills it with tracers, blood and
  // impacts; what this bot has not heard yet is the handful on the end.
  for (let i = world.effects.length - 1; i >= 0; i--) {
    const effect = world.effects[i];
    if (effect === undefined || effect.at < since) break;
    let name: HeardName;
    let pos: Vec3;
    let by: number | undefined;
    if (effect.kind === "shot") {
      name = effect.weapon;
      pos = effect.pos;
      by = effect.shooter;
    } else if (effect.kind === "sound" && effect.name !== "beep") {
      name = effect.name;
      pos = effect.pos;
      by = effect.by;
    } else continue;
    if (!fromOther(bot, makerOf(world, by))) continue;
    const heard = loudness(bot.pos, pos, name, world.map);
    if (heard > loudest) {
      loudest = heard;
      from = pos;
const SMOKE_CLEARANCE = CS_HULL.radius * 2;
/**
 * Where this bot should walk instead of straight at `step`, given the clouds
 * standing in the round.
 *
 * A cloud is not a wall — a body walks through one exactly as it walks through
 * air, and it should, because walking through smoke is half of what smoke is
 * for — but it *is* a wall to this bot's eyes: `canSee` refuses a line through
 * one, so a bot that strolls into a cloud arrives blind at whatever is waiting
 * on the other side and has given away the fight it was walking to. So the
 * scripted layer treats it as something to go around, and the policy is told
 * nothing: the shipped weights, `OBS_SIZE` and every head are untouched by all
 * of this.
 *
 * Two cases and no third. Standing in one, the shortest way out is straight
 * away from the middle, and that is where the bot walks. Heading into one, the
 * step is pushed sideways to whichever edge is nearer — the tangent, plus the
 * clearance — so the path bends around the cloud and rejoins itself. A cloud
 * behind the bot, beside the walk, or past the end of this step is left alone,
 * which is every cloud on most ticks; a round nobody smoked never reaches here
 * at all, because the caller checks the list is empty first.
 *
 * The step comes back unchanged when there is nothing to do, so the common case
 * allocates nothing.
 */
export function skirt(world: World, bot: Player, step: Vec3): Vec3 {
  for (const cloud of world.clouds) {
    const radius = cloudRadius(cloud, world.time);
    if (radius <= 0) continue;
    const keep = radius + SMOKE_CLEARANCE;
    const cx = cloud.pos[0] - bot.pos[0];
    const cy = cloud.pos[1] - bot.pos[1];
    const here = Math.hypot(cx, cy);
    if (here < keep) {
      // Inside it, or in its fringe: out, by the shortest line there is. Dead
      // in the middle there is no such line, so the bot keeps walking rather
      // than picking a direction out of nothing.
      if (here < 1e-6) continue;
      return [bot.pos[0] - (cx / here) * keep, bot.pos[1] - (cy / here) * keep, step[2]];
    }
    const dx = step[0] - bot.pos[0];
    const dy = step[1] - bot.pos[1];
    const len = Math.hypot(dx, dy);
    if (len < 1e-6) continue;
    const ux = dx / len, uy = dy / len;
    // How far along the walk the cloud sits, and how far off to one side.
    const along = cx * ux + cy * uy;
    if (along <= 0 || along > len + keep) continue;
    const off = cx * -uy + cy * ux;
    if (Math.abs(off) >= keep) continue;
    // Around the near edge: the perpendicular, away from the side the cloud is
    // on, by just enough to put the walk on the tangent.
    const side = off >= 0 ? -1 : 1;
    const push = (keep - Math.abs(off)) * side;
    return [step[0] + -uy * push, step[1] + ux * push, step[2]];
  }
  return step;
}
/** An enemy shooting nearby is a direction to look, even through a wall. */
function listen(world: World, bot: Player, brain: BotBrain): void {
  for (const other of world.players) {
    if (!other.alive || other.team === bot.team) continue;
    if (world.time - other.lastShotAt > 0.25) continue;
    if (dist(bot.pos, other.pos) > 2200) continue;
    brain.suspect = [other.pos[0], other.pos[1], other.pos[2] + 48];
  }
  if (from !== null) brain.suspect = reported(bot.pos, from, world.map, brain.random);
}
/**
@@ -454,12 +540,13 @@
function listen(world: World, bot: Player, brain: BotBrain): void {
export function scriptedFight(
  world: World, bot: Player, brain: BotBrain, target: Player, input: Input, dt: number,
): Input {
  const hands = flashed(bot, brain);
  const spraying = bot.shotIndex > 0 && world.time - bot.lastShotAt < 0.3;
  const wobble = brain.aimError * (spraying ? 1.6 : 1) * (brain.random() * 2 - 1) * 0.15;
  const wobble = hands.aimError * (spraying ? 1.6 : 1) * (brain.random() * 2 - 1) * 0.15;
  const aim = aimAt(bot, bodyCentre(target));
  turnTowards(bot, { yaw: aim.yaw + wobble, pitch: aim.pitch + wobble * 0.4 }, brain.aimSpeed, dt);
  const ready = world.time - brain.seenAt > brain.reaction;
  const onTarget = Math.abs(angleDelta(bot.yaw, aim.yaw)) < 3 + brain.aimError;
  turnTowards(bot, { yaw: aim.yaw + wobble, pitch: aim.pitch + wobble * 0.4 }, hands.aimSpeed, dt);
  const ready = world.time - brain.seenAt > hands.reaction;
  const onTarget = Math.abs(angleDelta(bot.yaw, aim.yaw)) < 3 + hands.aimError;
  const ammo = bot.ammo[bot.weapon];
  if (ammo !== undefined && ammo.mag === 0) input.reload = true;
  if (ready && onTarget && world.time > brain.restUntil) {
@@ -483,6 +570,24 @@
export function scriptedFight(
  return input;
}
/**
 * A bot with nothing left to fire, which on this map means a bot down to its
 * knife. The policy is not asked: it learned a rifle duel and is content to
 * hold a distance a knife cannot cross, and the two things a knife needs — be
 * pointed at them, be next to them — are not a reflex worth a network. So the
 * bot turns onto the enemy with its own hands, at its own skill's turn rate,
 * walks straight in and swings once the swing can land.
 */
export function knifeRush(
  bot: Player, brain: BotBrain, target: Player, input: Input, dt: number,
): Input {
  const hands = flashed(bot, brain);
  turnTowards(bot, aimAt(bot, bodyCentre(target)), hands.aimSpeed, dt);
  input.forward = 1;
  input.fire = dist(bot.pos, target.pos) < KNIFE_RANGE;
  return input;
}
/**
 * Ask the policy what to do about `target`. It decides once every SKIP ticks
 * and the answer is held in between, which is how it was trained and what a
@@ -511,11 +616,12 @@
export function think(world: World, bot: Player, brain: BotBrain, target: Player
 * is a bot you can beat; the same policy with steady hands is not.
 */
export function applyIntent(world: World, bot: Player, brain: BotBrain, intent: Intent, dt: number): void {
  const hands = flashed(bot, brain);
  if (world.time > brain.jitterUntil) {
    brain.jitter = (brain.random() * 2 - 1) * brain.aimError;
    brain.jitter = (brain.random() * 2 - 1) * hands.aimError;
    brain.jitterUntil = world.time + 0.25 + brain.random() * 0.35;
  }
  const limit = brain.aimSpeed;
  const limit = hands.aimSpeed;
  bot.yaw += clamp(intent.yawRate, -limit, limit) * dt + (brain.jitter - brain.jitterApplied);
  bot.pitch = clamp(
    bot.pitch + clamp(intent.pitchRate, -limit, limit) * dt + (brain.jitter - brain.jitterApplied) * 0.4,
@@ -533,96 +639,57 @@
function turnTowards(bot: Player, target: { yaw: number; pitch: number }, speed:
  bot.pitch = clamp(bot.pitch + clamp(dp, -maxTurn, maxTurn), -89, 89);
}
/**
 * Ask for a path when there is none, when it runs out, when it goes stale, or
 * when the objective itself changed under the bot's feet. A* is only ever run
 * here, which is a few times a round and never per tick.
 */
function repath(world: World, bot: Player, brain: BotBrain): void {
  // `ordered` is part of the objective and not just a tie-break inside
  // `chooseGoal`: a counter-terrorist that has rotated off its own site is
  // walking to a goal its site no longer names, so a call that happens to
  // agree with the roll still has to be a new objective to turn it round.
  // The hunt is part of it too: a counter-terrorist that has just run out of
  // clock is walking to a goal its site does not name, and nothing else in
  // this string would have changed to send it there. The gun count only
  // matters to a bot with an empty primary slot — one that already has a
  // rifle never diverts, so the floor changing under it is not its news.
  const objective =
    `${world.bomb.state}:${brain.site}${brain.holding ? ":hold" : ""}` +
    `${brain.ordered ? ":called" : ""}${hunting(world, bot, brain) ? ":hunt" : ""}` +
    `${bot.primary === null ? `:guns${primaryPickupCount(world)}` : ""}`;
  const stale =
    brain.path.length === 0 || brain.step >= brain.path.length ||
    world.time > brain.repathAt || objective !== brain.plannedFor;
  if (!stale) return;
  brain.goal = chooseGoal(world, bot, brain);
  brain.path = findPath(world.map, bot.pos, brain.goal);
  brain.step = 0;
  brain.plannedFor = objective;
  brain.repathAt = world.time + 3 + brain.random() * 3;
}
/**
 * Point the feet at the next waypoint and return how far off the view is from
 * it, in degrees, or null when the path has run out. The movement is in the
 * bot's own frame, so this works whether the view is following the path or
 * looking down the barrel of something else.
 */
function follow(bot: Player, brain: BotBrain, input: Input): number | null {
  const next = brain.path[brain.step];
  if (next === undefined) {
    brain.goal = null;
    return null;
  }
  if (dist2d(bot.pos, next) < 48) brain.step += 1;
  const off = angleDelta(bot.yaw, aimAt(bot, [next[0], next[1], bot.pos[2] + 48]).yaw);
  input.forward = Math.cos((off * Math.PI) / 180);
  input.side = -Math.sin((off * Math.PI) / 180);
  return off;
}
/** One bot's decision for this tick, expressed as the same input a person gives. */
export function botThink(world: World, bot: Player, dt: number): Input {
  const brain = brainOf(world, bot);
  const input: Input = { ...NO_INPUT };
  if (brain.reset) {
    brain.reset = false;
    // The round's plan, not a coin of this bot's own: the side arrives together.
    brain.slot = slotOf(world, bot);
    readOrders(world, bot, brain);
    // The job a bot has when no round was planned for it: its own coin flip for
    // a site, no wait and the spread these bots have always used. A plan, if one
    // arrived, replaces this on the next line and for the rest of the round.
    brain.job = { ...DEFAULT_JOB, site: brain.random() < 0.5 ? "A" : "B" };
    brain.jobPlan = null;
    brain.pushAt = 0;
    brain.goal = null;
    brain.path = [];
    brain.targetId = null;
    brain.suspect = null;
    brain.heardAt = world.time;
    brain.plannedFor = "";
    brain.memory.sinceSeen = 9;
    brain.hold = 0;
    brain.intent = { ...STILL };
    // A fresh round hands the body a fresh view; the pull is not owed back.
    brain.pull = [0, 0];
    brain.cover = null;
    brain.coverFor = -1;
    brain.coverLook = null;
    input.switchTo = bot.primary ?? bot.secondary;
  }
  const job = jobOf(world, bot, brain);
  if (world.match.phase === "freeze") {
    // Nothing that happens behind the barrier is worth turning round for.
    brain.heardAt = world.time;
    // Nobody moves in the freeze time, so a job's wait cannot start running
    // inside it: it is pushed along in front of the clock and starts the moment
    // the round goes live, which is the beat an entry is ahead by.
    brain.pushAt = world.time + job.delay;
    return input;
  }
  // Orders can change under a bot mid-round — but only ever because somebody
  // said something, so a world with a silent radio does not pay for the ones
  // that do not: the round's roll is already on the brain from `reset`.
  if (world.radio !== null) readOrders(world, bot, brain);
  // An empty gun is not a weapon: swap to whatever can still fire before
  // deciding anything else, so the decision below is made about the gun the
  // bot will actually be holding when the input is applied.
  const swap = nextWeapon(bot);
  if (swap !== null) input.switchTo = swap;
  // The hands ride the pattern whatever the head is doing, so a bot that stops
  // fighting — or stops firing — gives the pull back rather than walking off
  // aiming at the floor. Not on the scripted brain: that one is the baseline
  // the policy is measured against, and a baseline that moves measures nothing.
  if (brain.useLearned) ride(bot, brain, flashed(bot, brain).grip, dt);
  listen(world, bot, brain);
  const target = pickTarget(world, bot, brain);
  if (target !== null) {
    if (brain.targetId !== target.id) {
      // Contact, and only contact: a bot that had nobody in its sights now
      // has somebody, and `pickTarget` has already run the trace that proves
      // it can see them. Swapping from one enemy to another is the same fight
      // and says nothing; so is the next tick of the same sighting, which is
      // why a standoff down one corridor is one line and not ninety seconds
      // of them.
      if (brain.targetId === null) callout(world, bot, target.pos);
      brain.targetId = target.id;
      brain.seenAt = world.time;
    }
@@ -630,53 +697,137 @@
export function botThink(world: World, bot: Player, dt: number): Input {
    brain.targetId = null;
  }
  // --- reloading, which is not a fight. A bot with nothing in the magazine
  // gets out of sight until there is something in it, then the policy has it
  // back. Not the scripted brain: it is the baseline, and it does not move.
  if (brain.useLearned && world.time < bot.reloadUntil && takeCover(world, bot, brain, target, input, dt)) {
    return withBomb(world, bot, input);
  }
  // --- fighting, which is the policy's job
  if (target !== null) {
    // The gun this input is about is the one the swap above is handing it, not
    // the empty one still in its hands for the rest of this tick.
    const holding = swap ?? bot.weapon;
    if (holding === "knife") return withBomb(world, bot, knifeRush(bot, brain, target, input, dt));
    if (!brain.useLearned) return withBomb(world, bot, scriptedFight(world, bot, brain, target, input, dt));
    const intent = think(world, bot, brain, target, dt);
    applyIntent(world, bot, brain, intent, dt);
    const ammo = bot.ammo[bot.weapon];
    if (ammo !== undefined && ammo.mag === 0) input.reload = true;
    const ammo = bot.ammo[holding];
    // Reloading is worth asking for only when there is something to reload
    // from; an empty reserve is what the swap just answered.
    if (ammo !== undefined && ammo.mag === 0 && ammo.reserve > 0) input.reload = true;
    // Two things the policy does not get to decide. A bot that has only just
    // seen you does not shoot yet — that beat is what skill buys. And the
    // policy trained with a rifle, so it holds the trigger down; on a pistol
    // that is one shot and then nothing, so the trigger is released between
    // decisions and each decision is worth one pull.
    const held = WEAPONS[bot.weapon]?.automatic !== false || brain.hold === SKIP - 1;
    input.fire = intent.fire && held && world.time - brain.seenAt > brain.reaction;
    if (pushing(world, bot, brain)) {
      // Out of clock: the policy keeps the gun, the plan takes the feet. It
      // runs to the site shooting at whatever it is looking at rather than
      // trading ground for a duel it cannot afford to win slowly.
      repath(world, bot, brain);
      follow(bot, brain, input);
      input.walk = false;
      input.duck = false;
    } else {
      input.forward = intent.forward;
      input.side = intent.side;
      input.walk = intent.walk;
      input.duck = intent.duck;
    const held = WEAPONS[holding]?.automatic !== false || brain.hold === SKIP - 1;
    input.fire = intent.fire && held && world.time - brain.seenAt > flashed(bot, brain).reaction;
    input.forward = intent.forward;
    input.side = intent.side;
    input.walk = intent.walk;
    input.duck = intent.duck;
    return withBomb(world, bot, input);
  }
  // --- waiting. A support does not walk out with the entry; it gives it its
  // beat and follows. The bomb never waits — a round where the bomb stands at
  // spawn for two seconds is two seconds off the clock — and neither does a bot
  // with something in front of it, because the fight above returned already.
  if (world.time < brain.pushAt && !bot.hasBomb && world.bomb.state === "carried") {
    if (brain.suspect !== null) {
      const look = aimAt(bot, brain.suspect);
      turnTowards(bot, { yaw: look.yaw, pitch: clamp(look.pitch, -20, 20) }, brain.aimSpeed * 0.5, dt);
    }
    return withBomb(world, bot, input);
  }
  // --- moving
  repath(world, bot, brain);
  const off = follow(bot, brain, input);
  if (off !== null) {
    const look = brain.suspect !== null ? aimAt(bot, brain.suspect) : { yaw: bot.yaw + off, pitch: 0 };
  // --- moving. A path is asked for when there is none, when it runs out, when
  // it goes stale, or when the objective itself changed under the bot's feet.
  const objective = `${world.bomb.state}:${job.site}`;
  const stale =
    brain.path.length === 0 || brain.step >= brain.path.length ||
    world.time > brain.repathAt || objective !== brain.plannedFor;
  if (stale) {
    brain.goal = chooseGoal(world, bot, brain);
    brain.path = pathTo(world.level, bot.pos, brain.goal);
    brain.step = 0;
    brain.plannedFor = objective;
    brain.repathAt = world.time + 3 + brain.random() * 3;
  }
  const next = brain.path[brain.step];
  if (next !== undefined) {
    if (dist([bot.pos[0], bot.pos[1], 0], [next[0], next[1], 0]) < 48) brain.step += 1;
    // The path is A*'s and it knows nothing about smoke, which is right: the
    // cells are still walkable and a cloud is gone in fifteen seconds. What
    // bends is the *step*, here and only while there is a cloud to bend it.
    const walk = world.clouds.length === 0 ? next : skirt(world, bot, next);
    const aim = aimAt(bot, [walk[0], walk[1], bot.pos[2] + 48]);
    const look = brain.suspect !== null ? aimAt(bot, brain.suspect) : { yaw: aim.yaw, pitch: 0 };
    turnTowards(bot, { yaw: look.yaw, pitch: clamp(look.pitch, -20, 20) }, brain.aimSpeed * 0.5, dt);
    const off = angleDelta(bot.yaw, aim.yaw);
    input.forward = Math.cos((off * Math.PI) / 180);
    input.side = -Math.sin((off * Math.PI) / 180);
    input.walk = brain.suspect !== null && dist(bot.pos, brain.suspect) < 900;
  } else {
    brain.goal = null;
  }
  if (brain.suspect !== null && brain.random() < 0.004) brain.suspect = null;
  return withBomb(world, bot, input);
}
/**
 * One tick of reloading behind something: walk the path `coverFrom` cut, at a
 * run, with the view on where the threat was, and stand still once there. The
 * path is cut the first tick of a reload that has an enemy in view — a reload
 * started out of sight is already where it should be — and never recut: a bot
 * that changes its mind about cover twice in two seconds reaches none of it.
 *
 * False leaves the tick to the fight below, which is what happens when there
 * is no threat or nowhere within reach to hide from it: the policy strafes, as
 * it always did, and that is better than walking into the open.
 */
export function takeCover(
  world: World, bot: Player, brain: BotBrain, target: Player | null, input: Input, dt: number,
): boolean {
  if (brain.coverFor !== bot.reloadUntil) {
    brain.coverFor = bot.reloadUntil;
    brain.cover = null;
    brain.coverStep = 0;
    brain.coverLook = null;
    if (target !== null) {
      brain.cover = coverFrom(world, bot, target);
      brain.coverLook = bodyCentre(target);
    }
  }
  if (brain.cover === null) return false;
  if (target !== null) brain.coverLook = bodyCentre(target);
  brain.memory.sinceSeen = target !== null ? 0 : brain.memory.sinceSeen + dt;
  // Whatever the policy decided before the reload, it decides afresh after.
  brain.hold = 0;
  if (brain.coverLook !== null) {
    const look = aimAt(bot, brain.coverLook);
    turnTowards(bot, look, brain.aimSpeed * 0.5, dt);
  }
  let next = brain.cover[brain.coverStep];
  if (next !== undefined && dist([bot.pos[0], bot.pos[1], 0], [next[0], next[1], 0]) < 24) {
    brain.coverStep += 1;
    next = brain.cover[brain.coverStep];
  }
  if (next !== undefined) {
    const aim = aimAt(bot, [next[0], next[1], bot.pos[2] + 48]);
    const off = angleDelta(bot.yaw, aim.yaw);
    input.forward = Math.cos((off * Math.PI) / 180);
    input.side = -Math.sin((off * Math.PI) / 180);
  }
  return true;
}
/** Planting and defusing: press use when standing where it matters. */
function withBomb(world: World, bot: Player, input: Input): Input {
  const bomb = world.bomb;
  if (bot.team === "t" && bot.hasBomb && siteAt(world.map, bot.pos) !== null && world.match.phase === "live") {
  if (bot.team === "t" && bot.hasBomb && siteAt(world.level, bot.pos) !== null && world.match.phase === "live") {
    input.use = true;
    input.forward = 0;
    input.side = 0;
@@ -0,0 +1,229 @@
/**
 * The committed bundle, booted. `main.test.ts` proves the shooter's *sources*
 * run against the stub page in `stage.test-helper.ts`; this proves that
 * `static/app.<hash>.js` does, which is the file a browser actually downloads. A
 * bundling mistake — a mangled name the entry needed, a tree shake that took the
 * boot line with it, a half-written file — fails here rather than in the preview.
 *
 * Nothing under `src/client/` is imported except the stub page, which ships in
 * no bundle: the thing under test is the artifact, found on disk by name by
 * `scripts/bundle.test-helper.ts` — the same finder `src/range/bundle.test.ts`
 * uses. Nothing here rebuilds it; whether what is committed is what the sources
 * produce now is `scripts/build.test.ts`'s rule, and a rebuild would make this
 * test a test of the sources again.
 *
 * A minified file exposes nothing to poke, so every assertion below is about
 * what it did to the stub page: which ids it asked for, what it drew, what it
 * posted, what it wrote to the store, and the sentence it leaves in the menu on
 * a browser with no WebGL2.
 */
import { afterAll, expect, test } from "bun:test";
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { bundlePath, discardBundleCopies, importBundle } from "../../scripts/bundle.test-helper.ts";
import { fakeStage, type FakeStage } from "./stage.test-helper.ts";
afterAll(discardBundleCopies);
/** Whether this process had a `document` before any of this ran. It does not. */
const HAD_DOCUMENT = "document" in globalThis;
/** Bun's own `fetch`, held onto so the last test can see it handed back. */
const REAL_FETCH = globalThis.fetch;
const FRAME = 1000 / 30;
/**
 * How many frames the entry paints its atlas over: one layer each, and this
 * game has nine. Written out rather than imported from `src/client/materials.ts`
 * — nothing under `src/client/` but the stub page belongs in here, and a
 * minified file has no constant to read anyway.
 */
const LAYERS = 9;
/** Every id the shell renders that the entry has to find to run a match. */
const NEEDED = ["scene", "hud", "fps", "touch", "play", "name", "length", "side", "sens"];
type Booted = {
  stage: FakeStage;
  /** Every id the bundle asked the document for, in the order it asked. */
  asked: string[];
  undo: () => void;
};
/**
 * Install a stub page, import the committed bundle into it — the entry boots
 * itself on the way in, because the page says it is not still loading — and hand
 * back the page, the ids it looked up, and the undo that puts the globals back.
 * `loading: true` is the other page: one still being parsed, which the entry
 * has to wait for.
 */
async function booted(
  options: { webgl?: boolean; coarse?: boolean; loading?: boolean } = {},
): Promise<Booted> {
  const stage = fakeStage(options);
  if (options.loading === true) stage.document.readyState = "loading";
  const asked: string[] = [];
  const find = stage.document.getElementById;
  stage.document.getElementById = (id) => {
    asked.push(id);
    return find(id);
  };
  const undo = stage.install();
  try {
    await importBundle("app");
  } catch (error) {
    undo();
    throw error;
  }
  return { stage, asked, undo };
}
/** Every GL call the scene canvas was given, and the draws and uploads among them. */
const glCalls = (stage: FakeStage): [string, ...unknown[]][] => stage.scene.gl?.calls ?? [];
const drawn = (stage: FakeStage): [string, ...unknown[]][] =>
  glCalls(stage).filter((call) => call[0] === "drawElements");
const uploads = (stage: FakeStage): [string, ...unknown[]][] =>
  glCalls(stage).filter((call) => call[0] === "texImage3D");
test("the committed bundle boots the page, and a click on play plays a match", async () => {
  const { stage, asked, undo } = await booted({ coarse: true });
  try {
    // Importing it was enough: it found the page, read the store and asked for
    // a frame, with the menu still up and nothing drawn.
    expect(stage.frames.length).toBe(1);
    expect(stage.by("menu").hidden).toBe(false);
    expect(drawn(stage).length).toBe(0);
    // Nothing is uploaded yet and Play is held: the minified file paints its
    // atlas across the frames after boot, the same as the sources do.
    expect(uploads(stage).length).toBe(0);
    expect(stage.by("play").disabled).toBe(true);
    // The touch buttons the shell renders were bound too, every one of them.
    expect(stage.buttons.every((button) => button.listening.size > 0)).toBe(true);
    // A layer a frame, and on the last of them one upload of nine 128² layers.
    for (let layer = 0; layer < LAYERS; layer++) stage.step(FRAME);
    expect(uploads(stage).length).toBe(1);
    expect(uploads(stage)[0]?.slice(4, 7)).toEqual([128, 128, 9]);
    expect(stage.by("play").disabled).toBe(false);
    expect(stage.by("prep").hidden).toBe(true);
    expect(drawn(stage).length).toBe(0);
    stage.by("name").value = "Vesper";
    stage.by("side").value = "t";
    stage.by("length").value = "short";
    stage.by("sens").value = "4";
    stage.by("play").fire("click");
    // The menu went, the pointer was asked for, the phone's pad came up — this
    // page says its pointer is coarse — and the name went to `localStorage`.
    expect(stage.by("menu").hidden).toBe(true);
    expect(stage.scene.locks).toBe(1);
    expect(stage.by("touch").hidden).toBe(false);
    expect(stage.store.get("cs.name")).toBe("Vesper");
    // One frame: the room and the players drawn through the canvas's own WebGL2
    // context, and the HUD painted onto the recording `Paint` beside it.
    stage.hold("Tab", true);
    stage.step(FRAME);
    expect(drawn(stage).length).toBeGreaterThan(1);
    expect(stage.hud.paint.calls[0]?.[0]).toBe("clearRect");
    expect([stage.hud.width, stage.hud.height]).toEqual([800, 450]);
    expect(stage.by("fps").textContent).toContain("ms");
    // Drawn text, so minification has nothing to hide behind — and the side and
    // the name typed into the menu are what the scoreboard reads back.
    expect(stage.hud.paint.texts).toContain("$800");
    expect(stage.hud.paint.texts).toContain("T  Vesper  (you)");
    // Every id the page carries for this game was looked up by name.
    for (const id of NEEDED) expect(asked).toContain(id);
    // The leaderboard was posted to the page's own `fetch`, which is this stub:
    // no network was reached for and nothing was written anywhere.
    expect(stage.posts.map((post) => post.url)).toEqual(["/api/match"]);
    expect(JSON.parse(stage.posts[0]?.body ?? "{}").name).toBe("Vesper");
  } finally {
    undo();
  }
});
test("a bundled page with no WebGL2 is a sentence in the menu, not an exception", async () => {
  const { stage, undo } = await booted({ webgl: false });
  try {
    // The same sentence `main.test.ts` pins, out of the minified file.
    expect(stage.by("menu").innerHTML).toContain("No WebGL2");
    expect(stage.by("menu").hidden).toBe(false);
    // Nothing was started: no frame was asked for and no listener attached.
    expect(stage.frames.length).toBe(0);
    expect(stage.window.listening.size).toBe(0);
    expect(stage.document.listening.size).toBe(0);
    expect(stage.posts.length).toBe(0);
  } finally {
    undo();
  }
});
test("a page still being parsed is waited for, not booted on", async () => {
  const { stage, undo } = await booted({ loading: true });
  try {
    // The bundle is in the page's head: the ids it wants are not there yet, so
    // the entry asks to be told when they are and nothing runs until then.
    expect(stage.frames.length).toBe(0);
    expect(stage.document.listening.has("DOMContentLoaded")).toBe(true);
    expect(stage.by("fps").textContent).toBe("");
    stage.document.fire("DOMContentLoaded");
    expect(stage.frames.length).toBe(1);
    expect(stage.by("menu").hidden).toBe(false);
  } finally {
    undo();
  }
});
test("a bundle that is missing or doubled is a sentence saying what to do about it", () => {
  const dir = mkdtempSync(join(tmpdir(), "bundle-finder-"));
  try {
    expect(() => bundlePath("app", dir)).toThrow(/has no bundle.*run `bun run scripts\/build\.ts`/);
    writeFileSync(join(dir, "app.0123456789.js"), "");
    expect(bundlePath("app", dir)).toBe(join(dir, "app.0123456789.js"));
    writeFileSync(join(dir, "app.abcdef0123.js"), "");
    expect(() => bundlePath("app", dir)).toThrow(/has 2 bundles.*app\.0123456789\.js/);
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
});
test("the shooter bundles the engine's policy network, because its bots run it", () => {
  // The other end of `src/range/bundle.test.ts`'s claim, read as names the
  // minifier cannot rename: the activation the forward pass runs through, and
  // the `atob` the shipped weights are decoded with. `src/client/bots.ts`
  // unpacks once and runs it on the frame a bot thinks.
  const code = readFileSync(bundlePath("app"), "utf8");
  for (const name of ["Math.tanh", "atob"]) expect(code).toContain(name);
  // And `btoa` is not here, which is the tree shaking working in the other
  // direction: quantising a policy is `pack`, and `pack` only ever runs in
  // `scripts/train.ts`. A page that shipped the quantiser would be shipping a
  // trainer it cannot use.
  expect(code).not.toContain("btoa");
});
test("the shooter bundles the engine's mover, tuned by its own numbers", () => {
  // The other end of `src/range/bundle.test.ts`'s second claim. The solver is
  // the engine's since #123 and the numbers are still this game's: the fields
  // are here because `src/client/movement.ts` writes them, and so is the jump
  // velocity itself, which no engine module knows.
  const code = readFileSync(bundlePath("app"), "utf8");
  for (const field of ["airSpeedCap", "duckRate", "jumpVelocity", "stopSpeed"])
    expect(code).toContain(field);
  expect(code).toContain("301.993");
});
test("the stub page leaves nothing of itself behind", () => {
  // Every boot above undid its install, so no other test inherits a document —
  // nor a `fetch` that answers every URL with a leaderboard.
  expect("document" in globalThis).toBe(HAD_DOCUMENT);
  expect("window" in globalThis).toBe(false);
  expect("localStorage" in globalThis).toBe(false);
  expect(globalThis.fetch).toBe(REAL_FETCH);
});
@@ -1,60 +1,239 @@
/**
 * The buy panel's own tests, which are what `main.test.ts` used to assert
 * through a whole booted frame: the shelf a side is shown, the markup it is
 * drawn as — to the character, for a real world in its freeze time — what a
 * price is for the body in front of you, which tiles a wallet and a round leave
 * pressable, and what a press hands back.
 *
 * The page under it is the engine's `fakePage`: one element to draw into and a
 * `createElement` that makes buttons, which is the whole of what this module
 * borrows from a browser. Most of it needs no world at all — a `Market` is an
 * object with a phase in it and a `Buyer` is the kit and the wallet, the way
 * `economy.test.ts` writes them — and the exact-markup test uses a real
 * `createWorld`, because a module that only works against its own fixtures has
 * proved nothing.
 */
import { expect, test } from "bun:test";
import { NUMBER_ROW } from "./binding.ts";
import { fakePage, type FakeElement } from "../engine/index.ts";
import { drawBuy, HINT, labelOf, offers, REBUY_LABEL, type Counter } from "./buy.ts";
import { emptyAmmo, type BuyItem, type Buyer, type Market } from "./economy.ts";
import { DE_FORGE } from "./map.ts";
import { SHORT } from "./match.ts";
import { ARMOR_PRICE, HELMET_PRICE, WEAPONS } from "./weapons.ts";
import { buy, createWorld, NO_INPUT, update } from "./world.ts";
import { buyMenu } from "./buy.ts";
import { ARMOR_PRICE, DEFUSE_KIT_PRICE, HELMET_PRICE, WEAPONS } from "./weapons.ts";
import { createWorld } from "./world.ts";
const row = (world: ReturnType<typeof createWorld>, item: string) =>
  buyMenu(world, world.me).rows.find((r) => r.item === item);
const freeze: Market = { match: { phase: "freeze" } };
const live: Market = { match: { phase: "live" } };
test("too poor for a rifle: poor, and the price still shows", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 1);
  world.me.money = 100;
  const m4 = row(world, "m4a4");
  expect(m4?.state).toBe("poor");
  expect(m4?.price).toBe(WEAPONS.m4a4.price);
const buyer = (over: Partial<Buyer> = {}): Buyer => ({
  team: "ct", alive: true, money: 5000,
  armor: 0, helmet: false, defuseKit: false,
  weapon: "usp", primary: null, secondary: "usp",
  ammo: { knife: { mag: 0, reserve: 0 }, usp: emptyAmmo("usp") },
  pocket: { he: 0, flash: 0, smoke: 0 },
  ...over,
});
test("a side only sees its own gear", () => {
  const ct = createWorld(SHORT, "me", "ct", 5, 2);
  expect(row(ct, "ak47")).toBeUndefined();
  const t = createWorld(SHORT, "me", "t", 5, 2);
  expect(row(t, "kit")).toBeUndefined();
/** A panel to draw into, the buttons it made, and every item a press handed back. */
function shop(): {
  panel: FakeElement;
  counter: Counter;
  pressed: BuyItem[];
  /** How many times the rebuy control was pressed. */
  rebuys(): number;
  tiles(): FakeElement[];
  /** The one control under the grid: last round's loadout, bought again. */
  again(): FakeElement;
  labels(): (string | null)[];
  /** Whether any tile's label holds this, whatever number it was printed with. */
  says(part: string): boolean;
  /** The tile whose label holds this word, which is how a test names one. */
  tile(label: string): FakeElement;
} {
  const page = fakePage({ ids: ["buy"] });
  const panel = page.by("buy");
  const pressed: BuyItem[] = [];
  let again = 0;
  const tiles = (): FakeElement[] => panel.querySelector(".grid")?.children ?? [];
  return {
    panel,
    pressed,
    rebuys: () => again,
    tiles,
    again: () => {
      const found = panel.querySelector(".row")?.children[0];
      if (found === undefined) throw new Error("no rebuy control");
      return found;
    },
    labels: () => tiles().map((tile) => tile.textContent),
    says: (part) => tiles().some((tile) => tile.textContent?.includes(part) === true),
    // By what the label says and not by index: a weapon added to the table adds
    // a tile and moves every number after it, and a test about the armour should
    // not move when one is.
    tile: (label) => {
      const found = tiles().find((tile) => tile.textContent?.includes(label));
      if (found === undefined) throw new Error(`no tile for ${label}`);
      return found;
    },
    counter: {
      panel,
      button: () => page.document.createElement("button"),
      press: (item) => void pressed.push(item),
      again: () => void (again += 1),
    },
  };
}
test("the shelf is this side's guns, the armour, and the kit only a CT can carry", () => {
  // Every buyable weapon in the table, in the table's order, which is how the
  // smoke #165 added reached the panel without a line in here: the shelf is
  // `weapons.ts`'s list and not a second copy of it.
  expect(offers("ct").map((offer) => offer.item))
    .toEqual(["usp", "deagle", "mp9", "m4a4", "awp", "he", "flash", "smoke", "armor", "helmet", "kit"]);
  // A T's pistol is the Glock and its rifle is the AK, and there is no kit on the
  // shelf at all: a tile a side can never press is a tile that should not be there.
  expect(offers("t").map((offer) => offer.item))
    .toEqual(["glock", "deagle", "mp9", "ak47", "awp", "he", "flash", "smoke", "armor", "helmet"]);
  expect(offers("t").map((offer) => offer.label)).not.toContain("Defuse kit");
});
test("a gun already in hand is owned, not for sale again", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 3);
  world.me.money = 5000;
  buy(world, world.me, "m4a4");
  const m4 = row(world, "m4a4");
  expect(m4?.state).toBe("owned");
test("the panel a real world in its freeze time is drawn as, to the character", () => {
  const world = createWorld(DE_FORGE, SHORT, "me", "ct", 5, 3);
  expect(world.match.phase).toBe("freeze");
  expect(world.me.money).toBe(800);
  const it = shop();
  drawBuy(it.counter, world, world.me);
  expect(it.panel.innerHTML).toBe(
    `<h2>Buy <small>$800</small></h2><div class="grid"></div>` +
    `<div class="row"></div><p class="hint">${HINT}</p>`,
  );
  // Eleven tiles, each a `<button>` — a press that submits nothing — printed
  // with the key that presses it and the price this body pays, and dead exactly
  // where 800 dollars cannot reach. The eleventh key is the one after 0, because
  // a CT's shelf is one longer than the digits and a tile with no key on it is a
  // tile you need the mouse for.
  expect(it.tiles().map((tile) => tile.type)).toEqual(Array(11).fill("button"));
  expect(it.tiles().map((tile) => [tile.textContent, tile.disabled])).toEqual([
    ["1 · USP-S · $200", false],
    ["2 · Desert Eagle · $700", false],
    ["3 · MP9 · $1250", true],
    ["4 · M4A4 · $3100", true],
    ["5 · AWP · $4750", true],
    ["6 · HE Grenade · $300", false],
    ["7 · Flashbang · $200", false],
    ["8 · Smoke Grenade · $300", false],
    ["9 · Kevlar · $650", false],
    ["0 · Kevlar + Helmet · $1000", true],
    ["- · Defuse kit · $400", false],
  ]);
  // And the number a tile is printed with is the key `binding.ts` binds to that
  // index: the panel and the keyboard read one list, so they cannot disagree.
  expect(it.tiles().map((tile) => tile.textContent?.split(" · ")[0]))
    .toEqual([...NUMBER_ROW]);
  // Under them, the control that is not an item. Nothing was bought last round
  // here, so it is dead rather than live and empty.
  expect(it.again().textContent).toBe(REBUY_LABEL);
  expect(it.again().disabled).toBe(true);
});
test("a second grenade is owned, not a second purchase", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 4);
  world.me.money = 5000;
  buy(world, world.me, "he");
  const he = row(world, "he");
  expect(he?.state).toBe("owned");
  expect(he?.why).toContain("carrying");
test("drawing again is the panel again, not a second one under it", () => {
  const it = shop();
  const me = buyer();
  drawBuy(it.counter, freeze, me);
  const drawn = it.tiles().length;
  expect(drawn).toBe(offers("ct").length);
  me.money = 3000;
  drawBuy(it.counter, freeze, me);
  expect(it.tiles().length).toBe(drawn);
  expect(it.panel.innerHTML).toContain("$3000");
});
test("every row goes closed together once canBuy is false", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 5);
  world.me.money = 5000;
  for (let t = 0; t < SHORT.freezeTime + 0.5; t += 1 / 64) update(world, 1 / 64, NO_INPUT);
  expect(world.match.phase).toBe("live");
  const menu = buyMenu(world, world.me);
  expect(menu.rows.length).toBeGreaterThan(0);
  expect(menu.rows.every((r) => r.state === "closed")).toBe(true);
test("a price is for the body in front of you: a vest on is a helmet at helmet price", () => {
  const it = shop();
  drawBuy(it.counter, freeze, buyer({ armor: 100 }));
  expect(it.says(`Kevlar + Helmet · $${HELMET_PRICE}`)).toBe(true);
  // The vest is already on, so it is priced at nothing — and a tile at nothing is
  // pressable, although `economy.ts` refuses the buy. That is today's behaviour
  // and this pull moved it rather than fixing it: see #250.
  expect(it.says("Kevlar · $0")).toBe(true);
  expect(it.tile("Kevlar ·").disabled).toBe(false);
  // Bare, the helmet is the vest as well and costs both.
  const bare = shop();
  drawBuy(bare.counter, freeze, buyer());
  expect(bare.says(`Kevlar + Helmet · $${ARMOR_PRICE + HELMET_PRICE}`)).toBe(true);
  expect(bare.says(`Defuse kit · $${DEFUSE_KIT_PRICE}`)).toBe(true);
});
test("armour's price is what is already worn, not a constant", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 6);
  world.me.money = 5000;
  const bare = row(world, "helmet");
  expect(bare?.price).toBe(ARMOR_PRICE + HELMET_PRICE);
  buy(world, world.me, "armor");
  const armored = row(world, "helmet");
  expect(armored?.price).toBe(HELMET_PRICE);
test("a wallet that cannot reach a price is a dead tile, to the dollar", () => {
  const it = shop();
  drawBuy(it.counter, freeze, buyer({ money: WEAPONS.awp.price - 1 }));
  expect(it.tile(`AWP · $${WEAPONS.awp.price}`).disabled).toBe(true);
  const rich = shop();
  drawBuy(rich.counter, freeze, buyer({ money: WEAPONS.awp.price }));
  expect(rich.tile(`AWP · $${WEAPONS.awp.price}`).disabled).toBe(false);
});
test("outside the freeze time every tile is dead, and the prices are still readable", () => {
  const it = shop();
  drawBuy(it.counter, live, buyer({ money: 16_000 }));
  expect(it.tiles().length).toBe(offers("ct").length);
  expect(it.tiles().every((tile) => tile.disabled)).toBe(true);
  expect(it.says(`AWP · $${WEAPONS.awp.price}`)).toBe(true);
  // And to a body, wherever the round is: a corpse has nothing to spend it on.
  const dead = shop();
  drawBuy(dead.counter, freeze, buyer({ alive: false, money: 16_000 }));
  expect(dead.tiles().every((tile) => tile.disabled)).toBe(true);
});
test("a press hands the item back and spends nothing itself", () => {
  const it = shop();
  const me = buyer();
  drawBuy(it.counter, freeze, me);
  it.tile("USP-S").fire("click");
  it.tile("Kevlar + Helmet").fire("click");
  expect(it.pressed).toEqual(["usp", "helmet"]);
  // The wallet and the kit are the caller's to change: this module reads them.
  expect(me.money).toBe(5000);
  expect(me.helmet).toBe(false);
  // A dead tile is dead because a browser will not click it, not because the
  // panel checks twice — so what is asserted here is that one press is one item.
  it.tile("USP-S").fire("click");
  expect(it.pressed).toEqual(["usp", "helmet", "usp"]);
});
test("the rebuy control is live only when there is a loadout and a round to buy it in", () => {
  const it = shop();
  // Something was bought last round, and the round is one you can buy in.
  drawBuy(it.counter, freeze, buyer(), ["ak47", "armor"]);
  expect(it.again().disabled).toBe(false);
  it.again().fire("click");
  expect(it.rebuys()).toBe(1);
  // It spends nothing itself, the way a tile does not: the caller buys.
  expect(it.pressed).toEqual([]);
  // The same loadout outside the freeze time is a dead control, like every tile
  // beside it, and so is an empty one in the freeze time.
  const late = shop();
  drawBuy(late.counter, live, buyer(), ["ak47"]);
  expect(late.again().disabled).toBe(true);
  const nothing = shop();
  drawBuy(nothing.counter, freeze, buyer(), []);
  expect(nothing.again().disabled).toBe(true);
});
test("the hint under the grid says the keys, and an item answers to the name the shelf gave it", () => {
  const it = shop();
  drawBuy(it.counter, freeze, buyer());
  expect(it.panel.innerHTML).toContain(HINT);
  expect(HINT).toContain("number row");
  expect(HINT).toContain("X");
  expect(HINT).toContain("B or Escape closes");
  // The sentence a rebuy says is built out of these, so they are the shelf's
  // names and not a second table of them.
  expect(labelOf("ak47", "t")).toBe("AK-47");
  expect(labelOf("helmet", "ct")).toBe("Kevlar + Helmet");
  expect(labelOf("kit", "ct")).toBe("Defuse kit");
});
@@ -1,73 +1,144 @@
/**
 * The buy menu's rows: what each item costs, whether it can be bought right
 * now, and why not when it cannot. Pure data in, plain data out — nothing
 * here touches the DOM, so the panel in main.ts is free to paint it however
 * a phone or a screen reader needs.
 * The buy panel: the shop as a player reads it. What is on the shelf is this
 * side's guns, the armour, and the kit only a CT can carry; what each one costs
 * is `economy.ts`'s answer for *this* body — a vest already on is a helmet at
 * helmet price — and whether a tile can be pressed is the wallet and the round
 * together, which is the same `canBuy` a buy itself is refused by. Drawn from
 * scratch every time it opens and again after every press, so the prices and
 * the money in the heading are the prices and the money right now.
 *
 * Every tile is printed with the key that presses it — the number row, left to
 * right, from `binding.ts` — because the panel is read with the mouse still on
 * the game: the hand that buys is the hand that is walking out of spawn, and a
 * tile you can only reach by pointing at it is a tile that costs a pointer
 * round-trip. Under them is the one control that is not an item: last round's
 * loadout, bought again.
 *
 * It is not a browser and it is not the frame. It takes the element to draw
 * into, the two things a price is worked out from — the round and the player —
 * and the calls it cannot make itself: one that makes a `<button>`, one that
 * says which item was pressed, and one that says a rebuy was asked for. `main.ts` is the only file that knows where
 * that element came from; nothing here reaches for a document, a host or a
 * world. A press does not buy: it says what was wanted and hands it back, so
 * the wallet is still spent in one place — the frame, on the world it is
 * simulating — and a tile left over from a match that has ended cannot reach
 * into a match that has not begun.
 *
 * Nothing rendered here comes from outside the program: every label is a
 * constant of `weapons.ts` or of this file, and the only value interpolated is
 * a number off the player. No name, no field, nothing a person typed is in the
 * markup, which is why there is no escaping in it to read.
 */
import { buyable, WEAPONS } from "./weapons.ts";
import { canBuy, grenadeFull, priceOf, type BuyItem, type Player, type World } from "./world.ts";
import { NUMBER_ROW } from "./binding.ts";
import type { Listens } from "../engine/index.ts";
import { canBuy, priceOf, type BuyItem, type Buyer, type Market } from "./economy.ts";
import type { Team } from "./match.ts";
import { buyable } from "./weapons.ts";
export type BuyState = "ok" | "owned" | "poor" | "side" | "closed";
export type BuyRow = {
  item: BuyItem;
  label: string;
  price: number;
  state: BuyState;
  why: string;
};
export type BuyMenu = {
  rows: BuyRow[];
  money: number;
  /** Seconds left in the freeze time, however long it has been over — never negative. */
  secondsLeft: number;
};
/** Every item a side can ever buy — off-side gear (the other rifle, a T's defuse kit) never appears. */
const catalog = (team: "t" | "ct"): [BuyItem, string][] => [
  ...buyable(team).map((w) => [w.id, w.name] as [BuyItem, string]),
  ["armor", "Kevlar"],
  ["helmet", "Kevlar + Helmet"],
  ...(team === "ct" ? ([["kit", "Defuse kit"]] as [BuyItem, string][]) : []),
];
function owned(player: Player, item: BuyItem): boolean {
  if (item === "armor") return player.armor >= 100;
  if (item === "helmet") return player.helmet;
  if (item === "kit") return player.defuseKit;
  if (WEAPONS[item].kind === "grenade") return grenadeFull(player, WEAPONS[item].id);
  return player.primary === item || player.secondary === item;
}
function ownedWhy(item: BuyItem): string {
  if (item === "armor" || item === "helmet") return "already worn";
  if (item === "kit" || WEAPONS[item]?.kind === "grenade") return "already carrying one";
  return "already in hand";
}
function closedWhy(world: World, player: Player): string {
  if (!player.alive) return "you're dead this round";
  if (world.match.phase !== "freeze") return "the buy window is closed";
  return "";
}
/** One thing on the shelf: what a player reads, and what a press of it buys. */
export type Offer = { item: BuyItem; label: string };
/**
 * The rows the buy panel paints. Every row goes `closed` together the moment
 * `canBuy` does — the one rule this file is not allowed a second copy of —
 * and a row too expensive still shows what it costs, so the number is the
 * only thing a player has to check twice.
 * The element the panel is drawn into, as far as this file is concerned: the
 * markup it is given, and the grid it just wrote into that markup.
 * `unknown` because a browser's own `querySelector` is wider than any subset.
 */
export function buyMenu(world: World, player: Player): BuyMenu {
  const open = canBuy(world, player);
  const reason = open ? "" : closedWhy(world, player);
  const rows: BuyRow[] = catalog(player.team).map(([item, label]) => {
export type Shelf = {
  innerHTML: string;
  querySelector(selectors: string): unknown;
  appendChild(child: unknown): void;
};
/** One tile in the grid: a button, its label, whether it can be pressed. */
export type Tile = Listens & { type: string; textContent: string | null; disabled: boolean };
/**
 * What the page has to lend the panel: the element, a way to make a button, and
 * what a press means. `press` is the whole of what this module hands back —
 * the item wanted, once per press — and the caller decides what it costs.
 * `again` is the same thing for the one control that is not an item: last
 * round's loadout, which the caller buys back through the same `buy()`.
 */
export type Counter = {
  panel: Shelf;
  /** A fresh `<button>`, unattached. `document.createElement("button")` is one. */
  button(): Tile;
  press(item: BuyItem): void;
  again(): void;
};
/**
 * What the panel says under the grid: the keys, then the one rule. It reads the
 * way the menu's hint line reads, and it says the number row rather than naming
 * eleven keys, because each tile is printed with the key that presses it.
 */
export const HINT =
  "The number row buys the tile it is printed on · X buys last round's loadout again · " +
  "B or Escape closes. You can only buy in the freeze time.";
/** The control under the grid, and the key it answers to. */
export const REBUY_LABEL = "X · Rebuy last round";
/** The key printed on the nth tile, or "" for a shelf longer than the row. */
export const keyFor = (index: number): string => NUMBER_ROW[index] ?? "";
/** What a tile says: the key that presses it, its name, and what this body pays. */
export const tileLabel = (index: number, label: string, price: number): string => {
  const key = keyFor(index);
  return `${key === "" ? "" : `${key} · `}${label} · $${price}`;
};
/**
 * The shelf, in the order it is drawn: this side's guns and grenades as
 * `weapons.ts` lists them, then the armour, then the defuse kit — which is on
 * the shelf for a CT and not on it at all for a T, because a T cannot carry one
 * and a tile that is never pressable is a tile that should not be there.
 */
export function offers(team: Team): Offer[] {
  const guns: Offer[] = buyable(team).map((weapon) => ({ item: weapon.id, label: weapon.name }));
  const kit: Offer[] = team === "ct" ? [{ item: "kit", label: "Defuse kit" }] : [];
  return [...guns, { item: "armor", label: "Kevlar" }, { item: "helmet", label: "Kevlar + Helmet" }, ...kit];
}
/** The name this shelf gives an item, which is the name a sentence about it uses. */
export const labelOf = (item: BuyItem, team: Team): string =>
  offers(team).find((offer) => offer.item === item)?.label ?? item;
/**
 * Draw the panel: the heading with what is left to spend, one tile per offer —
 * numbered with the key that presses it — the rebuy control, and the hint. A
 * tile is dead when the wallet cannot reach the price or when the round is not
 * one a buy is allowed in at all — the panel shows the prices either way rather
 * than emptying itself, because what the next freeze time costs is worth
 * reading.
 *
 * `last` is what was bought the round before, and the whole of what this module
 * wants to know about it is whether there is any of it: a rebuy with nothing to
 * buy back is a dead control rather than a live one that does nothing.
 */
export function drawBuy(counter: Counter, market: Market, player: Buyer, last: readonly BuyItem[] = []): void {
  const open = canBuy(market, player);
  counter.panel.innerHTML =
    `<h2>Buy <small>$${player.money}</small></h2><div class="grid"></div>` +
    `<div class="row"></div><p class="hint">${HINT}</p>`;
  const grid = counter.panel.querySelector(".grid") as Shelf;
  // The index is the tile's place on the screen and the key that presses it,
  // read out of one list: `main.ts` turns the key back into this same index of
  // this same `offers`, so the number on a tile is the item it buys.
  offers(player.team).forEach(({ item, label }, index) => {
    const price = priceOf(item, player);
    if (!open) return { item, label, price, state: "closed", why: reason };
    if (owned(player, item)) return { item, label, price, state: "owned", why: ownedWhy(item) };
    if (price > player.money) return { item, label, price, state: "poor", why: "not enough money" };
    return { item, label, price, state: "ok", why: "" };
    const tile = counter.button();
    tile.type = "button";
    tile.textContent = tileLabel(index, label, price);
    tile.disabled = price > player.money || !open;
    tile.addEventListener("click", () => counter.press(item));
    grid.appendChild(tile);
  });
  return { rows, money: player.money, secondsLeft: Math.max(0, world.match.timer) };
  const again = counter.button();
  again.type = "button";
  again.textContent = REBUY_LABEL;
  again.disabled = !open || last.length === 0;
  again.addEventListener("click", () => counter.again());
  (counter.panel.querySelector(".row") as Shelf).appendChild(again);
}
@@ -1,63 +0,0 @@
import { expect, test } from "bun:test";
import {
  canSpeak, clearChatter, isNews, newChatter, noteCallout, sightingText,
  REPEAT_GAP, SIDE_GAP, SPEAKER_GAP,
} from "./callout.ts";
test("a sighting names the teammate and the place, in that order", () => {
  const said = sightingText("Krait", "A site");
  expect(said).toBe("Krait: enemy — A site");
});
test("a place the map could not name is left off rather than guessed at", () => {
  expect(sightingText("Pike", null)).toBe("Pike: enemy");
});
test("the gaps are ordered: the side's, then one bot's, then the same place", () => {
  // The HUD holds a line for four seconds and draws only the last one, so a
  // side that talks faster than SIDE_GAP overwrites itself unread.
  expect(SIDE_GAP).toBe(4);
  expect(SPEAKER_GAP).toBeGreaterThan(SIDE_GAP);
  expect(REPEAT_GAP).toBeGreaterThan(SPEAKER_GAP);
});
test("a fresh side may speak, and then not again until the gaps have run", () => {
  const chatter = newChatter(4);
  expect(canSpeak(chatter, 1, 0)).toBe(true);
  noteCallout(chatter, 1, "mid", 0);
  // Nobody at all, until the side's own gap is up.
  expect(canSpeak(chatter, 2, SIDE_GAP - 0.1)).toBe(false);
  expect(canSpeak(chatter, 2, SIDE_GAP)).toBe(true);
  // And not this bot again, for longer still: one voice cannot hold the feed.
  expect(canSpeak(chatter, 1, SIDE_GAP)).toBe(false);
  expect(canSpeak(chatter, 1, SPEAKER_GAP)).toBe(true);
});
test("the side does not repeat the same call about the same place", () => {
  const chatter = newChatter(4);
  noteCallout(chatter, 1, "mid", 0);
  expect(isNews(chatter, "mid", REPEAT_GAP - 0.1)).toBe(false);
  expect(isNews(chatter, "mid", REPEAT_GAP)).toBe(true);
  // Somewhere else is news at once: that is a second angle, not a repeat.
  expect(isNews(chatter, "A site", 0.1)).toBe(true);
  expect(isNews(chatter, null, 0.1)).toBe(true);
});
test("clearing forgets everything, in place", () => {
  const chatter = newChatter(4);
  const voices = chatter.spokeAt;
  noteCallout(chatter, 3, "mid", 100);
  expect(canSpeak(chatter, 3, 101)).toBe(false);
  clearChatter(chatter);
  expect(chatter.spokeAt).toBe(voices); // the same array, zeroed, never a new one
  expect(canSpeak(chatter, 3, 101)).toBe(true);
  expect(isNews(chatter, "mid", 101)).toBe(true);
});
test("a speaker the side has no slot for cannot corrupt the record", () => {
  const chatter = newChatter(2);
  noteCallout(chatter, 9, "mid", 5);
  expect(chatter.spokeAt.length).toBe(2);
  expect(chatter.lastAt).toBe(5); // the side still said it
});
@@ -1,113 +0,0 @@
/**
 * What a teammate says out loud when it sees somebody, and how often it is
 * allowed to say it.
 *
 * A bot already knows where the enemy is — it runs `canSee` against every one
 * of them every tick to decide whether to shoot. This is the rule that turns a
 * little of that into a line on the message feed: which words, about where,
 * and the three gaps that keep four teammates from filling the screen.
 *
 * One thing is said and no more: an enemy seen. The vocabulary is `map.ts`'s —
 * `placeAt` names the layout's own areas, so a callout can only ever say a
 * place the map itself carved. There is no table of coordinates here.
 *
 * Nothing in this file touches a world or allocates: it is a clock, three
 * numbers and a fixed set of words, so `world.ts` can ask "may this bot speak"
 * for the price of two comparisons on the tick where the answer is no — which
 * is nearly every tick.
 */
/**
 * One line, built only once the rate limit has already said yes. A place the
 * map could not name is dropped rather than guessed at.
 *
 * "enemy" is somebody being looked at down a barrel and means exactly that:
 * nothing in the game says this word about a footstep or a guess.
 */
export const sightingText = (name: string, place: string | null): string =>
  place === null ? `${name}: enemy` : `${name}: enemy — ${place}`;
// --- the rate limit -------------------------------------------------------
//
// Three gaps, because there are three different ways a radio becomes noise:
// the side as a whole, one bot on its own, and the same call said twice. The
// six-message cap in `say` is a backstop and not a limit — six lines a second
// is still six lines a second.
/**
 * Seconds between any two things the side says. The HUD holds a line for four
 * seconds (`MESSAGE_FADE` in hud.ts) and draws only the last one, so a side
 * that talks faster than this paints over its own previous line before it can
 * be read: one line, readable, is worth more than three that flicker.
 */
export const SIDE_GAP = 4;
/**
 * Seconds before the same bot says anything again. Six — one and a half
 * `SIDE_GAP`s — so the four teammates together can still fill every slot the
 * side's gap allows, but no one of them can hold the feed on its own: a bot in
 * a long fight calls it once and then lets somebody else talk.
 */
export const SPEAKER_GAP = 6;
/**
 * Seconds before the side calls the same place again. Twelve — three lines'
 * worth of `SIDE_GAP` — is long enough that five teammates walking into the
 * same angle say "enemy — mid" once between them, and short enough that a site
 * still being fought over a quarter of a minute later is worth mentioning
 * again.
 */
export const REPEAT_GAP = 12;
/**
 * What the side has said lately. Sized once, in `createWorld`, and zeroed in
 * place by `startRound`: nothing here is ever allocated during a round.
 */
export type Chatter = {
  /** When the side last said anything at all. */
  lastAt: number;
  /** When each player last said anything, by player id. */
  spokeAt: Float64Array;
  /** The place the side's last sighting named, and when it named it. */
  place: string | null;
  placeAt: number;
};
/** A side that has never said anything, with room for `players` voices. */
export const newChatter = (players: number): Chatter => ({
  lastAt: -Infinity,
  spokeAt: new Float64Array(players).fill(-Infinity),
  place: null,
  placeAt: -Infinity,
});
/** Forget it all, in place: a new round starts with nothing already said. */
export function clearChatter(chatter: Chatter): void {
  chatter.lastAt = -Infinity;
  chatter.spokeAt.fill(-Infinity);
  chatter.place = null;
  chatter.placeAt = -Infinity;
}
/**
 * The cheap half of the limit: has the side, and this bot, been quiet long
 * enough? Asked first and on every tick a bot makes contact, so it looks at
 * two numbers and nothing else — the place is not even worked out yet.
 */
export const canSpeak = (chatter: Chatter, speakerId: number, now: number): boolean =>
  now - chatter.lastAt >= SIDE_GAP &&
  now - (chatter.spokeAt[speakerId] ?? -Infinity) >= SPEAKER_GAP;
/** The other half: is this actually news, or the same call about the same place? */
export const isNews = (chatter: Chatter, place: string | null, now: number): boolean =>
  chatter.place !== place || now - chatter.placeAt >= REPEAT_GAP;
/** Write down that it was said. The caller has already asked both questions. */
export function noteCallout(
  chatter: Chatter, speakerId: number, place: string | null, now: number,
): void {
  chatter.lastAt = now;
  if (speakerId >= 0 && speakerId < chatter.spokeAt.length) chatter.spokeAt[speakerId] = now;
  chatter.place = place;
  chatter.placeAt = now;
}
@@ -0,0 +1,129 @@
/**
 * The alphabet every map of this game is written in, and what a page of it
 * becomes. A cell is one letter — rock, floor, a crate you can climb, a crate
 * you cannot, the two bombsites, the two spawns — and `levelOf` turns a grid of
 * those letters into a `Level`: the boxes a bullet stops in and the renderer
 * draws, the spawn points, the middle of each site, and the predicate that says
 * what a bot may stand on.
 *
 * It exists because there are two maps now and there will be more. `map.ts`
 * writes de_forge's page by hand and `generate.ts` writes one from a seed;
 * neither of them owns what a letter means, so neither of them can disagree
 * with the other about it. What a level *is* — the type, and the questions
 * asked of one every tick — is `level.ts`, which knows no alphabet at all, and
 * the arithmetic under this file is the engine's `grid.ts`, which knows less
 * still: what counts as solid or walkable goes in as a predicate.
 */
import * as g from "../engine/index.ts";
import type { Box, Grid, Vec3 } from "../engine/index.ts";
import type { Level } from "./level.ts";
import { FORGE, type Look } from "./looks.ts";
/** World units along one side of a cell: Source units, like everything here. */
export const CELL = 128;
/** How tall a wall stands. Nothing in this game can see or shoot over one. */
export const WALL_HEIGHT = 384;
/**
 * One letter of a map. `#` rock, `.` floor, `x` a crate you can jump onto, `X`
 * one you cannot, `A` and `B` the two bombsites, `t` and `c` the two spawns.
 */
export type Cell = "#" | "." | "x" | "X" | "A" | "B" | "t" | "c";
/**
 * The material ids this game's boxes are tagged with, by name — de_forge's own,
 * and what a level is dressed in when it asks for nothing else. Which numbers
 * these are is `looks.ts`'s business now: a generated map hands `levelOf` a
 * different set from the same seed that carved it, and everything below is
 * written in the names rather than in the numbers, so it never has to know.
 */
export const MAT = FORGE.materials;
/**
 * Solid to a walking bot: walls and both kinds of crate. This predicate is the
 * whole of what the engine's search knows about this alphabet, and it is the
 * one thing a level carries that is a function rather than a number.
 */
export const passable = (c: string): boolean => c !== "#" && c !== "x" && c !== "X";
/** The bounding slab of every cell paved with one letter, two units thick, in the level's own site material. */
function siteSlab(grid: Grid<Cell>, fill: Cell, mat: number): Box {
  let c0 = grid.width, r0 = grid.height, c1 = 0, r1 = 0;
  for (let r = 0; r < grid.height; r++)
    for (let c = 0; c < grid.width; c++)
      if (grid.cells[r * grid.width + c] === fill) {
        c0 = Math.min(c0, c); c1 = Math.max(c1, c);
        r0 = Math.min(r0, r); r1 = Math.max(r1, r);
      }
  if (c1 < c0) throw new Error(`no cell of this map is paved "${fill}": it has no site to plant on`);
  const a = g.worldOf(grid, c0, r0), b = g.worldOf(grid, c1, r1);
  return {
    min: [a[0] - CELL / 2, b[1] - CELL / 2, 0],
    max: [b[0] + CELL / 2, a[1] + CELL / 2, 2],
    mat,
  };
}
/** Every cell paved with one letter, as world points, in reading order. */
export function cellsOf(grid: Grid<Cell>, fill: Cell): Vec3[] {
  const out: Vec3[] = [];
  for (let r = 0; r < grid.height; r++)
    for (let c = 0; c < grid.width; c++)
      if (grid.cells[r * grid.width + c] === fill) out.push(g.worldOf(grid, c, r));
  return out;
}
function centre(list: Vec3[]): Vec3 {
  const s = list.reduce((a, p) => [a[0] + p[0], a[1] + p[1], 0] as Vec3, [0, 0, 0] as Vec3);
  return [s[0] / list.length, s[1] / list.length, 0];
}
/**
 * A page of letters, read as a level: the floor slab, the two painted sites,
 * the walls and both heights of crate merged into as few boxes as the shape
 * allows, the spawn points and the middle of each site.
 *
 * One piece of data feeds everything — what you collide with, what gets drawn,
 * where bots walk, where the bomb can be planted — so a map can never disagree
 * with itself. A grid with no `A`, no `B`, or no cell for a side to spawn on is
 * not a map anybody can play and says so here rather than at the first round.
 *
 * `look` is what it is painted in: one of the named sets in `looks.ts`, de_forge's
 * own unless a caller says otherwise. It touches the boxes' material tags and
 * nothing else — not a cell, not a spawn, not a site, not one coordinate — so
 * the same page of letters in two looks is the same map twice over, and a
 * generated one can be a different place for free.
 */
export function levelOf(name: string, grid: Grid<Cell>, look: Look = FORGE): Level {
  const halfX = (grid.width / 2) * CELL;
  const halfY = (grid.height / 2) * CELL;
  const mat = look.materials;
  const floor: Box = { min: [-halfX, -halfY, -32], max: [halfX, halfY, 0], mat: mat.FLOOR };
  const merge = (match: (c: Cell) => boolean, z0: number, z1: number, mat: number): Box[] =>
    g.mergeSolid(grid, match, z0, z1, mat);
  const spawns = { t: cellsOf(grid, "t"), ct: cellsOf(grid, "c") };
  for (const [side, list] of Object.entries(spawns))
    if (list.length === 0) throw new Error(`no cell of this map is a ${side} spawn`);
  return {
    name,
    grid,
    passable,
    wallHeight: WALL_HEIGHT,
    look: look.name,
    materials: mat,
    // Everything solid, in one list: the renderer draws it and bullets stop in it.
    boxes: [
      floor,
      siteSlab(grid, "A", mat.SITE),
      siteSlab(grid, "B", mat.SITE),
      ...merge((c) => c === "#", 0, WALL_HEIGHT, mat.WALL),
      ...merge((c) => c === "x", 0, 64, mat.CRATE),
      ...merge((c) => c === "X", 0, 128, mat.CRATE),
    ],
    spawns,
    sites: { A: centre(cellsOf(grid, "A")), B: centre(cellsOf(grid, "B")) },
    siteCells: { A: "A", B: "B" },
  };
}
@@ -1,8 +1,11 @@
import { expect, test } from "bun:test";
import { applyHit, hitboxes, traceBullet, type Actor } from "./combat.ts";
import { MAT, type Box } from "./map.ts";
import type { Vec3 } from "./math.ts";
import { WEAPONS, type Weapon } from "./weapons.ts";
import {
  applyHit, FULL_ARMOR, FULL_HEALTH, hitboxes, killRange, shotCost, traceBullet, wholeBody,
  type Actor,
} from "./combat.ts";
import type { Box } from "./level.ts";
import type { Vec3 } from "../engine/index.ts";
import { BULLET_RANGE, KNIFE_RANGE, WEAPONS } from "./weapons.ts";
const actor = (over: Partial<Actor> = {}): Actor => ({
  id: 1, team: "t", pos: [500, 0, 0], yaw: 180, duckAmount: 0,
@@ -20,25 +23,25 @@
test("a crouching head sits where a crouching head looks", () => {
test("a bullet at head height hits the head", () => {
  const target = actor();
  const hit = traceBullet([0, 0, 66], [1000, 0, 66], [], [target], 0, WEAPONS.ak47);
  const hit = traceBullet([0, 0, 66], [1000, 0, 66], [], [target], 0);
  expect(hit.kind).toBe("actor");
  if (hit.kind === "actor") expect(hit.group).toBe("head");
});
test("a wall in the way stops the bullet before the body", () => {
  const wall: Box = { min: [200, -100, 0], max: [216, 100, 384], mat: 1 };
  const hit = traceBullet([0, 0, 40], [1000, 0, 40], [wall], [actor()], 0, WEAPONS.ak47);
  const hit = traceBullet([0, 0, 40], [1000, 0, 40], [wall], [actor()], 0);
  expect(hit.kind).toBe("world");
  if (hit.kind === "world") expect(hit.point[0]).toBeCloseTo(200, 3);
});
test("you cannot shoot yourself", () => {
  const me = actor({ id: 7, pos: [10, 0, 0] });
  expect(traceBullet([0, 0, 40], [1000, 0, 40], [], [me], 7, WEAPONS.ak47).kind).toBe("none");
  expect(traceBullet([0, 0, 40], [1000, 0, 40], [], [me], 7).kind).toBe("none");
});
test("a dead body does not stop bullets", () => {
  expect(traceBullet([0, 0, 40], [1000, 0, 40], [], [actor({ alive: false })], 0, WEAPONS.ak47).kind).toBe("none");
  expect(traceBullet([0, 0, 40], [1000, 0, 40], [], [actor({ alive: false })], 0).kind).toBe("none");
});
test("two AK headshots are one too many", () => {
@@ -50,6 +53,21 @@
test("two AK headshots are one too many", () => {
  expect(target.alive).toBe(false);
});
test("a Deagle one-taps a helmeted head from the far corner of the map", () => {
  // A bullet fired the whole length one can be fired, at a head with a helmet
  // and a full vest: the trace says head, the hit says killed, and the body is
  // down in one. This is the end of the wire `weapons.test.ts` measures.
  const far = actor({ pos: [BULLET_RANGE - 500, 0, 0], armor: 100, helmet: true });
  const hit = traceBullet([0, 0, 66], [BULLET_RANGE, 0, 66], [], [far], 0);
  expect(hit.kind).toBe("actor");
  if (hit.kind !== "actor") return;
  expect(hit.group).toBe("head");
  expect(hit.distance).toBeGreaterThan(7000);
  const result = applyHit(far, WEAPONS.deagle, hit.group, hit.distance);
  expect(result).toEqual({ damage: 100, killed: true, headshot: true });
  expect(far.alive).toBe(false);
});
test("damage credited never exceeds the health that was there", () => {
  const target = actor({ health: 12 });
  const hit = applyHit(target, WEAPONS.ak47, "chest", 100);
@@ -57,76 +75,76 @@
test("damage credited never exceeds the health that was there", () => {
  expect(hit.killed).toBe(true);
});
// --- penetration ----------------------------------------------------------
/**
 * `shotCost` and `killRange` are what a page of weapon numbers is allowed to
 * ask, so every figure below is one a person can do on paper and check against
 * the same arithmetic the round runs on. If one of these moves, a number
 * printed somewhere moved with it, which is the point of both.
 */
const crate = (x0: number, x1: number, mat: number = MAT.CRATE): Box =>
  ({ min: [x0, -100, 0], max: [x1, 100, 384], mat });
/** One shot down the x axis at a body at 500, and what it took off them. */
const shootThrough = (weapon: Weapon, boxes: Box[]): number => {
  const target = actor();
  const hit = traceBullet([0, 0, 40], [1000, 0, 40], boxes, [target], 0, weapon);
  if (hit.kind !== "actor") return 0;
  return applyHit(target, weapon, hit.group, hit.distance, hit.damageScale).damage;
};
test("a rifle crosses a thin crate and still hurts, for less than the clear shot", () => {
  const through = shootThrough(WEAPONS.ak47, [crate(200, 280)]);
  const clear = shootThrough(WEAPONS.ak47, []);
  expect(through).toBeGreaterThan(0);
  expect(through).toBeLessThan(clear);
test("what one shot costs is the fight's own sum, to the point", () => {
  // 36 × 4 (head) = 144, nothing in the way of it.
  expect(shotCost(WEAPONS.ak47, "head", 0)).toEqual({ health: 144, armor: 0, shots: 1 });
  // 36 through 77.5% penetration is 27.9 → 28 health, and the vest takes half
  // of the 8.1 it stopped → 4. Four of those is 112, which is more than a body.
  expect(shotCost(WEAPONS.ak47, "chest", 0, FULL_ARMOR, true)).toEqual({ health: 28, armor: 4, shots: 4 });
  // A leg is never covered, so the vest changes nothing about it: 115 × 0.75.
  expect(shotCost(WEAPONS.awp, "leg", 0, FULL_ARMOR, true).health).toBe(86);
  // The first shot's cost is uncapped by what is left, which is how a table
  // shows the headroom a gun has: 63 × 4 × 0.955^(8192/500) × 0.925 = 110.
  expect(shotCost(WEAPONS.deagle, "head", BULLET_RANGE, FULL_ARMOR, true).health).toBe(110);
  // And a grenade has no bullet at all: nothing off, and nobody falls.
  expect(shotCost(WEAPONS.he, "chest", 0)).toEqual({ health: 0, armor: 0, shots: null });
});
test("a pistol's round stays in the crate a rifle's crosses", () => {
  expect(shootThrough(WEAPONS.glock, [crate(200, 280)])).toBe(0);
});
test("no round crosses a wall, a floor, a site plate or metal, however thin", () => {
  for (const mat of [MAT.WALL, MAT.FLOOR, MAT.SITE, MAT.METAL]) {
    expect(shootThrough(WEAPONS.awp, [crate(200, 216, mat)])).toBe(0);
test("the shots to kill are the shots the fight needs", () => {
  // Counted by firing them, not by dividing: the same loop a round runs, into
  // the same body, so the count on a page and the count in a fight are one
  // number. Checked here against a body shot the long way round.
  for (const weapon of [WEAPONS.glock, WEAPONS.ak47, WEAPONS.awp, WEAPONS.knife]) {
    for (const group of ["head", "chest", "leg"] as const) {
      const target = actor({ armor: FULL_ARMOR, helmet: true });
      let fired = 0;
      while (target.alive && fired < 64) {
        applyHit(target, weapon, group, 0);
        fired += 1;
      }
      expect(shotCost(weapon, group, 0, FULL_ARMOR, true).shots).toBe(fired);
    }
  }
  // And the arithmetic of one of them, on paper: a Glock's 30 to a vested chest
  // is 14 health and 8 armour a shot, so it takes eight of them.
  expect(shotCost(WEAPONS.glock, "chest", 0, FULL_ARMOR, true)).toEqual({ health: 14, armor: 8, shots: 8 });
});
test("a crate thicker than the round's limit stops it", () => {
  // 200 units of crate: the AWP's 230 goes through, the AK's 175 does not.
  expect(shootThrough(WEAPONS.ak47, [crate(200, 400)])).toBe(0);
  expect(shootThrough(WEAPONS.awp, [crate(200, 400)])).toBeGreaterThan(0);
test("how far one shot to the head still kills is searched to the unit", () => {
  // A Glock's 30 falls at 0.75 per 500 units: 30 × 4 × 0.75^(325/500) = 99.54,
  // which rounds to 100 and is exactly a body. One unit further it is 99.48,
  // rounds to 99, and the head gets up.
  expect(killRange(WEAPONS.glock, "head")).toBe(325);
  expect(shotCost(WEAPONS.glock, "head", 325).health).toBe(100);
  expect(shotCost(WEAPONS.glock, "head", 326).health).toBe(99);
  // The Deagle's promise, as a number: every unit a bullet can travel.
  expect(killRange(WEAPONS.deagle, "head", FULL_ARMOR, true)).toBe(BULLET_RANGE);
  // The M4A4's 33 × 4 through a helmet is 92, which is not a body at any range.
  expect(killRange(WEAPONS.m4a4, "head", FULL_ARMOR, true)).toBe(null);
  // A knife's answer is its own reach and never a bullet's.
  expect(killRange(WEAPONS.knife, "head")).toBe(KNIFE_RANGE);
});
test("two crates in a line stop the bullet: one surface a shot", () => {
  expect(shootThrough(WEAPONS.ak47, [crate(200, 280), crate(320, 400)])).toBe(0);
  const hit = traceBullet([0, 0, 40], [1000, 0, 40], [crate(200, 280), crate(320, 400)], [actor()], 0, WEAPONS.ak47);
  expect(hit.kind).toBe("world");
  if (hit.kind === "world") expect(hit.point[0]).toBeCloseTo(320, 3);
});
test("a punched crate reports the face it was punched at, and the tracer ends past it", () => {
  const hit = traceBullet([0, 0, 40], [1000, 0, 40], [crate(200, 280)], [actor()], 0, WEAPONS.ak47);
  expect(hit.kind).toBe("actor");
  expect(hit.through?.point[0]).toBeCloseTo(200, 3);
  expect(hit.through?.normal).toEqual([-1, 0, 0]);
  expect(hit.point[0]).toBeGreaterThan(280);
});
test("a body in front of the crate is hit at full damage, nothing punched", () => {
  const target = actor({ pos: [100, 0, 0] });
  const hit = traceBullet([0, 0, 40], [1000, 0, 40], [crate(200, 280)], [target], 0, WEAPONS.ak47);
  expect(hit.kind).toBe("actor");
  if (hit.kind === "actor") expect(hit.damageScale).toBe(1);
  expect(hit.through).toBeNull();
});
test("a knife has no penetration: a crate is a crate", () => {
  const hit = traceBullet([0, 0, 40], [1000, 0, 40], [crate(200, 216)], [actor()], 0, WEAPONS.knife);
  expect(hit.kind).toBe("world");
test("a whole body is the body the world spawns and the shop dresses", () => {
  const body = wholeBody(FULL_ARMOR, true);
  expect(body.health).toBe(FULL_HEALTH);
  expect(body.armor).toBe(FULL_ARMOR);
  expect(body.alive).toBe(true);
});
// --- the knife's back -----------------------------------------------------
/** One stab at a full-health, fully armoured target facing `yaw`, from `from`. */
const stab = (from: Vec3, yaw: number, weapon: Weapon = WEAPONS.knife) => {
  const target = actor({ pos: [0, 0, 0], yaw, armor: 100, helmet: true });
  const result = applyHit(target, weapon, "chest", 48, 1, from);
const stab = (from: Vec3, yaw: number, weapon = WEAPONS.knife) => {
  const target = actor({ pos: [0, 0, 0], yaw, armor: FULL_ARMOR, helmet: true });
  const result = applyHit(target, weapon, "chest", 48, from);
  return { target, result };
};
@@ -139,11 +157,11 @@
test("a stab in the back ends a 100/100 player in one; the same stab in the ches
  const front = stab([-40, 0, 64], 180); // same spot, they turned round
  expect(front.result.killed).toBe(false);
  expect(front.target.health).toBeGreaterThan(50);
  expect(front.target.armor).toBeLessThan(100); // armour still took its share
  expect(front.target.armor).toBeLessThan(FULL_ARMOR); // armour still took its share
});
test("a hit with nowhere to have come from is never a back", () => {
  const target = actor({ pos: [0, 0, 0], yaw: 0, armor: 100, helmet: true });
  const target = actor({ pos: [0, 0, 0], yaw: 0, armor: FULL_ARMOR, helmet: true });
  expect(applyHit(target, WEAPONS.knife, "chest", 48).killed).toBe(false);
});
@@ -2,13 +2,23 @@
 * Hitboxes and what a bullet does when it reaches one. A body is four boxes
 * stacked from the feet, scaled by how far the player is crouched, so a
 * crouching head really is where a crouching head looks.
 *
 * What a body *is* is here too — a hundred hit points and, when it bought one,
 * a hundred points of vest — because those two numbers are the denominator of
 * every answer in this file: "does this kill" is a comparison against them.
 * `src/client/world.ts` spawns on them and `src/client/economy.ts` sells them.
 */
import { MAT, type Box } from "./map.ts";
import { dist, type Vec3 } from "./math.ts";
import { HULL } from "./physics.ts";
import { rayBox, traceWorld, type Hit } from "./trace.ts";
import { computeDamage, fromBehind, penetration, type Hitgroup, type Weapon } from "./weapons.ts";
import type { Box } from "./level.ts";
import { dist, rayBox, traceWorld, type Vec3 } from "../engine/index.ts";
import { CS_HULL } from "./movement.ts";
import { computeDamage, fromBehind, type Hitgroup, reachOf, type Weapon } from "./weapons.ts";
/** The health a body spawns with, and the health it is killed by losing. */
export const FULL_HEALTH = 100;
/** The armour a vest is worth, bought whole or not at all. */
export const FULL_ARMOR = 100;
export type Actor = {
  id: number;
@@ -33,7 +43,7 @@
const PARTS: [Hitgroup, number, number, number][] = [
];
export function hitboxes(a: Actor): Part[] {
  const height = HULL.stand + (HULL.duck - HULL.stand) * a.duckAmount;
  const height = CS_HULL.stand + (CS_HULL.duck - CS_HULL.stand) * a.duckAmount;
  return PARTS.map(([group, lo, hi, w]) => ({
    group,
    min: [a.pos[0] - w, a.pos[1] - w, a.pos[2] + height * lo] as Vec3,
@@ -41,152 +51,58 @@
export function hitboxes(a: Actor): Part[] {
  }));
}
/** The face a bullet went in by, when it came out the other side. */
export type Punch = { point: Vec3; normal: Vec3 };
export type BulletHit =
  | {
      kind: "actor"; actor: Actor; group: Hitgroup; point: Vec3; distance: number;
      /** What is left of the damage: 1, or the weapon's share through a crate. */
      damageScale: number;
      /** Where it entered the crate it crossed, or null if it crossed nothing. */
      through: Punch | null;
    }
  | { kind: "world"; point: Vec3; normal: Vec3; distance: number; through: Punch | null }
  | { kind: "none"; point: Vec3; through: Punch | null };
  | { kind: "actor"; actor: Actor; group: Hitgroup; point: Vec3; distance: number }
  | { kind: "world"; point: Vec3; normal: Vec3; distance: number }
  | { kind: "none"; point: Vec3 };
const at = (from: Vec3, to: Vec3, t: number): Vec3 => [
  from[0] + (to[0] - from[0]) * t,
  from[1] + (to[1] - from[1]) * t,
  from[2] + (to[2] - from[2]) * t,
];
/** How far past the exit face the next leg starts, so it cannot re-enter. */
const SKIN = 0.25;
type Leg = { body: Extract<BulletHit, { kind: "actor" }> | null; world: Hit | null };
/**
 * One straight leg: the nearest body, and the nearest solid. `origin` is where
 * the shot came from, which is what range falloff measures against even when
 * this leg starts at the far side of a crate.
 */
function traceLeg(
  from: Vec3,
  to: Vec3,
  boxes: Box[],
  actors: Actor[],
  shooterId: number,
  origin: Vec3,
): Leg {
  const world = traceWorld(from, to, boxes);
  let bestT = world === null ? 1 : world.t;
  let body: Leg["body"] = null;
  for (const actor of actors) {
    if (!actor.alive || actor.id === shooterId) continue;
    for (const part of hitboxes(actor)) {
      const hit = rayBox(from, to, part.min, part.max);
      if (hit === null || hit.t >= bestT) continue;
      bestT = hit.t;
      const point = at(from, to, hit.t);
      body = {
        kind: "actor",
        actor,
        group: part.group,
        point,
        distance: dist(origin, point),
        damageScale: 1,
        through: null,
      };
    }
  }
  return { body, world };
}
/**
 * Where a bullet leaves the solid it just entered, or null if it stays in it.
 * Only `MAT.CRATE` is soft: a wall, a floor, a site plate and metal all stop
 * everything. The thickness is the entry and exit fractions of the same box,
 * so a round clipping a corner spends far less of its budget than one going
 * through the middle of a face.
 */
function punchThrough(
  from: Vec3,
  to: Vec3,
  hit: Hit,
  weapon: Weapon,
): { entry: Punch; exit: Vec3 } | null {
  const box = hit.what as Box;
  const limit = penetration(weapon);
  if (box.mat !== MAT.CRATE || limit.units <= 0) return null;
  const span = rayBox(from, to, box.min, box.max);
  if (span === null) return null;
  const segment = dist(from, to);
  if ((span.tExit - span.t) * segment > limit.units) return null;
  const tOut = span.tExit + SKIN / Math.max(segment, 1);
  if (tOut >= 1) return null; // the shot ran out of range inside the crate
  return { entry: { point: hit.point, normal: hit.normal }, exit: at(from, to, tOut) };
}
/**
 * The first thing a bullet meets: a body beats a wall only if it is nearer.
 * A crate thin enough for the round is crossed — once. Whatever the bullet
 * meets on the far side is what it hit, at `damageScale` of its damage, and
 * two crates in a line stop it as surely as a wall does.
 */
/** The first thing a bullet meets: a body beats a wall only if it is nearer. */
export function traceBullet(
  from: Vec3,
  to: Vec3,
  boxes: Box[],
  actors: Actor[],
  shooterId: number,
  weapon: Weapon,
): BulletHit {
  const near = traceLeg(from, to, boxes, actors, shooterId, from);
  if (near.body !== null) return near.body;
  if (near.world === null) return { kind: "none", point: to, through: null };
  const punched = punchThrough(from, to, near.world, weapon);
  if (punched === null)
    return {
      kind: "world",
      point: near.world.point,
      normal: near.world.normal,
      distance: dist(from, near.world.point),
      through: null,
    };
  const { entry, exit } = punched;
  const far = traceLeg(exit, to, boxes, actors, shooterId, from);
  if (far.body !== null)
    return { ...far.body, damageScale: penetration(weapon).survives, through: entry };
  if (far.world !== null)
    return {
      kind: "world",
      point: far.world.point,
      normal: far.world.normal,
      distance: dist(from, far.world.point),
      through: entry,
    };
  return { kind: "none", point: to, through: entry };
  const world = traceWorld(from, to, boxes);
  let bestT = world === null ? 1 : world.t;
  let best: BulletHit | null = null;
  for (const actor of actors) {
    if (!actor.alive || actor.id === shooterId) continue;
    for (const part of hitboxes(actor)) {
      const hit = rayBox(from, to, part.min, part.max);
      if (hit === null || hit.t >= bestT) continue;
      bestT = hit.t;
      best = {
        kind: "actor",
        actor,
        group: part.group,
        point: [
          from[0] + (to[0] - from[0]) * hit.t,
          from[1] + (to[1] - from[1]) * hit.t,
          from[2] + (to[2] - from[2]) * hit.t,
        ],
        distance: dist(from, to) * hit.t,
      };
    }
  }
  if (best !== null) return best;
  if (world !== null)
    return { kind: "world", point: world.point, normal: world.normal, distance: dist(from, to) * world.t };
  return { kind: "none", point: to };
}
/**
 * Apply a hit and say what it cost: health off, armour off, and whether it
 * killed. `from` is where the shot came from — the only thing the facing rule
 * needs — and leaving it out is a hit with no direction, never a back.
 * Take `health` off a body and `armor` off its vest, and say what it cost and
 * whether it killed. Where the two numbers came from — a bullet's hitgroup and
 * range, or a blast's distance — is the caller's business; what a body does
 * about them is the same either way, and is this.
 */
export function applyHit(
export function applyDamage(
  target: Actor,
  weapon: Weapon,
  group: Hitgroup,
  distance: number,
  damageScale = 1,
  from: Vec3 | null = null,
): { damage: number; killed: boolean; headshot: boolean } {
  const behind = from !== null && fromBehind(target.yaw, target.pos, from);
  const { health, armor } =
    computeDamage(weapon, distance, group, target.armor, target.helmet, damageScale, behind);
  health: number,
  armor: number,
): { damage: number; killed: boolean } {
  const dealt = Math.min(health, target.health);
  target.armor = Math.max(0, target.armor - armor);
  target.health -= health;
@@ -195,5 +111,109 @@
export function applyHit(
    target.health = 0;
    target.alive = false;
  }
  return { damage: dealt, killed, headshot: group === "head" };
  return { damage: dealt, killed };
}
/**
 * Apply a hit and say what it cost: health off, armour off, and whether it
 * killed. `from` is where the shot came from — the only thing the facing rule
 * needs — and leaving it out is a hit with no direction, never a back. It is
 * read off the body that fired and not off the muzzle, the same way the damage
 * arrow in `src/client/world.ts` reads a bearing off a person.
 */
export function applyHit(
  target: Actor,
  weapon: Weapon,
  group: Hitgroup,
  distance: number,
  from: Vec3 | null = null,
): { damage: number; killed: boolean; headshot: boolean } {
  const behind = from !== null && fromBehind(target.yaw, target.pos, from);
  const { health, armor } = computeDamage(weapon, distance, group, target.armor, target.helmet, behind);
  return { ...applyDamage(target, health, armor), headshot: group === "head" };
}
/**
 * A body with nothing yet wrong with it: full health, the vest it was asked
 * for, standing still. It is what a question about a weapon is asked against —
 * `shotCost` below fires into one — so anything that wants to know what a gun
 * does to a person shoots the same body the game does rather than inventing
 * one with numbers of its own.
 */
export const wholeBody = (armor: number, helmet: boolean): Actor => ({
  id: -1, team: "t", pos: [0, 0, 0], yaw: 0, duckAmount: 0,
  health: FULL_HEALTH, armor, helmet, alive: true,
});
/**
 * What one shot costs a whole body, and how many of them that body takes.
 *
 * `health` and `armor` are the first shot's, uncapped by what is left — a
 * Deagle that takes 110 off a 100-point body says 110, because the question
 * "how much headroom does it have at range" is the one being asked of it.
 * `shots` is not arithmetic on that number: the shots are *fired*, through
 * `applyHit` above, into `wholeBody`, so a vest wearing down between them is
 * counted the way the fight counts it. It is null when the body never falls —
 * a grenade in this table has no bullet, and a shot that rounds to nothing off
 * a leg at the far end of its range would stand there all day.
 */
export type ShotCost = { health: number; armor: number; shots: number | null };
/** The most shots worth firing before a body that will not fall is called immortal. */
const NEVER = 64;
export function shotCost(
  weapon: Weapon,
  group: Hitgroup,
  distance: number,
  armor = 0,
  helmet = false,
): ShotCost {
  const target = wholeBody(armor, helmet);
  const first = computeDamage(weapon, distance, group, target.armor, target.helmet);
  let shots = 0;
  while (target.alive && shots < NEVER) {
    applyHit(target, weapon, group, distance);
    shots += 1;
  }
  return { ...first, shots: target.alive ? null : shots };
}
/**
 * The farthest distance one shot to `group` still kills a whole body from, in
 * units, or null when it does not kill even with the muzzle against them.
 *
 * Damage falls with distance and never rises — `computeDamage` multiplies by
 * `rangeModifier^(d/500)`, and that is monotone — so the answer is a binary
 * search between the muzzle and the end of what the weapon reaches, about
 * thirteen calls to `shotCost` and exact to the unit. Rounding makes the edge a
 * step rather than a slope, which is why it is searched rather than solved: the
 * distance handed back is one the simulation itself would kill from.
 *
 * `reachOf` is the ceiling, so a knife's answer is inside its 64 units and a
 * gun's is inside the flight of a bullet: nothing here claims a kill at a
 * distance the weapon cannot reach.
 */
export function killRange(
  weapon: Weapon,
  group: Hitgroup,
  armor = 0,
  helmet = false,
): number | null {
  // One shot into a whole body, and whether it got up: `applyHit` answers that
  // directly, so the search asks the fight the same question thirteen times
  // rather than firing a magazine into a corpse to learn the first shot killed.
  const kills = (distance: number): boolean =>
    applyHit(wholeBody(armor, helmet), weapon, group, distance).killed;
  const reach = reachOf(weapon);
  if (!kills(0)) return null;
  if (kills(reach)) return reach;
  let near = 0;
  let far = reach;
  while (far - near > 1) {
    const mid = Math.floor((near + far) / 2);
    if (kills(mid)) near = mid;
    else far = mid;
  }
  return near;
}
@@ -0,0 +1,120 @@
import { expect, test } from "bun:test";
import { COVER_STEPS, coverFrom, exposed } from "./cover.ts";
import { botThink, makeBrain } from "./bots.ts";
import { DE_FORGE } from "./map.ts";
import { COMPETITIVE } from "./match.ts";
import { openCells } from "./level.ts";
import { useShipped } from "./shipped.ts";
import { WEAPONS } from "./weapons.ts";
import { applyInput, canSee, createWorld, eyePos, type Player, type World } from "./world.ts";
import type { Vec3 } from "../engine/index.ts";
useShipped();
type Scene = { world: World; me: Player; bot: Player };
const scene = (): Scene => {
  const world = createWorld(DE_FORGE, COMPETITIVE, "you", "ct", 1, 7);
  world.match.phase = "live";
  const bot = world.players[1] as Player;
  bot.brain = makeBrain(1, 99);
  bot.brain.reset = false;
  bot.brain.seenAt = -10;
  return { world, me: world.me, bot };
};
/**
 * The first pair of de_forge cells, in reading order, where the bot stands in
 * plain view of the player at a fighting distance and has cover within reach.
 * Found rather than typed in, so a map edit moves the scene and not the test.
 */
function standoff(s: Scene): Vec3[] {
  const cells = openCells(DE_FORGE, 2);
  for (let i = 0; i < cells.length; i += 5)
    for (let j = 0; j < cells.length; j += 11) {
      s.me.pos = [...(cells[i] as Vec3)];
      s.bot.pos = [...(cells[j] as Vec3)];
      const d = Math.hypot(s.me.pos[0] - s.bot.pos[0], s.me.pos[1] - s.bot.pos[1]);
      if (d < 600 || d > 1500 || !canSee(s.world, s.bot, s.me)) continue;
      const path = coverFrom(s.world, s.bot, s.me);
      if (path !== null && path.length > 1) return path;
    }
  throw new Error("de_forge has no standoff with cover in reach");
}
test("a body in the open is exposed, and one behind a wall is not", () => {
  const s = scene();
  const path = standoff(s);
  expect(exposed(s.world, eyePos(s.me), s.bot.pos)).toBe(true);
  const end = path[path.length - 1] as Vec3;
  expect(exposed(s.world, eyePos(s.me), end)).toBe(false);
});
test("cover is a short walk, and a bot already out of sight is already there", () => {
  const s = scene();
  const path = standoff(s);
  expect(path.length).toBeLessThanOrEqual(COVER_STEPS);
  // Stand where the path ends: there is nowhere further to go.
  s.bot.pos = [...(path[path.length - 1] as Vec3)];
  expect(coverFrom(s.world, s.bot, s.me)).toEqual([]);
});
/** Empty the bot's rifle and play its reload out, the bot at the wheel. */
function reloadUnderFire(s: Scene, useLearned: boolean): { hiddenAtEnd: boolean; at: Vec3 } {
  const dt = 1 / 64;
  s.bot.brain = makeBrain(1, 99, useLearned);
  s.bot.brain.reset = false;
  s.bot.brain.seenAt = -10;
  s.bot.weapon = "ak47";
  s.bot.primary = "ak47";
  s.bot.ammo.ak47 = { mag: 0, reserve: 90 };
  s.bot.yaw = Math.atan2(s.me.pos[1] - s.bot.pos[1], s.me.pos[0] - s.bot.pos[0]) * (180 / Math.PI);
  let started = false;
  for (let t = 0; t < Math.ceil((WEAPONS.ak47.reloadTime + 0.2) / dt); t++) {
    const input = botThink(s.world, s.bot, dt);
    applyInput(s.world, s.bot, input, dt);
    s.world.time += dt;
    if (s.bot.reloadUntil > 0) started = true;
    // Judge it the last tick the magazine is still going in.
    if (started && s.bot.reloadUntil > 0 && s.world.time + dt >= s.bot.reloadUntil) break;
  }
  expect(started).toBe(true);
  return {
    hiddenAtEnd: !canSee(s.world, s.bot, s.me),
    at: [...s.bot.pos],
  };
}
test("a bot that runs dry in view of an enemy reloads behind cover", () => {
  const s = scene();
  const path = standoff(s);
  const end = path[path.length - 1] as Vec3;
  const out = reloadUnderFire(s, true);
  // It went where the search said, and not wherever its strafing took it.
  expect(Math.hypot(out.at[0] - end[0], out.at[1] - end[1])).toBeLessThan(48);
  expect(out.hiddenAtEnd).toBe(true);
});
test("a bot takes cover once per reload, and the policy has it back when the magazine is in", () => {
  const s = scene();
  standoff(s);
  reloadUnderFire(s, true);
  const brain = s.bot.brain!;
  const cutFor = brain.coverFor;
  expect(brain.cover).not.toBeNull();
  // The reload finishes; the next tick is the fight's again, and a cover path
  // cut for a reload that is over is never walked.
  s.world.time = s.bot.reloadUntil + 0.01;
  applyInput(s.world, s.bot, { ...botThink(s.world, s.bot, 1 / 64) }, 1 / 64);
  expect(s.bot.reloadUntil).toBe(0);
  expect(brain.coverFor).toBe(cutFor);
  expect(s.bot.ammo.ak47?.mag).toBe(30);
});
test("the scripted baseline does not take cover: it is what the policy is measured against", () => {
  const s = scene();
  standoff(s);
  reloadUnderFire(s, false);
  expect(s.bot.brain!.cover).toBeNull();
  expect(s.bot.brain!.coverFor).toBe(-1);
});
@@ -0,0 +1,87 @@
/**
 * Cover: somewhere near a bot that an enemy cannot see into. A bot reloading
 * in the open is two and a half seconds of a body that cannot shoot back, and
 * before this is where the bots spent them — standing on the spot the fight
 * found them, strafing a metre either way. A person ducks behind the nearest
 * crate, and so, now, does a bot.
 *
 * The search is over the level's own cells, because they are what a bot can
 * walk to: rings of cells around the bot, nearest ring first, and the first
 * cell whose standing eye — and both shoulders — the threat's eye has no line
 * to. A wall hides a cell and so does a cloud, through the same `throughSmoke`
 * that `canSee` asks. The cell has to be reachable, too, by a path no longer
 * than a reload is worth walking; a cell behind a wall with the door on the
 * enemy's side is not cover, it is a detour.
 *
 * It is scripted and outside the policy, like the smoke-skirting next door in
 * `bots.ts`: `OBS_SIZE`, the heads and the shipped weights know nothing of it.
 */
import { visible, type Vec3 } from "../engine/index.ts";
import { colOf, findPath, rowOf, walkable, worldOf, type Level } from "./level.ts";
import { CS_HULL } from "./movement.ts";
import { eyePos, throughSmoke, type Player, type World } from "./world.ts";
/** How many cells out the search looks: four is 512 units, a reload's walk. */
export const COVER_RINGS = 4;
/** The longest path, in steps, worth walking to get out of sight. */
export const COVER_STEPS = 7;
/** How many of the nearest hidden cells are tried for a path before giving up. */
const COVER_TRIES = 4;
/**
 * Can the eye at `from` see a body standing at `at` (its feet)? The eye of
 * that body and a point a hull's radius to either side of it, across the line
 * of sight: a cell whose centre is hidden behind a corner but whose shoulder
 * pokes past it is not somewhere to reload.
 */
export function exposed(world: World, from: Vec3, at: Vec3): boolean {
  const eye: Vec3 = [at[0], at[1], at[2] + CS_HULL.eyeStand];
  const dx = eye[0] - from[0];
  const dy = eye[1] - from[1];
  const len = Math.hypot(dx, dy) || 1;
  const sx = (-dy / len) * CS_HULL.radius;
  const sy = (dx / len) * CS_HULL.radius;
  for (const side of [0, 1, -1]) {
    const point: Vec3 = [eye[0] + sx * side, eye[1] + sy * side, eye[2]];
    if (visible(from, point, world.level.boxes) && !throughSmoke(world, from, point)) return true;
  }
  return false;
}
/**
 * The path to the nearest cover from `threat`, or null when there is none
 * within reach. Nearest by straight line, ties broken by which is further from
 * the threat; the path is A*'s, ending on the cell's centre. A bot already out
 * of sight gets an empty path — it is where it should be.
 */
export function coverFrom(world: World, bot: Player, threat: Player): Vec3[] | null {
  const level: Level = world.level;
  const from = eyePos(threat);
  if (!exposed(world, from, bot.pos)) return [];
  const col = colOf(level, bot.pos[0]);
  const row = rowOf(level, bot.pos[1]);
  const hidden: { at: Vec3; near: number; away: number }[] = [];
  for (let ring = 1; ring <= COVER_RINGS; ring++) {
    for (let dr = -ring; dr <= ring; dr++)
      for (let dc = -ring; dc <= ring; dc++) {
        if (Math.max(Math.abs(dc), Math.abs(dr)) !== ring) continue;
        if (!walkable(level, col + dc, row + dr)) continue;
        const at = worldOf(level, col + dc, row + dr, bot.pos[2]);
        if (exposed(world, from, at)) continue;
        hidden.push({
          at,
          near: Math.hypot(at[0] - bot.pos[0], at[1] - bot.pos[1]),
          away: Math.hypot(at[0] - threat.pos[0], at[1] - threat.pos[1]),
        });
      }
  }
  hidden.sort((a, b) => a.near - b.near || b.away - a.away);
  for (const cell of hidden.slice(0, COVER_TRIES)) {
    const path = findPath(level, bot.pos, cell.at);
    if (path.length > 0 && path.length <= COVER_STEPS) return path;
  }
  return null;
}
@@ -1,90 +0,0 @@
/**
 * The crosshair's shape, without a canvas: four arms, where they start and
 * where they end. The one thing that has to stay true is the default — the
 * crosshair this game has always drawn — and the one thing a setting has to
 * do is move it.
 */
import { expect, test } from "bun:test";
import {
  CROSSHAIR_COLOURS, CROSSHAIR_COLOUR_NAMES, crosshairShape, DEFAULT_CROSSHAIR, SPREAD_GAP,
  type CrosshairStyle,
} from "./crosshair.ts";
const style = (over: Partial<CrosshairStyle> = {}): CrosshairStyle => ({ ...DEFAULT_CROSSHAIR, ...over });
/** How far the near end of the right-hand arm sits from the middle. */
const innerRight = (shape: { segments: { x1: number }[] }): number => shape.segments[0].x1 - 100;
/** How long the right-hand arm is. */
const armLength = (shape: { segments: { x1: number; x2: number }[] }): number =>
  shape.segments[0].x2 - shape.segments[0].x1;
test("the default is today's crosshair: a gap of four, arms of seven, two wide, no dot", () => {
  const shape = crosshairShape(style(), 0, 100, 100);
  expect(shape.colour).toBe("rgba(120, 255, 140, 0.9)");
  expect(shape.thickness).toBe(2);
  expect(shape.dot).toBeNull();
  expect(shape.segments).toEqual([
    { x1: 104, y1: 100, x2: 111, y2: 100 },
    { x1: 96, y1: 100, x2: 89, y2: 100 },
    { x1: 100, y1: 104, x2: 100, y2: 111 },
    { x1: 100, y1: 96, x2: 100, y2: 89 },
  ]);
});
test("a larger gap moves the arms out without making them longer", () => {
  const near = crosshairShape(style({ gap: 4 }), 0, 100, 100);
  const far = crosshairShape(style({ gap: 12 }), 0, 100, 100);
  expect(innerRight(far)).toBe(innerRight(near) + 8);
  expect(armLength(far)).toBe(armLength(near));
  // Every arm moves, not just the one: up is eight further up.
  expect(far.segments[3].y1).toBe(near.segments[3].y1 - 8);
});
test("a larger size makes the arms longer without moving them out", () => {
  const small = crosshairShape(style({ size: 7 }), 0, 100, 100);
  const big = crosshairShape(style({ size: 16 }), 0, 100, 100);
  expect(armLength(big)).toBe(16);
  expect(innerRight(big)).toBe(innerRight(small));
});
test("a dynamic crosshair opens with the spread, a static one never moves", () => {
  const still = crosshairShape(style(), 0, 100, 100);
  const spraying = crosshairShape(style(), 1.5, 100, 100);
  expect(innerRight(spraying)).toBeCloseTo(innerRight(still) + 1.5 * SPREAD_GAP, 10);
  expect(armLength(spraying)).toBe(armLength(still));
  const fixed = crosshairShape(style({ dynamic: false }), 1.5, 100, 100);
  expect(fixed.segments).toEqual(still.segments);
});
test("a spread that is not a number never reaches the arms", () => {
  const still = crosshairShape(style(), 0, 100, 100);
  for (const spread of [NaN, Infinity, -3]) {
    expect(crosshairShape(style(), spread, 100, 100).segments).toEqual(still.segments);
  }
});
test("the dot is there only when it is asked for, and it is as wide as the arms", () => {
  expect(crosshairShape(style({ dot: false }), 0, 100, 100).dot).toBeNull();
  expect(crosshairShape(style({ dot: true, thickness: 4 }), 0, 100, 100).dot)
    .toEqual({ x: 100, y: 100, radius: 2 });
  // The dot sits in the middle whatever the gap does.
  const wide = crosshairShape(style({ dot: true, gap: 18 }), 2, 100, 100);
  expect(wide.dot).toEqual({ x: 100, y: 100, radius: 1 });
});
test("the crosshair is drawn where it is told, not at some fixed middle", () => {
  const shape = crosshairShape(style(), 0, 640, 360);
  expect(shape.segments[0]).toEqual({ x1: 644, y1: 360, x2: 651, y2: 360 });
  expect(shape.segments[2]).toEqual({ x1: 640, y1: 364, x2: 640, y2: 371 });
});
test("every colour name resolves to a colour, and the names are the table's own keys", () => {
  for (const name of CROSSHAIR_COLOUR_NAMES) {
    expect(crosshairShape(style({ colour: name }), 0, 100, 100).colour).toBe(CROSSHAIR_COLOURS[name]);
    expect(CROSSHAIR_COLOURS[name]).toMatch(/^rgba\(/);
  }
  expect(CROSSHAIR_COLOUR_NAMES).toContain("green");
  expect(CROSSHAIR_COLOUR_NAMES.length).toBeGreaterThan(3);
});
@@ -1,108 +0,0 @@
/**
 * The crosshair: a style and the gun's current inaccuracy in, the lines and
 * the dot to draw out. Pure — no canvas, no world, no settings — so what a
 * gap of six or a static crosshair actually does to the shape is a test and
 * not a screenshot. `hud.ts` strokes whatever comes back; `settings.ts` is
 * where a style is validated before it ever reaches here.
 *
 * Colour is a name, never free text: a string that ends up in
 * `ctx.strokeStyle` is an input like any other, so the only strings that can
 * get there are the ones written down in this file.
 */
/** The colours a crosshair can be, and the only strings that reach the canvas. */
export const CROSSHAIR_COLOURS = {
  // The default is today's crosshair exactly, to the last hundredth of alpha.
  green: "rgba(120, 255, 140, 0.9)",
  white: "rgba(245, 247, 250, 0.9)",
  cyan: "rgba(96, 226, 255, 0.9)",
  yellow: "rgba(255, 220, 96, 0.9)",
  magenta: "rgba(255, 110, 224, 0.9)",
  red: "rgba(255, 82, 72, 0.9)",
} as const;
export type CrosshairColour = keyof typeof CROSSHAIR_COLOURS;
export const CROSSHAIR_COLOUR_NAMES = Object.keys(CROSSHAIR_COLOURS) as CrosshairColour[];
/**
 * The three numbers, with the range each one is allowed and the value it
 * falls back to. The page renders its `min`, `max` and `step` from here and
 * `parseSettings` clamps to the same pair, so a field and the parser can
 * never disagree about what is a legal crosshair.
 */
export const CROSSHAIR_LIMITS = {
  size: { min: 1, max: 20, fallback: 7 },
  gap: { min: 0, max: 20, fallback: 4 },
  thickness: { min: 1, max: 6, fallback: 2 },
} as const;
export type CrosshairStyle = {
  colour: CrosshairColour;
  /** How long each arm is, in pixels. */
  size: number;
  /** How far the arms start from the middle before any spread is added. */
  gap: number;
  /** The stroke width of the arms, and the diameter of the dot. */
  thickness: number;
  dot: boolean;
  /** Does the gap open with the gun's inaccuracy, or is it the same always? */
  dynamic: boolean;
};
export const DEFAULT_CROSSHAIR: CrosshairStyle = {
  colour: "green",
  size: CROSSHAIR_LIMITS.size.fallback,
  gap: CROSSHAIR_LIMITS.gap.fallback,
  thickness: CROSSHAIR_LIMITS.thickness.fallback,
  dot: false,
  dynamic: true,
};
/**
 * How many pixels a unit of `inaccuracy()` pushes the arms out by. Today's
 * law, kept: the gap was `4 + spread * 14`, and the 4 is now the setting.
 */
export const SPREAD_GAP = 14;
export type Segment = { x1: number; y1: number; x2: number; y2: number };
export type CrosshairShape = {
  /** The CSS colour, resolved from the name — what goes into the context. */
  colour: string;
  thickness: number;
  /** The four arms, in right, left, down, up order. */
  segments: Segment[];
  dot: { x: number; y: number; radius: number } | null;
};
/** The four directions an arm goes, in the order they are drawn. */
const ARMS: readonly [number, number][] = [[1, 0], [-1, 0], [0, 1], [0, -1]];
/**
 * The crosshair at `(cx, cy)` for a gun that is `spread` inaccurate. A
 * dynamic crosshair adds the spread to its gap — which is how this game
 * teaches you to stop before you shoot — and a static one ignores it
 * entirely. A spread that is not a finite, positive number is no spread.
 */
export function crosshairShape(
  style: CrosshairStyle,
  spread: number,
  cx: number,
  cy: number,
): CrosshairShape {
  const open = style.dynamic && Number.isFinite(spread) && spread > 0 ? spread * SPREAD_GAP : 0;
  const gap = style.gap + open;
  const segments = ARMS.map(([dx, dy]) => ({
    x1: cx + dx * gap,
    y1: cy + dy * gap,
    x2: cx + dx * (gap + style.size),
    y2: cy + dy * (gap + style.size),
  }));
  return {
    colour: CROSSHAIR_COLOURS[style.colour],
    thickness: style.thickness,
    segments,
    dot: style.dot ? { x: cx, y: cy, radius: style.thickness / 2 } : null,
  };
}
@@ -1,58 +0,0 @@
import { expect, test } from "bun:test";
import { beepInterval, beepPitch, stepBeep } from "./cues.ts";
const BOMB_TIME = 40; // COMPETITIVE.bombTime and SHORT.bombTime alike
test("the first beep lands right after the plant", () => {
  const dt = 1 / 64;
  let sinceLast = 0;
  let elapsed = 0;
  let pitch: number | null = null;
  while (pitch === null && elapsed < 5) {
    const step = stepBeep(sinceLast, BOMB_TIME, BOMB_TIME, dt);
    sinceLast = step.sinceLast;
    pitch = step.pitch;
    elapsed += dt;
  }
  expect(pitch).not.toBeNull();
  expect(elapsed).toBeGreaterThan(0.8);
  expect(elapsed).toBeLessThan(1.2);
});
test("intervals are monotonically shorter as the fuse runs down", () => {
  const points = [40, 30, 20, 10, 5, 1, 0];
  for (let i = 1; i < points.length; i++) {
    expect(beepInterval(points[i], BOMB_TIME)).toBeLessThanOrEqual(beepInterval(points[i - 1], BOMB_TIME));
  }
  expect(beepInterval(0, BOMB_TIME)).toBeLessThan(beepInterval(40, BOMB_TIME));
});
test("the pitch rises as the fuse runs down", () => {
  const points = [40, 30, 20, 10, 5, 1, 0];
  for (let i = 1; i < points.length; i++) {
    expect(beepPitch(points[i], BOMB_TIME)).toBeGreaterThanOrEqual(beepPitch(points[i - 1], BOMB_TIME));
  }
  expect(beepPitch(0, BOMB_TIME)).toBeGreaterThan(beepPitch(40, BOMB_TIME));
});
test("no beep when nothing is planted", () => {
  const step = stepBeep(0.99, null, BOMB_TIME, 1);
  expect(step.pitch).toBeNull();
  expect(step.sinceLast).toBe(0);
});
test("the rate is bounded however small dt is", () => {
  const duration = 1;
  const secondsLeft = 0; // the fastest cadence there is
  const dt = 1 / 20000;
  let sinceLast = 0;
  let beeps = 0;
  for (let t = 0; t < duration; t += dt) {
    const step = stepBeep(sinceLast, secondsLeft, BOMB_TIME, dt);
    sinceLast = step.sinceLast;
    if (step.pitch !== null) beeps += 1;
  }
  const interval = beepInterval(secondsLeft, BOMB_TIME);
  expect(beeps).toBeGreaterThan(0);
  expect(beeps).toBeLessThanOrEqual(Math.ceil(duration / interval) + 1);
});
@@ -1,42 +0,0 @@
/**
 * When a planted bomb beeps: pure arithmetic over the seconds left on the
 * fuse and how long it has been since the last beep. No audio, no world —
 * `world.ts` calls this to decide whether to push a sound this tick, pitch
 * and all, so `main.ts` only ever plays what it is told.
 */
import { clamp } from "./math.ts";
const MAX_INTERVAL = 1; // about a second apart just after the plant
const MIN_INTERVAL = 0.2; // a few a second in the last moments
const MIN_PITCH = 500;
const MAX_PITCH = 1200;
/** Seconds between beeps with this many seconds left on a `bombTime`-second fuse. */
export function beepInterval(secondsLeft: number, bombTime: number): number {
  const t = clamp(secondsLeft / bombTime, 0, 1);
  return MIN_INTERVAL + (MAX_INTERVAL - MIN_INTERVAL) * t;
}
/** The beep's pitch with this many seconds left: rising as it quickens. */
export function beepPitch(secondsLeft: number, bombTime: number): number {
  const t = clamp(secondsLeft / bombTime, 0, 1);
  return MAX_PITCH - (MAX_PITCH - MIN_PITCH) * t;
}
export type BeepStep = { sinceLast: number; pitch: number | null };
/**
 * Advance the beep clock by `dt`. `secondsLeft` is null when nothing is
 * planted, which silences it and resets the clock so the next plant starts
 * clean. However small `dt` is, this fires at most the whole intervals it
 * actually crossed and carries only the remainder forward — an accumulator,
 * the same shape `footsteps` in `world.ts` already uses for distance.
 */
export function stepBeep(sinceLast: number, secondsLeft: number | null, bombTime: number, dt: number): BeepStep {
  if (secondsLeft === null) return { sinceLast: 0, pitch: null };
  const next = sinceLast + dt;
  const interval = beepInterval(secondsLeft, bombTime);
  if (next < interval) return { sinceLast: next, pitch: null };
  return { sinceLast: next - interval, pitch: beepPitch(secondsLeft, bombTime) };
}
@@ -1,125 +0,0 @@
/**
 * The decal ring on its own: no GL, just the vertices it writes and the
 * colours it ages them into. What matters here is that the ring is a ring —
 * fixed, wrapping, replacing its oldest — that a mark lies in the surface it
 * was given, facing out of it, and that the fade is a function of the clock.
 */
import { expect, test } from "bun:test";
import {
  clear, decals, mark, shade,
  DECAL_CAPACITY, DECAL_FLOATS, DECAL_LIFE, DECAL_LIFT, DECAL_RADIUS, DECAL_VERTICES,
} from "./decals.ts";
import type { Vec3 } from "./math.ts";
/** Vertex `v` of hole `slot`, as position then colour. */
const vertex = (data: Float32Array, slot: number, v: number): number[] =>
  Array.from(data.subarray((slot * DECAL_VERTICES + v) * 6, (slot * DECAL_VERTICES + v) * 6 + 6));
test("a mark lies in the surface it was given, lifted off it and no wider than it says", () => {
  const d = decals();
  const at: Vec3 = [100, 200, 40];
  const normal: Vec3 = [0, -1, 0]; // a wall facing south
  expect(mark(d, at, normal, 1)).toBe(true);
  shade(d, 1);
  for (let v = 0; v < DECAL_VERTICES; v += 1) {
    const p = vertex(d.data, 0, v);
    // Every vertex is in one plane, half a unit out along the normal: a mark
    // in the wall z-fights with it and one off to the side is not the hit.
    expect(p[1]).toBeCloseTo(200 - DECAL_LIFT, 4);
    expect(Math.hypot((p[0] as number) - 100, (p[2] as number) - 40))
      .toBeLessThanOrEqual(DECAL_RADIUS + 1e-4);
  }
  // The fan is wound out of the wall: the cull keeps the face you can see, and
  // a mark wound the other way would be a hole you could only see from inside.
  for (let t = 0; t < DECAL_VERTICES / 3; t += 1) {
    const c = vertex(d.data, 0, t * 3), a = vertex(d.data, 0, t * 3 + 1), b = vertex(d.data, 0, t * 3 + 2);
    const ax = (a[0] as number) - (c[0] as number), ay = (a[1] as number) - (c[1] as number), az = (a[2] as number) - (c[2] as number);
    const bx = (b[0] as number) - (c[0] as number), by = (b[1] as number) - (c[1] as number), bz = (b[2] as number) - (c[2] as number);
    const face: Vec3 = [ay * bz - az * by, az * bx - ax * bz, ax * by - ay * bx];
    expect(face[0] * normal[0] + face[1] * normal[1] + face[2] * normal[2]).toBeGreaterThan(0);
  }
});
test("a floor and a wall both get a frame that is not degenerate", () => {
  const d = decals();
  for (const normal of [[0, 0, 1], [0, 0, -1], [1, 0, 0], [0, 1, 0]] as Vec3[]) {
    const fresh = decals();
    expect(mark(fresh, [0, 0, 0], normal, 0)).toBe(true);
    for (let v = 0; v < DECAL_VERTICES; v += 1) {
      const p = vertex(fresh.data, 0, v);
      expect(Number.isFinite(p[0] as number)).toBe(true);
      expect(Math.hypot(p[0] as number, p[1] as number, p[2] as number)).toBeGreaterThan(0);
    }
  }
  // And nothing that is not a surface is marked at all: a zero normal has no
  // plane to lie in, and `NaN` in a vertex buffer is a triangle across the sky.
  expect(mark(d, [0, 0, 0], [0, 0, 0], 0)).toBe(false);
  expect(mark(d, [NaN, 0, 0], [0, 0, 1], 0)).toBe(false);
  expect(d.used).toBe(0);
});
test("the ring is a ring: the oldest hole is the one that goes", () => {
  const d = decals();
  expect(d.data.length).toBe(DECAL_FLOATS);
  for (let i = 0; i < DECAL_CAPACITY + 3; i += 1) mark(d, [i, 0, 0], [0, 0, 1], i);
  expect(d.used).toBe(DECAL_CAPACITY);
  expect(shade(d, DECAL_CAPACITY)).toBe(DECAL_CAPACITY * DECAL_VERTICES);
  // The three oldest were overwritten in place, and the buffer is the size it
  // was when it was made: nothing here grows with the round.
  const xs = [];
  for (let slot = 0; slot < DECAL_CAPACITY; slot += 1) xs.push(vertex(d.data, slot, 0)[0] as number);
  xs.sort((a, b) => a - b);
  expect(xs[0]).toBe(3);
  expect(xs[DECAL_CAPACITY - 1]).toBe(DECAL_CAPACITY + 2);
  expect(d.data.length).toBe(DECAL_FLOATS);
});
test("the fade is the clock's, and a spent hole is drawn by nothing", () => {
  const d = decals();
  mark(d, [0, 0, 0], [0, 0, 1], 10);
  const centre = (): number => {
    shade(d, now);
    return vertex(d.data, 0, 0)[3] as number;
  };
  let now = 10;
  const fresh = centre();
  expect(fresh).toBeLessThan(0.5); // dark: the wall under it is a quarter of itself
  // Held through most of its life, then on its way back to the wall as it was.
  now = 10 + DECAL_LIFE * 0.5;
  expect(centre()).toBe(fresh);
  now = 10 + DECAL_LIFE * 0.9;
  expect(centre()).toBeGreaterThan(fresh);
  expect(centre()).toBeLessThan(1);
  // Past its life there is nothing to draw: not a faint one, none.
  now = 10 + DECAL_LIFE;
  expect(shade(d, now)).toBe(0);
  expect(centre()).toBe(1); // white, multiplied, is the wall untouched
  // A hole made after it is drawn alongside it, and the spent slot costs a
  // triangle the wall does not notice rather than a second draw to skip it.
  mark(d, [50, 0, 0], [0, 0, 1], now);
  expect(shade(d, now)).toBe(2 * DECAL_VERTICES);
});
test("clearing takes the holes and the memory of the impacts that made them", () => {
  const d = decals();
  for (let i = 0; i < 5; i += 1) mark(d, [i, 0, 0], [0, 0, 1], i);
  d.taken = 4;
  expect(shade(d, 4)).toBeGreaterThan(0);
  clear(d, 10);
  expect(d.used).toBe(0);
  expect(d.next).toBe(0);
  expect(shade(d, 10)).toBe(0);
  // `since` is what the next round starts on: an impact from the round that
  // just ended is still in the effect list for two seconds, and it is not a
  // mark on this round's walls.
  expect(d.taken).toBe(10);
  clear(d);
  expect(d.taken).toBe(-Infinity);
});
@@ -1,171 +0,0 @@
/**
 * Bullet holes: a fixed ring of marks on the level, drawn in one call.
 *
 * A spark says a round landed somewhere a quarter of a second ago. A hole says
 * it landed *there*, and it is still saying it when you come back round the
 * corner. That is the whole of this file: where a shot hit the level, which way
 * the surface faced, and when — as vertices, ready for the buffer.
 *
 * `DECAL_CAPACITY` slots are allocated once, at start-up, and the `next` one is
 * overwritten when the ring is full: the oldest hole in the round is the one
 * that goes. Sixty-four of them is two full AK magazines of evidence, 1152
 * vertices and 27 KB of buffer — a corner someone has been spraying reads as
 * sprayed, and a round that fires five hundred shots costs exactly the same as
 * one that fires sixty-five. Nothing here allocates after `decals()`: a shot
 * writes over a slot's vertices in place and a frame rewrites six floats of it.
 *
 * The colours are the whole of the fade, and the reason this needs no texture,
 * no second program and no alpha channel. Each mark is a fan of `DECAL_SPOKES`
 * triangles about a dark centre, drawn multiplied into what is already on the
 * wall (`DST_COLOR, ZERO`), so a vertex colour of 1 changes nothing at all: the
 * rim of every mark is white and invisible, the centre darkens the wall under
 * it, and as a hole ages its centre walks back up to white. Two attributes, a
 * position and a colour — which is exactly what the line program already takes.
 */
import type { Vec3 } from "./math.ts";
/** How many holes a round may show at once. The oldest is replaced. */
export const DECAL_CAPACITY = 64;
/** Triangles in the fan: six is round enough at the size a hole is drawn. */
export const DECAL_SPOKES = 6;
/** Seconds a hole lasts, of which the last `DECAL_FADE` of it is the fading. */
export const DECAL_LIFE = 25;
const DECAL_FADE = 0.35;
/** How wide a mark is, in world units — a player is 72 tall. */
export const DECAL_RADIUS = 3.4;
/**
 * How far off the surface the mark sits. The depth buffer's precision at three
 * thousand units out, with this projection's near plane, is under a tenth of a
 * unit, so half a unit is clear of z-fighting everywhere the eye can see a wall
 * and close enough that nothing reads as floating.
 */
export const DECAL_LIFT = 0.5;
/** How dark the centre of a fresh hole leaves the wall it is multiplied into. */
const DECAL_DARK = 0.24;
export const DECAL_VERTICES = DECAL_SPOKES * 3;
const FLOATS_PER_VERTEX = 6; // x, y, z, r, g, b — the line program's two attributes
const FLOATS_PER_DECAL = DECAL_VERTICES * FLOATS_PER_VERTEX;
/** The size of the ring's buffer, in floats: what the renderer allocates once. */
export const DECAL_FLOATS = DECAL_CAPACITY * FLOATS_PER_DECAL;
export type Decals = {
  /** The vertices themselves, interleaved the way the line buffer is. */
  data: Float32Array;
  /** When each slot was marked; `-Infinity` for one that never has been. */
  born: Float32Array;
  /** The slot the next hole takes. */
  next: number;
  /** How many slots have ever been filled: what is worth drawing and no more. */
  used: number;
  /**
   * The newest impact already turned into a hole. An impact effect lives two
   * seconds and a frame sees it a hundred and twenty times; this is what makes
   * it one hole rather than a hundred and twenty.
   */
  taken: number;
};
export function decals(): Decals {
  const born = new Float32Array(DECAL_CAPACITY);
  born.fill(-Infinity);
  return { data: new Float32Array(DECAL_FLOATS), born, next: 0, used: 0, taken: -Infinity };
}
/**
 * A fresh round starts on clean walls — and nothing is freed doing it.
 *
 * `since` is the clock the ring starts again on: an effect list holds two
 * seconds of impacts, and the last round's are not marks on this round's walls.
 */
export function clear(d: Decals, since = -Infinity): void {
  d.born.fill(-Infinity);
  d.next = 0;
  d.used = 0;
  d.taken = since;
}
const TAU = Math.PI * 2;
/**
 * Put a hole at `pos`, lying in the surface whose outward normal is `normal`.
 * A normal that is not a direction and a position that is not a number are the
 * two ways this can be asked for something it cannot draw, and both are refused
 * here rather than written into the buffer as `NaN`.
 */
export function mark(d: Decals, pos: Vec3, normal: Vec3, at: number): boolean {
  const len = Math.hypot(normal[0], normal[1], normal[2]);
  if (!(len > 1e-6) || !Number.isFinite(pos[0] + pos[1] + pos[2]) || !Number.isFinite(at)) return false;
  const nx = normal[0] / len, ny = normal[1] / len, nz = normal[2] / len;
  // Two axes across the surface. The one the normal is least aligned with is
  // crossed into it, so a floor and a wall both get a frame that is not
  // degenerate, and `t × b = n` keeps the fan wound outwards for the cull.
  const flat = Math.abs(nz) > 0.9;
  let tx = flat ? 0 : -ny, ty = flat ? -nz : nx, tz = flat ? ny : 0;
  const tl = Math.hypot(tx, ty, tz);
  tx /= tl; ty /= tl; tz /= tl;
  const bx = ny * tz - nz * ty, by = nz * tx - nx * tz, bz = nx * ty - ny * tx;
  const slot = d.next;
  d.next = (d.next + 1) % DECAL_CAPACITY;
  if (d.used < DECAL_CAPACITY) d.used += 1;
  d.born[slot] = at;
  const cx = pos[0] + nx * DECAL_LIFT, cy = pos[1] + ny * DECAL_LIFT, cz = pos[2] + nz * DECAL_LIFT;
  // The fan is spun by the shot's own timestamp: two holes side by side are
  // not the same hexagon, and no frame asks `Math.random`.
  const spin = at * 2.3;
  const data = d.data;
  let o = slot * FLOATS_PER_DECAL;
  for (let s = 0; s < DECAL_SPOKES; s += 1) {
    // The centre. Its colour is the fade, written every frame by `shade`.
    data[o] = cx; data[o + 1] = cy; data[o + 2] = cz;
    o += FLOATS_PER_VERTEX;
    // The two rim corners of this triangle, in order: a `for … of` over a pair
    // would be one array allocated per spoke per shot, which is the one thing
    // a ring allocated once is for.
    for (let k = 0; k < 2; k += 1) {
      const a = spin + ((s + k) / DECAL_SPOKES) * TAU;
      const ca = Math.cos(a) * DECAL_RADIUS, sa = Math.sin(a) * DECAL_RADIUS;
      data[o] = cx + tx * ca + bx * sa;
      data[o + 1] = cy + ty * ca + by * sa;
      data[o + 2] = cz + tz * ca + bz * sa;
      // The rim changes nothing: white, multiplied, is the wall as it was.
      data[o + 3] = 1; data[o + 4] = 1; data[o + 5] = 1;
      o += FLOATS_PER_VERTEX;
    }
  }
  return true;
}
/**
 * Age every hole into its centre's colour, and say how many vertices are worth
 * drawing: `0` when the ring is empty or everything in it has faded out, so a
 * round nobody has fired in pays no draw and no upload at all.
 *
 * A slot that has faded inside a ring that has not is written white, which is
 * a triangle the wall does not notice — the alternative is a second draw to
 * skip it with, and one draw is the point.
 */
export function shade(d: Decals, time: number): number {
  let live = false;
  const data = d.data;
  for (let slot = 0; slot < d.used; slot += 1) {
    // A float32 stamp read back against a float64 clock can be a shade in the
    // future, so an age at or below zero is a hole that has just been made and
    // not one to hide: only the far end of the life turns a mark off.
    const age = time - (d.born[slot] as number);
    const left = (DECAL_LIFE - age) / (DECAL_LIFE * DECAL_FADE);
    const strength = age >= DECAL_LIFE ? 0 : Math.min(1, left);
    if (strength > 0) live = true;
    const dark = 1 - (1 - DECAL_DARK) * strength;
    let o = slot * FLOATS_PER_DECAL + 3;
    for (let s = 0; s < DECAL_SPOKES; s += 1) {
      data[o] = dark; data[o + 1] = dark; data[o + 2] = dark;
      o += FLOATS_PER_VERTEX * 3; // past this triangle's two rim corners
    }
  }
  return live ? d.used * DECAL_VERTICES : 0;
}
@@ -1,34 +0,0 @@
import { expect, test } from "bun:test";
import { ears } from "./ears.ts";
test("a source dead ahead pans centre", () => {
  const { pan } = ears([100, 0, 0], [0, 0, 0], 0);
  expect(pan).toBeCloseTo(0, 6);
});
test("a source 90 degrees to the left pans left, and to the right pans right", () => {
  // Yaw grows anticlockwise (math.ts), so turning +90 from facing +x faces +y,
  // which puts +y on the listener's left.
  const left = ears([0, 100, 0], [0, 0, 0], 0);
  expect(left.pan).toBeLessThan(0);
  const right = ears([0, -100, 0], [0, 0, 0], 0);
  expect(right.pan).toBeGreaterThan(0);
});
test("a source directly behind is roughly centred and no louder than the same distance ahead", () => {
  const ahead = ears([100, 0, 0], [0, 0, 0], 0);
  const behind = ears([-100, 0, 0], [0, 0, 0], 0);
  expect(Math.abs(behind.pan)).toBeLessThan(0.05);
  expect(behind.volume).toBeLessThanOrEqual(ahead.volume + 1e-9);
});
test("volume falls with distance, never exceeds 1, and never divides by zero at zero distance", () => {
  const near = ears([50, 0, 0], [0, 0, 0], 0);
  const far = ears([2000, 0, 0], [0, 0, 0], 0);
  expect(near.volume).toBeLessThanOrEqual(1);
  expect(far.volume).toBeLessThan(near.volume);
  expect(far.volume).toBeGreaterThan(0);
  const here = ears([0, 0, 0], [0, 0, 0], 0);
  expect(Number.isFinite(here.volume)).toBe(true);
  expect(here.volume).toBeLessThanOrEqual(1);
});
@@ -1,26 +0,0 @@
/**
 * Where a sound sits around the listener, as plain data — no Web Audio here,
 * so it is tested headlessly. `pos` and `listener` are world positions; `yaw`
 * is the listener's view yaw in degrees, the same convention `math.ts` uses.
 */
import { angleDelta, dist2d, type Vec3 } from "./math.ts";
export type Ears = { pan: number; volume: number };
/** The same falloff `audio.shot` already used: full volume inside 120 units, gone by 900. */
const REFERENCE_DISTANCE = 900;
const MIN_DISTANCE = 120;
/** How a source at `pos` sounds to someone at `listener` looking along `yaw`. */
export function ears(pos: Vec3, listener: Vec3, yaw: number): Ears {
  const bearing = (Math.atan2(pos[1] - listener[1], pos[0] - listener[0]) * 180) / Math.PI;
  // Yaw grows anticlockwise (math.ts), so a source to the listener's left sits
  // at a positive angle off the view; a StereoPannerNode's -1 is the left
  // channel, so the sign is flipped to get there.
  const rel = (angleDelta(yaw, bearing) * Math.PI) / 180;
  const pan = -Math.sin(rel);
  const d = dist2d(pos, listener);
  const volume = Math.min(1, REFERENCE_DISTANCE / Math.max(MIN_DISTANCE, d));
  return { pan, volume };
}
@@ -1,87 +0,0 @@
import { expect, test } from "bun:test";
import { cuesHeard, EMPTY_EARSHOT, FOOTSTEP_EARSHOT, SITE_EARSHOT } from "./earshot.ts";
import type { Effect } from "./world.ts";
import type { Vec3 } from "./math.ts";
const HERE: Vec3 = [0, 0, 0];
test("a footstep past its earshot is not heard, and one inside it is", () => {
  const near: Effect = { kind: "sound", at: 1, pos: [FOOTSTEP_EARSHOT - 1, 0, 0], name: "step" };
  const far: Effect = { kind: "sound", at: 1, pos: [FOOTSTEP_EARSHOT + 1, 0, 0], name: "step" };
  expect(cuesHeard([near], 0, HERE, 1)).toEqual([{ kind: "step", pos: near.pos }]);
  expect(cuesHeard([far], 0, HERE, 1)).toEqual([]);
});
test("a dry trigger has its own, shorter earshot", () => {
  const near: Effect = { kind: "sound", at: 1, pos: [EMPTY_EARSHOT - 1, 0, 0], name: "empty" };
  const far: Effect = { kind: "sound", at: 1, pos: [EMPTY_EARSHOT + 1, 0, 0], name: "empty" };
  expect(cuesHeard([near], 0, HERE, 1)).toEqual([{ kind: "world", name: "empty", pos: near.pos, pitch: undefined }]);
  expect(cuesHeard([far], 0, HERE, 1)).toEqual([]);
});
test("a plant and a defuse carry past the site, out to the same ceiling", () => {
  const plant: Effect = { kind: "sound", at: 1, pos: [SITE_EARSHOT - 1, 0, 0], name: "plant" };
  const defuse: Effect = { kind: "sound", at: 1, pos: [SITE_EARSHOT - 1, 0, 0], name: "defuse" };
  const tooFar: Effect = { kind: "sound", at: 1, pos: [SITE_EARSHOT + 1, 0, 0], name: "plant" };
  expect(cuesHeard([plant], 0, HERE, 1)).toHaveLength(1);
  expect(cuesHeard([defuse], 0, HERE, 1)).toHaveLength(1);
  expect(cuesHeard([tooFar], 0, HERE, 1)).toEqual([]);
});
test("the bomb's beep and its blast carry from anywhere at all", () => {
  const beep: Effect = { kind: "sound", at: 1, pos: [1_000_000, 0, 0], name: "beep", pitch: 900 };
  const blast: Effect = { kind: "sound", at: 1, pos: [1_000_000, 0, 0], name: "blast" };
  expect(cuesHeard([beep], 0, HERE, 1)).toEqual([{ kind: "world", name: "beep", pos: beep.pos, pitch: 900 }]);
  expect(cuesHeard([blast], 0, HERE, 1)).toEqual([{ kind: "world", name: "blast", pos: blast.pos, pitch: undefined }]);
});
test("an effect at or before the cutoff is never returned", () => {
  const effect: Effect = { kind: "shot", at: 5, pos: HERE, weapon: "ak47", mine: false, shooter: 2 };
  expect(cuesHeard([effect], 5, HERE, 1)).toEqual([]);
  expect(cuesHeard([effect], 6, HERE, 1)).toEqual([]);
  expect(cuesHeard([effect], 4, HERE, 1)).toHaveLength(1);
});
test("no effect is ever heard twice across two calls, one after the other", () => {
  const first: Effect = { kind: "shot", at: 1, pos: HERE, weapon: "ak47", mine: false, shooter: 2 };
  const second: Effect = { kind: "shot", at: 2, pos: HERE, weapon: "ak47", mine: false, shooter: 2 };
  const effects = [first, second];
  // The first call hears both; a second call against the same list, its
  // cutoff moved on to the last thing it played, hears neither again — the
  // resume bug this rule exists to close.
  const firstPass = cuesHeard(effects, 0, HERE, 1);
  expect(firstPass).toHaveLength(2);
  const secondPass = cuesHeard(effects, 2, HERE, 1);
  expect(secondPass).toEqual([]);
});
test("a hurt cue is only ever the local player's", () => {
  const mine: Effect = { kind: "hurt", at: 1, victim: 1, from: [1, 0, 0], amount: 27 };
  const theirs: Effect = { kind: "hurt", at: 1, victim: 9, from: [1, 0, 0], amount: 27 };
  expect(cuesHeard([mine], 0, HERE, 1)).toEqual([{ kind: "hurt", from: [1, 0, 0], amount: 27 }]);
  expect(cuesHeard([theirs], 0, HERE, 1)).toEqual([]);
});
test("distance is measured from wherever `listener` is passed as, not any fixed place", () => {
  // Standing where a teammate's eyes are, spectating, rather than at the
  // corpse: a footstep near the teammate is heard, the same one near the
  // corpse position is not, because the corpse is not who is passed in.
  const teammateEyes: Vec3 = [2000, 0, 0];
  const step: Effect = { kind: "sound", at: 1, pos: [2000 + FOOTSTEP_EARSHOT - 1, 0, 0], name: "step" };
  expect(cuesHeard([step], 0, HERE, 1)).toEqual([]);
  expect(cuesHeard([step], 0, teammateEyes, 1)).toHaveLength(1);
});
test("a shot and a hitmark carry whatever audio.ts needs and nothing else", () => {
  const shot: Effect = { kind: "shot", at: 1, pos: [10, 20, 30], weapon: "awp", mine: true, shooter: 1 };
  const hit: Effect = { kind: "hitmark", at: 1, headshot: true, killed: false };
  expect(cuesHeard([shot], 0, HERE, 1)).toEqual([{ kind: "shot", pos: [10, 20, 30], weapon: "awp" }]);
  expect(cuesHeard([hit], 0, HERE, 1)).toEqual([{ kind: "hit", headshot: true, killed: false }]);
});
test("the hit cue carries whether it was the one that killed, ready for the kill tone", () => {
  // `audio.ts` still plays `hit(headshot)` and ignores this: the flag is on
  // the cue so the rewrite under #110 has it without touching earshot again.
  const fatal: Effect = { kind: "hitmark", at: 1, headshot: false, killed: true };
  expect(cuesHeard([fatal], 0, HERE, 1)).toEqual([{ kind: "hit", headshot: false, killed: true }]);
});
@@ -1,72 +0,0 @@
/**
 * What the ear is allowed to hear: which of a tick's effects turn into a cue
 * for `audio.ts` and which don't. Plain data in — the world's effects, the
 * time before which everything has already been played, and where the
 * listener stands — and plain cues out, one per thing that should be heard,
 * carrying only what `audio.ts` needs to play it: position, name, weapon,
 * pitch, amount. No Web Audio, no DOM, the shape `ears.ts` already set.
 *
 * `hearing.ts` is a bot's ears, wired for a node graph a rifle can turn its
 * head toward across the whole map. This is a person's: a handful of fixed
 * ceilings and a straight-line distance, because a human never had a node
 * graph to look things up in — a beep behind a wall is still a beep.
 */
import type { Effect, SoundName } from "./world.ts";
import { dist, type Vec3 } from "./math.ts";
import type { WorldSoundName } from "./audio.ts";
import type { WeaponId } from "./weapons.ts";
// A footstep further than this is not worth a node graph — about the width
// of a couple of site rooms in de_forge, not the whole map. A dry trigger
// carries about the same: it is the gun in your hands, or an enemy's right
// in front of you. A plant or a defuse is louder and more deliberate, heard
// well past the site but not the whole map. The bomb's own beep and the
// blast that ends it have no entry here at all: they carry everywhere, so a
// CT can walk to the site — or learn it just went off — by ear alone.
export const FOOTSTEP_EARSHOT = 1500;
export const EMPTY_EARSHOT = 900;
export const SITE_EARSHOT = 3000;
const EARSHOT: Partial<Record<SoundName, number>> = {
  step: FOOTSTEP_EARSHOT, empty: EMPTY_EARSHOT, plant: SITE_EARSHOT, defuse: SITE_EARSHOT,
};
/** One thing worth playing: exactly what `audio.ts` and `flinch` need, and nothing else. */
export type Cue =
  | { kind: "shot"; pos: Vec3; weapon: WeaponId }
  // A hit of your own: where it landed, and whether it was the one that
  // finished them. `audio.ts` plays `hit(headshot)` today and ignores
  // `killed` — the kill tone is #110's, and this is the flag waiting for it.
  | { kind: "hit"; headshot: boolean; killed: boolean }
  | { kind: "hurt"; from: Vec3; amount: number }
  | { kind: "step"; pos: Vec3 }
  | { kind: "world"; name: WorldSoundName; pos: Vec3; pitch?: number };
/**
 * The cues a listener at `listener` picks up out of `effects`, having
 * already heard everything at or before `since`. `localId` is whose pain
 * counts: a `hurt` effect is only ever the local player's, whoever the
 * camera is watching while they are dead.
 */
export function cuesHeard(effects: Effect[], since: number, listener: Vec3, localId: number): Cue[] {
  const cues: Cue[] = [];
  for (const effect of effects) {
    if (effect.at <= since) continue;
    if (effect.kind === "shot") cues.push({ kind: "shot", pos: effect.pos, weapon: effect.weapon });
    else if (effect.kind === "hitmark")
      cues.push({ kind: "hit", headshot: effect.headshot, killed: effect.killed });
    else if (effect.kind === "hurt") {
      if (effect.victim === localId) cues.push({ kind: "hurt", from: effect.from, amount: effect.amount });
    } else if (effect.kind === "sound") {
      const limit = EARSHOT[effect.name];
      if (limit !== undefined && dist(effect.pos, listener) > limit) continue;
      cues.push(
        effect.name === "step"
          ? { kind: "step", pos: effect.pos }
          : { kind: "world", name: effect.name, pos: effect.pos, pitch: effect.pitch },
      );
    }
  }
  return cues;
}
@@ -0,0 +1,130 @@
/**
 * The money's own tests. Most of them need no world at all: a buy reads one
 * field off the round and the rest off the player, so a `Market` here is an
 * object with a phase in it and a `Buyer` is the kit and the wallet. The last
 * test is the wiring — the same calls through a real `World` — because a module
 * that only works against its own fixtures has proved nothing.
 */
import { expect, test } from "bun:test";
import { buy, canBuy, CARRY, emptyAmmo, priceOf, type Buyer, type Market } from "./economy.ts";
import { DE_FORGE } from "./map.ts";
import { SHORT } from "./match.ts";
import { createWorld, NO_INPUT, update } from "./world.ts";
import { ARMOR_PRICE, DEFUSE_KIT_PRICE, HELMET_PRICE, WEAPONS } from "./weapons.ts";
const freeze: Market = { match: { phase: "freeze" } };
const live: Market = { match: { phase: "live" } };
const buyer = (over: Partial<Buyer> = {}): Buyer => ({
  team: "ct", alive: true, money: 5000,
  armor: 0, helmet: false, defuseKit: false,
  weapon: "usp", primary: null, secondary: "usp",
  ammo: { knife: { mag: 0, reserve: 0 }, usp: emptyAmmo("usp") },
  pocket: { he: 0, flash: 0, smoke: 0 },
  ...over,
});
test("a gun is paid for, put in your hands, and loaded", () => {
  const me = buyer();
  expect(buy(freeze, me, "m4a4")).toBe(true);
  expect(me.money).toBe(5000 - WEAPONS.m4a4.price);
  expect(me.primary).toBe("m4a4");
  expect(me.weapon).toBe("m4a4");
  expect(me.ammo.m4a4).toEqual({ mag: WEAPONS.m4a4.magazine, reserve: WEAPONS.m4a4.reserve });
  // A pistol is the other slot, and it does not take the rifle out of your hands
  // by being cheaper — it takes it out by being the thing you just bought.
  expect(buy(freeze, me, "deagle")).toBe(true);
  expect(me.secondary).toBe("deagle");
  expect(me.primary).toBe("m4a4");
});
test("a gun is the side's or it is nobody's, and the knife is not for sale", () => {
  const ct = buyer();
  expect(buy(freeze, ct, "ak47")).toBe(false);
  expect(buy(freeze, ct, "knife")).toBe(false);
  expect(ct.money).toBe(5000);
  expect(buy(freeze, buyer({ team: "t" }), "ak47")).toBe(true);
});
test("armour bought twice is not paid for twice", () => {
  const me = buyer();
  expect(buy(freeze, me, "armor")).toBe(true);
  expect(me.armor).toBe(100);
  expect(me.money).toBe(5000 - ARMOR_PRICE);
  // The vest is on: the second press is refused and costs nothing.
  expect(priceOf("armor", me)).toBe(0);
  expect(buy(freeze, me, "armor")).toBe(false);
  expect(me.money).toBe(5000 - ARMOR_PRICE);
});
test("a helmet on a bare chest is the vest as well, and on a vest it is the helmet alone", () => {
  const bare = buyer();
  expect(priceOf("helmet", bare)).toBe(ARMOR_PRICE + HELMET_PRICE);
  expect(buy(freeze, bare, "helmet")).toBe(true);
  expect(bare.armor).toBe(100);
  expect(bare.helmet).toBe(true);
  expect(bare.money).toBe(5000 - ARMOR_PRICE - HELMET_PRICE);
  expect(buy(freeze, bare, "helmet")).toBe(false); // and not a third time
  const vested = buyer({ armor: 100 });
  expect(priceOf("helmet", vested)).toBe(HELMET_PRICE);
  expect(buy(freeze, vested, "helmet")).toBe(true);
  expect(vested.money).toBe(5000 - HELMET_PRICE);
});
test("the kit is the CT's alone, and one each", () => {
  const ct = buyer();
  expect(priceOf("kit", ct)).toBe(DEFUSE_KIT_PRICE);
  expect(buy(freeze, ct, "kit")).toBe(true);
  expect(ct.defuseKit).toBe(true);
  expect(buy(freeze, ct, "kit")).toBe(false);
  expect(ct.money).toBe(5000 - DEFUSE_KIT_PRICE);
  expect(buy(freeze, buyer({ team: "t" }), "kit")).toBe(false);
});
test("a grenade goes in the pocket, up to what a pocket holds", () => {
  const me = buyer();
  expect(buy(freeze, me, "he")).toBe(true);
  expect(me.pocket.he).toBe(CARRY.he);
  expect(buy(freeze, me, "he")).toBe(false);
  // It is a pocket and not a slot: the gun in your hands is untouched.
  expect(me.weapon).toBe("usp");
  expect(me.money).toBe(5000 - WEAPONS.he.price);
});
test("a wallet that cannot reach it is refused, to the dollar", () => {
  const me = buyer({ money: WEAPONS.awp.price - 1 });
  expect(buy(freeze, me, "awp")).toBe(false);
  me.money = WEAPONS.awp.price;
  expect(buy(freeze, me, "awp")).toBe(true);
  expect(me.money).toBe(0);
});
test("a buy is refused once the round is live, and to a body", () => {
  const me = buyer();
  expect(canBuy(live, me)).toBe(false);
  expect(buy(live, me, "m4a4")).toBe(false);
  expect(me.money).toBe(5000);
  expect(me.primary).toBe(null);
  const dead = buyer({ alive: false });
  expect(canBuy(freeze, dead)).toBe(false);
  expect(buy(freeze, dead, "m4a4")).toBe(false);
});
test("the same calls are what the world makes: a buy in the freeze, refused once it is live", () => {
  const world = createWorld(DE_FORGE, SHORT, "me", "ct", 5, 3);
  world.me.money = 5000;
  expect(canBuy(world, world.me)).toBe(true);
  expect(buy(world, world.me, "m4a4")).toBe(true);
  expect(world.me.money).toBe(5000 - WEAPONS.m4a4.price);
  expect(world.me.weapon).toBe("m4a4");
  expect(buy(world, world.me, "ak47")).toBe(false); // the other side's rifle
  expect(buy(world, world.me, "helmet")).toBe(true);
  expect(world.me.helmet).toBe(true);
  for (let t = 0; t < SHORT.freezeTime + 0.5; t += 1 / 64) update(world, 1 / 64, NO_INPUT);
  expect(world.match.phase).toBe("live");
  expect(canBuy(world, world.me)).toBe(false);
  expect(buy(world, world.me, "deagle")).toBe(false);
});
@@ -0,0 +1,104 @@
/**
 * The money: what an item costs the player in front of you, whether the round
 * will let them have it, and what handing it over does to their wallet and
 * their kit. `match.ts` decides what a round *pays* — the win, the loss bonus,
 * the cap — and this decides what they can spend it on.
 *
 * It knows nothing about the world it is called from. A buy reads one thing off
 * the round (which phase it is in) and everything else off the player, so both
 * are named here by the members a buy actually touches, the way `combat.ts`
 * names an `Actor`: a `World` and a `Player` satisfy them, and this file cannot
 * reach back for either.
 */
import { FULL_ARMOR } from "./combat.ts";
import type { Phase, Team } from "./match.ts";
import {
  ARMOR_PRICE, DEFUSE_KIT_PRICE, HELMET_PRICE, WEAPONS, isThrown,
  type ThrownId, type WeaponId,
} from "./weapons.ts";
/** One gun's rounds: what is in the magazine, and what is left to fill it with. */
export type Ammo = { mag: number; reserve: number };
/** A gun as it comes out of the shop, and as a fresh round hands it back. */
export const emptyAmmo = (id: WeaponId): Ammo =>
  ({ mag: WEAPONS[id].magazine, reserve: WEAPONS[id].reserve });
/**
 * How many of each thrown weapon a player may carry into a round. One HE, one
 * flashbang and one smoke — three grenades, bought separately in the freeze,
 * each refused once the pocket holds its limit, and all gone with the body that
 * held them.
 */
export const CARRY: Record<ThrownId, number> = { he: 1, flash: 1, smoke: 1 };
export type BuyItem = WeaponId | "armor" | "helmet" | "kit";
/** Everything a buy reads or writes on the person doing it, and nothing else. */
export type Buyer = {
  team: Team;
  alive: boolean;
  money: number;
  armor: number;
  helmet: boolean;
  defuseKit: boolean;
  weapon: WeaponId;
  primary: WeaponId | null;
  secondary: WeaponId;
  ammo: Record<string, Ammo>;
  pocket: Record<ThrownId, number>;
};
/**
 * The round as a buy sees it: which phase it is in. That is the whole of what
 * the world has to say about whether the shop is open.
 */
export type Market = { match: { phase: Phase } };
export function priceOf(item: BuyItem, player: Buyer): number {
  if (item === "armor") return player.armor > 0 ? 0 : ARMOR_PRICE;
  if (item === "helmet") return player.armor > 0 && !player.helmet ? HELMET_PRICE : ARMOR_PRICE + HELMET_PRICE;
  if (item === "kit") return DEFUSE_KIT_PRICE;
  return WEAPONS[item]?.price ?? Infinity;
}
export const canBuy = (market: Market, player: Buyer): boolean =>
  market.match.phase === "freeze" && player.alive;
/** Buy one thing. Refuses anything the round, the side or the wallet says no to. */
export function buy(market: Market, player: Buyer, item: BuyItem): boolean {
  if (!canBuy(market, player)) return false;
  const price = priceOf(item, player);
  if (!Number.isFinite(price) || price > player.money) return false;
  if (item === "armor") {
    if (player.armor >= FULL_ARMOR) return false;
    player.armor = FULL_ARMOR;
  } else if (item === "helmet") {
    if (player.helmet) return false;
    player.armor = FULL_ARMOR;
    player.helmet = true;
  } else if (item === "kit") {
    if (player.team !== "ct" || player.defuseKit) return false;
    player.defuseKit = true;
  } else {
    const weapon = WEAPONS[item];
    if (weapon === undefined || weapon.kind === "knife") return false;
    if (weapon.team !== "both" && weapon.team !== player.team) return false;
    // A grenade goes in a pocket, not in your hands: it does not become the
    // weapon you are holding and it does not displace the gun you bought, and
    // one kind in there does not crowd out the other.
    if (isThrown(item)) {
      if (player.pocket[item] >= CARRY[item]) return false;
      player.pocket[item] += 1;
      player.money -= price;
      return true;
    }
    if (weapon.kind === "pistol") player.secondary = item;
    else player.primary = item;
    player.ammo[item] = emptyAmmo(item);
    player.weapon = item;
  }
  player.money -= price;
  return true;
}
@@ -1,21 +0,0 @@
import { expect, test } from "bun:test";
import { fullscreenControl } from "./fullscreen.ts";
test("a browser that cannot go fullscreen never shows the control", () => {
  expect(fullscreenControl(false, false)).toEqual({ shown: false, label: "Fullscreen", pressed: false });
  expect(fullscreenControl(false, true)).toEqual({ shown: false, label: "Fullscreen", pressed: false });
});
test("supported and not active: shown, unpressed, and says which way it will go", () => {
  const state = fullscreenControl(true, false);
  expect(state.shown).toBe(true);
  expect(state.pressed).toBe(false);
  expect(state.label).toBe("Fullscreen");
});
test("supported and active: shown, pressed, and the label reverses", () => {
  const state = fullscreenControl(true, true);
  expect(state.shown).toBe(true);
  expect(state.pressed).toBe(true);
  expect(state.label).toBe("Exit fullscreen");
});
@@ -1,75 +0,0 @@
/**
 * Fullscreen: a pure decision — is the control shown, and what does it say —
 * plus the thin DOM glue that asks for it. It always fullscreens the
 * *wrapper*, the element holding both `#stage` and `#touch`, never `#stage`
 * alone: fullscreening the canvas hides the pad and leaves a phone with no
 * buttons at all.
 */
export type FullscreenControl = {
  /** False on a browser that cannot do it at all — iOS Safari on an iPhone. */
  shown: boolean;
  label: string;
  pressed: boolean;
};
/** Pure: what the button shows, from support and the current element alone. */
export function fullscreenControl(supported: boolean, active: boolean): FullscreenControl {
  if (!supported) return { shown: false, label: "Fullscreen", pressed: false };
  return { shown: true, label: active ? "Exit fullscreen" : "Fullscreen", pressed: active };
}
export type FullscreenHandle = {
  toggle(): void;
  detach(): void;
};
/**
 * Wires one or more buttons — the menu's and the pause overlay's are the same
 * switch — to the wrapper's fullscreen state. `onExit` fires only when the
 * wrapper itself drops out of fullscreen (the system gesture or `Esc`), never
 * for some other element's fullscreen coming or going, and never on entry.
 */
export function attachFullscreen(
  wrapper: HTMLElement,
  buttons: HTMLButtonElement[],
  onExit: () => void,
): FullscreenHandle {
  const supported = document.fullscreenEnabled === true;
  const isActive = (): boolean => document.fullscreenElement === wrapper;
  let wasActive = isActive();
  const render = (): void => {
    const state = fullscreenControl(supported, isActive());
    for (const button of buttons) {
      button.hidden = !state.shown;
      button.textContent = state.label;
      button.setAttribute("aria-pressed", String(state.pressed));
    }
  };
  const onChange = (): void => {
    const active = isActive();
    if (wasActive && !active) onExit();
    wasActive = active;
    render();
  };
  const toggle = (): void => {
    if (!supported) return;
    if (isActive()) void document.exitFullscreen();
    else void wrapper.requestFullscreen().catch(() => {});
  };
  for (const button of buttons) button.addEventListener("click", toggle);
  document.addEventListener("fullscreenchange", onChange);
  render();
  return {
    toggle,
    detach: () => {
      document.removeEventListener("fullscreenchange", onChange);
      for (const button of buttons) button.removeEventListener("click", toggle);
    },
  };
}
@@ -0,0 +1,388 @@
/**
 * The generator, held to the two things it promises: that a seed is a map, the
 * same map on every machine, and that a map it hands back can be played — one
 * place, two sites, ten spawns, and a walk from each spawn to each site that A*
 * finds rather than a flood fill hopes for.
 *
 * Nothing here reads the generator's own gate and calls it a day: `flaws` is
 * what the generator itself refuses on, so the checks below path, flood and
 * count the level again from the outside. The last two tests are the point of
 * the whole file — a round of the real game, with the real bots, on a map
 * nobody wrote, played headlessly and pinned to a digest.
 */
import { expect, test } from "bun:test";
import { botThink } from "./bots.ts";
import { levelOf, type Cell } from "./cells.ts";
import { flaws, generateGrid, generateLevel, nameOf, page, seedOf, SIZE } from "./generate.ts";
import { compare as compareMap, layout } from "./layout.ts";
import { colOf, findPath, openCells, rowOf, siteAt, walkable, worldOf, type Box, type Level } from "./level.ts";
import { LOOKS, lookFor, type Look } from "./looks.ts";
import { LAYERS } from "./materials.ts";
import { levelMesh } from "./models.ts";
import { SHORT } from "./match.ts";
import { digest, withoutEntropy } from "./replay.ts";
import { applyInput, createWorld, type Player } from "./world.ts";
import { compare, fold, region, type Vec3 } from "../engine/index.ts";
/** How long a walk is, in Source units: the sum of the steps A* handed back. */
const walkLength = (path: Vec3[], from: Vec3): number => {
  let at = from, total = 0;
  for (const step of path) {
    total += Math.hypot(step[0] - at[0], step[1] - at[1]);
    at = step;
  }
  return total;
};
const letters = (level: Level): Cell[] => level.grid.cells as Cell[];
/** A level's own cells as a page of letters: `page` over the grid it carries. */
const rowsOf = (level: Level): string[] => page({ ...level.grid, cells: letters(level) });
test("a seed is a map, and the same seed is the same map for ever", () => {
  expect(page(generateGrid(7))).toEqual(page(generateGrid(7)));
  expect(page(generateGrid(7))).not.toEqual(page(generateGrid(8)));
  // Two levels from one seed agree about every point a round is played at.
  const a = generateLevel(7), b = generateLevel(7);
  expect(a.name).toBe("gen_7");
  expect(nameOf(1234)).toBe("gen_ya");
  expect(a.boxes).toEqual(b.boxes);
  expect(a.spawns).toEqual(b.spawns);
  expect(a.sites).toEqual(b.sites);
});
/**
 * The map `gen_14u5j6g` is, folded cell by cell into a hash by `layout.ts` —
 * which is the engine's `digest` door, the same instrument the rounds are
 * pinned with, given rows of letters instead of ticks of a world. The fold
 * moved into a module of its own for #159, where a generated map is pinned
 * beside the match played on it; the digest below is the one this test has
 * always had, to the bit.
 *
 * This is the claim the name makes: a person writes `gen_14u5j6g` down, hands
 * it to somebody on another machine, and that machine carves the same forty by
 * forty cells. Nothing here is timed, seeded by a clock or read off a file, so
 * a digest that moves is the generator's shape changing — which is allowed, and
 * is a line in the pull that says which maps changed, with these constants
 * pasted in from the failure.
 */
const NAMED = "gen_14u5j6g";
const NAMED_MAP = "d548dcae07259c836d93ad7d8df3a195281c4da8ee1ef53f9000f5d3e115def9";
const NAMED_BANDS: readonly string[] = [
  "c674e6e4c9f2", "45bb896cd286", "e16819fdf569", "6b799f4e0392",
];
test("a map you can name is the same map on every machine, cell for cell", () => {
  const seed = seedOf(NAMED);
  if (seed === null) throw new Error(`${NAMED} is not a map name, and it is the one this test is about`);
  const level = generateLevel(seed);
  // The name is the map's own name, not a label put beside it.
  expect(level.name).toBe(NAMED);
  expect(nameOf(seed)).toBe(NAMED);
  const why = compareMap(
    layout(level),
    { label: NAMED, constant: "NAMED_MAP", list: "NAMED_BANDS", digest: NAMED_MAP, bands: NAMED_BANDS },
    "src/client/generate.test.ts",
  );
  if (why !== null) throw new Error(why);
  // Asking twice is asking once: the whole point of a seed.
  expect(rowsOf(generateLevel(seed))).toEqual(rowsOf(level));
});
/**
 * The mesh `gen_14u5j6g` is drawn from, folded vertex by vertex: position, uv
 * and — the point of #151 — the atlas layer each one is painted from. The map
 * digest above pins the letters; this pins what a player actually sees, which
 * is the letters turned into boxes *and* the look those boxes wear.
 *
 * It moves when the generator's shape moves, when the mesher's does, or when
 * this seed is dressed in another look. All three are allowed and all three are
 * a line in the pull with these constants pasted in from the failure.
 */
const NAMED_LOOK = "plaza";
const NAMED_MESH = "16133a4f413aa063f8c76efced2dddfc9e00f6502d089ed0ccbcb3f15b9c641c";
const NAMED_MESH_BANDS: readonly string[] = [
  "0e887e4b6e6f", "4f8f475e35b3", "d970b6af42c6", "8108bf5a61ad",
  "9eb216318777", "c5a0dd4cf4b4", "4b75c09568eb", "33f24951e64b",
  "d5ba59402c79", "d7983405773e", "0e370c4f60ef",
];
test("a named map is the same geometry, painted from the same layers, everywhere", () => {
  const seed = seedOf(NAMED);
  if (seed === null) throw new Error(`${NAMED} is not a map name, and it is the one this test is about`);
  const level = generateLevel(seed);
  expect(level.look).toBe(NAMED_LOOK);
  const mesh = levelMesh(level.boxes);
  let at = 0;
  const run = fold({
    ticks: mesh.layer.length,
    step: (vertex) => void (at = vertex),
    line: () =>
      [
        mesh.position[at * 3], mesh.position[at * 3 + 1], mesh.position[at * 3 + 2],
        mesh.uv[at * 2], mesh.uv[at * 2 + 1], mesh.layer[at],
      ].join(" "),
    every: 120,
  });
  const why = compare(
    run,
    { label: `mesh of ${NAMED}`, constant: "NAMED_MESH", digest: NAMED_MESH, checkpoints: NAMED_MESH_BANDS },
    {
      file: "src/client/generate.test.ts",
      list: "NAMED_MESH_BANDS",
      hashes: "every vertex of the level mesh: its position, its uv and its atlas layer",
      every: 120,
      unit: "band",
    },
  );
  if (why !== null) throw new Error(why);
});
/**
 * A look is the seed's, the same on every machine, and a run of seeds does not
 * walk the table in order — the whole reason `lookFor` stirs its seed instead of
 * taking it modulo eight.
 *
 * The fraction measured here, and what it is worth: over seeds 0..99 all eight
 * looks turn up, 88 of the 99 consecutive pairs differ, and 87.5% of all 4,950
 * pairs do — which is the 7/8 a uniform draw over eight gives. The floors below
 * are well under those so a tweak to the stirring is not a failing test, but a
 * generator that dressed every map the same, or that dealt the looks in order,
 * fails both of them.
 */
test("a seed is a look, and two seeds are usually two looks", () => {
  expect(generateLevel(7).look).toBe(generateLevel(7).look);
  expect(lookFor(7).name).toBe(generateLevel(7).look);
  const looks = Array.from({ length: 100 }, (_, seed) => generateLevel(seed).look);
  expect(new Set(looks).size).toBe(LOOKS.length);
  let differ = 0;
  for (let i = 1; i < looks.length; i++) if (looks[i] !== looks[i - 1]) differ++;
  expect(differ).toBeGreaterThanOrEqual(75); // 88 of 99 measured
  let pairs = 0;
  for (let i = 0; i < looks.length; i++)
    for (let j = i + 1; j < looks.length; j++) if (looks[i] !== looks[j]) pairs++;
  expect(pairs / ((looks.length * (looks.length - 1)) / 2)).toBeGreaterThan(0.8); // 0.875 measured
});
test("a look paints a map and moves nothing else about it", () => {
  // Two levels off one seed, dressed differently by hand: same cells, same
  // spawns, same sites, same boxes to the unit — and different layers on them.
  const grid = generateGrid(31);
  const a = levelOf("gen_31", grid, LOOKS[0] as Look);
  const b = levelOf("gen_31", grid, LOOKS[4] as Look);
  expect(a.grid.cells).toEqual(b.grid.cells);
  expect(a.spawns).toEqual(b.spawns);
  expect(a.sites).toEqual(b.sites);
  expect(a.boxes.length).toBe(b.boxes.length);
  for (let i = 0; i < a.boxes.length; i++) {
    const one = a.boxes[i] as Box, two = b.boxes[i] as Box;
    expect(one.min).toEqual(two.min);
    expect(one.max).toEqual(two.max);
  }
  expect(a.boxes.map((box) => box.mat)).not.toEqual(b.boxes.map((box) => box.mat));
  expect(a.look).toBe("forge");
  expect(b.look).toBe("bunker");
});
test("a map is written on a page of letters, one string a row", () => {
  const grid = generateGrid(3);
  const rows = page(grid);
  expect(rows.length).toBe(SIZE);
  for (const row of rows) expect(row.length).toBe(SIZE);
  expect(rows[0]).toBe("#".repeat(SIZE)); // the border is rock, all the way round
  expect(rows[SIZE - 1]).toBe("#".repeat(SIZE));
  for (const row of rows) expect(row[0]).toBe("#");
  expect(rows.join("")).toBe(grid.cells.join(""));
});
test("every map is the other side's map turned half a circle", () => {
  // The whole of fairness: the cell at (col, row) is the cell at the far end of
  // the diagonal through the middle, with T for CT and A for B.
  const mate: Record<string, string> = { "#": "#", ".": ".", x: "x", X: "X", A: "B", B: "A", t: "c", c: "t" };
  for (let seed = 1; seed <= 40; seed++) {
    const grid = generateGrid(seed);
    for (let row = 0; row < grid.height; row++)
      for (let col = 0; col < grid.width; col++) {
        const here = grid.cells[row * grid.width + col] as string;
        const there = grid.cells[(grid.height - 1 - row) * grid.width + (grid.width - 1 - col)] as string;
        if (mate[here] !== there) throw new Error(`seed ${seed}: (${col}, ${row}) is ${here} but its mate is ${there}`);
      }
  }
});
test("the walk to your site is the walk to theirs, step for step", () => {
  // Turning the map half a circle turns the T spawn into the CT spawn and A
  // into B, so the two walks are the same walk. Reading order runs north to
  // south, so the mate of the first CT spawn cell is the *last* T spawn cell.
  for (const seed of [2, 13, 44, 101, 777]) {
    const level = generateLevel(seed);
    // The middle of the two sites are exact opposites, because a site is an odd
    // number of cells on both sides and the middle of an odd run is a cell.
    expect(level.sites.A[0]).toBe(-level.sites.B[0]);
    expect(level.sites.A[1]).toBe(-level.sites.B[1]);
    const ct = level.spawns.ct[0] as Vec3;
    const t = level.spawns.t[level.spawns.t.length - 1] as Vec3;
    const ctToA = walkLength(findPath(level, ct, level.sites.A), ct);
    const tToB = walkLength(findPath(level, t, level.sites.B), t);
    const ctToB = walkLength(findPath(level, ct, level.sites.B), ct);
    const tToA = walkLength(findPath(level, t, level.sites.A), t);
    expect(ctToA).toBeGreaterThan(0);
    expect(ctToA).toBeCloseTo(tToB, 6);
    expect(ctToB).toBeCloseTo(tToA, 6);
  }
});
test("two hundred seeds all come out playable, first time", () => {
  // The retry loop in `generateLevel` is insurance; this is the claim that it
  // is never spent. Every level here is the seed's first attempt.
  for (let seed = 0; seed < 200; seed++) {
    const level = generateLevel(seed);
    expect(flaws(level)).toEqual([]);
    // Ten players have somewhere of their own to stand, and it is floor.
    expect(level.spawns.t.length).toBeGreaterThanOrEqual(8);
    expect(level.spawns.ct.length).toBe(level.spawns.t.length);
    for (const side of ["t", "ct"] as const)
      for (const spot of level.spawns[side])
        expect(walkable(level, colOf(level, spot[0]), rowOf(level, spot[1]))).toBe(true);
    // The middle of each site is on that site and can be planted on.
    expect(siteAt(level, level.sites.A)).toBe("A");
    expect(siteAt(level, level.sites.B)).toBe("B");
    // One place: everything walkable can be walked to from a spawn.
    const first = level.spawns.t[0] as Vec3;
    const reached = region(level.grid, level.passable, colOf(level, first[0]), rowOf(level, first[1]));
    const stranded = letters(level).filter((c, i) => level.passable(c) && reached[i] === 0);
    expect(stranded).toEqual([]);
    // A map with room to move. Measured over a thousand seeds, the tightest
    // map is 286 cells of floor and the most open is 684, of 1,600.
    expect(openCells(level).length).toBeGreaterThan(SIZE * SIZE / 6);
  }
});
test("no generated map leaks outside its own grid, or paints a surface this game has not got", () => {
  for (let seed = 500; seed < 540; seed++) {
    const level = generateLevel(seed);
    // Since #151 a map is dressed from the seed, so the surfaces it may paint
    // are its own look's and not de_forge's — but they are still nine materials
    // already in the atlas, and never a tenth: a new layer is a repaint and a
    // bundle nobody pays for.
    const known = new Set<number>(Object.values(level.materials));
    const edge = [(level.grid.width / 2) * level.grid.cell, (level.grid.height / 2) * level.grid.cell];
    for (const box of level.boxes) {
      for (const axis of [0, 1]) {
        expect(box.min[axis as 0 | 1]).toBeGreaterThanOrEqual(-(edge[axis] as number));
        expect(box.max[axis as 0 | 1]).toBeLessThanOrEqual(edge[axis] as number);
      }
      expect(known.has(box.mat)).toBe(true);
      expect(box.mat).toBeLessThan(LAYERS);
    }
  }
});
test("the gate bites: a map with its site walled off, and one with nowhere to spawn", () => {
  const level = generateLevel(21);
  expect(flaws(level)).toEqual([]);
  // Fill the ring around bombsite A with rock and nobody can reach it. The
  // cells inside are still walkable and now cannot be walked to, so the gate
  // says both things.
  const shut = { ...level, grid: { ...level.grid, cells: [...level.grid.cells] } } as Level;
  const { width, height } = shut.grid;
  for (let row = 0; row < height; row++)
    for (let col = 0; col < width; col++)
      if (shut.grid.cells[row * width + col] === "A")
        for (let dr = -1; dr <= 1; dr++)
          for (let dc = -1; dc <= 1; dc++) {
            const c = col + dc, r = row + dr;
            if (c < 0 || r < 0 || c >= width || r >= height) continue;
            if (shut.grid.cells[r * width + c] !== "A") shut.grid.cells[r * width + c] = "#";
          }
  const complaints = flaws(shut).join("\n");
  expect(complaints).toContain("no path from the t spawn to bombsite A");
  expect(complaints).toContain("no path from the ct spawn to bombsite A");
  expect(complaints).toContain("cannot be walked to");
  // And a level with one spawn cell a side is not a level for ten players.
  const thin = { ...level, spawns: { t: [level.spawns.t[0] as Vec3], ct: [level.spawns.ct[0] as Vec3] } };
  expect(flaws(thin).length).toBe(2);
  expect(flaws(thin)[0]).toContain("a side is five players");
});
test("a map arrives in a couple of milliseconds, which is a menu press", () => {
  for (let seed = 0; seed < 20; seed++) generateLevel(seed); // warm
  const started = performance.now();
  const runs = 40;
  for (let seed = 900; seed < 900 + runs; seed++) generateLevel(seed);
  const each = (performance.now() - started) / runs;
  // Measured at 2.1 ms a map on this machine: the carving, the crates that are
  // checked for cutting the map in two, the meshing and four A* searches.
  // Twenty is the ceiling a slow CI box has to beat, not the number to read.
  expect(each).toBeLessThan(20);
});
// --- and the game played on it --------------------------------------------
test("a bot walks a map nobody wrote, on that map's own cells", () => {
  const level = generateLevel(64);
  const world = createWorld(level, SHORT, "me", "ct", 1, 5);
  expect(world.level).toBe(level);
  world.match.phase = "live";
  world.me.alive = false;
  const bot = world.players.find((p) => p.bot) as Player;
  const from: [number, number] = [bot.pos[0], bot.pos[1]];
  for (let tick = 0; tick < 64 * 3; tick++) {
    world.time += 1 / 64;
    applyInput(world, bot, botThink(world, bot, 1 / 64), 1 / 64);
  }
  // It went somewhere, along cells of this map, and this map's walls held it in.
  expect(Math.hypot(bot.pos[0] - from[0], bot.pos[1] - from[1])).toBeGreaterThan(200);
  const path = (bot.brain as { path: Vec3[] }).path;
  expect(path.length).toBeGreaterThan(1);
  for (const step of path)
    expect(walkable(level, colOf(level, step[0]), rowOf(level, step[1]))).toBe(true);
  expect(Math.abs(bot.pos[0])).toBeLessThan((level.grid.width / 2) * level.grid.cell);
  expect(Math.abs(bot.pos[1])).toBeLessThan((level.grid.height / 2) * level.grid.cell);
});
/**
 * Ten seconds of a five-a-side round on `gen_5`, seed 11, through the same
 * script `replay.ts` pins de_forge with. Computed on this branch, where the
 * generator was written.
 *
 * It pins two things at once: that the simulation is deterministic on a
 * generated map, and that this seed still makes *this* map. Tuning the
 * generator — a room more, a crate fewer — moves it, and that is the point:
 * paste the new digest in the pull that tuned it and say which seed's map
 * changed shape. A digest that moves for any other reason is a bug.
 *
 * Re-pinned for #164 with the other two: the snapshot in `replay.ts` now
 * carries both pockets, how long each body is blinded for and which kind each
 * live grenade is, so every digest in this repository moved with it. The map
 * and the play are untouched — the assertions under this one still find the
 * same spawns on the same cells, and the same ten seconds folded with the old
 * field list still comes to the digest this line held before,
 * 48a1d4466065e045b8933b3fbf5ece767a825a60165e6455b4e310a8d7dd5cae.
 */
// Re-pinned for #165, which put a smoke grenade in the game: the hash moved
// and the play did not. A pocket is three counts now rather than two, a
// grenade's kind is an index into three rather than a flag, and every tick
// carries however many clouds are standing — and nothing in this run throws
// anything, so `clouds` is empty on all 640 ticks of it.
const GENERATED_ROUND = "619ce3102805d11dc40e8d545267e99034bfb3bdab2961202703423a87f6e500";
test("a seeded round on a generated map plays exactly as it played", () => {
  const level = generateLevel(5);
  const run = withoutEntropy(() => digest(createWorld(level, SHORT, "me", "ct", 5, 11), 10 * 64));
  expect(run.digest).toBe(GENERATED_ROUND);
  // Nobody fell through the floor or stood in a wall for ten seconds.
  for (const p of createWorld(level, SHORT, "me", "ct", 5, 11).players)
    expect(walkable(level, colOf(level, p.pos[0]), rowOf(level, p.pos[1]))).toBe(true);
  expect(worldOf(level, 0, 0)[2]).toBe(0);
});
@@ -0,0 +1,331 @@
/**
 * A map from a number. Rooms, corridors, two bombsites, two spawns and cover,
 * carved out of solid rock into the alphabet `cells.ts` reads — so a generated
 * map is one more value of `Level` and nothing in the simulation, the renderer
 * or the bots learns a thing to play it.
 *
 * Two promises hold the whole file up.
 *
 * **It is fair.** Everything is stamped twice: a cell at (col, row) and the cell
 * at (width - 1 - col, height - 1 - row), with `t` becoming `c` and `A`
 * becoming `B` on the way. The map is therefore its own opponent's map turned
 * half a circle, so the walk from T spawn to A is the walk from CT spawn to B,
 * step for step, and no seed can hand one side a shorter round. A test paths
 * both and compares the lengths.
 *
 * **It is playable.** Every room hangs off a spanning tree of corridors that
 * reaches the middle, which is the one room both halves share, so the map is
 * one place by construction rather than by luck; `region` then rubs out
 * anything the tree missed, a crate that would cut the map in two is taken back
 * off, and `flaws` reads the finished level for the things a round needs —
 * spawns to stand on, sites to plant on, and a path from each spawn to each
 * site. A seed whose map has a flaw is not shipped: the next seed is derived
 * from it and the work is done again.
 *
 * Determinism is the point: a seed is a map, on every machine, for ever. The
 * only source of randomness is the engine's `rng`, which is the same generator
 * the rounds themselves run on.
 */
import { region, rng, type Grid, type Vec3 } from "../engine/index.ts";
import { nameOf, seedFrom, seedOf } from "../mapname.ts";
import { CELL, levelOf, type Cell } from "./cells.ts";
import { colOf, findPath, rowOf, type Level } from "./level.ts";
import { lookFor } from "./looks.ts";
/**
 * What a map is called and what a name means, both from `src/mapname.ts` and
 * re-exported here so the three live beside each other for a reader: `nameOf`
 * is the name of a seed's map, `seedOf` is the seed of a name — which is how a
 * map you played is a map you can ask for again — and `seedFrom` is the seed a
 * match id means, which is the number every carving below starts from. All
 * three are there rather than here because the server validates `?map=` and
 * names today's map with them, and may not import a generator to do it.
 */
export { nameOf, seedFrom, seedOf };
/** Cells on a side. 40 is 5,120 Source units: a little tighter than de_forge. */
export const SIZE = 40;
/** How many attempts a seed gets before the generator gives up on it. */
const ATTEMPTS = 8;
/** [col0, row0, col1, row1], inclusive both ends, like de_forge's areas. */
type Rect = { c0: number; r0: number; c1: number; r1: number };
type Point = { col: number; row: number };
/** What a letter becomes when it is stamped on the other side of the map. */
const MATE: Record<Cell, Cell> = {
  "#": "#", ".": ".", x: "x", X: "X", A: "B", B: "A", t: "c", c: "t",
};
/** The page of letters a grid is, one string a row: what a test or a terminal reads. */
export const page = (grid: Grid<Cell>): string[] =>
  Array.from({ length: grid.height }, (_, r) => grid.cells.slice(r * grid.width, (r + 1) * grid.width).join(""));
// --- carving --------------------------------------------------------------
/**
 * One map under construction: the cells, and the only way anything is written
 * into them. Every write is two writes — the cell, and the cell half a circle
 * away with its letter turned round — so symmetry is not something to remember
 * at the end but the only thing this page can do.
 */
function sheet(size: number): {
  cells: Cell[];
  set: (col: number, row: number, cell: Cell) => void;
  fill: (rect: Rect, cell: Cell) => void;
} {
  const cells: Cell[] = new Array(size * size).fill("#");
  // The border is rock and stays rock: nothing is ever carved into the outer ring.
  const inside = (col: number, row: number): boolean =>
    col >= 1 && row >= 1 && col <= size - 2 && row <= size - 2;
  const set = (col: number, row: number, cell: Cell): void => {
    if (!inside(col, row)) return;
    cells[row * size + col] = cell;
    cells[(size - 1 - row) * size + (size - 1 - col)] = MATE[cell];
  };
  const fill = (rect: Rect, cell: Cell): void => {
    for (let r = rect.r0; r <= rect.r1; r++)
      for (let c = rect.c0; c <= rect.c1; c++) set(c, r, cell);
  };
  return { cells, set, fill };
}
const centreOf = (rect: Rect): Point => ({
  col: Math.floor((rect.c0 + rect.c1) / 2),
  row: Math.floor((rect.r0 + rect.r1) / 2),
});
/**
 * An L from one room to another, two or three cells wide: along the columns to
 * the elbow, then down the rows, both runs carved as rectangles so the corner
 * they share is open and nobody has to cut it. Which run goes first is the
 * seed's business, which is what keeps a map from being all right angles the
 * same way round.
 */
function corridor(
  paint: ReturnType<typeof sheet>,
  a: Point,
  b: Point,
  width: number,
  columnsFirst: boolean,
): void {
  const elbow = columnsFirst ? { col: b.col, row: a.row } : { col: a.col, row: b.row };
  const span = (from: Point, to: Point): Rect => ({
    c0: Math.min(from.col, to.col),
    r0: Math.min(from.row, to.row),
    c1: Math.max(from.col, to.col) + (from.row === to.row ? 0 : width - 1),
    r1: Math.max(from.row, to.row) + (from.col === to.col ? 0 : width - 1),
  });
  paint.fill(span(a, elbow), ".");
  paint.fill(span(elbow, b), ".");
}
/**
 * The corridors: a spanning tree over the rooms, nearest room first, grown from
 * the middle — so every room reaches the middle, and the middle is the room
 * both halves of the map share. Then one or two edges more, chosen at random,
 * because a map with exactly one route between two places is a queue rather
 * than a fight.
 */
function connect(paint: ReturnType<typeof sheet>, rooms: Point[], random: () => number): void {
  const joined = [0];
  const waiting = rooms.map((_, i) => i).slice(1);
  const width = (): number => (random() < 0.45 ? 3 : 2);
  while (waiting.length > 0) {
    let best = 0, from = 0, far = Infinity;
    for (let w = 0; w < waiting.length; w++)
      for (const j of joined) {
        const p = rooms[waiting[w] as number] as Point, q = rooms[j] as Point;
        const d = Math.hypot(p.col - q.col, p.row - q.row);
        if (d < far) { far = d; best = w; from = j; }
      }
    const next = waiting.splice(best, 1)[0] as number;
    corridor(paint, rooms[from] as Point, rooms[next] as Point, width(), random() < 0.5);
    joined.push(next);
  }
  const extra = 1 + Math.floor(random() * 2);
  for (let i = 0; i < extra && rooms.length > 2; i++) {
    const a = Math.floor(random() * rooms.length);
    const b = (a + 1 + Math.floor(random() * (rooms.length - 1))) % rooms.length;
    corridor(paint, rooms[a] as Point, rooms[b] as Point, width(), random() < 0.5);
  }
}
// --- the map --------------------------------------------------------------
/**
 * One attempt at a layout, as a grid of letters. Everything is decided in the
 * northern half and stamped into the southern half turned half a circle: the CT
 * spawn is the T spawn, the A site is the B site, and the middle room is its
 * own reflection, which is where the two halves meet.
 */
export function generateGrid(seed: number, size = SIZE): Grid<Cell> {
  const random = rng(seed);
  const pick = (from: number, to: number): number => from + Math.floor(random() * (to - from + 1));
  const paint = sheet(size);
  const middle = size / 2;
  // The CT spawn: eight by four, across the top, near the middle column.
  const spawnC0 = pick(middle - 6, middle - 2);
  const spawn: Rect = { c0: spawnC0, r0: 2, c1: spawnC0 + 7, r1: 5 };
  // The A site: seven wide, five or seven deep, out on one flank — clear of the
  // spawn's columns and wholly in the northern half, so its mate is the B site
  // on the other flank and the two can never touch. Both sides of it are odd
  // on purpose: the middle of an odd run of cells is a cell, so the point the
  // bomb is planted at is the centre of a cell rather than the seam between
  // two, and the two sites' middles are exact opposites of each other. A seam
  // rounds the wrong way on one side of the map and hands that side a shorter
  // walk, which is the one thing this file is not allowed to do.
  const siteC0 = random() < 0.5 ? pick(size - 12, size - 9) : pick(2, 6);
  const siteR0 = pick(3, 12);
  const site: Rect = { c0: siteC0, r0: siteR0, c1: siteC0 + 6, r1: siteR0 + (random() < 0.5 ? 4 : 6) };
  // The middle: the one room that is its own mate, and the seam of the map.
  const midC0 = middle - pick(3, 5), midR0 = middle - pick(2, 4);
  const mid: Rect = { c0: midC0, r0: midR0, c1: size - 1 - midC0, r1: size - 1 - midR0 };
  // Three or four halls in the northern half, wherever they land: they may cross
  // anything, because the letters go on last.
  const halls: Rect[] = [];
  for (let i = 0, want = pick(3, 4); i < want; i++) {
    const w = pick(4, 7), h = pick(3, 5);
    const c0 = pick(2, size - 3 - w), r0 = pick(2, middle - 3 - h);
    halls.push({ c0, r0, c1: c0 + w, r1: r0 + h });
  }
  for (const rect of [spawn, site, mid, ...halls]) paint.fill(rect, ".");
  connect(paint, [centreOf(mid), centreOf(spawn), centreOf(site), ...halls.map(centreOf)], random);
  // The letters last, so a corridor that crossed a spawn is spawn floor rather
  // than a hole in it.
  paint.fill(site, "A");
  paint.fill(spawn, "c");
  // Anything the tree missed is rock again: a courtyard nobody can reach is a
  // place the renderer draws, the bots path into and the round never visits.
  // Rubbing it out cell by cell keeps the symmetry it was carved with, because
  // what one spawn can reach is what the other can: the two are the same room
  // turned half a circle, and the middle joins them.
  const grid: Grid<Cell> = { width: size, height: size, cell: CELL, cells: paint.cells };
  const home = centreOf(spawn);
  const reached = region(grid, (c) => c !== "#", home.col, home.row);
  for (let i = 0; i < grid.cells.length; i++)
    if (reached[i] === 0 && grid.cells[i] !== "#") grid.cells[i] = "#";
  crates(paint, grid, centreOf(site), random);
  return grid;
}
/**
 * Cover, in pairs: a crate and the crate half a circle away, lower-case to jump
 * on and upper-case to hide behind. A crate goes on floor in a roomy place —
 * every orthogonal neighbour open and six of the eight — never on a spawn and
 * never on a bombsite, whose cells decide where the bomb is planted. If the
 * pair cuts the map in two it comes back off, which is why a generated map can
 * be crated at all: a plug in a two-wide corridor is a round nobody can finish.
 */
function crates(
  paint: ReturnType<typeof sheet>,
  grid: Grid<Cell>,
  siteMiddle: Point,
  random: () => number,
): void {
  const { width, cells } = grid;
  const open = (col: number, row: number): boolean =>
    col >= 0 && row >= 0 && col < width && row < grid.height && cells[row * width + col] !== "#";
  const walkable = (c: Cell): boolean => c !== "#" && c !== "x" && c !== "X";
  const roomy = (col: number, row: number): boolean => {
    if (!open(col, row)) return false;
    if (cells[row * width + col] !== ".") return false;
    if (!open(col - 1, row) || !open(col + 1, row) || !open(col, row - 1) || !open(col, row + 1)) return false;
    let around = 0;
    for (let dr = -1; dr <= 1; dr++)
      for (let dc = -1; dc <= 1; dc++) if ((dc !== 0 || dr !== 0) && open(col + dc, row + dr)) around++;
    return around >= 6;
  };
  const spots: Point[] = [];
  for (let row = 1; row < grid.height / 2; row++)
    for (let col = 1; col < width - 1; col++) if (roomy(col, row)) spots.push({ col, row });
  let want = 6 + Math.floor(random() * 5);
  while (want > 0 && spots.length > 0) {
    const spot = spots.splice(Math.floor(random() * spots.length), 1)[0] as Point;
    if (!roomy(spot.col, spot.row)) continue;
    const before = cells[spot.row * width + spot.col] as Cell;
    const mate = cells[(grid.height - 1 - spot.row) * width + (width - 1 - spot.col)] as Cell;
    paint.set(spot.col, spot.row, random() < 0.7 ? "x" : "X");
    const still = region(grid, walkable, siteMiddle.col, siteMiddle.row);
    let cut = false;
    for (let i = 0; i < cells.length && !cut; i++)
      if (still[i] === 0 && walkable(cells[i] as Cell)) cut = true;
    if (cut) {
      cells[spot.row * width + spot.col] = before;
      cells[(grid.height - 1 - spot.row) * width + (width - 1 - spot.col)] = mate;
      continue;
    }
    want--;
  }
}
// --- the gate -------------------------------------------------------------
/**
 * What is wrong with this map, in sentences. A round needs somewhere for ten
 * players to stand, two sites big enough to plant on, and a way from each spawn
 * to each site that A* can actually find — the bots walk it, so it is asked of
 * A* rather than of a flood fill. An empty list is a map that can be played.
 */
export function flaws(level: Level): string[] {
  const bad: string[] = [];
  for (const side of ["t", "ct"] as const)
    if (level.spawns[side].length < 8)
      bad.push(`${level.name}: ${level.spawns[side].length} cells to spawn ${side} on, and a side is five players`);
  for (const letter of ["A", "B"] as const) {
    const paved = level.grid.cells.filter((c) => c === letter).length;
    if (paved < 10) bad.push(`${level.name}: bombsite ${letter} is ${paved} cells, too small to fight over`);
  }
  for (const side of ["t", "ct"] as const)
    for (const letter of ["A", "B"] as const) {
      const from = level.spawns[side][0] as Vec3;
      if (findPath(level, from, level.sites[letter]).length === 0)
        bad.push(`${level.name}: no path from the ${side} spawn to bombsite ${letter}`);
    }
  const first = level.spawns.t[0] as Vec3;
  const reached = region(level.grid, level.passable, colOf(level, first[0]), rowOf(level, first[1]));
  let stranded = 0;
  for (let i = 0; i < level.grid.cells.length; i++)
    if (reached[i] === 0 && level.passable(level.grid.cells[i] as Cell)) stranded++;
  if (stranded > 0) bad.push(`${level.name}: ${stranded} cells are walkable and cannot be walked to`);
  return bad;
}
/**
 * A map from a seed, whole and playable. The seed is tried, and a layout with a
 * flaw in it is not shipped: the seed is mixed into another one and the work is
 * done again, up to eight times. In 2,000 seeds measured none needed a second
 * attempt, so the loop is insurance rather than a plan, and a seed that somehow
 * spends all eight says so loudly instead of handing back a map nobody can
 * finish a round on.
 *
 * The look is the seed's too, out of `looks.ts`: the floor, the walls, the
 * cover and the sites are painted from one of eight named sets of the nine
 * materials already in the atlas, so a name is a layout *and* a place. It is
 * taken from the seed a person wrote down and not from `at`, which a retry
 * moves — the name promises the look, and a map that needed a second attempt
 * is still the map that name asked for.
 */
export function generateLevel(seed: number, size = SIZE): Level {
  let at = seed >>> 0;
  let last: string[] = [];
  const look = lookFor(seed);
  for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
    const level = levelOf(nameOf(seed), generateGrid(at, size), look);
    last = flaws(level);
    if (last.length === 0) return level;
    at = (Math.imul(at, 1664525) + 1013904223) >>> 0;
  }
  throw new Error(`no map came out of seed ${seed >>> 0} in ${ATTEMPTS} attempts: ${last.join("; ")}`);
}
@@ -0,0 +1,556 @@
/**
 * The grenade, checked by hand.
 *
 * The flight is arithmetic and is asserted as arithmetic: the solver takes
 * both half-kicks of gravity before it moves a body down, which is
 * semi-implicit Euler, so after `n` ticks of `dt` a body thrown level from
 * `z0` at `v` is at
 *
 *     x = v · n · dt        z = z0 − g · dt² · n(n+1)/2
 *
 * — half a tick of gravity below the continuous parabola, and exact to the
 * bit. Everything below is that formula, the bounce (0.45 of what it arrived
 * with, reversed), and the blast's own numbers: 98 in the lap, 49 at half the
 * radius, nothing at 350.
 */
import { expect, test } from "bun:test";
import { DE_FORGE } from "./map.ts";
import { SHORT } from "./match.ts";
import {
  blastCentre, blastHits, flashHits, MIN_BLIND, stepGrenade, throwGrenade, THROW_LIFT, THROW_SPEED,
  viewAngle, type Looker,
} from "./grenade.ts";
import { CS_HULL, NADE_HULL, NADE_MOVE } from "./movement.ts";
import { blastDamage, blindSeconds, FLASH, HE, WEAPONS } from "./weapons.ts";
import type { Actor } from "./combat.ts";
import type { Box, Vec3 } from "../engine/index.ts";
import { digest, TICK, withoutEntropy } from "./replay.ts";
import { buy, CARRY } from "./economy.ts";
import {
  causeName, createWorld, eyePos, NO_INPUT, throwOne, update,
  type Effect, type Input, type Player, type World,
} from "./world.ts";
import { effectAt, eyeHeight } from "../engine/index.ts";
/** Did anything the world remembers look like this? The buffer is read by index. */
function heard(world: World, is: (e: Effect) => boolean): boolean {
  for (let i = 0; i < world.effects.count; i++) {
    const effect = effectAt(world.effects, i);
    if (effect !== undefined && is(effect)) return true;
  }
  return false;
}
const FLOOR: Box = { min: [-4000, -4000, -64], max: [4000, 4000, 0], mat: 0 };
const EAST_WALL: Box = { min: [300, -4000, 0], max: [364, 4000, 400], mat: 0 };
/** A body at `pos`, made the way a test can read. */
const actor = (pos: Vec3, over: Partial<Actor> = {}): Actor => ({
  id: 9, team: "t", pos, yaw: 0, duckAmount: 0, health: 100, armor: 0, helmet: false, alive: true,
  ...over,
});
const EAST: Vec3 = [1, 0, 0];
test("the grenade is in the buy menu with CS's numbers, and carries a blast", () => {
  expect(WEAPONS.he).toBe(HE);
  expect(HE.price).toBe(300);
  expect(HE.blast).toEqual({ damage: 98, radius: 350, fuse: 1.5, armorPenetration: 0.5 });
  // Its own tuning, and not the player's: 0.4 of CS's gravity, a bounce, and
  // no step — a grenade does not climb an eighteen-unit ledge like a person.
  expect(NADE_MOVE.gravity).toBe(320);
  expect(NADE_MOVE.restitution).toBe(0.45);
  expect(NADE_MOVE.stepSize).toBe(0);
  expect(NADE_HULL.stand).toBe(4);
});
test("a grenade thrown level flies where the arithmetic says", () => {
  const g = throwGrenade(0, "ct", "he", [0, 0, 64], EAST, [FLOOR]);
  // It leaves the hand eighteen units ahead of the eye, at 750 u/s.
  expect(g.pos).toEqual([18, 0, 64]);
  expect(g.vel).toEqual([THROW_SPEED, 0, 0]);
  const gravity = NADE_MOVE.gravity;
  for (let n = 1; n <= 16; n++) {
    stepGrenade(g, TICK, [FLOOR]);
    expect(g.pos[0]).toBeCloseTo(18 + THROW_SPEED * n * TICK, 6);
    expect(g.pos[2]).toBeCloseTo(64 - gravity * TICK * TICK * ((n * (n + 1)) / 2), 6);
    expect(g.fuse).toBeCloseTo(HE.blast.fuse - n * TICK, 10);
  }
  // A quarter of a second in: 187.5 units along, and 10.2 units of drop.
  const quarter = 16;
  expect(g.pos[0] - 18).toBeCloseTo(THROW_SPEED * quarter * TICK, 6);
  expect(64 - g.pos[2]).toBeCloseTo(gravity * TICK * TICK * ((quarter * (quarter + 1)) / 2), 6);
});
test("a grenade thrown at a wall comes back with 0.45 of what it arrived with", () => {
  const g = throwGrenade(0, "ct", "he", [0, 0, 64], EAST, [FLOOR, EAST_WALL]);
  let bounces = 0;
  let after = 0;
  for (let n = 0; n < 64 && bounces === 0; n++) {
    if (stepGrenade(g, TICK, [FLOOR, EAST_WALL])) {
      bounces += 1;
      after = g.vel[0];
    }
  }
  expect(bounces).toBe(1);
  // 750 out, 0.45 of it back: −337.5 u/s, and it is against the wall's face,
  // its own two-unit radius short of it.
  expect(after).toBeCloseTo(-THROW_SPEED * NADE_MOVE.restitution, 6);
  expect(g.pos[0]).toBeCloseTo(EAST_WALL.min[0] - NADE_HULL.radius, 6);
});
test("a grenade dropped on the floor bounces, then comes to rest on it", () => {
  const g = throwGrenade(0, "ct", "he", [0, 0, 200], [0, 0, -1], [FLOOR]);
  let bounces = 0;
  for (let n = 0; n < 64 * 6; n++) if (stepGrenade(g, TICK, [FLOOR])) bounces += 1;
  expect(bounces).toBeGreaterThan(0);
  expect(g.onGround).toBe(true);
  expect(g.pos[2]).toBe(0);
  expect(Math.hypot(g.vel[0], g.vel[1], g.vel[2])).toBeLessThan(1);
});
test("the blast falls off in a straight line to nothing at the radius", () => {
  const blast = HE.blast;
  expect(blastDamage(blast, 0)).toBeCloseTo(98, 10);
  expect(blastDamage(blast, blast.radius / 2)).toBeCloseTo(49, 10);
  expect(blastDamage(blast, blast.radius)).toBe(0);
  expect(blastDamage(blast, blast.radius + 1)).toBe(0);
  expect(blastDamage(blast, 87.5)).toBeCloseTo(73.5, 10);
});
test("the blast is 98 at the centre, 49 at half the radius, and armour halves it", () => {
  // The grenade at the feet of a body standing at the origin: the centre of
  // the blast is 2 units up and the middle of the chest is 54, so 52 units is
  // as close as a standing body gets — 98 · (1 − 52/350) = 83.4.
  const g = throwGrenade(0, "ct", "he", [0, 0, 0], [0, 0, 0], [FLOOR]);
  const at = (x: number, over: Partial<Actor> = {}): { health: number; armor: number } => {
    const hits = blastHits(g, [actor([x, 0, 0], over)], []);
    return { health: hits[0]?.health ?? 0, armor: hits[0]?.armor ?? 0 };
  };
  const centre = blastCentre(g);
  const chest = 0.75 * 72; // the middle of the chest box, 62%..88% of a 72-unit hull
  const near = Math.hypot(0, chest - centre[2]);
  expect(at(0).health).toBe(Math.round(blastDamage(HE.blast, near)));
  expect(at(0).health).toBe(83);
  // Half the radius away along the floor: √(175² + 52²) = 182.6 units, which
  // is 98 · (1 − 182.6/350) = 46.9.
  const half = Math.hypot(175, chest - centre[2]);
  expect(at(175).health).toBe(Math.round(blastDamage(HE.blast, half)));
  expect(at(175).health).toBe(47);
  // Past it, nothing at all — no entry, not a zero.
  expect(blastHits(g, [actor([400, 0, 0])], [])).toEqual([]);
  // Armour takes half of what it stops, like every other source of damage:
  // 83.44 becomes 42 through the vest, and the vest wears 21 down.
  expect(at(0, { armor: 100 })).toEqual({ health: 42, armor: 21 });
});
test("a grenade behind a crate hurts nobody on the far side", () => {
  const g = throwGrenade(0, "ct", "he", [0, 0, 0], [0, 0, 0], [FLOOR]);
  const behind = actor([200, 0, 0]);
  // In the open, 200 units is well inside the radius and it hurts.
  expect(blastHits(g, [behind], [FLOOR])[0]?.health).toBeGreaterThan(0);
  // A crate between the two takes all of it: `traceWorld` decides, not distance.
  const crate: Box = { min: [100, -80, 0], max: [140, 80, 90], mat: 0 };
  expect(blastHits(g, [behind], [FLOOR, crate])).toEqual([]);
  // And the man standing beside the crate, with nothing in the way, still dies.
  expect(blastHits(g, [actor([200, 200, 0])], [FLOOR, crate])[0]?.health).toBeGreaterThan(0);
});
test("the blast does not reach the thrower's own side", () => {
  const g = throwGrenade(0, "ct", "he", [0, 0, 0], [0, 0, 0], [FLOOR]);
  expect(blastHits(g, [actor([0, 0, 0], { team: "ct" })], [FLOOR])).toEqual([]);
  expect(blastHits(g, [actor([0, 0, 0], { team: "t" })], [FLOOR]).length).toBe(1);
});
// --- in a round -----------------------------------------------------------
const TICKS_PER_SECOND = 64;
/** A world past the freeze, with `me` holding one grenade and nothing else to do. */
function ready(seed: number, teamSize = 5): World {
  const world = createWorld(DE_FORGE, SHORT, "me", "ct", teamSize, seed);
  world.me.money = 5000;
  expect(buy(world, world.me, "he")).toBe(true);
  for (let t = 0; t < (SHORT.freezeTime + 0.5) * TICKS_PER_SECOND; t++) update(world, TICK, NO_INPUT);
  expect(world.match.phase).toBe("live");
  return world;
}
test("a grenade is bought like anything else, one at a time, and goes in a pocket", () => {
  const world = createWorld(DE_FORGE, SHORT, "me", "ct", 5, 11);
  world.me.money = 5000;
  const before = world.me.weapon;
  expect(buy(world, world.me, "he")).toBe(true);
  expect(world.me.pocket.he).toBe(CARRY.he);
  expect(world.me.money).toBe(5000 - HE.price);
  // It did not become the gun in your hands and it did not displace one.
  expect(world.me.weapon).toBe(before);
  expect(world.me.primary).toBe(null);
  // One a round, CS's rule: the second is refused and costs nothing.
  expect(buy(world, world.me, "he")).toBe(false);
  expect(world.me.money).toBe(5000 - HE.price);
});
test("the throw key throws one, once a press, and never during the freeze", () => {
  const world = createWorld(DE_FORGE, SHORT, "me", "ct", 5, 12);
  world.me.money = 5000;
  buy(world, world.me, "he");
  const held: Input = { ...NO_INPUT, throwing: "he" };
  // Frozen: the key does nothing and the grenade stays in the pocket.
  update(world, TICK, held);
  expect(world.grenades.length).toBe(0);
  expect(world.me.pocket.he).toBe(1);
  for (let t = 0; t < (SHORT.freezeTime + 0.5) * TICKS_PER_SECOND; t++) update(world, TICK, NO_INPUT);
  // Live, and held down for half a second: exactly one leaves the hand.
  for (let t = 0; t < 32; t++) update(world, TICK, held);
  expect(world.grenades.length).toBe(1);
  expect(world.me.pocket.he).toBe(0);
  expect(world.grenades[0]?.owner).toBe(world.me.id);
  // And the throw was heard where the hand was.
  expect(heard(world, (e) => e.kind === "sound" && e.name === "throw")).toBe(true);
});
test("the fuse is the same number of ticks whatever the frame rate", () => {
  /** Step `world` in frames of `perFrame` ticks; return the tick it went off on. */
  const fuseTicks = (perFrame: number): number => {
    const world = ready(21);
    world.me.pitch = THROW_LIFT; // aim down by the lift: a dead level throw
    expect(throwOne(world, world.me)).toBe(true);
    let ticks = 0;
    while (world.grenades.length > 0 && ticks < 64 * 5) {
      for (let f = 0; f < perFrame; f++) {
        update(world, TICK, NO_INPUT);
        ticks += 1;
      }
    }
    return ticks;
  };
  // 1.5 seconds of 64 Hz ticks is 96 of them, and a frame that batches four of
  // them at a time — a sixteen-frame-a-second phone — detonates on the same one.
  expect(fuseTicks(1)).toBe(Math.ceil(HE.blast.fuse * TICKS_PER_SECOND));
  expect(fuseTicks(4)).toBe(fuseTicks(1));
});
test("a blast that hurts someone marks the hit, and one that kills names the grenade", () => {
  // One a side, so the only thing that can hurt anybody here is the grenade:
  // nobody on this player's team exists to shoot, and this player never fires.
  const world = ready(31, 1);
  const victim = world.players.find((p) => p.team === "t") as Player;
  const where: Vec3 = [victim.pos[0], victim.pos[1], victim.pos[2]];
  victim.armor = 0;
  const kills = world.me.kills;
  expect(throwOne(world, world.me)).toBe(true);
  let healthBefore = victim.health;
  let damageBefore = world.me.damage;
  for (let t = 0; t < 2 * TICKS_PER_SECOND && world.grenades.length > 0; t++) {
    // Hold the victim still and the grenade at their feet: what is under test
    // is the blast, not whether a thrown one can be aimed at a moving bot.
    victim.pos = [where[0], where[1], where[2]];
    for (const g of world.grenades) {
      g.pos = [where[0], where[1], where[2]];
      g.vel = [0, 0, 0];
    }
    healthBefore = victim.health;
    damageBefore = world.me.damage;
    update(world, TICK, NO_INPUT);
  }
  expect(victim.health).toBeLessThan(healthBefore);
  expect(world.me.damage).toBeGreaterThan(damageBefore);
  expect(heard(world, (e) => e.kind === "hitmark")).toBe(true);
  // The mark says whether the blast finished them, as a bullet's does.
  expect(heard(world, (e) => e.kind === "hitmark" && e.killed === !victim.alive)).toBe(true);
  expect(heard(world, (e) => e.kind === "blast")).toBe(true);
  expect(heard(world, (e) => e.kind === "sound" && e.name === "blast")).toBe(true);
  // 83 hit points at the feet of a body with no vest is not a kill on its own,
  // so a kill is only asserted when the blast actually finished them.
  if (!victim.alive) {
    expect(world.me.kills).toBe(kills + 1);
    const entry = world.feed[world.feed.length - 1];
    expect(entry?.weapon).toBe("he");
    expect(causeName(entry?.weapon ?? "knife")).toBe("HE Grenade");
  }
});
test("a blast that finishes a hurt man puts the grenade in the feed", () => {
  const world = ready(33, 1);
  const victim = world.players.find((p) => p.team === "t") as Player;
  victim.health = 20; // one blast away, whatever the falloff says
  const where: Vec3 = [victim.pos[0], victim.pos[1], victim.pos[2]];
  expect(throwOne(world, world.me)).toBe(true);
  for (let t = 0; t < 2 * TICKS_PER_SECOND && world.grenades.length > 0; t++) {
    victim.pos = [where[0], where[1], where[2]];
    for (const g of world.grenades) {
      g.pos = [where[0], where[1], where[2]];
      g.vel = [0, 0, 0];
    }
    update(world, TICK, NO_INPUT);
  }
  expect(victim.alive).toBe(false);
  expect(world.me.kills).toBe(1);
  const entry = world.feed[world.feed.length - 1];
  expect(entry?.weapon).toBe("he");
  expect(entry?.killer).toBe(world.me.name);
  expect(WEAPONS.he.name).toBe("HE Grenade");
});
test("a grenade is drawn where the body is, and forgotten when it goes off", () => {
  const world = ready(41);
  expect(throwOne(world, world.me)).toBe(true);
  const g = world.grenades[0];
  if (g === undefined) throw new Error("the throw made no grenade");
  const start: Vec3 = [g.pos[0], g.pos[1], g.pos[2]];
  for (let t = 0; t < 16; t++) update(world, TICK, NO_INPUT);
  expect(world.grenades.length).toBe(1);
  expect(g.pos).not.toEqual(start);
  for (let t = 0; t < 2 * TICKS_PER_SECOND; t++) update(world, TICK, NO_INPUT);
  expect(world.grenades.length).toBe(0);
});
test("a round with a grenade in it is still bit-for-bit reproducible", () => {
  const TICKS = 8 * TICKS_PER_SECOND;
  // A script that buys one in the freeze and throws it the moment it is live.
  const script = [
    { atTick: 0, input: {}, buy: "he" as const },
    { atTick: 5 * TICKS_PER_SECOND, input: { throwing: "he" as const } },
    { atTick: 5 * TICKS_PER_SECOND + 8, input: {} },
  ];
  const run = (): ReturnType<typeof digest> =>
    withoutEntropy(() => {
      const world = createWorld(DE_FORGE, SHORT, "me", "ct", 5, 7);
      world.me.money = 5000;
      return digest(world, TICKS, script);
    });
  const quiet = withoutEntropy(() => digest(createWorld(DE_FORGE, SHORT, "me", "ct", 5, 7), TICKS));
  const a = run();
  const b = run();
  expect(a.digest).toBe(b.digest);
  expect(a.seconds).toEqual(b.seconds);
  // And it is a different run from the one where nobody threw anything: the
  // grenade is in the hash, so a thrown one cannot hide.
  expect(a.digest).not.toBe(quiet.digest);
});
test("an input that never sets the throw plays exactly as it did before", () => {
  // The whole of what a bot had to learn for this feature: nothing.
  expect(NO_INPUT.throwing).toBe(null);
  const world = ready(51);
  world.me.pocket.he = 1;
  const before = eyePos(world.me);
  for (let t = 0; t < 64; t++) update(world, TICK, NO_INPUT);
  expect(world.grenades.length).toBe(0);
  expect(world.me.pocket.he).toBe(1);
  expect(before.length).toBe(3);
});
// --- the flash ------------------------------------------------------------
/** A body at `pos` looking along `yaw`/`pitch`: what a flash needs to see. */
const looker = (pos: Vec3, over: Partial<Looker> = {}): Looker => ({
  ...actor(pos), pitch: 0, ...over,
});
/** The height a standing body's eye is at: what a flash is measured to. */
const EYE = eyeHeight({ duckAmount: 0 }, CS_HULL);
/**
 * A flashbang lying still with its centre at `where`, out of nobody's hand.
 * The tests below put it at eye height so the distances are the round numbers
 * they are written as rather than a hypotenuse nobody can check by hand.
 */
const lit = (where: Vec3): ReturnType<typeof throwGrenade> =>
  throwGrenade(0, "ct", "flash", [where[0], where[1], where[2] - NADE_HULL.stand / 2], [0, 0, 0], [FLOOR]);
test("a flashbang is a grenade like the other one: same flight, its own fuse", () => {
  const he = throwGrenade(0, "ct", "he", [0, 0, 64], EAST, [FLOOR]);
  const flash = throwGrenade(0, "ct", "flash", [0, 0, 64], EAST, [FLOOR]);
  expect(flash.weapon).toBe("flash");
  expect(flash.fuse).toBe(FLASH.flash.fuse);
  expect(he.fuse).toBe(HE.blast.fuse);
  // The same body through the same solver: sixteen ticks apart they are still
  // in exactly the same place, because nothing about the flight is the kind's.
  for (let n = 0; n < 16; n++) {
    stepGrenade(he, TICK, [FLOOR]);
    stepGrenade(flash, TICK, [FLOOR]);
  }
  expect(flash.pos).toEqual(he.pos);
  expect(flash.vel).toEqual(he.vel);
  // And it does no damage to anybody, however close they stand.
  expect(blastHits(flash, [actor([0, 0, 0])], [FLOOR])).toEqual([]);
  // While the HE blinds nobody: the two ends are the only thing that differs.
  expect(flashHits(he, [looker([0, 0, 0])], [FLOOR])).toEqual([]);
});
test("a flash blinds by how much of it you could see, and not at all with no line", () => {
  const g = lit([0, 0, EYE]);
  const seconds = (l: Looker, boxes: Box[] = [FLOOR]): number =>
    flashHits(g, [l], boxes)[0]?.seconds ?? 0;
  const max = FLASH.flash.maxBlind;
  // Standing 300 units east, looking west straight at it: 1.6 · 1 · (1 − 300/1200).
  const staring = looker([300, 0, 0], { yaw: 180 });
  expect(seconds(staring)).toBeCloseTo(max * 0.75, 6);
  // Looking away works: the same body turned round sees none of it.
  expect(seconds(looker([300, 0, 0], { yaw: 0 }))).toBe(0);
  // And half turned away — 90° off, which is 45/105 of the way from 30 to 135.
  expect(seconds(looker([300, 0, 0], { yaw: 90 }))).toBeCloseTo(max * (45 / 105) * 0.75, 6);
  // A wall works: `traceWorld` decides whether there was a line at all, and a
  // crate between the two takes every bit of it however squarely they looked.
  const crate: Box = { min: [100, -80, 0], max: [140, 80, 120], mat: 0 };
  expect(seconds(staring, [FLOOR, crate])).toBe(0);
  // The man beside the crate, with nothing in the way, is blinded as before.
  expect(seconds(looker([300, 300, 0], { yaw: 225 }), [FLOOR, crate])).toBeGreaterThan(0);
  // Being behind it works: a flash at your back, with your view down the far
  // way, is over your shoulder and costs nothing however close it went off.
  expect(seconds(looker([-300, 0, 0], { yaw: 180 }))).toBe(0);
  expect(seconds(looker([-20, 0, 0], { yaw: 180 }))).toBe(0);
  // Being behind *someone* is not cover: a body is not a wall, and the trace
  // is against the world's boxes exactly like the blast's is.
  const shield = looker([150, 0, 0], { yaw: 180 });
  expect(flashHits(g, [shield, staring], [FLOOR]).length).toBe(2);
  // Past the radius it is a light in another room.
  expect(seconds(looker([1300, 0, 0], { yaw: 180 }))).toBe(0);
  // And a flicker is not a blinding: anything under MIN_BLIND is no entry.
  expect(blindSeconds(FLASH.flash, 0, 1150)).toBeLessThan(MIN_BLIND);
  expect(flashHits(g, [looker([1150, 0, 0], { yaw: 180 })], [FLOOR])).toEqual([]);
});
test("a flash does not care whose side you are on, and the dead keep their sight", () => {
  const g = lit([0, 0, EYE]);
  const mine = looker([200, 0, 0], { yaw: 180, team: "ct" }); // the thrower's own side
  const theirs = looker([200, 0, 0], { yaw: 180, team: "t" });
  const dead = looker([200, 0, 0], { yaw: 180, team: "t", alive: false });
  expect(flashHits(g, [mine], [FLOOR]).length).toBe(1);
  expect(flashHits(g, [theirs], [FLOOR]).length).toBe(1);
  expect(flashHits(g, [dead], [FLOOR])).toEqual([]);
  // The same two under the HE: it spares the thrower's team and hurts the other.
  const he = throwGrenade(0, "ct", "he", [0, 0, 0], [0, 0, 0], [FLOOR]);
  expect(blastHits(he, [mine], [FLOOR])).toEqual([]);
  expect(blastHits(he, [theirs], [FLOOR]).length).toBe(1);
});
test("the angle a flash is judged at is the whole view, not the yaw", () => {
  const overhead: Vec3 = [0, 0, EYE + 200];
  const g = lit(overhead);
  const below = looker([0, 0, 0]);
  // It went off straight overhead: looking up is looking at it, and looking
  // level is ninety degrees off it whichever way the body is turned.
  expect(viewAngle({ ...below, pitch: -90 }, overhead)).toBeCloseTo(0, 6);
  expect(viewAngle({ ...below, pitch: 0 }, overhead)).toBeCloseTo(90, 6);
  expect(viewAngle({ ...below, pitch: 0, yaw: 90 }, overhead)).toBeCloseTo(90, 6);
  const up = flashHits(g, [{ ...below, pitch: -90 }], [FLOOR])[0]?.seconds ?? 0;
  const level = flashHits(g, [{ ...below, pitch: 0 }], [FLOOR])[0]?.seconds ?? 0;
  expect(up).toBeGreaterThan(level);
  expect(up).toBeCloseTo(FLASH.flash.maxBlind * (1 - 200 / FLASH.flash.radius), 6);
});
test("a flash is bought alongside the HE, one of each, and thrown on its own key", () => {
  const world = createWorld(DE_FORGE, SHORT, "me", "ct", 5, 13);
  world.me.money = 5000;
  expect(buy(world, world.me, "he")).toBe(true);
  expect(buy(world, world.me, "flash")).toBe(true);
  // Carried alongside, not instead of: both are in the pocket at once.
  expect(world.me.pocket).toEqual({ he: CARRY.he, flash: CARRY.flash, smoke: 0 });
  expect(world.me.money).toBe(5000 - HE.price - FLASH.price);
  // One of each a round: the second of either is refused and costs nothing.
  expect(buy(world, world.me, "flash")).toBe(false);
  expect(buy(world, world.me, "he")).toBe(false);
  expect(world.me.money).toBe(5000 - HE.price - FLASH.price);
  // And neither went into your hands.
  expect(world.me.weapon).toBe(world.me.secondary);
  for (let t = 0; t < (SHORT.freezeTime + 0.5) * TICKS_PER_SECOND; t++) update(world, TICK, NO_INPUT);
  // The flash key throws the flash and leaves the HE where it was.
  for (let t = 0; t < 32; t++) update(world, TICK, { ...NO_INPUT, throwing: "flash" });
  expect(world.grenades.length).toBe(1);
  expect(world.grenades[0]?.weapon).toBe("flash");
  expect(world.me.pocket).toEqual({ he: 1, flash: 0, smoke: 0 });
});
/** Everyone but `p` put out of the round, so only the flash can change anything. */
const alone = (world: World, p: Player): void => {
  for (const other of world.players) if (other !== p) other.alive = false;
};
test("a flash that goes off blinds everyone looking at it, and the clock burns it down", () => {
  // One a side, and both bodies held still, alive and whole for the second and
  // a half the fuse burns: what is under test is who the flash reaches.
  const world = ready(37, 1);
  const me = world.me;
  const victim = world.players.find((p) => p.team === "t" && p.alive) as Player;
  // Standing next to each other in the open, looking at one another, with the
  // flash between them: what is under test is the blinding, not the throw.
  victim.pos = [me.pos[0] + 64, me.pos[1], me.pos[2]];
  victim.yaw = 180;
  me.yaw = 0;
  const where: Vec3 = [me.pos[0] + 32, me.pos[1], me.pos[2] + EYE];
  me.pocket.flash = 1;
  expect(throwOne(world, me, "flash")).toBe(true);
  for (let t = 0; t < 3 * TICKS_PER_SECOND && world.grenades.length > 0; t++) {
    for (const g of world.grenades) {
      g.pos = [where[0], where[1], where[2]];
      g.vel = [0, 0, 0];
    }
    victim.pos = [me.pos[0] + 64, me.pos[1], me.pos[2]];
    victim.yaw = 180;
    victim.health = 100;
    me.health = 100;
    me.yaw = 0;
    update(world, TICK, NO_INPUT);
  }
  // Both of them were looking at it, so both are blinded: light is not on a side.
  expect(victim.blind).toBeGreaterThan(0);
  expect(me.blind).toBeGreaterThan(0);
  expect(me.blind).toBeLessThanOrEqual(FLASH.flash.maxBlind);
  // It was heard as a flash, not as a blast, and it drew its own pop.
  expect(heard(world, (e) => e.kind === "sound" && e.name === "flash")).toBe(true);
  expect(heard(world, (e) => e.kind === "sound" && e.name === "blast")).toBe(false);
  expect(heard(world, (e) => e.kind === "blast" && e.weapon === "flash")).toBe(true);
  // Nobody was hurt and nothing went in the feed: a flash is a chance, not a kill.
  expect(victim.health).toBe(100);
  expect(world.feed.length).toBe(0);
  // And it burns down on the simulation's clock, a tick at a time, to nothing.
  const left = me.blind;
  update(world, TICK, NO_INPUT);
  expect(me.blind).toBeCloseTo(left - TICK, 10);
  for (let t = 0; t < 3 * TICKS_PER_SECOND; t++) update(world, TICK, NO_INPUT);
  expect(me.blind).toBe(0);
  expect(world.match.phase === "live" || world.match.phase === "over").toBe(true);
});
test("two flashes in the face are not twice the blindness: neither passes the ceiling", () => {
  const world = ready(39, 1);
  const me = world.me;
  alone(world, me);
  me.yaw = 0; // looking straight at where each of them goes off, forty units out
  const max = FLASH.flash.maxBlind;
  /** Go off at the eye, and step until it is gone. */
  const pop = (): void => {
    const g = throwGrenade(
      me.id, me.team, "flash", [me.pos[0] + 40, me.pos[1], me.pos[2] + EYE - NADE_HULL.stand / 2], [0, 0, 0], [],
    );
    g.fuse = TICK;
    world.grenades.push(g);
    while (world.grenades.length > 0) update(world, TICK, NO_INPUT);
  };
  pop();
  const first = me.blind;
  expect(first).toBeGreaterThan(max * 0.9);
  expect(first).toBeLessThanOrEqual(max);
  // A second one on top of the first: the longer of the two, never the sum.
  pop();
  expect(me.blind).toBeLessThanOrEqual(max);
  expect(me.blind).toBeGreaterThan(max * 0.9);
  expect(me.blind).toBeLessThan(first * 2);
});
@@ -0,0 +1,356 @@
/**
 * The thrown grenade: a body, a fuse, and whatever it does when the fuse runs
 * out. Three kinds are thrown today — the HE, the flashbang and the smoke — and
 * the only thing in this file that knows which is `Grenade.weapon`: the flight,
 * the bounce, the fuse and the sounds are one piece of machinery all three use,
 * and what arrives at the far end is `blastHits` for one, `flashHits` for
 * another and `cloudFrom` for the third. A fourth kind is a row in `weapons.ts`
 * and a function here.
 *
 * There is no solver in this file. A grenade in flight is a `Body` like a
 * player is, and it is moved by the same `move` in `src/engine/physics.ts` —
 * handed `NADE_MOVE` and `NADE_HULL` from `src/client/movement.ts` instead of
 * the player's pair, which is the whole of why it floats, bounces and comes to
 * rest instead of walking. It has its own four-unit hull on purpose: sharing
 * the player's would let it step eighteen units up a ledge like a person.
 *
 * The fuse burns on the simulation's clock — `dt` seconds a tick, at the fixed
 * 64 Hz `world.ts` steps at — so it is the same number of ticks on a phone as
 * on a desktop, and the same number in a replay as in a match.
 *
 * Neither of the first two reaches anything it cannot see. `blastHits` and
 * `flashHits` both trace from the middle of the detonation through the engine's
 * own `visible`, so a wall, a crate or a corner takes all of it: a grenade
 * cannot kill through a wall here and a flash cannot blind through one, which
 * are the properties the two tests of that name hold.
 *
 * The smoke is the odd one and it is odd in the other direction: it reaches
 * nobody at all, and what it leaves behind outlives it. `cloudFrom` turns a
 * spent canister into a `Cloud` — a ball with a clock — which the world keeps
 * and `canSee` in `src/client/world.ts` traces against. Nothing about a cloud
 * is drawing: it is the same ball on the screen and in the simulation.
 */
import {
  angleVectors, clamp, dist, dot, eyeHeight, move, normalize, stuck, sub, visible,
  type Body, type Box, type Vec3, type Wish,
} from "../engine/index.ts";
import { hitboxes, type Actor } from "./combat.ts";
import { CS_HULL, NADE_HULL, NADE_MOVE } from "./movement.ts";
import {
  blastDamage, blindSeconds, fuseOf, SMOKE, WEAPONS, throughArmor,
  type Smoke, type ThrownId,
} from "./weapons.ts";
/** A grenade in the world: a body, which kind it is, whose it is, and how long it has left. */
export type Grenade = Body & {
  /** Which thrown weapon this is — what happens at zero on the fuse. */
  weapon: ThrownId;
  /** The player id that threw it — who the kill is credited to. */
  owner: number;
  team: "t" | "ct";
  /** Seconds left on the fuse. It detonates on the tick this reaches zero. */
  fuse: number;
};
/**
 * A grenade wishes for nothing: it has no legs. The same object every tick,
 * because it never changes and a frame allocates nothing.
 */
const STILL: Wish = {
  forward: 0, side: 0, yaw: 0, jump: false, duck: false, walk: false, maxSpeed: 0,
};
/** How fast it leaves the hand, in u/s. CS's full throw is 750. */
export const THROW_SPEED = 750;
/**
 * Degrees above the crosshair a throw goes. CS tilts a throw up by ten so that
 * a grenade thrown at a wall across the room arrives at head height rather
 * than at your feet; aim ten degrees down and it flies dead level.
 */
export const THROW_LIFT = 10;
/** How far in front of the eye it appears, in units: out of the hand, not the face. */
const HAND = 18;
/**
 * The sounds a grenade makes, in the order one round of it happens. The first
 * two belong to every thrown thing; the rest are each a kind's own — the HE's
 * `blast`, the flashbang's `flash`, the canister's `smoke` — which is why this
 * is one widening type and not a second one per grenade.
 */
export type GrenadeSound = "throw" | "bounce" | "blast" | "flash" | "smoke";
/**
 * Below this the knock of a bounce is not worth a sound: a grenade rolling to
 * a stop taps the floor every tick and nobody wants to hear that. In u/s of
 * the component that reversed.
 */
const HEARD = 90;
/**
 * A grenade of kind `weapon` leaving a hand at `from` along `dir`. It appears a
 * little ahead of the eye so it is not thrown from inside the thrower's own head
 * — unless that would put it inside a wall, in which case it starts at the eye,
 * because a grenade that spawns inside geometry is a grenade that falls through
 * the map. The fuse is the kind's own and comes from the weapon table; nothing
 * about the flight does, which is why both kinds fly identically.
 */
export function throwGrenade(
  owner: number,
  team: "t" | "ct",
  weapon: ThrownId,
  from: Vec3,
  dir: Vec3,
  boxes: Box[],
): Grenade {
  const ahead: Vec3 = [
    from[0] + dir[0] * HAND,
    from[1] + dir[1] * HAND,
    from[2] + dir[2] * HAND,
  ];
  const clear = !stuck(ahead, NADE_HULL.stand, boxes, NADE_HULL);
  const pos: Vec3 = clear ? ahead : [from[0], from[1], from[2]];
  return {
    pos,
    vel: [dir[0] * THROW_SPEED, dir[1] * THROW_SPEED, dir[2] * THROW_SPEED],
    onGround: false,
    ducking: false,
    duckAmount: 0,
    weapon,
    owner,
    team,
    fuse: fuseOf(WEAPONS[weapon]),
  };
}
/**
 * One tick of a grenade: the engine's solver moves it, the fuse burns by `dt`.
 * True when it hit something hard enough to be heard — which is a component of
 * its velocity coming back the other way, since a bounce is the only thing
 * that can reverse one.
 */
export function stepGrenade(g: Grenade, dt: number, boxes: Box[]): boolean {
  const vx = g.vel[0], vy = g.vel[1], vz = g.vel[2];
  move(g, STILL, dt, boxes, NADE_MOVE, NADE_HULL);
  g.fuse -= dt;
  return (
    (vx * g.vel[0] < 0 && Math.abs(vx) > HEARD) ||
    (vy * g.vel[1] < 0 && Math.abs(vy) > HEARD) ||
    (vz * g.vel[2] < 0 && Math.abs(vz) > HEARD)
  );
}
/**
 * How slowly a grenade has to be moving, in u/s, to count as having stopped.
 * A shell settling on concrete never quite reaches zero — the solver leaves it
 * a fraction of a unit a second — so "at rest" is a small number and not one.
 */
const REST_SPEED = 20;
/**
 * How many seconds past its fuse a smoke will wait for the floor before it
 * opens anyway. A canister thrown off a ledge, wedged in a corner or bouncing
 * down a long stair is still a grenade somebody threw, and one that never opens
 * is worse than one that opens in the air. Two seconds is longer than any throw
 * on any map this game generates takes to settle.
 */
const REST_PATIENCE = 2;
/** Is this grenade lying still enough for a cloud to grow where it stopped? */
export const atRest = (g: Grenade): boolean =>
  g.onGround && Math.hypot(g.vel[0], g.vel[1], g.vel[2]) < REST_SPEED;
/**
 * Has this one's fuse run out — has it done whatever it does yet?
 *
 * For the HE and the flashbang this is the comparison it has always been: zero
 * on the fuse is the tick it goes off, in the air or on the floor, because a
 * blast and a flash happen wherever the thing happens to be.
 *
 * A smoke is different in the one way that matters to a round: a cloud grows
 * where the canister *stopped*, so a fuse that runs out in mid-flight is held
 * — the fuse keeps burning negative, which is what makes the wait a number the
 * digest can see — until the thing is on the floor and still, or until
 * `REST_PATIENCE` seconds have gone by and it opens where it is.
 */
export function spent(g: Grenade): boolean {
  if (g.weapon !== "smoke") return g.fuse <= 0;
  return g.fuse <= -REST_PATIENCE || (g.fuse <= 0 && atRest(g));
}
/** The middle of the explosion: the middle of the grenade, not its feet. */
export const blastCentre = (g: Grenade): Vec3 => [g.pos[0], g.pos[1], g.pos[2] + NADE_HULL.stand / 2];
/** What the blast is aimed at on a body: the middle of the chest box. */
function chestOf(actor: Actor): Vec3 {
  const parts = hitboxes(actor);
  const chest = parts.find((p) => p.group === "chest") ?? parts[0];
  if (chest === undefined) return [actor.pos[0], actor.pos[1], actor.pos[2]];
  return [
    (chest.min[0] + chest.max[0]) / 2,
    (chest.min[1] + chest.max[1]) / 2,
    (chest.min[2] + chest.max[2]) / 2,
  ];
}
/** One body the blast reached, and what it cost them. */
export type Caught = { actor: Actor; distance: number; health: number; armor: number };
/**
 * Who this blast reaches and for how much: the falloff in `weapons.ts` decides
 * the damage by distance, `throughArmor` takes the vest's share of it like
 * every other source of damage in this game, and the engine's `visible`
 * decides whether any of it arrives at all.
 *
 * The thrower's own side is left out — this match has no friendly fire, the
 * same rule a bullet is under in `world.ts` — which also means a grenade does
 * not hurt the person who threw it.
 */
export function blastHits(g: Grenade, actors: Actor[], boxes: Box[]): Caught[] {
  const blast = WEAPONS[g.weapon].blast;
  if (blast === undefined) return [];
  const centre = blastCentre(g);
  const caught: Caught[] = [];
  for (const actor of actors) {
    if (!actor.alive || actor.team === g.team) continue;
    const chest = chestOf(actor);
    const distance = dist(centre, chest);
    const raw = blastDamage(blast, distance);
    if (raw <= 0) continue;
    if (!visible(centre, chest, boxes)) continue;
    caught.push({ actor, distance, ...throughArmor(raw, actor.armor, blast.armorPenetration) });
  }
  return caught;
}
// --- the flash ------------------------------------------------------------
/** What a flash needs on top of a body: which way the eyes were pointing. */
export type Looker = Actor & { pitch: number };
/** The eye a flash is seen with — the same height a bullet leaves from. */
const eyeOf = (a: Looker): Vec3 => [a.pos[0], a.pos[1], a.pos[2] + eyeHeight(a, CS_HULL)];
/**
 * Degrees between where `a` was looking and `at`. The whole view direction, not
 * just the yaw: a flash at your feet is one you are looking away from, and a
 * player who was staring at the floor should keep their sight.
 */
export function viewAngle(a: Looker, at: Vec3): number {
  const to = sub(at, eyeOf(a));
  if (dist(at, eyeOf(a)) < 1e-6) return 0;
  const look = angleVectors(a.yaw, a.pitch).forward;
  return (Math.acos(clamp(dot(look, normalize(to)), -1, 1)) * 180) / Math.PI;
}
/**
 * Below this a flash is a flicker, not a blinding: a tenth of a second is six
 * ticks, less than a frame of white, and not worth taking anybody's screen for.
 */
export const MIN_BLIND = 0.1;
/** One body a flash reached, and for how long it took their sight. */
export type Blinded = { actor: Looker; seconds: number; angle: number; distance: number };
/**
 * Who this flash blinds and for how long. Three questions in this order, and
 * the cheap ones first: was there a line at all (the engine's `visible`, eye to
 * pop — a wall takes all of it), how far away was it, and how much of the view
 * it went off in. `blindSeconds` in `weapons.ts` is the curve; this is the
 * geometry it is fed.
 *
 * Unlike the blast, a flash does not care whose side you are on. It is light in
 * a room: it blinds the thrower's team, the thrower, and the enemy alike, which
 * is CS's rule and the only one that makes throwing one a decision.
 *
 * Anything under `MIN_BLIND` is dropped rather than returned as a flicker
 * nobody can act on.
 */
export function flashHits(g: Grenade, actors: Looker[], boxes: Box[]): Blinded[] {
  const flash = WEAPONS[g.weapon].flash;
  if (flash === undefined) return [];
  const centre = blastCentre(g);
  const blinded: Blinded[] = [];
  for (const actor of actors) {
    if (!actor.alive) continue;
    const eye = eyeOf(actor);
    const distance = dist(centre, eye);
    if (distance >= flash.radius) continue;
    if (!visible(centre, eye, boxes)) continue;
    const angle = viewAngle(actor, centre);
    const seconds = blindSeconds(flash, angle, distance);
    if (seconds < MIN_BLIND) continue;
    blinded.push({ actor, seconds, angle, distance });
  }
  return blinded;
}
// --- the cloud ------------------------------------------------------------
/**
 * A cloud of smoke standing in the world: where its middle is, when it opened,
 * and whose canister it was. Everything else about it — how wide it is right
 * now, whether it is still there at all — is arithmetic on `born` and the
 * world's clock, which is why there is no radius on this record and no tick of
 * a cloud anywhere in the game. A cloud is not stepped; it is *read*.
 */
export type Cloud = {
  pos: Vec3;
  /** The simulated second the canister opened. */
  born: number;
  /** The player id that threw it. Nothing reads it yet; the feed will. */
  owner: number;
};
/**
 * How high above the canister the middle of the ball sits, in units. A smoke
 * lying on the floor with its middle at its own height would be a ball half
 * buried in concrete and a hole a crouching body could see under; lifting it
 * most of a standing hull puts the bottom of the ball on the floor and the top
 * of it over a head, which is the wall a smoke is supposed to be.
 */
const CLOUD_LIFT = 58;
/** The cloud a spent canister leaves behind, opening at `time`. */
export const cloudFrom = (g: Grenade, time: number): Cloud => ({
  pos: [g.pos[0], g.pos[1], g.pos[2] + CLOUD_LIFT],
  born: time,
  owner: g.owner,
});
/**
 * How wide this cloud is at `time`, in units, and zero once it is gone —
 *
 *     r(age) = radius · age / grow                  age < grow
 *            = radius                               grow ≤ age < life − fade
 *            = radius · (life − age) / fade         life − fade ≤ age < life
 *            = 0                                    age < 0 or age ≥ life
 *
 * One number, read by three callers that must never disagree: the sight test in
 * `world.ts`, the ball `scene.ts` places, and the wash `hud.ts` puts over the
 * screen when your eye is inside it. A cloud that blocked a bot's line for a
 * second longer than it was drawn would be exactly the bug this shape rules
 * out.
 *
 * The default is the one smoke grenade in the table. It is an argument because
 * a test wants to say "a cloud this wide" without reaching for the weapon.
 */
/**
 * Is this cloud over? Asked by the world's housekeeping rather than by the
 * radius above, because the two differ at exactly one instant and it is the
 * instant that matters: a cloud is *born* at radius zero and is not gone, and a
 * prune written against the radius would drop every cloud on the tick it opened.
 */
export const cloudGone = (cloud: Cloud, time: number, smoke: Smoke = SMOKE.smoke): boolean =>
  time - cloud.born >= smoke.life;
export function cloudRadius(cloud: Cloud, time: number, smoke: Smoke = SMOKE.smoke): number {
  const age = time - cloud.born;
  if (age < 0 || age >= smoke.life) return 0;
  if (age < smoke.grow) return smoke.radius * (age / smoke.grow);
  const left = smoke.life - age;
  if (left < smoke.fade) return smoke.radius * (left / smoke.fade);
  return smoke.radius;
}
@@ -1,157 +0,0 @@
import { expect, test } from "bun:test";
import { blastDamage, blastFalloff, GRENADE, step, thrown, type Grenade } from "./grenades.ts";
import { TELEPORT } from "./interpolate.ts";
import { colOf, DE_FORGE, rowOf, walkable, WALL_HEIGHT, type Box } from "./map.ts";
import type { Vec3 } from "./math.ts";
import { BOMB_BLAST_RADIUS } from "./world.ts";
import { WEAPONS } from "./weapons.ts";
const TICK = 1 / 64;
const FLOOR: Box[] = [{ min: [-10000, -10000, -64], max: [10000, 10000, 0], mat: 0 }];
/** Step `g` for `seconds`, stopping at the tick its fuse runs out. */
const fly = (g: Grenade, seconds: number, boxes: Box[]): number => {
  let bounces = 0;
  for (let t = 0; t < seconds; t += TICK) {
    const { bounced, detonated } = step(g, TICK, boxes);
    if (bounced) bounces += 1;
    if (detonated) break;
  }
  return bounces;
};
test("a flat throw falls like a thrown thing: the range the numbers say", () => {
  // Thrown level — the pitch cancels the lift the throw adds — from 200 units
  // up over a floor at zero. It is a projectile from there: it should land
  // v·√(2h/g) away, the same answer as the back of an envelope.
  const from: Vec3 = [0, 0, 200];
  const g = thrown(0, "t", from, 0, GRENADE.throwLift, [0, 0, 0]);
  const drop = (g.pos[2] as number) - GRENADE.radius;
  const expected = GRENADE.throwSpeed * Math.sqrt((2 * drop) / GRENADE.gravity);
  let landed = 0;
  for (let t = 0; t < 2; t += TICK) {
    const before = g.pos[2] as number;
    step(g, TICK, FLOOR);
    if ((g.pos[2] as number) <= GRENADE.radius + 0.01 && before > GRENADE.radius + 0.01) {
      landed = g.pos[0] as number;
      break;
    }
  }
  expect(landed).toBeGreaterThan(expected * 0.95);
  expect(landed).toBeLessThan(expected * 1.05);
  expect(Math.abs(g.pos[1] as number)).toBeLessThan(1); // straight ahead, +x
});
test("the thrower's own speed goes with it: running throws further", () => {
  const still = thrown(0, "t", [0, 0, 200], 0, GRENADE.throwLift, [0, 0, 0]);
  const running = thrown(0, "t", [0, 0, 200], 0, GRENADE.throwLift, [250, 0, 0]);
  fly(still, 0.5, FLOOR);
  fly(running, 0.5, FLOOR);
  expect(running.pos[0] as number).toBeGreaterThan((still.pos[0] as number) + 100);
});
test("a wall bounces it back, slower, and it never ends up inside one", () => {
  const wall: Box[] = [...FLOOR, { min: [300, -500, 0], max: [340, 500, 400], mat: 0 }];
  const g = thrown(0, "t", [0, 0, 64], 0, 0, [0, 0, 0]);
  const bounces = fly(g, GRENADE.fuse, wall);
  expect(bounces).toBeGreaterThan(0);
  expect(g.pos[0] as number).toBeLessThan(300);
  expect(Math.hypot(g.vel[0], g.vel[1], g.vel[2])).toBeLessThan(GRENADE.throwSpeed);
  // Out of the wall and above the floor, by its own radius, wherever it ended.
  expect(g.pos[0] as number).toBeLessThanOrEqual(300 - GRENADE.radius + 0.001);
  expect(g.pos[2] as number).toBeGreaterThanOrEqual(GRENADE.radius - 0.001);
});
test("thrown at a wall of de_forge it stays in the map and comes to rest", () => {
  const at = DE_FORGE.spawns.t[0] as Vec3;
  const eye: Vec3 = [at[0], at[1], 64];
  // Eight directions from a spawn, hard: none of them may put it outside.
  for (let i = 0; i < 8; i++) {
    const g = thrown(0, "t", eye, i * 45, -20, [0, 0, 0]);
    fly(g, GRENADE.fuse, DE_FORGE.boxes);
    expect(Number.isFinite(g.pos[0]) && Number.isFinite(g.pos[2])).toBe(true);
    expect(walkable(DE_FORGE, colOf(DE_FORGE, g.pos[0] as number), rowOf(DE_FORGE, g.pos[1] as number))).toBe(true);
    expect(g.pos[2] as number).toBeGreaterThan(0);
    expect(g.pos[2] as number).toBeLessThan(WALL_HEIGHT);
  }
});
test("a grenade dropped on the floor stops instead of trembling on it", () => {
  const g: Grenade = { kind: "he", owner: 0, team: "t", pos: [0, 0, 120], prev: [0, 0, 120], vel: [0, 0, 0], fuse: 5 };
  fly(g, 1.5, FLOOR);
  expect(g.vel).toEqual([0, 0, 0]);
  expect(g.pos[2]).toBeCloseTo(GRENADE.radius, 6);
});
test("the fuse runs on the clock: nothing before 1.6s, and then it goes", () => {
  const g = thrown(0, "t", [0, 0, 64], 0, 0, [0, 0, 0]);
  let fired = -1;
  for (let i = 0; i < 200; i++) {
    if (step(g, TICK, FLOOR).detonated) { fired = i; break; }
  }
  expect(fired).toBeGreaterThanOrEqual(Math.floor(GRENADE.fuse / TICK) - 1);
  expect(fired).toBeLessThanOrEqual(Math.ceil(GRENADE.fuse / TICK));
});
test("a hard hit sounds and a settling one does not", () => {
  const fast: Grenade = { kind: "he", owner: 0, team: "t", pos: [0, 0, 60], prev: [0, 0, 60], vel: [0, 0, -400], fuse: 5 };
  expect(fly(fast, 0.25, FLOOR)).toBeGreaterThan(0);
  const settled: Grenade = { kind: "he", owner: 0, team: "t", pos: [0, 0, GRENADE.radius], prev: [0, 0, GRENADE.radius], vel: [0, 0, 0], fuse: 5 };
  for (let i = 0; i < 10; i++) expect(step(settled, TICK, FLOOR).bounced).toBe(false);
});
test("damage is full at the centre, nothing at the radius, and armour halves it", () => {
  expect(blastFalloff(0)).toBe(1);
  expect(blastFalloff(GRENADE.blastRadius)).toBe(0);
  const centre = blastDamage(0, 0).health;
  const middle = blastDamage(GRENADE.blastRadius / 2, 0).health;
  const edge = blastDamage(GRENADE.blastRadius, 0).health;
  expect(centre).toBeGreaterThan(90);
  expect(middle).toBeLessThan(centre);
  expect(middle).toBeGreaterThan(edge);
  expect(edge).toBe(0);
  expect(blastDamage(GRENADE.blastRadius * 2, 0).health).toBe(0);
  const armoured = blastDamage(0, 100);
  expect(armoured.health).toBeLessThan(centre * 0.6);
  expect(armoured.armor).toBeGreaterThan(0);
});
test("the bomb's blast is the same function as the HE's, with its own radius and damage", () => {
  const bomb = WEAPONS.bomb;
  const at = (distance: number, armor: number) =>
    blastDamage(distance, armor, BOMB_BLAST_RADIUS, bomb.damage, bomb.armorPenetration);
  // A lethal core: full armour still leaves less than nothing at its centre.
  const centre = at(0, 100);
  expect(centre.health).toBeGreaterThanOrEqual(100);
  // Falling to zero at the edge, same as the HE's.
  expect(at(BOMB_BLAST_RADIUS, 0).health).toBe(0);
  expect(at(BOMB_BLAST_RADIUS * 2, 0).health).toBe(0);
  // Armour still takes its share in between.
  const middle = BOMB_BLAST_RADIUS * 5 / 6;
  expect(at(middle, 100).health).toBeLessThan(at(middle, 0).health);
});
test("a grenade remembers where it was, so the renderer can draw it between two ticks", () => {
  const g = thrown(0, "t", [0, 0, 64], 0, 0, [0, 0, 0]);
  // It has not moved yet: the first frame draws it at the hand, not between
  // the hand and the origin.
  expect(g.prev).toEqual(g.pos);
  const held = g.prev;
  const was = [...g.pos] as Vec3;
  step(g, TICK, FLOOR);
  expect(g.prev).toEqual(was);
  expect(g.pos[0]).toBeGreaterThan(was[0]); // it flew
  // Twelve units at most in a tick, which is a move and not a teleport.
  expect(Math.hypot(g.pos[0] - g.prev[0], g.pos[1] - g.prev[1], g.pos[2] - g.prev[2])).toBeLessThan(TELEPORT);
  const then = [...g.pos] as Vec3;
  step(g, TICK, FLOOR);
  expect(g.prev).toEqual(then);
  expect(g.prev).toBe(held); // written into the array it already had
});
@@ -1,166 +0,0 @@
/**
 * A thrown object's flight, and nothing else: it leaves a hand with a velocity,
 * falls under the same gravity a player does, bounces off the world losing
 * speed each time, comes to rest, and its fuse runs out wherever it is by then.
 *
 * There is no WebGL, no audio and no HUD here — `world.ts` steps these and
 * decides what a detonation means — so a throw can be checked in a test by
 * reading three numbers, which is the only way to know a grenade lands where
 * the arc says it does.
 *
 * A grenade is a ball of `GRENADE.radius`, not a hull: it is resolved out of
 * whatever box it ended up inside along the shallowest face, and reflects off
 * that face. One ball against fifty boxes a tick, and only while one is in the
 * air, so nothing here is on the path of a round that never buys one.
 */
import type { Box } from "./map.ts";
import { rememberPos } from "./interpolate.ts";
import { angleVectors, clamp, type Vec3 } from "./math.ts";
import { armorSplit, WEAPONS } from "./weapons.ts";
export type Grenade = {
  kind: "he";
  owner: number; // the player id who threw it; the blast is credited to them
  team: "t" | "ct"; // their side when it left the hand, for friendly fire
  pos: Vec3;
  vel: Vec3;
  fuse: number; // seconds left, counted down every step
  /**
   * Where it was when the previous step ended, written by `step` itself before
   * it moves. Nothing in the simulation reads it: it is what lets the renderer
   * draw a grenade partway between two ticks instead of twelve units on from
   * the last one.
   */
  prev: Vec3;
};
export const GRENADE = {
  radius: 4, // the ball the world is resolved against
  gravity: 800, // the same gravity a player falls under
  bounce: 0.45, // the share of the speed into a surface that comes back out
  friction: 0.75, // the share of the speed along it that survives the hit
  rest: 50, // below this, a grenade against a floor stops dead
  fuse: 1.6, // seconds from the hand to the bang, whatever it hit on the way
  throwSpeed: 780, // u/s out of the hand, before the thrower's own velocity
  throwLift: 12, // degrees above where you are looking
  throwFrom: 18, // units in front of the eye it appears
  blastRadius: 350, // where the damage has fallen to nothing
  /** A bounce softer than this is a grenade settling, not a wall being hit. */
  bounceSound: 90,
};
/** What one step did, for the caller that owns sound and damage. */
export type Step = { bounced: boolean; detonated: boolean };
/** What the world did to a grenade this step: the hardest hit, and a floor. */
type Contact = { into: number; floor: boolean };
/**
 * Push `g` out of `box` along the face it is least far through and reflect it
 * off that face, recording the speed it went in with. A grenade that is not
 * inside the box at all costs three comparisons and nothing else.
 */
function resolve(g: Grenade, box: Box, contact: Contact): void {
  const r = GRENADE.radius;
  let axis = 0, sign = 0, depth = Infinity;
  for (let i = 0; i < 3; i++) {
    const above = (g.pos[i] as number) - r - (box.max[i] as number); // clear of the far face
    const below = (box.min[i] as number) - (g.pos[i] as number) - r; // clear of the near one
    if (above >= 0 || below >= 0) return;
    if (-above < depth) { depth = -above; axis = i; sign = 1; }
    if (-below < depth) { depth = -below; axis = i; sign = -1; }
  }
  g.pos[axis] += depth * sign;
  if (axis === 2 && sign === 1) contact.floor = true;
  const into = -(g.vel[axis] as number) * sign;
  if (into <= 0) return; // it was already leaving; the push-out is enough
  if (into > contact.into) contact.into = into;
  g.vel[axis] = (g.vel[axis] as number) * -GRENADE.bounce;
  for (let i = 0; i < 3; i++) if (i !== axis) g.vel[i] = (g.vel[i] as number) * GRENADE.friction;
}
/**
 * One tick of flight: gravity, the move, then the world. The fuse runs on the
 * clock and not on what it hit, so `detonated` is true exactly once — the
 * caller drops the grenade from its list when it sees it.
 */
export function step(g: Grenade, dt: number, boxes: Box[]): Step {
  rememberPos(g.prev, g.pos);
  g.fuse -= dt;
  g.vel[2] -= GRENADE.gravity * dt;
  g.pos[0] += (g.vel[0] as number) * dt;
  g.pos[1] += (g.vel[1] as number) * dt;
  g.pos[2] += (g.vel[2] as number) * dt;
  const contact: Contact = { into: 0, floor: false };
  for (const box of boxes) resolve(g, box, contact);
  // A grenade rolling out of speed on a floor stops, rather than trembling on
  // it for the rest of the fuse: gravity would give it a new hop every tick.
  if (contact.floor && Math.hypot(g.vel[0], g.vel[1], g.vel[2]) < GRENADE.rest) {
    g.vel[0] = 0;
    g.vel[1] = 0;
    g.vel[2] = 0;
  }
  return { bounced: contact.into >= GRENADE.bounceSound, detonated: g.fuse <= 0 };
}
/**
 * A grenade leaving `eye`: forward along the view, lifted a little so it
 * arcs rather than sliding along the floor, with the thrower's own velocity
 * added — running out of a doorway throws it further than standing does.
 */
export function thrown(
  owner: number,
  team: "t" | "ct",
  eye: Vec3,
  yaw: number,
  pitch: number,
  velocity: Vec3,
): Grenade {
  // Pitch is positive downwards, so lifting the throw subtracts from it.
  const dir = angleVectors(yaw, pitch - GRENADE.throwLift).forward;
  const from: Vec3 = [
    eye[0] + dir[0] * GRENADE.throwFrom,
    eye[1] + dir[1] * GRENADE.throwFrom,
    eye[2] + dir[2] * GRENADE.throwFrom,
  ];
  return {
    kind: "he",
    owner,
    team,
    pos: [from[0], from[1], from[2]],
    // It has not moved yet, so it has not moved: a grenade's first frame is
    // drawn at the hand it left and never between there and the origin.
    prev: [from[0], from[1], from[2]],
    vel: [
      dir[0] * GRENADE.throwSpeed + velocity[0],
      dir[1] * GRENADE.throwSpeed + velocity[1],
      dir[2] * GRENADE.throwSpeed + velocity[2],
    ],
    fuse: GRENADE.fuse,
  };
}
/** The share of a blast something `distance` from its `radius` takes: 1 to 0. */
export const blastFalloff = (distance: number, radius: number = GRENADE.blastRadius): number =>
  clamp(1 - distance / radius, 0, 1);
/**
 * What a blast `distance` away costs someone wearing `armor`. Full at the
 * centre, nothing at `radius`, and armour takes its share the way it does off
 * a bullet — a vest is worth about half an HE. The bomb calls this too, with
 * its own radius and centre damage in place of the HE's: one blast rule, not
 * two, so `distance` is the only thing either caller has to get right.
 */
export function blastDamage(
  distance: number,
  armor: number,
  radius: number = GRENADE.blastRadius,
  centreDamage: number = WEAPONS.he.damage,
  penetration: number = WEAPONS.he.armorPenetration,
): { health: number; armor: number } {
  const damage = centreDamage * blastFalloff(distance, radius);
  if (armor <= 0 || damage <= 0) return { health: Math.round(damage), armor: 0 };
  return armorSplit(damage, armor, penetration);
}
@@ -1,110 +0,0 @@
import { expect, test } from "bun:test";
import { AUDIBLE, fromOther, loudness, loudnessOf, reported, wallsBetween, type HeardName } from "./hearing.ts";
import { DE_FORGE } from "./map.ts";
import { dist2d, type Vec3 } from "./math.ts";
/**
 * Two pairs of standing spots on de_forge, 512 units apart each. One pair is
 * two ends of ct mid with nothing between them; the other is b link and ct
 * mid, which are the same distance apart with the wall at column 19 in the
 * way. Everything below is one against the other.
 */
const CLEAR: [Vec3, Vec3] = [[-192, 1856, 2], [320, 1856, 2]];
const THROUGH_A_WALL: [Vec3, Vec3] = [[-448, 1856, 2], [64, 1856, 2]];
/** Ct mid to halfway down mid: 896 units of open corridor, for what a wall is worth. */
const DOWN_MID: [Vec3, Vec3] = [[64, 1856, 2], [64, 960, 2]];
test("the two test pairs are the same distance apart, one of them through a wall", () => {
  expect(dist2d(CLEAR[0], CLEAR[1])).toBeCloseTo(512, 6);
  expect(dist2d(THROUGH_A_WALL[0], THROUGH_A_WALL[1])).toBeCloseTo(512, 6);
  expect(wallsBetween(DE_FORGE, CLEAR[0], CLEAR[1])).toBe(0);
  expect(wallsBetween(DE_FORGE, THROUGH_A_WALL[0], THROUGH_A_WALL[1])).toBe(1);
});
test("a sound falls away with distance until it is not worth hearing", () => {
  const here: Vec3 = [-192, 1856, 2];
  const near = loudness(here, [64, 1856, 2], "ak47", DE_FORGE);
  const far = loudness(here, [1856, 1856, 2], "ak47", DE_FORGE);
  expect(near).toBeGreaterThan(far);
  expect(far).toBeGreaterThan(0);
  // And far enough away, nothing at all: a rifle across the whole map.
  expect(loudness(here, [1856, -2600, 2], "ak47", DE_FORGE)).toBe(0);
  // Right on top of the listener a sound is at its own full loudness, no more.
  expect(loudness(here, here, "ak47", DE_FORGE)).toBeCloseTo(loudnessOf("ak47"), 6);
});
test("a gunshot is the loudest thing on the map", () => {
  const [here, there] = CLEAR;
  const rifle = loudness(here, there, "ak47", DE_FORGE);
  const quieter: HeardName[] = ["step", "plant", "defuse", "explode", "blast", "bounce", "empty", "beep", "knife"];
  for (const name of quieter) {
    expect(loudness(here, there, name, DE_FORGE)).toBeLessThan(rifle);
  }
  // The AWP is the one exception, and it is a gun.
  expect(loudness(here, there, "awp", DE_FORGE)).toBeGreaterThan(rifle);
});
test("a wall costs distance, not silence", () => {
  const clear = loudness(CLEAR[0], CLEAR[1], "step", DE_FORGE);
  const muffled = loudness(THROUGH_A_WALL[0], THROUGH_A_WALL[1], "step", DE_FORGE);
  expect(muffled).toBeGreaterThan(0);
  expect(muffled).toBeLessThan(clear);
  // The same footstep 896 units away in the clear — down mid, which is open
  // that far — is about as quiet: the wall is worth a few hundred units of
  // walking, which is what it should be.
  const far = loudness(DOWN_MID[0], DOWN_MID[1], "step", DE_FORGE);
  expect(wallsBetween(DE_FORGE, DOWN_MID[0], DOWN_MID[1])).toBe(0);
  expect(Math.abs(muffled - far)).toBeLessThan(0.02);
});
test("far enough away, a wall is the difference between heard and not", () => {
  // A footstep a thousand units away carries down open mid, and does not from
  // b link to the far end of ct mid — the same distance, with a wall in it.
  const clear = loudness([64, 1856, 2], [64, 856, 2], "step", DE_FORGE);
  const blocked = loudness([-704, 1856, 2], [296, 1856, 2], "step", DE_FORGE);
  expect(clear).toBeGreaterThanOrEqual(AUDIBLE);
  expect(blocked).toBe(0);
});
test("where a sound seems to come from is a point near by and a direction far off", () => {
  // A random source stuck at its extreme, so the error is the whole error.
  const worst = (): number => 1;
  const here: Vec3 = [-192, 1856, 2];
  const close: Vec3 = [here[0] + 200, here[1], 2];
  const far: Vec3 = [here[0] + 2000, here[1], 2];
  const closeError = dist2d(reported(here, close, DE_FORGE, worst), close);
  const farError = dist2d(reported(here, far, DE_FORGE, worst), far);
  expect(closeError).toBeLessThan(40);
  expect(farError).toBeGreaterThan(200);
  // The bearing, though, is about as good either way: a far sound is a
  // direction to look, not a place to shoot at.
  const bearing = (from: Vec3, to: Vec3): number => Math.atan2(to[1] - from[1], to[0] - from[0]);
  const off = (truth: Vec3): number =>
    Math.abs(bearing(here, reported(here, truth, DE_FORGE, worst)) - bearing(here, truth));
  expect(off(far)).toBeLessThan(off(close) * 2 + 0.05);
  expect(off(far)).toBeLessThan(0.3); // under twenty degrees at two thousand units
});
test("a wall makes a sound harder to place as well as quieter", () => {
  const worst = (): number => 1;
  const clear = dist2d(reported(CLEAR[0], CLEAR[1], DE_FORGE, worst), CLEAR[1]);
  const muffled = dist2d(reported(THROUGH_A_WALL[0], THROUGH_A_WALL[1], DE_FORGE, worst), THROUGH_A_WALL[1]);
  expect(muffled).toBeGreaterThan(clear);
});
test("a heard point is at shoulder height, not on the floor", () => {
  const still = (): number => 0.5; // no error at all
  const at = reported([-192, 1856, 2], [320, 1856, 2], DE_FORGE, still);
  expect(at[0]).toBeCloseTo(320, 6);
  expect(at[1]).toBeCloseTo(1856, 6);
  expect(at[2]).toBeGreaterThan(2);
});
test("your own side's noise is not news; anyone else's is", () => {
  const me = { id: 3, team: "ct" as const };
  expect(fromOther(me, { id: 3, team: "ct" })).toBe(false); // yourself
  expect(fromOther(me, { id: 5, team: "ct" })).toBe(false); // a teammate
  expect(fromOther(me, { id: 5, team: "t" })).toBe(true); // an enemy
  expect(fromOther(me, undefined)).toBe(true); // the bomb, or a grenade in the air
});
@@ -1,130 +0,0 @@
/**
 * What a sound is worth to whoever is standing somewhere else: how loud it
 * arrives, and where they think it came from. Plain data in and out — a
 * position, a name and the map — so it is the same answer for a bot as it
 * would be for anything else that wanted to listen.
 *
 * A sound is named by what made it: one of `world.ts`'s `SoundName`s, or, for
 * a gunshot, the weapon that fired it. That is the whole of the loudness
 * table: an AWP carries across the map, a footstep carries across a room, and
 * a dry trigger barely leaves the hands it clicked in.
 *
 * Walls muffle rather than silence. Working out how much would be a trace per
 * sound per listener, which is five listeners times every effect every tick,
 * so this counts the solid cells on the straight line instead and charges each
 * one extra distance: cheap, deterministic, and wrong in the direction that
 * matters least — a sound around a corner reads as a sound further away.
 */
import { cellAt, colOf, rowOf, CELL, type MapDef } from "./map.ts";
import { dist2d, type Vec3 } from "./math.ts";
import type { SoundName, Team } from "./world.ts";
import type { WeaponId } from "./weapons.ts";
/** Everything that can be heard: the world's own noises, and a shot per gun. */
export type HeardName = SoundName | WeaponId;
/**
 * How loud each thing is at the source, relative to each other. A rifle is
 * 1 by construction and nothing else is louder, which is what keeps a gunshot
 * the thing a bot turns to when a gunshot and a footstep arrive together.
 */
const LOUDNESS: Record<HeardName, number> = {
  // Guns, loudest first. The AWP is the only thing on the map that beats a rifle.
  awp: 1.25, deagle: 1.05, ak47: 1, m4a4: 0.95, mp9: 0.8, glock: 0.7, usp: 0.6,
  // A knife swing is a whisper, and neither of these is ever fired as a shot:
  // a grenade is thrown and the bomb is never held.
  knife: 0.08, he: 0.1, bomb: 0,
  // The world. A plant and a defuse are deliberate and carry past the site; a
  // footstep is a room away; a dry trigger is the gun in your own hands.
  explode: 0.95, blast: 0.9, plant: 0.9, defuse: 0.8, beep: 0.5,
  step: 0.45, bounce: 0.35, empty: 0.25,
};
/**
 * Below this a sound is not information, it is the room. It is set where it
 * is because a rifle shot lands on it at about 2500 units — the distance the
 * bots have always turned round for — and a running footstep at about 1100,
 * which is roughly a site room and a corridor.
 */
export const AUDIBLE = 0.1;
/** Inside this everything is at its own full loudness; past it, it falls away. */
const NEAR = 250;
/** What one solid cell between the two of you costs, in units of apparent distance. */
const WALL_COST = 3 * CELL;
/** The error on a heard point as a share of how far away it is, in the clear. */
const SPREAD = 0.08;
/** What each wall in the way adds to that share: muffled is also harder to place. */
const SPREAD_PER_WALL = 0.07;
/** Where a bot looks when it looks at a noise: shoulder height, not the floor. */
const SHOULDER = 48;
/** The loudness this name leaves its source at, 0 for anything that cannot be heard. */
export const loudnessOf = (name: HeardName): number => LOUDNESS[name] ?? 0;
/**
 * Solid cells on the straight line from `from` to `to`, sampled a cell at a
 * time. Only full-height walls count: a crate is something you hear over.
 */
export function wallsBetween(map: MapDef, from: Vec3, to: Vec3): number {
  const span = dist2d(from, to);
  const steps = Math.max(1, Math.round(span / CELL));
  let walls = 0;
  for (let i = 0; i < steps; i++) {
    const t = (i + 0.5) / steps;
    const x = from[0] + (to[0] - from[0]) * t;
    const y = from[1] + (to[1] - from[1]) * t;
    if (cellAt(map, colOf(map, x), rowOf(map, y)) === "#") walls += 1;
  }
  return walls;
}
const falloff = (base: number, distance: number): number => (base * NEAR) / Math.max(NEAR, distance);
/**
 * How loud a sound made at `pos` arrives at `listener`, or 0 when it does not
 * arrive at all. The clear-line answer is worked out first and rejected before
 * any cell is looked at, so most of what happens on a tick costs one hypot.
 */
export function loudness(listener: Vec3, pos: Vec3, name: HeardName, map: MapDef): number {
  const base = loudnessOf(name);
  if (base <= 0) return 0;
  const span = dist2d(listener, pos);
  if (falloff(base, span) < AUDIBLE) return 0; // too far even with nothing in the way
  const heard = falloff(base, span + wallsBetween(map, listener, pos) * WALL_COST);
  return heard < AUDIBLE ? 0 : heard;
}
/**
 * Where the listener believes the sound came from: the truth, thrown off by
 * an error that grows with distance and with every wall it came through. The
 * angle it is wrong by stays about the same, which is the point — a footstep
 * across the map is a direction to look, not a place to shoot at.
 */
export function reported(
  listener: Vec3, pos: Vec3, map: MapDef, random: () => number,
): Vec3 {
  const span = dist2d(listener, pos);
  const error = span * (SPREAD + wallsBetween(map, listener, pos) * SPREAD_PER_WALL);
  return [
    pos[0] + (random() * 2 - 1) * error,
    pos[1] + (random() * 2 - 1) * error,
    pos[2] + SHOULDER,
  ];
}
/** Who made a sound: a player, or nobody at all — the bomb, or a grenade already in the air. */
export type Maker = { id: number; team: Team } | undefined;
/**
 * Is this sound news? Your own footsteps are not, and neither are your side's:
 * five bots walking together would otherwise spend the round turning round to
 * look at each other.
 */
export const fromOther = (listener: { id: number; team: Team }, maker: Maker): boolean =>
  maker === undefined || (maker.id !== listener.id && maker.team !== listener.team);
@@ -1,732 +1,913 @@
/**
 * The HUD against a recording 2D context: no browser, no canvas, just the
 * calls it would have made. It is the only way to check the damage indicator
 * points the right way round, which is the one thing about it that can be
 * wrong without looking wrong.
 * This test exists so #18 could move the HUD onto the engine's overlay and
 * prove it drew the same thing. It did, and this is what says it still does.
 *
 * It says what a player reads off the screen — the number that goes red, the
 * clock that stops, the crosshair that opens, the feed that fades — and not how
 * `hud.ts` is arranged to draw it. Nothing here asserts a coordinate that only
 * means something to the current layout: a panel that moves two pixels left is
 * not a change a player sees, and a pin that fails on one is a pin someone
 * deletes rather than uses.
 *
 * The `Paint` it draws onto is the HUD's — the engine's surface with the styles
 * narrowed to the strings this game writes into them, which is why the recorder
 * hands a `string` back when the brush is read. The recorder writes down the
 * brush as well as the call, because the colour a line was drawn in is half of
 * what is pinned here; it lived in this file until the radar wanted the same
 * one, and it is `paint.test-helper.ts` now.
 *
 * No canvas, no document, no browser.
 */
import { expect, test } from "bun:test";
import { DEFAULT_CROSSHAIR, type CrosshairStyle } from "./crosshair.ts";
import { drawHud } from "./hud.ts";
import { TICK } from "./loop.ts";
import { SHORT } from "./match.ts";
import type { Motion } from "./motion.ts";
import type { Camera } from "./renderer.ts";
import { WEAPONS } from "./weapons.ts";
import { applyInput, createWorld, eyePos, NO_INPUT, type Player, type World } from "./world.ts";
import { drawHud, HIT_MARK_LIFE, HURT_LIFE, KILL_MARK_LIFE, NOT_READY_ALPHA, painAlpha, whiteout } from "./hud.ts";
import { recorder, type Call, type Recorder } from "./paint.test-helper.ts";
import { DE_FORGE } from "./map.ts";
import { SHORT } from "./match.ts";
import { inaccuracy, WEAPONS } from "./weapons.ts";
import {
  createWorld, currentWeapon, EFFECT_CAPACITY,
  type Effect, type Player, type World,
} from "./world.ts";
// `Ammo` is economy.ts's; world.ts imports it rather than exporting it.
import type { Ammo } from "./economy.ts";
import { createEffects, pushEffect } from "../engine/index.ts";
type Call = {
  name: string; args: number[]; text: string; alpha: number;
  stroke: string; fill: string; lineWidth: number;
};
function recorder(): { ctx: CanvasRenderingContext2D; calls: Call[] } {
  const calls: Call[] = [];
  // The alpha in force when the call was made, snapshotted: a fade is a
  // property and not an argument, so it is the only way to see one. The
  // colours and the line width are read the same way and for the same
  // reason — a crosshair's colour is a property of the context, not of the
  // stroke that used it.
  const log = (name: string) => (...args: unknown[]): void => {
    calls.push({
      name,
      args: args.filter((a) => typeof a === "number") as number[],
      text: args.filter((a) => typeof a === "string").join(" "),
      alpha: ctx.globalAlpha,
      stroke: typeof ctx.strokeStyle === "string" ? ctx.strokeStyle : "",
      fill: typeof ctx.fillStyle === "string" ? ctx.fillStyle : "",
      lineWidth: ctx.lineWidth,
    });
  };
  const ctx = {
    clearRect: log("clearRect"), fillRect: log("fillRect"), rect: log("rect"),
    beginPath: log("beginPath"), moveTo: log("moveTo"), lineTo: log("lineTo"),
    arc: log("arc"), stroke: log("stroke"), fill: log("fill"),
    fillText: log("fillText"), save: log("save"), restore: log("restore"),
    clip: log("clip"), translate: log("translate"), rotate: log("rotate"),
    drawImage: log("drawImage"), closePath: log("closePath"),
    measureText: () => ({ width: 10 }),
    createRadialGradient: (...args: unknown[]) => {
      calls.push({
        name: "createRadialGradient", args: args as number[], text: "", alpha: 1,
        stroke: "", fill: "", lineWidth: 1,
      });
      return { addColorStop: (): void => {} };
    },
    globalAlpha: 1, lineWidth: 1, fillStyle: "", strokeStyle: "",
    font: "", textAlign: "", textBaseline: "",
  };
  return { ctx: ctx as unknown as CanvasRenderingContext2D, calls };
/** A buffer holding exactly these effects, in this order, and nothing else. */
function these(...list: Effect[]): ReturnType<typeof createEffects<Effect>> {
  const effects = createEffects<Effect>(EFFECT_CAPACITY);
  for (const effect of list) pushEffect(effects, effect, effect.at);
  return effects;
}
const W = 1280, H = 720;
/** The one effect this frame is about, in a buffer of its own. */
const only = (effect: Effect): ReturnType<typeof createEffects<Effect>> => these(effect);
/** The camera `main.ts` builds for the player being drawn, punch and all aside. */
const cameraFor = (view: Player): Camera =>
  ({ pos: eyePos(view), yaw: view.yaw, pitch: view.pitch, fov: view.scoped ? 40 : 90 });
/** One frame of the HUD, drawing `view` — the person unless a spectator is watching. */
const draw = (into: { ctx: CanvasRenderingContext2D }, world: World, view: Player = world.me,
  scoreboard = false, crosshair?: CrosshairStyle, alpha = 1): void =>
  drawHud(into.ctx, world, view, cameraFor(view), W, H, scoreboard, crosshair, alpha);
/** Where the middle of a stroked wedge lands on the screen. */
const wedgePoint = (call: Call): { x: number; y: number } => {
  const [x, y, r, start, end] = call.args as [number, number, number, number, number];
  const middle = (start + end) / 2;
  return { x: x + Math.cos(middle) * r, y: y + Math.sin(middle) * r };
};
const hurtWorld = (yaw: number, from: [number, number, number], victim: number): World => {
  const world = createWorld(SHORT, "me", "ct", 5, 71);
  world.me.pos = [0, 0, 0];
  world.me.yaw = yaw;
  world.effects.length = 0;
  world.effects.push({ kind: "hurt", at: world.time, victim, from, amount: 30 });
  return world;
};
// The damage wedges are arcs centred on the crosshair; the radar draws its
// own arcs too, off in the corner, so a plain count of "arc" calls is no
// longer enough to isolate them.
const wedgeArcs = (calls: Call[]): Call[] => calls.filter((c) => c.name === "arc" && c.args[0] === W / 2);
test("a hit from behind puts the wedge below the crosshair, one from the left on its left", () => {
  const behind = recorder();
  draw(behind, hurtWorld(0, [-500, 0, 40], 0));
  const back = wedgeArcs(behind.calls).map(wedgePoint);
  expect(back.length).toBe(1);
  expect(back[0].y).toBeGreaterThan(H / 2 + 20);
  expect(Math.abs(back[0].x - W / 2)).toBeLessThan(20);
  const left = recorder();
  draw(left, hurtWorld(0, [0, 500, 40], 0));
  const side = wedgeArcs(left.calls).map(wedgePoint);
  expect(side.length).toBe(1);
  expect(side[0].x).toBeLessThan(W / 2 - 20);
  expect(Math.abs(side[0].y - H / 2)).toBeLessThan(20);
});
test("a fall hurts from straight below: no wedge, since there is no way it came from", () => {
  const frame = recorder();
  draw(frame, hurtWorld(0, [0, 0, 0], 0));
  expect(wedgeArcs(frame.calls).length).toBe(0);
});
test("hits stack, and damage to anyone but the player being drawn is not drawn", () => {
  const two = recorder();
  const world = hurtWorld(0, [-500, 0, 40], 0);
  world.effects.push({ kind: "hurt", at: world.time, victim: 0, from: [0, -500, 40], amount: 18 });
  draw(two, world);
  expect(wedgeArcs(two.calls).length).toBe(2);
  const bot = recorder();
  draw(bot, hurtWorld(0, [-500, 0, 40], 4));
  expect(wedgeArcs(bot.calls).length).toBe(0);
});
test("an old hit has faded out by the time the effects list is trimmed", () => {
  const world = hurtWorld(0, [-500, 0, 40], 0);
  world.time += 1.5; // still in the list, which update keeps for two seconds
  const frame = recorder();
  draw(frame, world);
  expect(wedgeArcs(frame.calls).length).toBe(0);
});
test("the hurt vignette follows health and its gradient is built once, not per frame", () => {
  const healthy = recorder();
  const world = createWorld(SHORT, "me", "ct", 5, 73);
  draw(healthy, world);
  const full = (calls: Call[]): Call[] =>
    calls.filter((c) => c.name === "fillRect" && c.args[0] === 0 && c.args[1] === 0 && c.args[2] === W);
  expect(full(healthy.calls).length).toBe(0);
  world.me.health = 20;
  const hurt = recorder();
  draw(hurt, world);
  expect(full(hurt.calls).length).toBe(1);
  // The second frame at the same size reuses the gradient the first one made.
  const again = recorder();
  draw(again, world);
  expect(full(again.calls).length).toBe(1);
  expect(again.calls.filter((c) => c.name === "createRadialGradient").length).toBe(0);
});
// --- the world this suite draws --------------------------------------------
/**
 * The crosshair's arms as the context was told to draw them: each `moveTo`
 * paired with the `lineTo` that follows it, kept only when it starts at the
 * middle of the screen. Nothing else in a quiet frame starts there — the
 * radar's own lines are off in the corner and the hit markers need an effect.
 * One match, built once for the whole file: `createWorld` lays out ten players,
 * spawns, bots and a bomb, and doing that per test is seconds nobody needs.
 * Every test draws a *copy* of it instead, so a test that spends a magazine or
 * kills a bot does not reach the next one.
 */
function armsDrawn(calls: Call[]): { from: number[]; to: number[]; stroke: string; lineWidth: number }[] {
  const arms: { from: number[]; to: number[]; stroke: string; lineWidth: number }[] = [];
  for (let i = 0; i < calls.length - 1; i++) {
    const move = calls[i], line = calls[i + 1];
    if (move.name !== "moveTo" || line.name !== "lineTo") continue;
    const along = (move.args[0] === W / 2) !== (move.args[1] === H / 2);
    if (!along) continue;
    arms.push({ from: move.args, to: line.args, stroke: move.stroke, lineWidth: move.lineWidth });
  }
  return arms;
const BASE = createWorld(DE_FORGE, SHORT, "you", "ct", 5, 64);
const copyAmmo = (ammo: Record<string, Ammo>): Record<string, Ammo> =>
  Object.fromEntries(Object.entries(ammo).map(([id, a]) => [id, { ...a }]));
/** A copy of the base world, changed the one way this test is about. */
function scene(change: (world: World) => void = () => {}): World {
  const players = BASE.players.map((p) => ({ ...p, ammo: copyAmmo(p.ammo) }));
  const world: World = {
    ...BASE,
    match: { ...BASE.match, score: { ...BASE.match.score }, losses: { ...BASE.match.losses } },
    players,
    me: players[0] as Player,
    bomb: { ...BASE.bomb, defuser: null },
    effects: createEffects<Effect>(EFFECT_CAPACITY),
    feed: [],
    messages: [],
  };
  change(world);
  return world;
}
/** A quiet frame: alive, still, and holding the knife, which has no spread. */
const quietWorld = (): World => {
  const world = createWorld(SHORT, "me", "ct", 5, 67);
  world.me.weapon = "knife";
  world.me.vel = [0, 0, 0];
  return world;
};
const WIDTH = 1280;
const HEIGHT = 720;
test("the default crosshair is the one this game has always drawn", () => {
  const frame = recorder();
  draw(frame, quietWorld());
  // Four green arms, starting 4px out and running 7px, stroked 2px wide —
  // right, left, down, up, exactly as the hard-coded loop drew them.
  expect(armsDrawn(frame.calls).map((a) => [...a.from, ...a.to])).toEqual([
    [W / 2 + 4, H / 2, W / 2 + 11, H / 2],
    [W / 2 - 4, H / 2, W / 2 - 11, H / 2],
    [W / 2, H / 2 + 4, W / 2, H / 2 + 11],
    [W / 2, H / 2 - 4, W / 2, H / 2 - 11],
  ]);
  for (const arm of armsDrawn(frame.calls)) {
    expect(arm.stroke).toBe("rgba(120, 255, 140, 0.9)");
    expect(arm.lineWidth).toBe(2);
  }
  // No dot by default: nothing is filled in the middle of the screen.
  expect(frame.calls.some((c) => c.name === "arc" && c.args[0] === W / 2 && c.args[1] === H / 2)).toBe(false);
  // And the default is what a frame drawn with no style at all gets, so the
  // HUD and the settings agree about what "today's crosshair" means.
  const explicit = recorder();
  draw(explicit, quietWorld(), undefined, false, DEFAULT_CROSSHAIR);
  expect(armsDrawn(explicit.calls)).toEqual(armsDrawn(frame.calls));
});
test("the style is what gets drawn: colour, gap, size, thickness and the dot", () => {
  const style: CrosshairStyle =
    { colour: "cyan", size: 16, gap: 10, thickness: 4, dot: true, dynamic: false };
  const frame = recorder();
  draw(frame, quietWorld(), undefined, false, style);
  const arms = armsDrawn(frame.calls);
  expect(arms.map((a) => [...a.from, ...a.to])).toEqual([
    [W / 2 + 10, H / 2, W / 2 + 26, H / 2],
    [W / 2 - 10, H / 2, W / 2 - 26, H / 2],
    [W / 2, H / 2 + 10, W / 2, H / 2 + 26],
    [W / 2, H / 2 - 10, W / 2, H / 2 - 26],
  ]);
  expect(arms[0].stroke).toBe("rgba(96, 226, 255, 0.9)");
  expect(arms[0].lineWidth).toBe(4);
  // The dot: a filled circle in the middle, in the same colour as the arms.
  const dot = frame.calls.find((c) => c.name === "arc" && c.args[0] === W / 2 && c.args[1] === H / 2);
  expect(dot).toBeDefined();
  expect((dot as Call).args[2]).toBe(2);
  expect((dot as Call).fill).toBe("rgba(96, 226, 255, 0.9)");
});
test("a dynamic crosshair opens as the gun loses accuracy; a static one holds still", () => {
  const running = (crosshair?: CrosshairStyle): number => {
    const world = quietWorld();
    world.me.weapon = "ak47";
    world.me.vel = [250, 0, 0];
    world.me.onGround = false; // in the air, where a rifle is at its worst
    const frame = recorder();
    draw(frame, world, undefined, false, crosshair);
    return armsDrawn(frame.calls)[0].from[0] - W / 2;
  };
  const still = (): number => {
    const frame = recorder();
    draw(frame, quietWorld(), undefined, false);
    return armsDrawn(frame.calls)[0].from[0] - W / 2;
  };
  expect(running()).toBeGreaterThan(still() + 10);
  // The same jump with the same rifle, and the arms do not move at all.
  expect(running({ ...DEFAULT_CROSSHAIR, dynamic: false })).toBe(still());
});
/** A world where the person is dead and one named teammate is still up. */
const spectatedWorld = (): World => {
  const world = createWorld(SHORT, "me", "ct", 5, 79);
  const mates = world.players.filter((p) => p.team === "ct" && p !== world.me);
  for (const p of mates.slice(1)) p.alive = false;
  world.me.alive = false;
  world.me.health = 0;
  world.feed.push({
    at: world.time, killer: "Krait", killerId: 9, victim: world.me.name, victimId: world.me.id,
    weapon: "ak47", headshot: true, killerTeam: "t",
  });
  return world;
};
test("dead, the HUD is the watched player's: their numbers, no crosshair, and who killed you", () => {
  const world = spectatedWorld();
  const mate = world.players.find((p) => p.alive && p.team === "ct") as Player;
  mate.health = 64;
  mate.money = 4321;
  const frame = recorder();
  draw(frame, world, mate);
  const texts = frame.calls.filter((c) => c.name === "fillText").map((c) => c.text);
  expect(texts).toContain("64"); // the watched player's health, not the corpse's zero
  expect(texts).toContain("$4321");
  expect(texts.join("|")).toContain(`Watching ${mate.name}`);
  expect(texts.join("|")).toContain("Krait killed you with AK-47");
  expect(texts.join("|")).toContain("headshot");
  // The crosshair is four strokes out from the middle; a spectator gets none.
  expect(frame.calls.filter((c) => c.name === "moveTo" && c.args[1] === H / 2).length).toBe(0);
});
test("a fall that killed you says so, rather than naming you as your own killer", () => {
  const world = spectatedWorld();
  world.feed.push({
    at: world.time, killer: world.me.name, killerId: world.me.id, victim: world.me.name, victimId: world.me.id,
    weapon: "fall", headshot: false, killerTeam: "ct",
  });
  const mate = world.players.find((p) => p.alive && p.team === "ct") as Player;
  const frame = recorder();
  draw(frame, world, mate);
  const texts = frame.calls.filter((c) => c.name === "fillText").map((c) => c.text).join("|");
  expect(texts).toContain("You fell too far");
  expect(texts).toContain(`${world.me.name}  Fall  ${world.me.name}`);
});
test("a spectator does not inherit the dead player's hit markers", () => {
  const world = spectatedWorld();
  const mate = world.players.find((p) => p.alive && p.team === "ct") as Player;
  world.effects.push({ kind: "hitmark", at: world.time, headshot: false, killed: false });
  const watching = recorder();
  draw(watching, world, mate);
  // The radar draws its own moveTo near the corner for the self arrow; the
  // hit marker's crosses are the ones centred on the crosshair.
  const centred = watching.calls.filter((c) => c.name === "moveTo" && Math.abs(c.args[0] - W / 2) < 50);
  expect(centred.length).toBe(0);
  // Alive, the same effect is the marker it was drawn for.
  const alive = createWorld(SHORT, "me", "ct", 5, 79);
  alive.effects.push({ kind: "hitmark", at: alive.time, headshot: false, killed: false });
  const own = recorder();
  draw(own, alive);
  expect(own.calls.filter((c) => c.name === "moveTo").length).toBeGreaterThan(4);
});
test("the mark for a kill is a different shape from the one for a hit, and lasts longer", () => {
  /** The strokes a frame put in the middle of the screen: the crosshair's and the marker's. */
  const centred = (killed: boolean, age = 0, headshot = false): Call[] => {
    const world = createWorld(SHORT, "me", "ct", 5, 81);
    world.effects.push({ kind: "hitmark", at: world.time - age, headshot, killed });
    const frame = recorder();
    draw(frame, world);
    return frame.calls.filter((c) =>
      c.name === "moveTo" && Math.abs(c.args[0] - W / 2) < 50 && Math.abs(c.args[1] - H / 2) < 50);
  };
  // The crosshair alone, with the marker long expired: the baseline to subtract.
  const crosshairOnly = centred(false, 10).length;
  expect(centred(false, 10, false).length).toBe(crosshairOnly);
  expect(centred(false).length - crosshairOnly).toBe(4); // four ticks out of the corners
  expect(centred(true).length - crosshairOnly).toBe(6); // and an X through the middle
  expect(centred(true).some((c) => c.lineWidth === 3)).toBe(true); // heavier
  expect(centred(false).every((c) => c.lineWidth !== 3)).toBe(true);
  // A third of a second on, the plain mark is gone and the kill is still up.
  expect(centred(false, 0.35).length).toBe(crosshairOnly);
  expect(centred(true, 0.35).length - crosshairOnly).toBe(6);
  // A headshot kill is still the headshot's red, X and all.
  expect(centred(true, 0, true).some((c) => c.stroke === "rgba(255,90,90,0.95)")).toBe(true);
});
test("a gun under your feet that you would have to ask for says so", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 89);
  world.me.primary = "m4a4";
  world.pickups.push({
    weapon: "ak47",
    pos: [world.me.pos[0], world.me.pos[1], world.me.pos[2] + 4],
    ammo: { mag: 12, reserve: 90 },
  });
  const carrying = recorder();
  draw(carrying, world);
  expect(carrying.calls.some((c) => c.text === "E — take AK-47")).toBe(true);
  // With no primary it is taken by walking over it, so there is nothing to ask.
  world.me.primary = null;
  const empty = recorder();
  draw(empty, world);
  expect(empty.calls.some((c) => c.text.includes("take AK-47"))).toBe(false);
  // And a gun across the map is not under anyone's feet.
  world.me.primary = "m4a4";
  world.pickups[0].pos = [world.me.pos[0] + 400, world.me.pos[1], world.me.pos[2]];
  const far = recorder();
  draw(far, world);
  expect(far.calls.some((c) => c.text.includes("take AK-47"))).toBe(false);
});
test("the round result stays up through the end delay and the freeze that follows", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 83);
  world.match.phase = "over";
  world.messages.push({ at: world.time, text: "Counter-Terrorists win — defused the bomb" });
  world.time += SHORT.endDelay + SHORT.freezeTime - 1; // well past the four-second fade
  const ending = recorder();
  draw(ending, world);
  expect(ending.calls.some((c) => c.text.includes("defused the bomb"))).toBe(true);
  world.match.phase = "freeze";
  const freezing = recorder();
  draw(freezing, world);
  expect(freezing.calls.some((c) => c.text.includes("defused the bomb"))).toBe(true);
  // Live again, an old line is gone: it is the round's result, not wallpaper.
  world.match.phase = "live";
  const live = recorder();
  draw(live, world);
  expect(live.calls.some((c) => c.text.includes("defused the bomb"))).toBe(false);
});
test("the damage report is drawn while the round is over, and not while it is live", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 103);
  const enemy = world.players.find((p) => p.team === "t") as Player;
  world.damageLog[world.me.id][enemy.id] = { damage: 42, hits: 2, killed: true };
  world.match.phase = "over";
  const over = recorder();
  draw(over, world);
  const overTexts = over.calls.filter((c) => c.name === "fillText").map((c) => c.text);
  expect(overTexts.some((t) => t.includes(`${enemy.name} — 42 dmg`))).toBe(true);
  expect(overTexts.some((t) => t.startsWith("Dealt"))).toBe(true);
  world.match.phase = "live";
  const live = recorder();
  draw(live, world);
  const liveTexts = live.calls.filter((c) => c.name === "fillText").map((c) => c.text);
  expect(liveTexts.some((t) => t.includes(`${enemy.name} — 42 dmg`))).toBe(false);
  // The scoreboard covers the same pixels, so a held Tab wins over the report.
  world.match.phase = "over";
  const withScoreboard = recorder();
  draw(withScoreboard, world, world.me, true);
  const scoreboardTexts = withScoreboard.calls.filter((c) => c.name === "fillText").map((c) => c.text);
  expect(scoreboardTexts.some((t) => t.startsWith("Dealt"))).toBe(false);
});
test("the radar sits in the bottom-left corner and labels both sites", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 91);
  const frame = recorder();
  draw(frame, world);
  const texts = frame.calls.filter((c) => c.name === "fillText").map((c) => c.text);
  expect(texts).toContain("A");
  expect(texts).toContain("B");
  // The radar's border is a full circle, away from the money line, the kill
  // feed and the clock, all of which live in the top half of the screen.
  const border = frame.calls.find(
    (c) => c.name === "arc" && c.args[0] < W / 2 && c.args[1] > H / 2 && c.args[3] === 0,
/**
 * Draw one frame of the HUD onto a fresh recorder. `view` is whose eyes it is
 * drawn from — left out, yours, which is every frame of a round you are alive
 * in; a player once you are dead and watching them.
 */
function draw(
  world: World,
  options: {
    width?: number; height?: number; scoreboard?: boolean; view?: Player; dpr?: number; motion?: Motion;
  } = {},
): Recorder {
  const paint = recorder();
  drawHud(
    paint, world, options.width ?? WIDTH, options.height ?? HEIGHT,
    options.scoreboard ?? false, options.view ?? world.me, options.dpr ?? 1, options.motion,
  );
  expect(border).toBeDefined();
});
test("the ammo counter dims while the gun is coming up, and lifts as it comes level", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 208);
  world.me.primary = "awp";
  world.me.weapon = "awp";
  world.me.ammo.awp = { mag: WEAPONS.awp.magazine, reserve: WEAPONS.awp.reserve };
  world.time = 30;
  // A round start hands the gun over already up: nothing to say about it.
  const ammoOf = (r: { calls: Call[] }): Call =>
    r.calls.find((c) => c.name === "fillText" && c.text.startsWith(`${WEAPONS.awp.magazine} /`)) as Call;
  const up = recorder();
  draw(up, world);
  expect(ammoOf(up).alpha).toBe(1);
  // Drawn off the knife: 1.25 s in which the trigger does nothing, said in the
  // one place on the HUD that claims the gun is ready to use.
  applyInput(world, world.me, { ...NO_INPUT, switchTo: "knife" }, TICK);
  world.time += TICK;
  applyInput(world, world.me, { ...NO_INPUT, switchTo: "awp" }, TICK);
  const coming = recorder();
  draw(coming, world);
  expect(ammoOf(coming).alpha).toBeLessThan(1);
  // The weapon's name goes with it, and nothing above them does.
  expect((coming.calls.find((c) => c.text === "AWP") as Call).alpha).toBeLessThan(1);
  expect((coming.calls.find((c) => c.text === "$800") as Call).alpha).toBe(1);
  // Still dim a whole second in, and full strength the moment the shot clock
  // frees the trigger — the frame the view model is level.
  world.time += 1;
  const nearly = recorder();
  draw(nearly, world);
  expect(ammoOf(nearly).alpha).toBeLessThan(1);
  world.time = world.me.nextShotAt;
  const ready = recorder();
  draw(ready, world);
  expect(ammoOf(ready).alpha).toBe(1);
});
test("the cooldown between two shots is not a deploy, so the ammo counter holds", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 209);
  world.time = 30;
  const ammoOf = (r: { calls: Call[] }): Call =>
    r.calls.find((c) => c.name === "fillText" && c.text.includes(" / ")) as Call;
  // The USP mid-cooldown: the gun is up and working, not arriving.
  world.me.lastShotAt = world.time;
  world.me.nextShotAt = world.time + 60 / WEAPONS.usp.rpm;
  const firing = recorder();
  draw(firing, world);
  expect(ammoOf(firing).alpha).toBe(1);
});
test("the HUD says what is in the pocket, and counts it where the ammo goes", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 97);
  world.me.grenades = { he: 1 };
  const carrying = recorder();
  draw(carrying, world);
  const texts = (r: { calls: Call[] }): string[] =>
    r.calls.filter((c) => c.name === "fillText").map((c) => c.text);
  expect(texts(carrying).some((t) => t.startsWith("HE ×1"))).toBe(true);
  // Held, the count is what the magazine would have said, under its name.
  world.me.weapon = "he";
  const held = recorder();
  draw(held, world);
  expect(texts(held)).toContain("×1");
  expect(texts(held)).toContain("HE Grenade");
  // With none, neither line is there to read.
  world.me.grenades = {};
  world.me.weapon = world.me.secondary;
  const without = recorder();
  draw(without, world);
  expect(without.calls.some((c) => c.text.includes("HE"))).toBe(false);
});
/**
 * A world with nothing solid in it, the person at the origin looking east, and
 * one live teammate and one live enemy to put wherever a test needs them. The
 * boxes are replaced rather than emptied in place: `world.boxes` starts out as
 * the shared map's own list, which no test may edit.
 */
function plateWorld(): { world: World; me: Player; mate: Player; enemy: Player } {
  const world = createWorld(SHORT, "me", "ct", 5, 61);
  const me = world.me;
  me.pos = [0, 0, 0];
  me.yaw = 0;
  me.pitch = 0;
  const mates = world.players.filter((p) => p.team === "ct" && p !== me);
  const enemies = world.players.filter((p) => p.team === "t");
  for (const p of [...mates.slice(1), ...enemies.slice(1)]) p.alive = false;
  const mate = mates[0] as Player, enemy = enemies[0] as Player;
  mate.pos = [600, 60, 0];
  enemy.pos = [600, -60, 0];
  world.boxes = [];
  return { world, me, mate, enemy };
  return paint;
}
/** A wall across the view at `x`, tall enough to hide anyone standing behind it. */
const wallAt = (x: number): { min: [number, number, number]; max: [number, number, number]; mat: number } =>
  ({ min: [x, -400, 0], max: [x + 16, 400, 200], mat: 0 });
/** Every line on the screen a player could actually read: alpha zero is not on it. */
const readable = (paint: Recorder): Call[] =>
  paint.calls.filter((c) => c.op === "fillText" && c.alpha > 0);
const written = (calls: Call[]): string[] => calls.filter((c) => c.name === "fillText").map((c) => c.text);
const words = (paint: Recorder): string[] => readable(paint).map((c) => String(c.args[0]));
test("a name over the player in front of you, with health when they are yours", () => {
  const { world, mate, enemy } = plateWorld();
  mate.health = 64;
  enemy.health = 37;
  const frame = recorder();
  draw(frame, world);
  const texts = written(frame.calls);
const says = (paint: Recorder, text: string): boolean => words(paint).includes(text);
  expect(texts).toContain(mate.name);
  expect(texts).toContain(enemy.name);
  expect(texts).toContain("64"); // the teammate's health, under their name
  expect(texts).not.toContain("37"); // an enemy's health is nobody's business
});
/** The one readable line that reads exactly this, and the brush that drew it. */
function line(paint: Recorder, text: string): Call {
  const hits = readable(paint).filter((c) => c.args[0] === text);
  expect(hits.length).toBe(1);
  return hits[0] as Call;
}
test("no wallhack: a player behind a box has no plate, and gets one again in the open", () => {
  const { world, mate, enemy } = plateWorld();
  world.boxes = [wallAt(300)];
  const hidden = recorder();
  draw(hidden, world);
  expect(written(hidden.calls)).not.toContain(mate.name);
  expect(written(hidden.calls)).not.toContain(enemy.name);
// --- the crosshair ---------------------------------------------------------
  // Same frame, same players, with the wall gone.
  world.boxes = [];
  const open = recorder();
  draw(open, world);
  expect(written(open.calls)).toContain(mate.name);
  expect(written(open.calls)).toContain(enemy.name);
});
/**
 * The crosshair's arm reaching right, as how far each of its two ends is from
 * the middle of the screen. An arm is a filled rectangle of whole device pixels
 * now rather than a stroked segment — see `engine/pixels.ts` — so it is found
 * as the first fill that starts right of the centre and straddles the middle
 * row, which nothing else on the HUD does.
 */
function armOf(paint: Recorder, width = WIDTH, height = HEIGHT): { near: number; far: number } {
  const cx = width / 2, cy = height / 2;
  const arm = paint.calls.find((c) =>
    c.op === "fillRect" && Number(c.args[0]) > cx &&
    Number(c.args[1]) <= cy && Number(c.args[1]) + Number(c.args[3]) >= cy);
  if (arm === undefined) throw new Error("no crosshair arm was filled");
  const near = Number(arm.args[0]) - cx;
  return { near, far: near + Number(arm.args[2]) };
}
test("a plate needs a live player in front of the eye, and no scoreboard over it", () => {
  const { world, mate, enemy } = plateWorld();
  enemy.alive = false; // a body is not a player
  mate.pos = [-600, 0, 0]; // behind the camera, which looks east
  const away = recorder();
  draw(away, world);
  expect(written(away.calls)).not.toContain(mate.name);
  expect(written(away.calls)).not.toContain(enemy.name);
/** Whether a crosshair was drawn at all: four arms, or none. */
const aimed = (paint: Recorder, width = WIDTH, height = HEIGHT): boolean =>
  paint.calls.some((c) =>
    c.op === "fillRect" && Number(c.args[0]) > width / 2 &&
    Number(c.args[1]) <= height / 2 && Number(c.args[1]) + Number(c.args[3]) >= height / 2);
  // In front but off to the side past the 90° frustum: still nothing.
  mate.pos = [600, 1400, 0];
  const wide = recorder();
  draw(wide, world);
  expect(written(wide.calls)).not.toContain(mate.name);
/** How far the crosshair's first arm starts from the middle of the screen. */
const gapOf = (paint: Recorder, width = WIDTH): number => armOf(paint, width).near;
  // In front, alive, and visible — but a held Tab is showing the scoreboard,
  // which names everyone anyway, so the plates stay out of it.
  mate.pos = [600, 0, 0];
  const held = recorder();
  draw(held, world, world.me, true);
  expect(written(held.calls).filter((t) => t === mate.name).length).toBe(0);
  const plain = recorder();
  draw(plain, world);
  expect(written(plain.calls)).toContain(mate.name);
});
test("the plates are the watched player's while spectating, not the corpse's", () => {
  const { world, me, mate, enemy } = plateWorld();
  me.alive = false;
  me.health = 0;
  mate.pos = [600, 0, 0];
  mate.yaw = 0;
  enemy.pos = [1200, 0, 0]; // clear of the teammate, blocked from the corpse
  world.boxes = [wallAt(300)];
  const watching = recorder();
  draw(watching, world, mate);
  expect(written(watching.calls)).toContain(enemy.name);
  expect(written(watching.calls)).not.toContain(mate.name); // never the player you are
  // From the corpse's own eye the wall is in the way, which is the difference.
  const corpse = recorder();
  draw(corpse, world, me);
  expect(written(corpse.calls)).not.toContain(enemy.name);
});
test("a plate across the map is a hint: fainter, and clamped small", () => {
  const { world, mate, enemy } = plateWorld();
  mate.alive = false; // one plate in the frame, and no health bar under it
  enemy.pos = [500, 0, 0];
  const near = recorder();
  draw(near, world);
  enemy.pos = [4000, 0, 0];
  const far = recorder();
  draw(far, world);
  const plate = (calls: Call[]): Call => calls.find((c) => c.name === "fillText" && c.text === enemy.name) as Call;
  // The backing behind the name is the only small fillRect in the frame; its
  // height is the font size the plate was drawn at.
  const backing = (calls: Call[]): Call => calls.find((c) => c.name === "fillRect" && c.args[2] < 30) as Call;
  expect(plate(near.calls)).toBeDefined();
  expect(plate(far.calls)).toBeDefined();
  expect(plate(far.calls).alpha).toBeLessThan(plate(near.calls).alpha * 0.5);
  expect(plate(far.calls).alpha).toBeGreaterThan(0.1); // faint, never invisible
  expect(backing(far.calls).args[3]).toBeLessThan(backing(near.calls).args[3]);
  // Clamped at both ends: a player in your face is not twice the size either.
  enemy.pos = [120, 0, 0];
  const close = recorder();
  draw(close, world);
  expect(backing(close.calls).args[3]).toBeCloseTo(backing(near.calls).args[3], 6);
});
test("a name plate sits over the body the renderer drew, not the tick it left", () => {
  // The scene is drawn between two ticks; a plate taken from the newest one
  // would swim above the head it belongs to. `alpha` is the same number both.
  const { world, mate, enemy } = plateWorld();
  mate.alive = false;
  enemy.prev.pos = [600, -20, 0];
  enemy.pos = [600, 20, 0];
  const plateX = (alpha: number): number => {
    const frame = recorder();
    draw(frame, world, world.me, false, undefined, alpha);
    const call = frame.calls.find((c) => c.name === "fillText" && c.text === enemy.name) as Call;
    return call.args[0] as number;
  };
  const oldest = plateX(0), half = plateX(0.5), newest = plateX(1);
  // Looking east with the player crossing from right to left of the screen.
  expect(oldest).not.toBeCloseTo(newest, 0);
  expect(half).toBeCloseTo((oldest + newest) / 2, 0);
});
// --- motion: what reduced motion is allowed to turn down, and what it is not.
/** One frame drawn at a motion setting, and the calls it made. */
const drawAt = (world: World, motion: Motion, view: Player = world.me): Call[] => {
  const into = recorder();
  drawHud(into.ctx, world, view, cameraFor(view), W, H, false, DEFAULT_CROSSHAIR, 1, motion);
  return into.calls;
};
test("reduced motion holds a damage wedge steady where full motion fades it out", () => {
  const fresh = hurtWorld(0, [-500, 0, 40], 0);
  const older = hurtWorld(0, [-500, 0, 40], 0);
  older.time += 0.8; // most of the way through HURT_FADE, and still in the list
  const wedge = (world: World, motion: Motion): Call => wedgeArcs(drawAt(world, motion))[0] as Call;
  // Full motion: the same wedge, most of a second later, is most of the way gone.
  expect(wedge(older, "full").alpha).toBeLessThan(wedge(fresh, "full").alpha * 0.5);
  // Reduced: it is the same strength for its whole life. Nothing slides.
  expect(wedge(older, "reduced").alpha).toBeCloseTo(wedge(fresh, "reduced").alpha, 10);
  // And it still says everything it said: where the hit came from, and how
  // hard — a 60-damage hit is a stronger wedge than a 10-damage one, reduced
  // motion or not, and it is in the same place either way.
  const soft = hurtWorld(0, [-500, 0, 40], 0);
  (soft.effects[0] as { amount: number }).amount = 10;
  expect(wedge(soft, "reduced").alpha).toBeLessThan(wedge(fresh, "reduced").alpha);
  expect(wedgePoint(wedge(fresh, "reduced"))).toEqual(wedgePoint(wedge(fresh, "full")));
  // It ends where it always ended: a wedge past HURT_FADE is not drawn at all,
  // so "steady" is a strength held and never a wedge that outstays its hit.
  const gone = hurtWorld(0, [-500, 0, 40], 0);
  gone.time += 1.5;
  expect(wedgeArcs(drawAt(gone, "reduced")).length).toBe(0);
});
test("the hurt vignette is the same steady tint under either motion, and no frame of it reads a clock", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 79);
  world.me.health = 20;
  const vignette = (motion: Motion): Call =>
    drawAt(world, motion).filter(
      (c) => c.name === "fillRect" && c.args[0] === 0 && c.args[1] === 0 && c.args[2] === W,
    )[0] as Call;
  // There is no time term in it — only `view.health` — so it is already the
  // steady tint reduced motion would ask for, and three seconds of world time
  // change nothing about it on either setting.
  const before = vignette("full").alpha;
  expect(vignette("reduced").alpha).toBe(before);
  world.time += 3;
  expect(vignette("full").alpha).toBe(before);
  expect(vignette("reduced").alpha).toBe(before);
  // What it does say is how close to dead you are, and reduced motion is not
  // allowed to take that away: nearly dead is a deeper tint than nearly hurt.
  world.me.health = 5;
  expect(vignette("reduced").alpha).toBeGreaterThan(before);
  // And a healthy player has no tint at all, either way.
  world.me.health = 100;
  expect(vignette("reduced")).toBeUndefined();
  expect(vignette("full")).toBeUndefined();
});
test("reduced motion leaves the hit marker, the kill feed and the crosshair exactly where they were", () => {
  const world = createWorld(SHORT, "me", "ct", 5, 83);
  world.me.weapon = "ak47";
  world.me.vel = [180, 0, 0]; // moving, so the dynamic crosshair is open
  world.effects.length = 0;
  world.effects.push({ kind: "hitmark", at: world.time - 0.1, headshot: true, killed: true });
  world.feed.push({
    at: world.time, killer: "me", killerId: world.me.id, killerTeam: "ct", victim: "them",
    weapon: "ak47", headshot: true, victimId: 5,
const spreadOf = (world: World, moving: number): number =>
  inaccuracy(currentWeapon(world.me), {
    moving,
    inAir: !world.me.onGround,
    ducking: world.me.duckAmount > 0.5,
    scoped: world.me.scoped,
  });
  // Every call, argument for argument and alpha for alpha: the whole of the
  // rest of the HUD is information, and a setting that moved any of it would
  // be a setting that changes the game.
  expect(drawAt(world, "reduced")).toEqual(drawAt(world, "full"));
test("the crosshair opens exactly as far as the gun is inaccurate, and is gone when you are", () => {
  const still = scene();
  const rest = draw(still);
  // At a standstill it is the gun's own spread and nothing else — in whole
  // device pixels, because half a pixel of crosshair is a grey smear and not a
  // finer aim. At a ratio of 1, which is what this file draws at, a device
  // pixel is a CSS pixel and the number is the one it always was, rounded.
  expect(gapOf(rest)).toBe(Math.round(4 + spreadOf(still, 0) * 14));
  // Each arm is seven pixels long, from the gap outwards.
  expect(armOf(rest).far).toBe(gapOf(rest) + 7);
  // Running wide open: any speed at or over the walk cap counts as fully moving.
  const running = scene((w) => { w.me.vel = [1000, 0, 0]; });
  expect(gapOf(draw(running))).toBe(Math.round(4 + spreadOf(running, 1) * 14));
  expect(gapOf(draw(running))).toBeGreaterThan(gapOf(rest));
  // Scoped it draws tight, and darkens everything outside the sight.
  const scoped = draw(scene((w) => { w.me.scoped = true; }));
  expect(gapOf(scoped)).toBeLessThan(gapOf(rest));
  expect(scoped.calls.some((c) => c.op === "arc")).toBe(true);
  expect(scoped.calls.find((c) => c.op === "fill")?.args[0]).toBe("evenodd");
  // Dead players do not aim: no crosshair, no sight, nothing stroked at all.
  const dead = draw(scene((w) => { w.me.alive = false; }));
  expect(dead.calls.some((c) => c.op === "stroke")).toBe(false);
  expect(aimed(dead)).toBe(false);
});
test("the crosshair is whole device pixels and centred, at every ratio Windows has", () => {
  // The report behind this: Windows ships display scaling at 125% and 150%, and
  // a crosshair stroked through a centre at 800.5 is a grey smear three columns
  // wide. Every arm is a filled rectangle of whole pixels now, and the four of
  // them are symmetrical about the true centre of the canvas.
  for (const dpr of [1, 1.25, 1.5, 2]) {
    // An even backing store and an odd one: 125% of an odd CSS width is where
    // the centre lands in the middle of a pixel rather than on a boundary.
    for (const width of [Math.round(1280 * dpr), Math.round(1280 * dpr) + 1]) {
      const height = width - 1;
      const paint = draw(scene(), { width, height, dpr });
      const arms = paint.calls.filter((c) =>
        c.op === "fillRect" && Number(c.args[2]) < width / 4 && Number(c.args[3]) < height / 4);
      expect(arms.length).toBeGreaterThanOrEqual(4);
      for (const arm of arms.slice(0, 4))
        for (const n of arm.args.slice(0, 4)) expect(Number.isInteger(Number(n))).toBe(true);
      // The arm reaching right and the one reaching left are the same distance
      // from the centre, so the cross does not lean at 125%.
      const { near, far } = armOf(paint, width, height);
      const left = paint.calls.filter((c) =>
        c.op === "fillRect" && Number(c.args[0]) + Number(c.args[2]) < width / 2 &&
        Number(c.args[1]) <= height / 2 && Number(c.args[1]) + Number(c.args[3]) >= height / 2);
      const mirror = left[0] as Call;
      expect(width / 2 - (Number(mirror.args[0]) + Number(mirror.args[2]))).toBe(near);
      expect(width / 2 - Number(mirror.args[0])).toBe(far);
    }
  }
});
test("a crosshair is the same size on the glass however dense the screen is", () => {
  // Seven CSS pixels of arm is seven device pixels at 1 and fourteen at 2. It
  // used to be seven either way, so on a retina screen the cross was half the
  // size it is on a plain one — and at 125% it was four fifths of it.
  const at = (dpr: number): number => {
    const { near, far } = armOf(
      draw(scene(), { width: Math.round(1280 * dpr), height: Math.round(720 * dpr), dpr }),
      Math.round(1280 * dpr), Math.round(720 * dpr),
    );
    return far - near;
  };
  // Within half a device pixel of seven CSS pixels at each ratio, which is as
  // exact as whole pixels allow — and the point is that it scales at all.
  for (const dpr of [1, 1.25, 1.5, 2]) expect(Math.abs(at(dpr) - 7 * dpr)).toBeLessThanOrEqual(0.5);
  expect(at(1)).toBe(7);
  expect(at(2)).toBe(14);
});
test("a hit is marked white, a headshot red, and both are gone a quarter second later", () => {
  const hit = draw(scene((w) => {
    w.time = 10;
    w.effects = only({ kind: "hitmark", at: 9.9, headshot: false, killed: false });
  }));
  // One stroke, and it is the marker: the crosshair is filled, not stroked.
  const body = hit.calls.filter((c) => c.op === "stroke");
  expect(body.length).toBe(1);
  expect(aimed(hit)).toBe(true);
  expect(body[0]?.stroke).toBe("rgba(255,255,255,0.9)");
  const head = draw(scene((w) => {
    w.time = 10;
    w.effects = only({ kind: "hitmark", at: 9.9, headshot: true, killed: false });
  }));
  expect(head.calls.filter((c) => c.op === "stroke")[0]?.stroke).toBe("rgba(255,90,90,0.95)");
  const old = draw(scene((w) => {
    w.time = 10;
    w.effects = only({ kind: "hitmark", at: 9.7, headshot: true, killed: false });
  }));
  // A quarter second later the marker is gone and nothing is stroked at all —
  // the crosshair, which is still drawn, is four fills.
  expect(old.calls.filter((c) => c.op === "stroke").length).toBe(0);
  expect(aimed(old)).toBe(true);
});
test("the hit that kills is an X, not a fifth tick, and it stays up longer", () => {
  const mark = (at: number, killed: boolean): Recorder => draw(scene((w) => {
    w.time = 10;
    w.effects = only({ kind: "hitmark", at, headshot: false, killed });
  }));
  const strokes = (paint: Recorder): number => paint.calls.filter((c) => c.op === "lineTo").length;
  const hit = mark(9.9, false);
  const kill = mark(9.9, true);
  // The same four ticks, and for a kill two more strokes through the middle.
  expect(strokes(kill) - strokes(hit)).toBe(2);
  expect(strokes(hit) - strokes(mark(9, false))).toBe(4);
  // Past a hit's quarter second a kill's mark is still up; past its own
  // KILL_MARK_LIFE it is gone too.
  const later = 10 - (HIT_MARK_LIFE + KILL_MARK_LIFE) / 2;
  expect(mark(later, false).calls.some((c) => c.op === "stroke")).toBe(false);
  expect(mark(later, true).calls.some((c) => c.op === "stroke")).toBe(true);
  expect(mark(10 - KILL_MARK_LIFE - 0.01, true).calls.some((c) => c.op === "stroke")).toBe(false);
});
// --- health, money and armour ----------------------------------------------
test("health reads white while you are standing and red when you are nearly gone", () => {
  expect(line(draw(scene()), "100").fill).toBe("#f3f5f8");
  expect(line(draw(scene((w) => { w.me.health = 31; })), "31").fill).toBe("#f3f5f8");
  // Thirty itself is already the red one: the HUD asks `health > 30`.
  expect(line(draw(scene((w) => { w.me.health = 30; })), "30").fill).toBe("#ff6b5b");
  expect(line(draw(scene((w) => { w.me.health = 9; })), "9").fill).toBe("#ff6b5b");
  // It is a whole number, and never a negative one.
  expect(says(draw(scene((w) => { w.me.health = 45.6; })), "46")).toBe(true);
  expect(says(draw(scene((w) => { w.me.health = -12; })), "0")).toBe(true);
});
test("the wallet, the armour and the kit say what you bought", () => {
  const poor = draw(scene());
  expect(says(poor, "$800")).toBe(true);
  expect(says(poor, "no armour")).toBe(true);
  expect(says(poor, "defuse kit")).toBe(false);
  const kitted = draw(scene((w) => {
    w.me.money = 4250;
    w.me.armor = 100;
    w.me.helmet = true;
    w.me.defuseKit = true;
  }));
  expect(says(kitted, "$4250")).toBe(true);
  expect(says(kitted, "armour 100 + helmet")).toBe(true);
  expect(says(kitted, "defuse kit")).toBe(true);
  // A terrorist with a kit in the inventory is still a terrorist: no kit line.
  const t = draw(scene((w) => { w.me.team = "t"; w.me.defuseKit = true; }));
  expect(says(t, "defuse kit")).toBe(false);
});
// --- ammo ------------------------------------------------------------------
test("ammo reads mag / reserve, the knife reads a dash, and reloading says so", () => {
  const loaded = draw(scene((w) => {
    w.me.weapon = "usp";
    w.me.ammo.usp = { mag: 5, reserve: 20 };
  }));
  expect(says(loaded, "5 / 20")).toBe(true);
  expect(says(loaded, WEAPONS.usp.name)).toBe(true);
  expect(says(loaded, "reloading")).toBe(false);
  const knife = draw(scene((w) => { w.me.weapon = "knife"; }));
  expect(says(knife, "—")).toBe(true);
  expect(says(knife, WEAPONS.knife.name)).toBe(true);
  // Mid-reload the magazine still reads empty, and the word is on the screen.
  const reloading = draw(scene((w) => {
    w.time = 10;
    w.me.reloadUntil = 10.5;
    w.me.ammo.usp = { mag: 0, reserve: 24 };
  }));
  expect(says(reloading, "0 / 24")).toBe(true);
  expect(line(reloading, "reloading").fill).toBe("#f0c060");
  // The instant it finishes the word goes.
  expect(says(draw(scene((w) => { w.time = 10; w.me.reloadUntil = 10; })), "reloading")).toBe(false);
  // Mid-switch the same line says so instead: the weapon is in the hands but
  // not up yet, and the word goes the instant it is.
  const switching = draw(scene((w) => { w.time = 10; w.me.deployUntil = 10.5; }));
  expect(line(switching, "switching").fill).toBe("#f0c060");
  expect(says(switching, "reloading")).toBe(false);
  expect(says(draw(scene((w) => { w.time = 10; w.me.deployUntil = 10; })), "switching")).toBe(false);
  // And a switch that cut a reload short reads as the switch it is.
  const both = draw(scene((w) => { w.time = 10; w.me.deployUntil = 10.5; w.me.reloadUntil = 12; }));
  expect(says(both, "switching")).toBe(true);
  expect(says(both, "reloading")).toBe(false);
  // While it is on its way up the counter and the name are dimmed, and the
  // word that explains it is not; the tick it is up they are whole again.
  const drawing = (until: number): Recorder => draw(scene((w) => {
    w.time = 10;
    w.me.weapon = "usp";
    w.me.ammo.usp = { mag: 12, reserve: 24 };
    w.me.deployUntil = until;
  }));
  const rising = drawing(10.5);
  expect(line(rising, "12 / 24").alpha).toBeCloseTo(NOT_READY_ALPHA, 10);
  expect(line(rising, WEAPONS.usp.name).alpha).toBeCloseTo(NOT_READY_ALPHA, 10);
  expect(line(rising, "switching").alpha).toBe(1);
  const up = drawing(10);
  expect(line(up, "12 / 24").alpha).toBe(1);
  expect(line(up, WEAPONS.usp.name).alpha).toBe(1);
  // Carrying the bomb is written beside the gun's name.
  const carrier = draw(scene((w) => { w.me.team = "t"; w.me.hasBomb = true; }));
  expect(says(carrier, `${WEAPONS.usp.name}  ·  bomb`)).toBe(true);
});
// --- the clock and the score -----------------------------------------------
test("the clock counts the phase down, goes red when the bomb is down, and stops between rounds", () => {
  const freeze = draw(scene((w) => { w.match.phase = "freeze"; w.match.timer = 8; }));
  expect(line(freeze, "0:08").fill).toBe("#f3f5f8");
  const live = draw(scene((w) => { w.match.phase = "live"; w.match.timer = 95; }));
  expect(line(live, "1:35").fill).toBe("#f3f5f8");
  const planted = draw(scene((w) => { w.match.phase = "planted"; w.match.timer = 40; }));
  expect(line(planted, "0:40").fill).toBe("#ff6b5b");
  // Nothing is being counted between rounds or after the match: no clock to read.
  for (const phase of ["over", "match_over"] as const) {
    const paint = draw(scene((w) => { w.match.phase = phase; w.match.timer = 5; }));
    expect(says(paint, "--:--")).toBe(true);
    expect(says(paint, "0:05")).toBe(false);
  }
});
test("the score sits either side of the clock, each in its team's colour, and so do the survivors", () => {
  const paint = draw(scene((w) => {
    w.match.score = { t: 7, ct: 11 };
    for (const p of w.players) if (p.team === "t" && p !== w.me) p.alive = false;
  }));
  expect(line(paint, "7").fill).toBe("#e2b04a");
  expect(line(paint, "11").fill).toBe("#6fa8e8");
  // Five terrorists, all of them down; five counter-terrorists, all still up.
  expect(line(paint, "T 0").fill).toBe("#e2b04a");
  expect(line(paint, "CT 5").fill).toBe("#6fa8e8");
});
// --- the kill feed ---------------------------------------------------------
const kill = (at: number, over: Partial<World["feed"][number]> = {}): World["feed"][number] => ({
  at, killer: "Kestrel", victim: "Pike", weapon: "ak47", headshot: false, killerTeam: "t", ...over,
});
test("a kill is named with the gun that made it, fades for eight seconds and is then gone", () => {
  const fresh = draw(scene((w) => { w.time = 100; w.feed = [kill(100)]; }));
  const entry = line(fresh, `Kestrel  ${WEAPONS.ak47.name}  Pike`);
  expect(entry.alpha).toBe(1);
  expect(entry.fill).toBe("#e2b04a");
  // Halfway out it is half there, and a CT's kill is the other colour.
  const fading = draw(scene((w) => {
    w.time = 100;
    w.feed = [kill(92.5, { killerTeam: "ct", headshot: true })];
  }));
  const faded = line(fading, `Kestrel  ${WEAPONS.ak47.name} ⌖  Pike`);
  expect(faded.alpha).toBeCloseTo(0.5, 10);
  expect(faded.fill).toBe("#6fa8e8");
  // Eight seconds old is the end of it: nothing readable, and nothing at all after.
  const spent = draw(scene((w) => { w.time = 100; w.feed = [kill(92)]; }));
  expect(readable(spent).some((c) => String(c.args[0]).includes("Kestrel"))).toBe(false);
  const gone = draw(scene((w) => { w.time = 100; w.feed = [kill(91.9)]; }));
  expect(gone.calls.some((c) => c.op === "fillText" && String(c.args[0]).includes("Kestrel"))).toBe(false);
  // A fall is its own cause: the victim on both sides and the word, not a gun.
  const fell = draw(scene((w) => { w.time = 100; w.feed = [kill(100, { killer: "Pike", weapon: "fall" })]; }));
  expect(line(fell, "Pike  Fall  Pike").alpha).toBe(1);
  // The feed shows the last five kills, newest last, oldest dropped.
  const busy = draw(scene((w) => {
    w.time = 100;
    w.feed = [1, 2, 3, 4, 5, 6].map((n) => kill(99, { victim: `Down ${n}` }));
  }));
  expect(words(busy).filter((s) => s.includes("Down")).length).toBe(5);
  expect(words(busy).some((s) => s.includes("Down 1"))).toBe(false);
  expect(words(busy).some((s) => s.includes("Down 6"))).toBe(true);
});
test("the round's last word is on the screen for four seconds", () => {
  const said = draw(scene((w) => {
    w.time = 100;
    w.messages = [{ at: 99.9, text: "The bomb has been planted at A." }];
  }));
  expect(says(said, "The bomb has been planted at A.")).toBe(true);
  const stale = draw(scene((w) => {
    w.time = 100;
    w.messages = [{ at: 96, text: "The bomb has been planted at A." }];
  }));
  expect(says(stale, "The bomb has been planted at A.")).toBe(false);
});
// --- planting and defusing -------------------------------------------------
/** The filled fraction of the use bar: the bar's width over the panel behind it. */
function useBar(paint: Recorder): { fraction: number; fill: string } {
  const rects = paint.calls.filter((c) => c.op === "fillRect");
  const bar = rects[rects.length - 1] as Call;
  const panel = rects[rects.length - 2] as Call;
  return { fraction: Number(bar.args[2]) / (Number(panel.args[2]) - 4), fill: bar.fill };
}
test("the use bar fills as far as the plant or the defuse has got", () => {
  const nothing = draw(scene());
  expect(says(nothing, "Planting")).toBe(false);
  const planting = draw(scene((w) => {
    w.me.team = "t";
    w.me.hasBomb = true;
    w.bomb.plantProgress = SHORT.plantTime / 2;
  }));
  expect(says(planting, "Planting")).toBe(true);
  expect(useBar(planting).fraction).toBeCloseTo(0.5, 10);
  expect(useBar(planting).fill).toBe("#e2b04a");
  const defusing = draw(scene((w) => {
    w.bomb.state = "planted";
    w.bomb.defuser = w.me;
    w.bomb.defuseProgress = SHORT.defuseTime * 0.25;
  }));
  expect(says(defusing, "Defusing")).toBe(true);
  expect(useBar(defusing).fraction).toBeCloseTo(0.25, 10);
  expect(useBar(defusing).fill).toBe("#6fa8e8");
  // A kit is faster, and says so, and the bar is full when the wire is cut.
  const kit = draw(scene((w) => {
    w.me.defuseKit = true;
    w.bomb.state = "planted";
    w.bomb.defuser = w.me;
    w.bomb.defuseProgress = SHORT.defuseTimeWithKit;
  }));
  expect(says(kit, "Defusing (kit)")).toBe(true);
  expect(useBar(kit).fraction).toBeCloseTo(1, 10);
});
// --- dead, and the scoreboard ----------------------------------------------
const ALONE = "You are dead — watching the round out";
const SWITCH = "fire — next player · aim — the one before";
/** A teammate to watch, and the world with you dead in it. */
function spectating(change: (world: World) => void = () => {}): { world: World; mate: Player } {
  const world = scene((w) => {
    w.me.alive = false;
    change(w);
  });
  const mate = world.players.find((p) => p !== world.me && p.team === world.me.team) as Player;
  return { world, mate };
}
test("a dead player watching nobody is told so, until the match itself is over", () => {
  // The whole side down and the round still running — a planted bomb — is the
  // only frame left where the camera is your own body and there is no name.
  expect(says(draw(scene()), ALONE)).toBe(false);
  expect(says(draw(scene((w) => { w.me.alive = false; })), ALONE)).toBe(true);
  expect(says(draw(scene((w) => {
    w.me.alive = false;
    w.match.phase = "match_over";
  })), ALONE)).toBe(false);
});
test("watching someone says whose eyes these are, in their team's colour, and how to change them", () => {
  const { world, mate } = spectating();
  const paint = draw(world, { view: mate });
  expect(says(paint, `Watching ${mate.name}`)).toBe(true);
  expect(says(paint, SWITCH)).toBe(true);
  expect(says(paint, ALONE)).toBe(false);
  expect(line(paint, `Watching ${mate.name}`).fill).toBe("#6fa8e8"); // this side is CT
  // Alive, there is nothing to say: no banner, no keys.
  const playing = draw(scene());
  expect(words(playing).some((w) => w.startsWith("Watching"))).toBe(false);
  expect(says(playing, SWITCH)).toBe(false);
});
test("the numbers under a spectated round are the watched player's, not your corpse's", () => {
  const { world, mate } = spectating((w) => {
    w.me.health = 89; // a corpse's last number, which is nobody's business now
    w.me.money = 1234;
  });
  mate.health = 57;
  mate.money = 4300;
  mate.weapon = "ak47";
  mate.ammo["ak47"] = { mag: 21, reserve: 60 };
  const paint = draw(world, { view: mate });
  expect(says(paint, "57")).toBe(true);
  expect(says(paint, "$4300")).toBe(true);
  expect(says(paint, "21 / 60")).toBe(true);
  expect(says(paint, WEAPONS.ak47.name)).toBe(true);
  // Nothing of yours is on the screen: not your health, not your wallet.
  expect(says(paint, "89")).toBe(false);
  expect(says(paint, "$1234")).toBe(false);
  // And their crosshair is drawn, because *they* are aiming: a dead player's
  // own view had none, which is what made the old spectate look broken.
  expect(paint.calls.some((c) => c.op === "moveTo")).toBe(true);
});
test("the scoreboard ranks by kills, then by damage, marks you, and dims the dead", () => {
  const world = scene((w) => {
    const [me, second, third, fourth] = w.players;
    if (!me || !second || !third || !fourth) throw new Error("this scene wants four players");
    me.kills = 2; me.deaths = 1; me.headshots = 1; me.damage = 310.4; me.money = 3200;
    second.kills = 5; second.damage = 700;
    third.kills = 2; third.damage = 480; // same kills as me, more damage: above me
    fourth.kills = 0; fourth.alive = false;
  });
  const paint = draw(world, { scoreboard: true });
  const rows = readable(paint).filter((c) => c.align === "left" && String(c.args[0]).includes("  "));
  const names = rows.map((c) => String(c.args[0]));
  expect(names[0]).toContain(world.players[1]?.name);
  expect(names[1]).toContain(world.players[2]?.name);
  expect(names[2]).toContain("you");
  // Your own row is the white one, and it is the only one that says so.
  const mine = rows[2] as Call;
  expect(mine.fill).toBe("#ffffff");
  expect(names.filter((n) => n.includes("(you)")).length).toBe(1);
  expect(rows.filter((r) => r.fill === "#ffffff").length).toBe(1);
  // Every other row wears its team's colour, and a dead one is dimmed.
  expect(rows.filter((r) => r.fill === "#e2b04a" || r.fill === "#6fa8e8").length).toBe(9);
  const down = rows.find((r) => String(r.args[0]).includes(world.players[3]?.name ?? "")) as Call;
  expect(down.alpha).toBeCloseTo(0.45, 10);
  expect(mine.alpha).toBe(1);
  // The columns are there, and your figures are under them, rounded.
  expect(words(paint)).toContain("kills");
  expect(words(paint)).toContain("damage");
  const figures = readable(paint).filter((c) => c.align === "right");
  expect(figures.map((c) => String(c.args[0]))).toContain("310");
  expect(figures.map((c) => String(c.args[0]))).toContain("$3200");
  // It is drawn over everything: its scrim comes after the health it covers.
  const scrim = paint.calls.findIndex((c) => c.fill === "rgba(10, 12, 16, 0.88)");
  const health = paint.calls.findIndex((c) => c.op === "fillText" && c.args[0] === "100");
  expect(scrim).toBeGreaterThan(health);
  // And nothing of it is on the screen when it is not being held open.
  expect(says(draw(world), "kills")).toBe(false);
});
// --- both ends of the screen -----------------------------------------------
/** A frame with every panel on it at once, so a layout test has something to lay out. */
const busyWorld = (): World => scene((w) => {
  w.time = 100;
  w.match.phase = "planted";
  w.match.timer = 37;
  w.match.score = { t: 9, ct: 12 };
  w.me.health = 24;
  w.me.armor = 100;
  w.me.helmet = true;
  w.me.defuseKit = true;
  w.me.money = 12450;
  w.me.reloadUntil = 101;
  w.bomb.state = "planted";
  w.bomb.defuser = w.me;
  w.bomb.defuseProgress = 1;
  w.effects = these(
    { kind: "hitmark", at: 99.95, headshot: true, killed: false },
    // Somebody is shooting back, which is a wash and an arc on the same frame.
    { kind: "hurt", at: 99.9, from: [w.me.pos[0] - 400, w.me.pos[1] + 250, 0], damage: 27 },
  );
  w.feed = [kill(99), kill(97, { killerTeam: "ct" }), kill(94, { headshot: true })];
  w.messages = [{ at: 99.5, text: "The bomb has been planted at B." }];
  for (const p of w.players) p.kills = p.id;
  (w.players[4] as Player).alive = false;
});
/** Every call that put something over the edge of the canvas. */
function offCanvas(paint: Recorder, width: number, height: number): Call[] {
  const on = (x: number, y: number): boolean => x >= 0 && y >= 0 && x <= width && y <= height;
  return paint.calls.filter((c) => {
    const [a, b, c3, d] = c.args.map(Number);
    if (c.op === "fillText") return !on(Number(c.args[1]), Number(c.args[2]));
    if (c.op === "moveTo" || c.op === "lineTo") return !on(a as number, b as number);
    if (c.op === "arc") return !on((a as number) - (c3 as number), (b as number) - (c3 as number)) ||
      !on((a as number) + (c3 as number), (b as number) + (c3 as number));
    if (c.op === "fillRect" || c.op === "rect" || c.op === "clearRect")
      return !on(a as number, b as number) || !on((a as number) + (c3 as number), (b as number) + (d as number));
    return false;
  });
}
const fontsUsed = (paint: Recorder): string[] =>
  [...new Set(paint.calls.filter((c) => c.op === "fillText").map((c) => c.font))].sort();
test("the whole readout fits a phone and a desk, and says the same amount at both", () => {
  const world = busyWorld();
  const phone = draw(world, { width: 360, height: 640, scoreboard: true });
  const desk = draw(world, { width: 1920, height: 1080, scoreboard: true });
  expect(offCanvas(phone, 360, 640)).toEqual([]);
  expect(offCanvas(desk, 1920, 1080)).toEqual([]);
  // The scale is `width / 1280`, clamped to 0.7 .. 1.4: 21/13/11 px on a phone,
  // 42/27/21 on a desk, and no other size on either.
  expect(fontsUsed(phone)).toEqual([
    "11px system-ui, sans-serif", "13px system-ui, sans-serif", "21px system-ui, sans-serif",
  ]);
  expect(fontsUsed(desk)).toEqual([
    "21px system-ui, sans-serif", "27px system-ui, sans-serif", "42px system-ui, sans-serif",
  ]);
  // The same world reads the same on both: every line of it, in the same order.
  expect(words(phone)).toEqual(words(desk));
  expect(phone.calls.length).toBe(desk.calls.length);
  expect(phone.calls.map((c) => c.op)).toEqual(desk.calls.map((c) => c.op));
  // And the frame starts by clearing the one it is drawn on, whatever its size.
  expect(phone.calls[0]?.op).toBe("clearRect");
  expect(phone.calls[0]?.args).toEqual([0, 0, 360, 640]);
});
test("the same canvas turned sideways is drawn at the new size, not the one before", () => {
  // The engine's tools are built for one surface at one size and kept between
  // frames, because a frame that rebuilt them would allocate for no new number.
  // A phone rotating is the frame where a cache that ignored the size would
  // draw the old one: same canvas, same world, different width.
  const world = busyWorld();
  const paint = recorder();
  drawHud(paint, world, 1280, 720, false, world.me);
  const before = paint.calls.length;
  drawHud(paint, world, 360, 640, false, world.me);
  const after = paint.calls.slice(before);
  expect(after[0]?.args).toEqual([0, 0, 360, 640]);
  expect([...new Set(after.filter((c) => c.op === "fillText").map((c) => c.font))].sort()).toEqual([
    "11px system-ui, sans-serif", "13px system-ui, sans-serif", "21px system-ui, sans-serif",
  ]);
  // The clock bar is 240 units wide at the scale the *new* width says. It is
  // the first filled rectangle that is not a full-screen wash — this world has
  // somebody shooting back in it, and the pain flash goes on before anything.
  // (The four narrow rectangles before it are the crosshair's arms.)
  const bar = after.find((c) =>
    c.op === "fillRect" && c.args[2] !== 360 && Number(c.args[2]) > 100) as Call;
  expect(bar.args[2]).toBe(Math.round(240 * 0.7));
});
// --- flashed ---------------------------------------------------------------
/** Every full-screen wash this frame drew, with the brush that drew it. */
const washes = (paint: Recorder, width = WIDTH, height = HEIGHT): Call[] =>
  paint.calls.filter((c) => c.op === "fillRect" && c.args[2] === width && c.args[3] === height);
/** The opacity of an `rgba(...)` fill, or 0 for anything else. */
const opacity = (fill: string): number => Number(/rgba\([^)]*,([^,)]+)\)$/.exec(fill)?.[1] ?? 0);
test("a flashed player gets white over the world, and the crosshair back before it ends", () => {
  const max = 1.6;
  // Unflashed there is no wash at all: this costs a frame nothing.
  expect(washes(draw(scene()))).toEqual([]);
  // The white is read off the simulation's own number, in seconds.
  const full = washes(draw(scene((w) => { (w.me as Player).blind = max; })));
  expect(full.length).toBe(1);
  expect(opacity(full[0]?.fill ?? "")).toBeCloseTo(whiteout(max), 6);
  // It never quite reaches one: the world is always a ghost behind it.
  expect(whiteout(max)).toBeLessThan(1);
  expect(whiteout(max)).toBeGreaterThan(0.85);
  // It fades, and it is gone with the blindness.
  expect(whiteout(0.45)).toBeLessThan(whiteout(0.9));
  expect(whiteout(0.9)).toBe(whiteout(max)); // held at full while there is time left
  expect(washes(draw(scene((w) => { (w.me as Player).blind = 0; })))).toEqual([]);
  // The crosshair is drawn *under* the wash and is readable again for the last
  // half second of any flash: at 0.45 s left the white is under a half.
  expect(whiteout(0.45)).toBeLessThan(0.5);
  const half = draw(scene((w) => { (w.me as Player).blind = 0.45; }));
  const wash = washes(half)[0] as Call;
  const crosshair = half.calls.findIndex((c) =>
    c.op === "fillRect" && Number(c.args[0]) > WIDTH / 2 &&
    Number(c.args[1]) <= HEIGHT / 2 && Number(c.args[1]) + Number(c.args[3]) >= HEIGHT / 2);
  expect(crosshair).toBeGreaterThanOrEqual(0);
  expect(half.calls.indexOf(wash)).toBeGreaterThan(crosshair);
  // And the numbers go on top of it: a flashed player still reads their health.
  const flashed = draw(scene((w) => { (w.me as Player).blind = max; }));
  const health = flashed.calls.findIndex((c) => c.op === "fillText" && c.args[0] === "100");
  expect(health).toBeGreaterThan(flashed.calls.indexOf(washes(flashed)[0] as Call));
});
// --- hurt: where it came from, and how hard ---------------------------------
/**
 * Every damage arc this frame drew, as the angle each sits at *on the screen*:
 * zero is straight ahead, ninety is off to your right and a hundred and eighty
 * is behind you. The recorded call is a canvas angle — zero to the right of the
 * middle, growing clockwise — so this is that, turned a quarter turn.
 *
 * Only the arcs: the scope's sight and the radar's dots go through `arc` too
 * and are *filled*, so what is taken here is an arc in the hurt red that was
 * stroked — the brush and the call that closed the path, both of which the
 * recorder wrote down.
 */
const arcs = (paint: Recorder): { at: number; alpha: number; radius: number }[] =>
  paint.calls
    .filter((c, i) =>
      c.op === "arc" && c.stroke.startsWith("rgba(255,70,60") && paint.calls[i + 1]?.op === "stroke")
    .map((c) => ({
      at: turn(((Number(c.args[3]) + Number(c.args[4])) / 2) * (180 / Math.PI) + 90),
      alpha: Number(/,([^,)]+)\)$/.exec(c.stroke)?.[1] ?? 0),
      radius: Number(c.args[2]),
    }));
/** An angle in degrees, folded into -180 .. 180. */
const turn = (degrees: number): number => ((((degrees + 180) % 360) + 360) % 360) - 180;
/** How far from straight ahead an arc is, whichever way round it went. */
const behindness = (at: number): number => Math.abs(at);
/** A world in which somebody at `from` has just shot you, while you face `yaw`. */
const shotAt = (from: [number, number], yaw: number, damage = 27, ago = 0.1): World =>
  scene((w) => {
    w.time = 10;
    w.me.pos = [0, 0, 0];
    w.me.yaw = yaw;
    w.effects = only({ kind: "hurt", at: 10 - ago, from: [from[0], from[1], 0], damage });
  });
test("the arc points at whoever hit you, and turning takes it with you", () => {
  // Facing east. North is your left, so an attacker due north is drawn left.
  const left = arcs(draw(shotAt([0, 500], 0)));
  expect(left.length).toBe(1);
  expect(left[0]?.at).toBeCloseTo(-90, 6);
  // The same attacker, you turned ninety degrees to face them: dead ahead.
  expect(arcs(draw(shotAt([0, 500], 90)))[0]?.at).toBeCloseTo(0, 6);
  // And ninety the other way puts them behind you, which is the same ninety
  // degrees of arc travel in the other direction.
  expect(behindness(arcs(draw(shotAt([0, 500], -90)))[0]?.at ?? 0)).toBeCloseTo(180, 6);
  // Shot in the back, facing east: an attacker due west is at the bottom.
  expect(behindness(arcs(draw(shotAt([-500, 0], 0)))[0]?.at ?? 0)).toBeCloseTo(180, 6);
  // Turn ninety degrees to your left and the arc walks exactly ninety degrees
  // round the ring the other way: what was behind you is now off your left.
  const turned = arcs(draw(shotAt([-500, 0], 90)))[0]?.at ?? 0;
  expect(turned).toBeCloseTo(-90, 6);
  expect(behindness(turn(180 - turned))).toBeCloseTo(90, 6);
  // To your right, and nowhere near the crosshair: the ring is 28% of the
  // shorter side out, which on this canvas is 201 pixels from the middle.
  const right = arcs(draw(shotAt([0, -500], 0)));
  expect(right[0]?.at).toBeCloseTo(90, 6);
  expect(right[0]?.radius).toBeCloseTo(HEIGHT * 0.28, 6);
});
test("under reduced motion an arc holds its strength for its life and then goes", () => {
  const steady = (ago: number) =>
    arcs(draw(shotAt([-500, 0], 0, 27, ago), { motion: "reduced" }));
  expect(steady(0)[0]?.alpha).toBeCloseTo(0.85, 3);
  // Where the full setting has faded to half, this one has not moved.
  expect(steady(HURT_LIFE / 2)[0]?.alpha).toBeCloseTo(0.85, 3);
  expect(steady(HURT_LIFE - 0.01)[0]?.alpha).toBeCloseTo(0.85, 3);
  // Its life is the same life: gone on the same tick.
  expect(steady(HURT_LIFE)).toEqual([]);
  // And the bearing is the bearing — only the fade was decoration.
  expect(behindness(steady(0.1)[0]?.at ?? 0)).toBeCloseTo(180, 6);
});
test("an arc fades over its life and is gone at the end of it, and two attackers are two arcs", () => {
  const fresh = arcs(draw(shotAt([-500, 0], 0, 27, 0)));
  expect(fresh[0]?.alpha).toBeCloseTo(0.85, 3);
  // Half way through its life it is half there.
  const half = arcs(draw(shotAt([-500, 0], 0, 27, HURT_LIFE / 2)));
  expect(half[0]?.alpha).toBeCloseTo(0.425, 3);
  // A hair inside its life is still drawn; the life itself is the end of it.
  expect(arcs(draw(shotAt([-500, 0], 0, 27, HURT_LIFE - 0.01))).length).toBe(1);
  expect(arcs(draw(shotAt([-500, 0], 0, 27, HURT_LIFE)))).toEqual([]);
  expect(arcs(draw(shotAt([-500, 0], 0, 27, HURT_LIFE + 1)))).toEqual([]);
  // Two people shooting you from two sides is two arcs, each at its own bearing.
  const crossfire = arcs(draw(scene((w) => {
    w.time = 10;
    w.me.pos = [0, 0, 0];
    w.me.yaw = 0;
    w.effects = these(
      { kind: "hurt", at: 9.9, from: [0, 500, 0], damage: 27 },
      { kind: "hurt", at: 9.9, from: [0, -500, 0], damage: 27 },
    );
  })));
  expect(crossfire.length).toBe(2);
  expect(crossfire.map((a) => Math.round(a.at)).sort((a, b) => a - b)).toEqual([-90, 90]);
  // Untouched, there is no arc at all: this costs a quiet frame nothing.
  expect(arcs(draw(scene()))).toEqual([]);
});
test("a fall hurts from straight below: the pain flash says it, and there is no arc since it came from no side", () => {
  // `shotAt` from where you stand is exactly what `land` records: your own feet.
  const fell = draw(shotAt([0, 0], 0, 12, 0));
  expect(arcs(fell)).toEqual([]);
  expect(opacity(washes(fell)[0]?.fill ?? "")).toBeCloseTo(painAlpha(12, 0), 3);
});
test("the pain flash is as hard as the hit was, is gone in a quarter second, and is under the crosshair", () => {
  // Nothing taken, nothing washed.
  expect(washes(draw(scene()))).toEqual([]);
  // An AK round to an armoured chest: a sixth of a red screen at its worst.
  const round = draw(shotAt([-500, 0], 0, 27, 0));
  expect(opacity(washes(round)[0]?.fill ?? "")).toBeCloseTo(painAlpha(27, 0), 3);
  expect(painAlpha(27, 0)).toBeCloseTo(0.162, 3);
  // A body-shot AWP is the whole of it, and half a body is already the cap: a
  // hit that takes more than fifty does not wash the screen out any further.
  expect(painAlpha(100, 0)).toBeCloseTo(0.3, 6);
  expect(painAlpha(50, 0)).toBe(painAlpha(100, 0));
  // It never comes near what a flashbang is allowed to do.
  expect(painAlpha(100, 0)).toBeLessThan(whiteout(1.6) / 3);
  // It fades, and a third of a second is the end of it.
  expect(painAlpha(100, 0.125)).toBeCloseTo(0.15, 6);
  expect(painAlpha(100, 0.25)).toBe(0);
  expect(washes(draw(shotAt([-500, 0], 0, 100, 0.25)))).toEqual([]);
  // The arc outlives it by a long way: the wash says *ouch* and the arc says
  // where, and only one of those is worth having over your sights.
  expect(arcs(draw(shotAt([-500, 0], 0, 100, 0.25))).length).toBe(1);
  // And the crosshair goes on *after* it, so the shot you take back is aimed
  // at exactly what it was aimed at before — the opposite way round from the
  // white-out, which is meant to blind you.
  const wash = washes(round)[0] as Call;
  expect(round.calls.indexOf(wash)).toBeLessThan(round.calls.findIndex((c) => c.op === "stroke"));
  // A spectator is not the one being shot at: a dead player watching a mate
  // gets neither the wash nor the arc, whatever your corpse last took.
  const { world, mate } = spectating((w) => {
    w.time = 10;
    w.effects = only({ kind: "hurt", at: 9.95, from: [-500, 0, 0], damage: 100 });
  });
  const watching = draw(world, { view: mate });
  expect(washes(watching)).toEqual([]);
  expect(arcs(watching)).toEqual([]);
});
test("the pocket line names each grenade you are carrying, and both at once", () => {
  const none = draw(scene());
  expect(words(none).some((t) => t.includes("HE"))).toBe(false);
  const both = draw(scene((w) => {
    (w.me as Player).pocket = { he: 1, flash: 1, smoke: 0 };
  }));
  const named = words(both).find((t) => t.includes("HE")) ?? "";
  expect(named).toContain("HE");
  expect(named).toContain("flash");
  const only = draw(scene((w) => { (w.me as Player).pocket = { he: 0, flash: 1, smoke: 0 }; }));
  const line = words(only).find((t) => t.includes("flash")) ?? "";
  expect(line).not.toContain("HE");
});
@@ -1,653 +1,499 @@
/**
 * The HUD, drawn on a 2D canvas over the scene: crosshair, health, ammo, the
 * round clock, the kill feed, the names over the players you can see, and the
 * scoreboard. It reads the world and draws; it never changes anything.
 * round clock, the kill feed, the scoreboard, the radar, and — the one thing on
 * it about damage coming the other way — the flash and the arcs that say you
 * were hit and from where. It reads the world and draws; it never changes
 * anything.
 *
 * It is handed the player it is drawing rather than reaching for `world.me`:
 * while the person is dead the camera is on a teammate, and the numbers under
 * it have to be that teammate's or the HUD belongs to a corpse.
 * The radar is `src/client/minimap.ts` — the level from above is a picture of
 * its own and everything about drawing one is in there. What stays here is what
 * stays here for every other thing on the screen: where the square sits and how
 * big it is, which is the one question this file answers.
 *
 * What it draws onto is a `Paint` — the seventeen members of a 2D context it
 * actually uses, and not a whole `CanvasRenderingContext2D`. A browser's
 * context is one; so is a recorder in a test, which is how `main.test.ts` runs
 * a frame of this with no canvas in the room. It is the engine's `Paint`, with
 * the styles narrowed to the strings this game writes into them.
 *
 * The furniture is the engine's: `overlay` hands back the scale, the pad, the
 * scaled fonts, the scrim, a line of text with an alignment and a fade, the
 * crosshair, a progress bar, a row of right-aligned columns and the `m:ss`
 * clock — the same tools `src/range/readout.ts` draws its panel with. What is
 * left in this file is Counter-Strike's and nothing else: where a thing sits,
 * which phase has a clock, and the words. What colour a side is drawn in is
 * `src/client/palette.ts`, because the radar draws the same ten players.
 */
import { crosshairShape, DEFAULT_CROSSHAIR, type CrosshairStyle } from "./crosshair.ts";
import { lerpPos } from "./interpolate.ts";
import { angleDelta, clamp, rad, type Vec3 } from "./math.ts";
import { walkable, type MapDef } from "./map.ts";
import { DEFAULT_MOTION, type Motion } from "./motion.ts";
import { hullHeight, MOVE } from "./physics.ts";
import { project, type Projected } from "./project.ts";
import { buildRadar } from "./radar.ts";
import type { Camera } from "./renderer.ts";
import { drawReport } from "./reportPanel.ts";
import { deathNotice } from "./spectate.ts";
import { inaccuracy, WEAPONS } from "./weapons.ts";
import {
  canSee, causeName, currentWeapon, deploying, eyePos, grenadeCount, grenadeKinds, offeredPickup, useProgress,
  type Player, type World,
} from "./world.ts";
const T_COLOR = "#e2b04a";
const CT_COLOR = "#6fa8e8";
  angleDelta, clamp, effectAt, overlay, ratioOf,
  type Overlay, type Paint as Surface, type Vec3,
} from "../engine/index.ts";
import { drawMinimap } from "./minimap.ts";
import { DEFAULT_MOTION, type Motion } from "./motion.ts";
import { CS_MOVE } from "./movement.ts";
import { BLUE, CROSSHAIR, CT_COLOR, GREY, RED, T_COLOR, teamColor, WHITE } from "./palette.ts";
import { inaccuracy } from "./weapons.ts";
import { useProgress } from "./bomb.ts";
import { scoreLines } from "./summary.ts";
import { causeName, currentWeapon, eyePos, insideSmoke, type Player, type World } from "./world.ts";
/**
 * How long a damage indicator lives. Well inside the two seconds `update`
 * keeps an effect for, so the trim window stays where it is.
 * Everything this module asks of the thing it draws on. Nothing else: it is the
 * engine's surface, with `fillStyle` and the rest narrowed to `string`, because
 * this game only ever writes colours into them and a test that records the
 * brush wants a string back.
 */
const HURT_FADE = 1.1;
export type Paint = Surface & {
  fillStyle: string;
  strokeStyle: string;
  font: string;
  textAlign: string;
  textBaseline: string;
};
/** How long a round message stays up when the clock is not holding it there. */
const MESSAGE_FADE = 4;
/**
 * The radar's square, before the scale: 180 of them on a 1280-wide canvas. It
 * is also capped at a third of the shorter side, so a short landscape phone
 * does not get a map with the clock sitting on it.
 */
const RADAR = 180;
/**
 * What is left of the ammo counter and the weapon's name while the gun is
 * still coming up. The gun rising in the middle of the screen is the cue; this
 * is the one that says what it means, because a person who clicks and gets
 * nothing for the 1.25 s an AWP takes should not have to guess why. It lifts
 * on the frame `nextShotAt` passes — the frame the gun is level and the
 * trigger answers — so the two cues end together.
 * still coming up: a click that does nothing for the 1.25 s an AWP takes
 * should not leave anyone guessing why.
 */
const NOT_READY_ALPHA = 0.35;
export const NOT_READY_ALPHA = 0.35;
/**
 * How long a hit marker lives, and how much longer the one for a kill does:
 * long enough to register as its own thing at a glance, still well inside the
 * two seconds `update` keeps an effect for.
 * long enough to register as its own thing at a glance, well inside the time
 * the effect ring keeps an effect for.
 */
const HIT_MARK_LIFE = 0.25;
const KILL_MARK_LIFE = 0.45;
export const HIT_MARK_LIFE = 0.25;
export const KILL_MARK_LIFE = 0.45;
const KILL_STROKES: [number, number][] = [[1, 1], [1, -1]];
// The vignette is one radial gradient per canvas size, kept between frames:
// building it costs an allocation and drawHud runs sixty times a second, so it
// is built with its colours at full strength and faded with globalAlpha.
let vignette: CanvasGradient | null = null;
let vignetteSize = "";
/** What a dead player is told, in the two cases there are. */
const DEAD = "You are dead — watching the round out";
const WATCHING = "Watching";
const SWITCH = "fire — next player · aim — the one before";
function hurtVignette(ctx: CanvasRenderingContext2D, width: number, height: number): CanvasGradient {
  const size = `${width}x${height}`;
  if (vignette === null || vignetteSize !== size) {
    const gradient = ctx.createRadialGradient(
      width / 2, height / 2, Math.min(width, height) * 0.22,
      width / 2, height / 2, Math.max(width, height) * 0.62,
    );
    gradient.addColorStop(0, "rgba(140, 0, 0, 0)");
    gradient.addColorStop(0.55, "rgba(160, 6, 6, 0.4)");
    gradient.addColorStop(1, "rgba(190, 14, 14, 0.95)");
    vignette = gradient;
    vignetteSize = size;
/** The scoreboard's heading row, and the empty other half of each `columns` call. */
const FIGURES = ["kills", "deaths", "hs", "damage", "money"] as const;
const NOTHING: readonly string[] = [];
/**
 * The tools, kept from frame to frame. `overlay` is built for one surface at
 * one size — a resize, not a frame — and a frame that rebuilt it would allocate
 * an object and ten closures sixty times a second for no new number. The cache
 * is one entry deep and keyed on what it was built from, so a test drawing onto
 * a fresh recorder gets fresh tools and never another test's.
 */
let tools: Overlay | null = null;
let builtOn: Paint | null = null;
function toolsFor(ctx: Paint, width: number, height: number, dpr: number): Overlay {
  if (
    tools === null || builtOn !== ctx ||
    tools.width !== width || tools.height !== height || tools.ratio !== ratioOf(dpr)
  ) {
    tools = overlay(ctx, width, height, dpr);
    builtOn = ctx;
  }
  return vignette;
  return tools;
}
/**
 * The wedges around the crosshair pointing at whatever just hurt `view`, in its
 * own yaw frame, and the red vignette that deepens as its health drops. Several
 * hits stack: each is its own wedge, fading on its own clock. A spectator sees
 * neither: `hurt` effects are only ever pushed for the person, so a teammate's
 * id matches nothing here.
 * The white-out, as opacity: how much white is over the world with `blind`
 * seconds of a flash left to run —
 *
 * `steady` is reduced motion, decided once by `drawHud` and passed down rather
 * than asked per wedge. It takes the fade off a wedge and nothing else: where
 * it came from and how hard it hit are what a wedge says, and a strength that
 * slides to nothing over a second is only how it leaves. The vignette is the
 * same picture on both settings by construction — there is no clock anywhere
 * in it, only `view.health`, so it is already the steady tint reduced motion
 * would ask for, and deepening as you are shot is information rather than
 * decoration.
 */
function drawDamage(
  ctx: CanvasRenderingContext2D,
  world: World,
  view: Player,
  width: number,
  height: number,
  steady: boolean,
): void {
  const low = clamp((55 - view.health) / 55, 0, 1);
  if (view.alive && low > 0) {
    ctx.globalAlpha = 0.65 * low * low;
    ctx.fillStyle = hurtVignette(ctx, width, height);
    ctx.fillRect(0, 0, width, height);
    ctx.globalAlpha = 1;
  }
  const eye = eyePos(view);
  const radius = Math.min(width, height) * 0.14;
  for (const effect of world.effects) {
    if (effect.kind !== "hurt" || effect.victim !== view.id) continue;
    const age = world.time - effect.at;
    if (age < 0 || age > HURT_FADE) continue;
    // A fall hurts from straight below: no bearing, so no wedge — the
    // vignette and the flinch are the whole of it.
    if (Math.hypot(effect.from[0] - eye[0], effect.from[1] - eye[1]) < 1) continue;
    const bearing = (Math.atan2(effect.from[1] - eye[1], effect.from[0] - eye[0]) * 180) / Math.PI;
    // Yaw grows anticlockwise, so a source to the left is a positive angle off
    // the view; the canvas turns clockwise from +x, so the wedge sits at minus
    // that angle, a quarter turn back from straight up.
    const middle = rad(-angleDelta(view.yaw, bearing)) - Math.PI / 2;
    const half = rad(14 + clamp(effect.amount, 0, 60) * 0.2);
    const fade = steady ? 1 : clamp(1 - age / HURT_FADE, 0, 1);
    ctx.globalAlpha = fade * clamp(0.35 + effect.amount / 50, 0, 0.9);
    ctx.strokeStyle = "#ff4238";
    ctx.lineWidth = Math.max(3, Math.round(radius * 0.13));
    ctx.beginPath();
    ctx.arc(width / 2, height / 2, radius, middle - half, middle + half);
    ctx.stroke();
  }
  ctx.globalAlpha = 1;
}
const clock = (seconds: number): string => {
  const s = Math.max(0, Math.ceil(seconds));
  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
};
// The radar's map is a few hundred walkable cells, the same every frame: baked
// once into an offscreen canvas at the on-screen size and rotated by the
// canvas transform as the view turns, instead of walked and re-rotated by
// hand sixty times a second. Rebuilt only when the size or the map changes,
// same as the vignette above — keyed by the map itself, so a switch to a
// second layout can never draw the first one's walls.
let radarMap: OffscreenCanvas | HTMLCanvasElement | null = null;
let radarMapSize = -1;
let radarMapFor: MapDef | null = null;
function radarMapImage(map: MapDef, size: number): CanvasImageSource | null {
  if (radarMap === null || radarMapSize !== size || radarMapFor !== map) {
    if (typeof OffscreenCanvas !== "undefined") radarMap = new OffscreenCanvas(size, size);
    else if (typeof document !== "undefined") {
      const canvas = document.createElement("canvas");
      canvas.width = size;
      canvas.height = size;
      radarMap = canvas;
    } else return null; // no canvas to build one on, e.g. a headless test
    const rctx = radarMap.getContext("2d") as CanvasRenderingContext2D;
    const cw = size / map.gridW, ch = size / map.gridH;
    rctx.fillStyle = "rgba(190, 198, 212, 0.55)";
    for (let r = 0; r < map.gridH; r++)
      for (let c = 0; c < map.gridW; c++)
        if (walkable(map, c, r)) rctx.fillRect(c * cw, r * ch, cw + 0.5, ch + 0.5);
    radarMapSize = size;
    radarMapFor = map;
  }
  return radarMap;
}
/**
 * The radar: `view`'s map, rotated so its yaw points up, in a circle at
 * `(x, y)` of `size` pixels across. Only ever `view`'s team, the bomb once
 * it is planted, and the two sites — the data `buildRadar` hands back, with
 * no enemy in it to draw even by mistake.
 */
function drawRadar(
  ctx: CanvasRenderingContext2D,
  world: World,
  view: Player,
  x: number,
  y: number,
  size: number,
): void {
  const radius = size / 2;
  const cx = x + radius, cy = y + radius;
  ctx.fillStyle = "rgba(8, 10, 14, 0.6)";
  ctx.beginPath();
  ctx.arc(cx, cy, radius, 0, Math.PI * 2);
  ctx.fill();
  ctx.save();
  ctx.beginPath();
  ctx.arc(cx, cy, radius, 0, Math.PI * 2);
  ctx.clip();
  const image = radarMapImage(world.map, Math.max(1, Math.round(size)));
  if (image !== null) {
    // The image is baked with north up; turning it to match the view's yaw
    // is one canvas rotation, not a re-walk of the grid.
    ctx.save();
    ctx.translate(cx, cy);
    ctx.rotate(rad(view.yaw - 90));
    ctx.drawImage(image, -radius, -radius, size, size);
    ctx.restore();
  }
  const teamColor = view.team === "t" ? T_COLOR : CT_COLOR;
  ctx.textAlign = "center";
  for (const blip of buildRadar(world, view)) {
    const px = cx + blip.x * radius, py = cy + blip.y * radius;
    if (blip.kind === "site") {
      ctx.fillStyle = "rgba(255, 255, 255, 0.9)";
      ctx.beginPath();
      ctx.arc(px, py, Math.max(3, radius * 0.05), 0, Math.PI * 2);
      ctx.fill();
      ctx.font = `${Math.round(radius * 0.16)}px system-ui, sans-serif`;
      ctx.fillText(blip.label, px, py - radius * 0.09);
    } else if (blip.kind === "bomb") {
      ctx.fillStyle = "#ff6b5b";
      ctx.beginPath();
      ctx.arc(px, py, Math.max(3, radius * 0.06), 0, Math.PI * 2);
      ctx.fill();
    } else if (blip.kind === "mate") {
      ctx.fillStyle = teamColor;
      ctx.beginPath();
      ctx.arc(px, py, Math.max(2, radius * 0.045), 0, Math.PI * 2);
      ctx.fill();
    } else {
      // self: an arrow, not a dot, pointing at `facing` — always straight up,
      // since the whole radar is already turned to match the view's yaw.
      const r = Math.max(4, radius * 0.08);
      const dir = blip.facing - Math.PI / 2;
      ctx.fillStyle = "#ffffff";
      ctx.beginPath();
      ctx.moveTo(px + Math.cos(dir) * r, py + Math.sin(dir) * r);
      ctx.lineTo(px + Math.cos(dir + 2.4) * r * 0.6, py + Math.sin(dir + 2.4) * r * 0.6);
      ctx.lineTo(px + Math.cos(dir - 2.4) * r * 0.6, py + Math.sin(dir - 2.4) * r * 0.6);
      ctx.closePath();
      ctx.fill();
    }
  }
  ctx.restore();
  ctx.strokeStyle = "rgba(255, 255, 255, 0.35)";
  ctx.lineWidth = 2;
  ctx.beginPath();
  ctx.arc(cx, cy, radius, 0, Math.PI * 2);
  ctx.stroke();
}
/** A plate is full strength this close and at its faintest by here. */
const PLATE_NEAR = 400;
const PLATE_FAR = 3000;
/** How far above the top of the hull the plate floats, in world units. */
const PLATE_LIFT = 14;
/**
 * A name over every player the eye can actually see: in front of it, inside
 * the frustum, traced clear of the level's boxes, and alive. That list is the
 * whole point — a name drawn through a wall is a wallhack — so the test that
 * puts a box in the way is the one that matters, and the trace is `canSee`,
 * the same eye-to-eye geometry the bots shoot by.
 *     alpha(b) = PEAK · min(1, b / WHITEOUT_FADE)
 *
 * Teammates carry their health, in your side's colour; an enemy is a name and
 * nothing else. Both fade with distance and are clamped in size, so the far
 * side of the map is a hint rather than a billboard. The geometry is
 * `project.ts`'s: this function only decides what a plate looks like.
 * Two deliberate limits, because a full-screen white-out is the easiest thing
 * in this game to make unplayable. It never reaches 1, so the world is always a
 * ghost behind it rather than gone. And it falls to nothing over the last
 * `WHITEOUT_FADE` seconds, so the crosshair under it is readable again once
 * alpha drops under about a half — at `b = 0.49 s` — whatever the flash was
 * worth. The longest a flash can be is `FLASH.maxBlind`, 1.6 seconds, of which
 * at most the first 0.7 is full white.
 */
function drawPlates(
  ctx: CanvasRenderingContext2D,
  world: World,
  view: Player,
  camera: Camera,
  width: number,
  height: number,
  scale: number,
  alpha: number,
): void {
  const plates: { player: Player; at: Projected }[] = [];
  const blend: Vec3 = [0, 0, 0];
  for (const p of world.players) {
    if (p === view || !p.alive) continue;
    if (!canSee(world, view, p)) continue; // one trace per player per frame
    // Over the head the renderer drew, not the head the last tick left: a
    // plate that sat on the newest tick would swim above a body drawn between
    // two of them. `alpha` is the same number the scene was drawn with.
    lerpPos(p.prev.pos, p.pos, alpha, blend);
    const head: [number, number, number] = [blend[0], blend[1], blend[2] + hullHeight(p) + PLATE_LIFT];
    const at = project(head, camera, width, height);
    if (at !== null) plates.push({ player: p, at });
  }
  // Furthest first, so the near one is the one you read where two overlap.
  plates.sort((a, b) => b.at.depth - a.at.depth);
export const whiteout = (blind: number): number => PEAK * Math.min(1, blind / WHITEOUT_FADE);
  ctx.textAlign = "center";
  const teamColor = view.team === "t" ? T_COLOR : CT_COLOR;
  for (const { player, at } of plates) {
    // 15px at 900 units, shrinking with the perspective divide the way the
    // player under it does — but clamped both ways, so a plate is never a
    // headline in your face nor a line of pixels you cannot read.
    const size = Math.round(clamp((15 * 900 * scale) / at.depth, 9 * scale, 17 * scale));
    const mate = player.team === view.team;
    ctx.globalAlpha = clamp(1 - (at.depth - PLATE_NEAR) / (PLATE_FAR - PLATE_NEAR), 0.16, 1);
    ctx.font = `${size}px system-ui, sans-serif`;
    const nameWidth = ctx.measureText(player.name).width;
    ctx.fillStyle = "rgba(10, 12, 16, 0.42)";
    ctx.fillRect(at.x - nameWidth / 2 - size * 0.3, at.y - size, nameWidth + size * 0.6, size * 1.25);
    ctx.fillStyle = mate ? teamColor : "#eef0f5";
    ctx.fillText(player.name, at.x, at.y);
    if (mate) {
      // Health as a bar under the name: a number to read and a length to
      // glance at, which is what "is this one worth trading for" asks.
      const fraction = clamp(player.health / 100, 0, 1);
      const barW = Math.round(size * 3), barH = Math.max(2, Math.round(size * 0.18));
      const barY = at.y + size * 0.4;
      ctx.fillStyle = "rgba(10, 12, 16, 0.5)";
      ctx.fillRect(at.x - barW / 2, barY, barW, barH);
      ctx.fillStyle = fraction > 0.3 ? "#7ddc8a" : "#ff6b5b";
      ctx.fillRect(at.x - barW / 2, barY, barW * fraction, barH);
      // The number keeps the bar's colour: one glance says how much and
      // whether it is the kind of much you go and help with.
      ctx.font = `${Math.max(8, Math.round(size * 0.78))}px system-ui, sans-serif`;
      ctx.fillText(String(Math.max(0, Math.round(player.health))), at.x, barY + barH + size * 0.78);
    }
  }
  ctx.globalAlpha = 1;
/** The most white there ever is, and the seconds it takes to clear. */
const PEAK = 0.92;
const WHITEOUT_FADE = 0.9;
/**
 * Taking damage, on the screen, is two things with two clocks.
 *
 * **The arc** says where it came from: a stroke on a ring around the middle of
 * the view, in the direction of whoever hit you *relative to where you are
 * facing now*, so it swings as you turn and sits still if you do not. It lives
 * `HURT_LIFE` seconds and fades linearly to nothing over them — long enough to
 * read while you are still turning, short enough that it is never telling you
 * about a fight that is over. Every live hit draws its own, so two people
 * shooting you from two sides is two arcs and not an average of them.
 *
 * **The flash** says how hard: a red wash whose opacity is the damage over
 * `PAIN_FULL` — half a body — capped, and gone `PAIN_LIFE` seconds later.
 *
 * The numbers are meant to be argued with, so here they are out loud. An AK
 * round to an armoured chest at 500 units is 27 damage, which peaks at
 * `0.3 · 27/50 ≈ 0.16` of red; an AWP body shot is 111 and peaks at the full
 * 0.3. A quarter of a second at a third of a colour is a hit you cannot miss
 * and nothing you have to wait out: an M4 fires every 0.09 s and an AWP every
 * 1.46, so the flash is over before your next shot either way, and the worst of
 * it is a third of what `whiteout` above is allowed to do — a flashbang is
 * meant to take the round off you and a bullet is not.
 *
 * And it draws *under* the crosshair, which is the one rule a full-screen wash
 * on an aiming game has to keep: the crosshair goes on after it, at its own
 * colour, so the shot you take back is aimed at exactly what it was aimed at
 * before. `whiteout` is the deliberate other way round.
 */
export const HURT_LIFE = 1.25;
const PAIN_LIFE = 0.25;
const PAIN_FULL = 50;
const PAIN_PEAK = 0.3;
/** How much red is over the world from one hit of `damage`, `age` seconds on. */
export const painAlpha = (damage: number, age: number): number =>
  age < 0 || age >= PAIN_LIFE ? 0 : PAIN_PEAK * Math.min(1, damage / PAIN_FULL) * (1 - age / PAIN_LIFE);
/** The red it washes in, and the red the arcs are stroked in. */
const PAIN = "190,30,26";
const HURT = "255,70,60";
/** How far out the arcs sit as a fraction of the shorter side, and how wide each is. */
const HURT_RADIUS = 0.28;
const HURT_HALF = 0.34; // radians: an arc about 39° across
const HURT_ALPHA = 0.85;
/**
 * Where a hit at `from` sits on that ring, for a body at `at` facing `yaw`, as
 * the angle `ctx.arc` wants: zero to the right of the middle of the screen,
 * growing clockwise. Straight ahead is the top of the ring and behind you is
 * the bottom, so turning ninety degrees walks the arc ninety degrees round it.
 *
 * Height is dropped on purpose: this is a bearing you turn by, and a shot from
 * a floor above is still a shot from over there.
 */
export function hurtAngle(yaw: number, from: Vec3, at: Vec3): number {
  const bearing = (Math.atan2(from[1] - at[1], from[0] - at[0]) * 180) / Math.PI;
  // `angleDelta` counts counter-clockwise, which on the ground is to your left;
  // the screen's angles run the other way, and that is the minus sign.
  return -Math.PI / 2 - (angleDelta(yaw, bearing) * Math.PI) / 180;
}
/**
 * How much grey is over the world when the eye is inside a cloud of smoke.
 *
 * It is a constant and not a ramp, on purpose: the simulation's answer inside a
 * cloud is a flat *no* — `canSee` refuses a line that meets the ball at all, so
 * a bot one unit inside one is as blind as a bot in the middle — and a wash
 * that faded with depth would be the screen disagreeing with the round. Like
 * the white-out above it stops short of 1, so the crosshair and the world are a
 * ghost behind it rather than gone; unlike the white-out it does not fade,
 * because a cloud does not fade while you are standing in it.
 *
 * From outside, a cloud is a ball `scene.ts` places and this draws nothing at
 * all. The two are the same fact from the two sides of one surface.
 */
export const FOG = 0.9;
/**
 * Paint the HUD for this frame. `view` is whose eyes the camera is in — you, or
 * the player you are watching once you are dead — and it is what every number
 * about a body is read off: the crosshair that opens as far as *their* gun is
 * inaccurate, their health, their armour, their magazine, their defuse bar. The
 * round, the feed and the scoreboard belong to the match and are the same from
 * anybody's eyes. Left out, the view is you, which is every frame of a round
 * you are alive in.
 *
 * `width` and `height` are the canvas's backing store — device pixels, not CSS
 * pixels — and `dpr` is how many of those go to a CSS pixel, so that the
 * crosshair is the same size on the glass and exact on the grid at 125% and
 * 150% as well as at 100%. Left out it is 1, which is what every test draws at.
 */
export function drawHud(
  ctx: CanvasRenderingContext2D,
  ctx: Paint,
  world: World,
  view: Player,
  camera: Camera,
  width: number,
  height: number,
  showScoreboard: boolean,
  crosshair: CrosshairStyle = DEFAULT_CROSSHAIR,
  alpha = 1,
  view: Player = world.me,
  dpr = 1,
  motion: Motion = DEFAULT_MOTION,
): void {
  const ui = toolsFor(ctx, width, height, dpr);
  ctx.clearRect(0, 0, width, height);
  ctx.textBaseline = "alphabetic";
  // One value, read once a frame, the way the view and the crosshair are:
  // what it turns down is decided here and handed on, never re-decided per
  // element further down.
  const steady = motion === "reduced";
  const spectating = view !== world.me;
  const over = world.match.phase === "match_over";
  const weapon = currentWeapon(view);
  const pad = Math.max(12, Math.round(width * 0.02));
  const pad = ui.pad;
  // Damage is something a body takes, so the indicator is drawn only from the
  // eyes of the body that took it: yours, while you are standing. A spectator
  // is not being shot at, and a corpse is not turning to face anything.
  const hurting = view === world.me && view.alive;
  // --- being shot: where it came from, and how close to dead it left us
  drawDamage(ctx, world, view, width, height, steady);
  // --- the pain flash, first of everything and under the crosshair. The
  // strongest hit still on the clock decides it rather than the sum of them:
  // two rifle rounds in one tick is one hit's worth of red and not two, which
  // is what keeps a burst from washing the screen out.
  if (hurting) {
    let pain = 0;
    for (let i = 0; i < world.effects.count; i++) {
      const effect = effectAt(world.effects, i);
      if (effect === undefined || effect.kind !== "hurt") continue;
      pain = Math.max(pain, painAlpha(effect.damage, world.time - effect.at));
    }
    if (pain > 0) {
      ctx.fillStyle = `rgba(${PAIN},${pain.toFixed(3)})`;
      ctx.fillRect(0, 0, width, height);
    }
  }
  // --- crosshair, opening up exactly as much as the gun is inaccurate — as
  // far as the player's own style lets it: what the arms look like is
  // crosshair.ts's, and the only thing decided here is the spread they answer
  // to. A colour is a name that module resolves, never a string from storage.
  if (view.alive && !spectating && !over) {
  // --- crosshair, opening up exactly as much as the gun is inaccurate
  if (view.alive) {
    const speed = Math.hypot(view.vel[0], view.vel[1]);
    const spread = inaccuracy(weapon, {
      moving: clamp(speed / MOVE.maxSpeed, 0, 1),
      moving: clamp(speed / CS_MOVE.maxSpeed, 0, 1),
      inAir: !view.onGround,
      ducking: view.duckAmount > 0.5,
      scoped: view.scoped,
    });
    const shape = crosshairShape(crosshair, spread, width / 2, height / 2);
    ctx.strokeStyle = shape.colour;
    ctx.lineWidth = shape.thickness;
    ctx.beginPath();
    for (const segment of shape.segments) {
      ctx.moveTo(segment.x1, segment.y1);
      ctx.lineTo(segment.x2, segment.y2);
    }
    ctx.stroke();
    if (shape.dot !== null) {
      ctx.fillStyle = shape.colour;
    // The gap and the arm in CSS pixels, turned into whole device pixels here:
    // the cross is the same size on the glass at 100%, 125% and 200%, and every
    // edge of it is a pixel's edge. `px` never rounds down to nothing, so the
    // tightest scoped crosshair is still a cross.
    ui.crosshair(width / 2, height / 2, ui.px(4 + spread * 14), ui.px(7), CROSSHAIR);
    if (view.scoped) {
      ctx.fillStyle = "rgba(0,0,0,0.55)";
      ctx.beginPath();
      ctx.arc(shape.dot.x, shape.dot.y, shape.dot.radius, 0, Math.PI * 2);
      ctx.fill();
      ctx.rect(0, 0, width, height);
      ctx.arc(width / 2, height / 2, Math.min(width, height) * 0.36, 0, Math.PI * 2, true);
      ctx.fill("evenodd");
    }
  }
  // The scope mask belongs to the camera, not to the crosshair: a spectator
  // watching a scoped teammate is looking down that scope's field of view.
  if (view.alive && view.scoped) {
    ctx.fillStyle = "rgba(0,0,0,0.55)";
    ctx.beginPath();
    ctx.rect(0, 0, width, height);
    ctx.arc(width / 2, height / 2, Math.min(width, height) * 0.36, 0, Math.PI * 2, true);
    ctx.fill("evenodd");
  }
  // --- hit markers, which are the person's own hits and nobody else's: a
  // spectator never inherits the ones the corpse left behind.
  if (!spectating && view.alive) {
    for (const effect of world.effects) {
      if (effect.kind !== "hitmark") continue;
      const age = world.time - effect.at;
      if (age > (effect.killed ? KILL_MARK_LIFE : HIT_MARK_LIFE)) continue;
      ctx.strokeStyle = effect.headshot ? "rgba(255,90,90,0.95)" : "rgba(255,255,255,0.9)";
      ctx.lineWidth = effect.killed ? 3 : 2;
      const r = 9 + age * 20;
      ctx.beginPath();
      for (const [dx, dy] of [[1, 1], [-1, -1], [1, -1], [-1, 1]]) {
        ctx.moveTo(width / 2 + dx * r * 0.55, height / 2 + dy * r * 0.55);
        ctx.lineTo(width / 2 + dx * r, height / 2 + dy * r);
  // --- hit markers. Four arms like the crosshair's, but on the diagonals and
  // growing as the mark ages, which is not a shape the engine hands out.
  for (let i = 0; i < world.effects.count; i++) {
    const effect = effectAt(world.effects, i);
    if (effect === undefined || effect.kind !== "hitmark") continue;
    const age = world.time - effect.at;
    if (age > (effect.killed ? KILL_MARK_LIFE : HIT_MARK_LIFE)) continue;
    ctx.strokeStyle = effect.headshot ? "rgba(255,90,90,0.95)" : "rgba(255,255,255,0.9)";
    // On the diagonals, so there is no pixel grid to land on and no point
    // pretending there is — but it is still the same size on the glass at every
    // ratio, which is the half of this a dense screen used to lose.
    ctx.lineWidth = ui.px(effect.killed ? 3 : 2);
    const r = ui.px(9 + age * 20);
    ctx.beginPath();
    const arms: [number, number][] = [[1, 1], [-1, -1], [1, -1], [-1, 1]];
    for (const [dx, dy] of arms) {
      ctx.moveTo(width / 2 + dx * r * 0.55, height / 2 + dy * r * 0.55);
      ctx.lineTo(width / 2 + dx * r, height / 2 + dy * r);
    }
    // The hit that finished them closes the four ticks into an X through the
    // middle: a different shape, not a shade of the same one.
    if (effect.killed)
      for (const [dx, dy] of KILL_STROKES) {
        ctx.moveTo(width / 2 - dx * r * 0.45, height / 2 - dy * r * 0.45);
        ctx.lineTo(width / 2 + dx * r * 0.45, height / 2 + dy * r * 0.45);
      }
      // The one that finished them closes the four ticks into an X through the
      // middle — two more strokes on the same path, heavier and held longer,
      // so a kill is a different shape and not a shade of the same one. A
      // headshot kill is that X in the headshot's red.
      if (effect.killed)
        for (const [dx, dy] of [[1, 1], [1, -1]]) {
          ctx.moveTo(width / 2 - dx * r * 0.45, height / 2 - dy * r * 0.45);
          ctx.lineTo(width / 2 + dx * r * 0.45, height / 2 + dy * r * 0.45);
        }
    ctx.stroke();
  }
  // --- flashed: white over the world, and nothing else. The blindness itself
  // is the simulation's — `view.blind`, in seconds, burned down at 64 Hz — so
  // this is only how it looks and a bot flashed by the same grenade suffers the
  // same number. It goes on after the crosshair and before the numbers: it
  // dims the crosshair as it should and never hides the clock or your health.
  if (view.blind > 0) {
    ctx.fillStyle = `rgba(255,255,255,${whiteout(view.blind).toFixed(3)})`;
    ctx.fillRect(0, 0, width, height);
  }
  // --- and in the smoke: the same idea from inside a cloud instead of outside
  // one. The ball `scene.ts` draws is opaque and its far faces are culled, so
  // an eye within it would otherwise see straight through the thing that is
  // blocking every sightline in the simulation. Which eye is the view's, so a
  // spectator sees the fog the body they are watching is standing in.
  if (view.alive && insideSmoke(world, eyePos(view))) {
    ctx.fillStyle = `rgba(196,200,208,${FOG})`;
    ctx.fillRect(0, 0, width, height);
  }
  // --- and where it came from: one arc per hit, over the washes for the same
  // reason your health is drawn over them — being blinded or standing in smoke
  // is exactly when knowing which way to turn is worth most.
  if (hurting) {
    const radius = Math.min(width, height) * HURT_RADIUS;
    ctx.lineWidth = Math.max(3, Math.round(5 * ui.scale));
    for (let i = 0; i < world.effects.count; i++) {
      const effect = effectAt(world.effects, i);
      if (effect === undefined || effect.kind !== "hurt") continue;
      const age = world.time - effect.at;
      if (age < 0 || age >= HURT_LIFE) continue;
      // A fall hurts from straight below: no bearing, so no arc — the pain
      // flash above is the whole of it.
      if (Math.hypot(effect.from[0] - view.pos[0], effect.from[1] - view.pos[1]) < 1) continue;
      const mid = hurtAngle(view.yaw, effect.from, view.pos);
      // Under reduced motion the arc holds its strength and then goes: where
      // it came from is what it says, and a slide to nothing is only how it
      // leaves. The pain flash above is left alone — how hard is information.
      const fade = motion === "reduced" ? 1 : 1 - age / HURT_LIFE;
      ctx.strokeStyle = `rgba(${HURT},${(HURT_ALPHA * fade).toFixed(3)})`;
      ctx.beginPath();
      ctx.arc(width / 2, height / 2, radius, mid - HURT_HALF, mid + HURT_HALF);
      ctx.stroke();
    }
  }
  const scale = clamp(width / 1280, 0.7, 1.4);
  const big = `${Math.round(30 * scale)}px system-ui, sans-serif`;
  const mid = `${Math.round(19 * scale)}px system-ui, sans-serif`;
  const small = `${Math.round(15 * scale)}px system-ui, sans-serif`;
  const panel = (x: number, y: number, w: number, h: number): void => {
    ctx.fillStyle = "rgba(12, 14, 18, 0.55)";
    ctx.fillRect(x, y, w, h);
  };
  // --- who is that: names over the players the eye can see, drawn under the
  // rest of the HUD so a plate never covers the clock or the ammo, and not at
  // all while the scoreboard — which says the same thing better — is up.
  if (!showScoreboard) drawPlates(ctx, world, view, camera, width, height, scale, alpha);
  // --- radar: bottom-left, clear of the money line above and the health and
  // armour numbers below, at 360px of a 1280px-wide HUD — about 28% of the
  // width, the same share at any size since it scales with everything else.
  const radarSize = Math.round(360 * scale);
  drawRadar(ctx, world, view, pad, height - pad - Math.round(78 * scale) - radarSize, radarSize);
  const scale = ui.scale;
  const big = ui.font(30);
  const mid = ui.font(19);
  const small = ui.font(15);
  // --- round clock and score
  const barW = Math.round(240 * scale);
  panel(width / 2 - barW / 2, 0, barW, Math.round(44 * scale));
  ctx.textAlign = "center";
  ctx.font = big;
  ui.panel(width / 2 - barW / 2, 0, barW, Math.round(44 * scale));
  const phase = world.match.phase;
  const time = phase === "freeze" || phase === "live" || phase === "planted" ? clock(world.match.timer) : "--:--";
  ctx.fillStyle = phase === "planted" ? "#ff6b5b" : "#f3f5f8";
  ctx.fillText(time, width / 2, Math.round(32 * scale));
  ctx.font = mid;
  ctx.fillStyle = T_COLOR;
  ctx.textAlign = "right";
  ctx.fillText(String(world.match.score.t), width / 2 - barW / 2 - 8 * scale, Math.round(32 * scale));
  ctx.fillStyle = CT_COLOR;
  ctx.textAlign = "left";
  ctx.fillText(String(world.match.score.ct), width / 2 + barW / 2 + 8 * scale, Math.round(32 * scale));
  const timed = phase === "freeze" || phase === "live" || phase === "planted";
  const clockY = Math.round(32 * scale);
  ui.text(timed ? ui.clock(world.match.timer) : "--:--", width / 2, clockY, {
    align: "center", font: big, fill: phase === "planted" ? RED : WHITE,
  });
  ui.text(String(world.match.score.t), width / 2 - barW / 2 - 8 * scale, clockY,
    { align: "right", font: mid, fill: T_COLOR });
  ui.text(String(world.match.score.ct), width / 2 + barW / 2 + 8 * scale, clockY,
    { align: "left", font: mid, fill: CT_COLOR });
  // --- health, armour, money
  ctx.textAlign = "left";
  ctx.font = big;
  ctx.fillStyle = view.health > 30 ? "#f3f5f8" : "#ff6b5b";
  ctx.fillText(String(Math.max(0, Math.round(view.health))), pad, height - pad);
  ctx.font = small;
  ctx.fillStyle = "#9fd0ff";
  ctx.fillText(
    `${view.armor > 0 ? `armour ${view.armor}${view.helmet ? " + helmet" : ""}` : "no armour"}`,
  ui.text(String(Math.max(0, Math.round(view.health))), pad, height - pad,
    { align: "left", font: big, fill: view.health > 30 ? WHITE : RED });
  ui.text(
    view.armor > 0 ? `armour ${view.armor}${view.helmet ? " + helmet" : ""}` : "no armour",
    pad, height - pad - Math.round(30 * scale),
    { align: "left", font: small, fill: BLUE },
  );
  ctx.fillStyle = "#7ddc8a";
  ctx.font = mid;
  ctx.fillText(`$${view.money}`, pad, pad + Math.round(18 * scale));
  ctx.font = small;
  let carried = pad + Math.round(38 * scale);
  if (view.team === "ct" && view.defuseKit) {
    ctx.fillStyle = "#9fd0ff";
    ctx.fillText("defuse kit", pad, carried);
    carried += Math.round(20 * scale);
  }
  // What is in the pocket, whether or not it is in the hands: a grenade you
  // forgot you bought is a grenade you never threw. Every kind carried reads
  // on the one line — with one kind, as today; empty draws nothing, which is
  // the whole of how this avoids a layout shift when the pocket runs out.
  // Untestable until a second real kind exists to carry: check this line's
  // width at 360px once one does, since it grows sideways with each kind.
  const pocket = grenadeKinds(view);
  if (pocket.length > 0) {
    ctx.fillStyle = "#c8e6a0";
    const label = pocket
      .map((id) => `${WEAPONS[id].name.replace(" Grenade", "")} ×${grenadeCount(view, id)}`)
      .join("  ");
    ctx.fillText(`${label}  ·  4`, pad, carried);
  }
  // --- the radar, top left, and the money under it rather than over it
  const radar = Math.min(Math.round(RADAR * scale), Math.round(Math.min(width, height) * 0.3));
  drawMinimap(ctx, ui, world, view, pad, pad, radar);
  const moneyY = pad + radar + Math.round(22 * scale);
  ui.text(`$${view.money}`, pad, moneyY, { align: "left", font: mid, fill: "#7ddc8a" });
  if (view.team === "ct" && view.defuseKit)
    ui.text("defuse kit", pad, moneyY + Math.round(20 * scale), { align: "left", font: small, fill: BLUE });
  // --- ammo and weapon, dimmed while the gun is still on its way up: the
  // simulation refuses the trigger until `nextShotAt` passes, and an AWP owes
  // 1.25 s of that. The reload line below keeps its own full strength — a
  // reload says what it is in words, and the two never overlap anyway.
  ctx.textAlign = "right";
  ctx.globalAlpha = deploying(world, view) ? NOT_READY_ALPHA : 1;
  ctx.font = big;
  ctx.fillStyle = "#f3f5f8";
  // simulation refuses the trigger until `deployUntil`, and the gun rising in
  // the middle of the screen ends on that same tick, so the two cues end
  // together. The busy line below keeps its full strength — it says in words
  // what the dimming means.
  const ready = world.time < view.deployUntil ? NOT_READY_ALPHA : 1;
  const ammo = view.ammo[weapon.id];
  // A grenade counts what is left in the pocket where a gun counts its magazine.
  const ammoText = weapon.kind === "grenade"
    ? `×${grenadeCount(view, weapon.id)}`
    : weapon.magazine === 0 ? "—" : `${ammo?.mag ?? 0} / ${ammo?.reserve ?? 0}`;
  ctx.fillText(ammoText, width - pad, height - pad);
  ctx.font = small;
  ctx.fillStyle = "#c8ccd4";
  ctx.fillText(weapon.name + (view.hasBomb ? "  ·  bomb" : ""), width - pad, height - pad - Math.round(30 * scale));
  ctx.globalAlpha = 1;
  if (world.time < view.reloadUntil) {
    ctx.fillStyle = "#f0c060";
    ctx.fillText("reloading", width - pad, height - pad - Math.round(50 * scale));
  }
  const ammoText = weapon.magazine === 0 ? "—" : `${ammo?.mag ?? 0} / ${ammo?.reserve ?? 0}`;
  ui.text(ammoText, width - pad, height - pad, { align: "right", font: big, fill: WHITE, alpha: ready });
  // What is in your hands, and then what is in your pockets: the grenades you
  // bought and the bomb, each named only while you are carrying it.
  ui.text(
    weapon.name +
      (view.pocket.he > 0 ? "  ·  HE" : "") +
      (view.pocket.flash > 0 ? "  ·  flash" : "") +
      (view.pocket.smoke > 0 ? "  ·  smoke" : "") +
      (view.hasBomb ? "  ·  bomb" : ""),
    width - pad, height - pad - Math.round(30 * scale),
    { align: "right", font: small, fill: GREY, alpha: ready },
  );
  // What the gun is busy doing, in the one line there is room for. The two
  // cannot both be true — a switch cancels the reload it interrupted and a
  // reload cannot start until the new weapon is up — so this is an order of
  // reading and not a choice between two things happening at once.
  const busy = world.time < view.deployUntil ? "switching" : world.time < view.reloadUntil ? "reloading" : null;
  if (busy !== null)
    ui.text(busy, width - pad, height - pad - Math.round(50 * scale), { align: "right", font: small, fill: "#f0c060" });
  // --- who is left
  ctx.textAlign = "center";
  ctx.font = small;
  const aliveT = world.players.filter((p) => p.team === "t" && p.alive).length;
  const aliveCT = world.players.filter((p) => p.team === "ct" && p.alive).length;
  ctx.fillStyle = T_COLOR;
  ctx.fillText(`T ${aliveT}`, width / 2 - Math.round(60 * scale), Math.round(62 * scale));
  ctx.fillStyle = CT_COLOR;
  ctx.fillText(`CT ${aliveCT}`, width / 2 + Math.round(60 * scale), Math.round(62 * scale));
  const leftY = Math.round(62 * scale);
  ui.text(`T ${aliveT}`, width / 2 - Math.round(60 * scale), leftY, { align: "center", font: small, fill: T_COLOR });
  ui.text(`CT ${aliveCT}`, width / 2 + Math.round(60 * scale), leftY, { align: "center", font: small, fill: CT_COLOR });
  // --- kill feed
  ctx.textAlign = "right";
  ctx.font = small;
  world.feed.slice(-5).forEach((entry, i) => {
    const age = world.time - entry.at;
    if (age > 8) return;
    const y = pad + Math.round((20 + i * 22) * scale);
    ctx.globalAlpha = clamp(8 - age, 0, 1);
    ctx.fillStyle = entry.killerTeam === "t" ? T_COLOR : CT_COLOR;
    const text = `${entry.killer}  ${causeName(entry.weapon)}${entry.headshot ? " ⌖" : ""}  ${entry.victim}`;
    ctx.fillText(text, width - pad, y);
    ctx.globalAlpha = 1;
    ui.text(text, width - pad, pad + Math.round((20 + i * 22) * scale), {
      align: "right", font: small, fill: teamColor(entry.killerTeam), alpha: 8 - age,
    });
  });
  // --- what the round is saying. The line stays up for four seconds, and a
  // round result stays until the next round goes live: the end delay plus the
  // freeze is long enough to read who won and why, which is the point of it.
  // --- what the round is saying
  const message = world.messages[world.messages.length - 1];
  const holding = phase === "over" || phase === "freeze" || phase === "match_over";
  if (message !== undefined && (holding || world.time - message.at < MESSAGE_FADE)) {
    ctx.textAlign = "center";
    ctx.font = mid;
    ctx.fillStyle = "rgba(255,255,255,0.92)";
    ctx.fillText(message.text, width / 2, height * 0.22);
  }
  // --- a gun under your feet that you would have to ask for. A gun you have
  // no slot for is taken by walking over it and says nothing, because by the
  // time it could be read it is already in your hands.
  const offered = !spectating && view.alive ? offeredPickup(world, view) : null;
  if (offered !== null) {
    ctx.textAlign = "center";
    ctx.font = mid;
    ctx.fillStyle = "rgba(255,255,255,0.92)";
    ctx.fillText(`E — take ${WEAPONS[offered.weapon].name}`, width / 2, height * 0.58);
  }
  if (message !== undefined && world.time - message.at < 4)
    ui.text(message.text, width / 2, height * 0.22, { align: "center", font: mid, fill: "rgba(255,255,255,0.92)" });
  // --- planting or defusing
  const progress = useProgress(world, view);
  if (progress !== null) {
    const w = Math.round(260 * scale), h = Math.round(14 * scale);
    const x = width / 2 - w / 2, y = height * 0.62;
    panel(x - 2, y - 2, w + 4, h + 4);
    ctx.fillStyle = progress.label.startsWith("Def") ? "#6fa8e8" : "#e2b04a";
    ctx.fillRect(x, y, w * progress.fraction, h);
    ctx.font = small;
    ctx.fillStyle = "#fff";
    ctx.textAlign = "center";
    ctx.fillText(progress.label, width / 2, y - 8 * scale);
    ui.panel(x - 2, y - 2, w + 4, h + 4);
    ui.bar(x, y, w, h, progress.fraction, progress.label.startsWith("Def") ? CT_COLOR : T_COLOR);
    ui.text(progress.label, width / 2, y - 8 * scale, { align: "center", font: small, fill: "#fff" });
  }
  // --- dead: who killed you, and whose eyes you are borrowing until the round
  // is over. The kill feed is where the killer comes from; the bomb credits
  // nobody, so it names you as your own killer there and this reads that way.
  if (!world.me.alive && !over) {
    const top = height * 0.38;
    ctx.textAlign = "center";
    ctx.font = big;
    ctx.fillStyle = "rgba(255,255,255,0.88)";
    ctx.fillText("You are dead", width / 2, top);
    const notice = deathNotice(world, world.me);
    if (notice !== null) {
      ctx.font = mid;
      ctx.fillStyle = "#ff8f86";
      const how = notice.weapon === "fall" ? "You fell too far" :
        `${notice.killer} killed you with ${causeName(notice.weapon)}` + (notice.headshot ? " — headshot" : "");
      ctx.fillText(how, width / 2, top + Math.round(30 * scale));
  // --- dead: whose eyes this is, and how to move to the next pair
  if (!world.me.alive && world.match.phase !== "match_over") {
    if (view === world.me) {
      // Nobody left to watch: your own body is the only camera in the round.
      ui.text(DEAD, width / 2, height * 0.4, { align: "center", font: big, fill: "rgba(255,255,255,0.85)" });
    } else {
      // Above the bottom row, so it never lands on the health or the ammo —
      // at 360 pixels wide those are a thumb's width from the middle.
      const w = Math.round(420 * scale), h = Math.round(34 * scale);
      const y = height - pad - Math.round(64 * scale);
      ui.panel(width / 2 - w / 2, y - h + Math.round(8 * scale), w, h);
      ui.text(`${WATCHING} ${view.name}`, width / 2, y - Math.round(14 * scale),
        { align: "center", font: mid, fill: teamColor(view.team) });
      ui.text(SWITCH, width / 2, y, { align: "center", font: small, fill: GREY });
    }
    ctx.font = small;
    ctx.fillStyle = "#c8ccd4";
    ctx.fillText(
      spectating ? `Watching ${view.name} — fire or click for the next` : "Nobody left to watch",
      width / 2, top + Math.round(56 * scale),
    );
  }
  // --- the damage report: only during the round-over delay, and never under
  // the scoreboard, which a held Tab can ask for at the same moment.
  if (!showScoreboard) drawReport(ctx, world, view, width, height, scale);
  if (showScoreboard) drawScoreboard(ctx, world, width, height, scale);
  if (showScoreboard) drawScoreboard(ctx, ui, world);
}
function drawScoreboard(
  ctx: CanvasRenderingContext2D,
  world: World,
  width: number,
  height: number,
  scale: number,
): void {
function drawScoreboard(ctx: Paint, ui: Overlay, world: World): void {
  const { width, height, scale } = ui;
  const w = Math.min(width - 40, Math.round(760 * scale));
  const rowH = Math.round(26 * scale);
  const h = rowH * (world.players.length + 5);
  const h = rowH * (world.players.length + 4);
  const x = width / 2 - w / 2, y = height / 2 - h / 2;
  ctx.fillStyle = "rgba(10, 12, 16, 0.88)";
  ctx.fillRect(x, y, w, h);
  ctx.font = `${Math.round(15 * scale)}px system-ui, sans-serif`;
  // Which band the fight is being played at, so a screenshot of the scoreline
  // still means something once the round it was taken in is long over.
  ctx.textAlign = "center";
  ctx.fillStyle = "#9aa4b4";
  const difficulty = world.difficulty.charAt(0).toUpperCase() + world.difficulty.slice(1);
  ctx.fillText(`Difficulty: ${difficulty}`, x + w / 2, y + rowH);
  ctx.textAlign = "left";
  ctx.fillStyle = "#c8ccd4";
  ctx.fillText("player", x + 16, y + rowH * 2);
  ctx.textAlign = "right";
  for (const [i, label] of ["kills", "deaths", "hs", "damage", "money"].entries())
    ctx.fillText(label, x + w - 16 - i * Math.round(90 * scale), y + rowH * 2);
  const right = x + w - 16, stride = Math.round(90 * scale);
  ui.panel(x, y, w, h, "rgba(10, 12, 16, 0.88)");
  ui.text("player", x + 16, y + rowH, { align: "left", font: ui.font(15), fill: GREY });
  // The headings sit on the row they head, so there is no lead over a value.
  ui.columns(FIGURES, NOTHING, { x: right, y: y + rowH, lead: 0 }, stride);
  const order = [...world.players].sort((a, b) => b.kills - a.kills || b.damage - a.damage);
  order.forEach((p, row) => {
    const ty = y + rowH * (row + 3.4);
    ctx.textAlign = "left";
    ctx.fillStyle = p === world.me ? "#ffffff" : p.team === "t" ? T_COLOR : CT_COLOR;
    ctx.globalAlpha = p.alive ? 1 : 0.45;
    ctx.fillText(`${p.team === "t" ? "T" : "CT"}  ${p.name}${p.bot ? "" : "  (you)"}`, x + 16, ty);
    ctx.textAlign = "right";
    for (const [i, value] of [p.kills, p.deaths, p.headshots, Math.round(p.damage), `$${p.money}`].entries())
      ctx.fillText(String(value), x + w - 16 - i * Math.round(90 * scale), ty);
  // The rows, and the order they are in, are `summary.ts`'s: the screen at the
  // end of the match draws the same ten lines out of the same function, so what
  // you read holding Tab and what you read afterwards cannot be in two orders.
  scoreLines(world).forEach((p, row) => {
    const ty = y + rowH * (row + 2.4);
    // A dead player's whole row is dimmed — the name and the figures both — so
    // the fade is set around them rather than passed to each line.
    const dim = p.alive ? 1 : 0.45;
    ui.text(`${p.team === "t" ? "T" : "CT"}  ${p.name}${p.you ? "  (you)" : ""}`, x + 16, ty, {
      align: "left", fill: p.you ? "#ffffff" : teamColor(p.team), alpha: dim,
    });
    ctx.globalAlpha = dim;
    ui.columns(NOTHING, [
      String(p.kills), String(p.deaths), String(p.headshots), String(p.damage), `$${p.money}`,
    ], { x: right, y: ty }, stride);
    ctx.globalAlpha = 1;
  });
}
@@ -1,399 +0,0 @@
/**
 * Input against a canvas and a document that are three lines of fake each: no
 * browser, just the events one would send. What is worth checking here is the
 * touch build, because that is where two fingers have to mean two different
 * things at the same moment — the one that steers and the one that fires.
 */
import { afterEach, expect, test } from "bun:test";
import {
  attachButtons, createControls, DEFAULT_BINDINGS, lookDelta, MOUSE_DEGREES, TOUCH_DEGREES,
  type Controls,
} from "./input.ts";
import { downAt } from "./press.ts";
import { DEFAULT_ZOOM_RATIO } from "./zoom.ts";
type Listener = (event: unknown) => void;
/** An EventTarget that remembers its listeners so a test can fire them. */
function target(extra: Record<string, unknown> = {}): Record<string, unknown> & {
  fire(type: string, event?: Record<string, unknown>): void;
} {
  const listeners = new Map<string, Set<Listener>>();
  return {
    ...extra,
    addEventListener(type: string, fn: Listener): void {
      const set = listeners.get(type) ?? new Set<Listener>();
      set.add(fn);
      listeners.set(type, set);
    },
    removeEventListener(type: string, fn: Listener): void {
      listeners.get(type)?.delete(fn);
    },
    fire(type: string, event: Record<string, unknown> = {}): void {
      for (const fn of Array.from(listeners.get(type) ?? [])) {
        fn({ preventDefault: () => {}, ...event });
      }
    },
  };
}
type Canvas = ReturnType<typeof target>;
const globals = globalThis as unknown as Record<string, unknown>;
const before = { window: globals.window, document: globals.document };
// The fakes are this file's and nobody else's: the rest of the suite runs in
// the same process, and hud.ts asks whether `document` exists.
afterEach(() => {
  globals.window = before.window;
  globals.document = before.document;
});
/** A canvas 1000 wide: the stick is x < 380, the look and the trigger are past it. */
function harness(bindings = DEFAULT_BINDINGS): { canvas: Canvas; controls: Controls } {
  const canvas = target({ clientWidth: 1000, clientHeight: 600 });
  globals.window = target();
  globals.document = target({ pointerLockElement: null });
  const controls = createControls(canvas as unknown as HTMLCanvasElement, 2.2, bindings);
  return { canvas, controls };
}
/** One touch point, as the browser would hand it over. */
const at = (identifier: number, clientX: number, clientY = 300): Record<string, unknown> =>
  ({ identifier, clientX, clientY });
const touch = (canvas: Canvas, type: string, ...points: Record<string, unknown>[]): void =>
  canvas.fire(type, { changedTouches: points });
/** Is `control` down on the first step of a frame of `steps` steps? */
const firstStep = (controls: Controls, control: string, steps = 2): boolean =>
  downAt(controls.take(steps), control, 0);
test("a second finger on the looking side fires, and the first keeps aiming", () => {
  const { canvas, controls } = harness();
  touch(canvas, "touchstart", at(1, 700));
  touch(canvas, "touchmove", at(1, 740));
  const [turned] = controls.takeLook();
  expect(turned).toBeGreaterThan(0);
  // The trigger lands while the aiming finger is still down.
  touch(canvas, "touchstart", at(2, 900, 500));
  expect(firstStep(controls, "fire")).toBe(true);
  // ...and the aiming finger goes on steering, from where it actually is.
  touch(canvas, "touchmove", at(1, 780));
  const [again] = controls.takeLook();
  expect(again).toBeCloseTo(turned, 6);
  expect(firstStep(controls, "fire")).toBe(true); // still held
  touch(canvas, "touchend", at(2, 900, 500));
  expect(firstStep(controls, "fire")).toBe(false);
  touch(canvas, "touchmove", at(1, 820));
  expect(controls.takeLook()[0]).toBeCloseTo(turned, 6);
});
test("the finger that fires does not steer", () => {
  const { canvas, controls } = harness();
  touch(canvas, "touchstart", at(1, 700));
  controls.takeLook();
  touch(canvas, "touchstart", at(2, 900));
  touch(canvas, "touchmove", at(2, 500, 100)); // a trigger finger twitching
  expect(controls.takeLook()).toEqual([0, 0]);
});
test("a cancelled trigger releases: no stuck fire on a phone", () => {
  const { canvas, controls } = harness();
  touch(canvas, "touchstart", at(1, 700));
  touch(canvas, "touchstart", at(2, 900));
  controls.take(1);
  touch(canvas, "touchcancel", at(2, 900));
  expect(controls.take(1).held.has("fire")).toBe(false);
});
test("two trigger fingers are one trigger: the last one up releases it", () => {
  const { canvas, controls } = harness();
  touch(canvas, "touchstart", at(1, 700));
  touch(canvas, "touchstart", at(2, 850), at(3, 950));
  touch(canvas, "touchend", at(2, 850));
  expect(controls.take(1).held.has("fire")).toBe(true);
  touch(canvas, "touchend", at(3, 950));
  expect(controls.take(1).held.has("fire")).toBe(false);
});
test("the left third is still the stick, and a second finger there does not fire", () => {
  const { canvas, controls } = harness();
  touch(canvas, "touchstart", at(1, 100));
  touch(canvas, "touchmove", at(1, 160));
  const frame = controls.take(1);
  expect(controls.inputAt(frame, 0).side).toBeCloseTo(1, 6);
  expect(frame.held.has("fire")).toBe(false);
  touch(canvas, "touchend", at(1, 160));
  expect(controls.inputAt(controls.take(1), 0).side).toBe(0);
});
// --- the scope's share of the look: the same movement is worth fewer degrees
// while the view is zoomed, and the pure function is where that is decided.
test("a mouse delta is scaled by the zoom while scoped, and untouched while not", () => {
  const plain = lookDelta(100, 2.2, false, DEFAULT_ZOOM_RATIO);
  expect(plain).toBeCloseTo(100 * 2.2 * MOUSE_DEGREES, 10);
  expect(lookDelta(100, 2.2, true, DEFAULT_ZOOM_RATIO)).toBeCloseTo(plain * DEFAULT_ZOOM_RATIO, 10);
  // Less than half as fast at the default: the whole point of the setting.
  expect(lookDelta(100, 2.2, true, DEFAULT_ZOOM_RATIO)).toBeLessThan(plain / 2);
  // A ratio of 1 is the old behaviour, scoped or not.
  expect(lookDelta(100, 2.2, true, 1)).toBeCloseTo(plain, 10);
  // Direction survives the scaling.
  expect(lookDelta(-100, 2.2, true, DEFAULT_ZOOM_RATIO)).toBeCloseTo(-plain * DEFAULT_ZOOM_RATIO, 10);
  // A thumb's pixels are worth more degrees than a mouse's, scaled the same way.
  const thumb = lookDelta(100, 2.2, false, DEFAULT_ZOOM_RATIO, TOUCH_DEGREES);
  expect(thumb).toBeCloseTo(100 * 2.2 * TOUCH_DEGREES, 10);
  expect(lookDelta(100, 2.2, true, DEFAULT_ZOOM_RATIO, TOUCH_DEGREES))
    .toBeCloseTo(thumb * DEFAULT_ZOOM_RATIO, 10);
});
test("a locked mouse turns less while the scope is up, and the ratio takes effect mid-scope", () => {
  const { canvas: _canvas, controls } = harness();
  const window = globals.window as Canvas;
  controls.locked = true;
  window.fire("mousemove", { movementX: 50, movementY: 0 });
  const [hip] = controls.takeLook();
  expect(hip).toBeCloseTo(50 * 2.2 * MOUSE_DEGREES, 10);
  controls.scoped = true;
  window.fire("mousemove", { movementX: 50, movementY: 0 });
  expect(controls.takeLook()[0]).toBeCloseTo(hip * DEFAULT_ZOOM_RATIO, 10);
  // What the pause overlay's field does: the next movement feels it at once.
  controls.zoomRatio = 1;
  window.fire("mousemove", { movementX: 50, movementY: 0 });
  expect(controls.takeLook()[0]).toBeCloseTo(hip, 10);
});
test("a drag while scoped is scaled too — the pad is not left with the old behaviour", () => {
  const { canvas, controls } = harness();
  touch(canvas, "touchstart", at(1, 700));
  touch(canvas, "touchmove", at(1, 740));
  const [hip] = controls.takeLook();
  expect(hip).toBeCloseTo(40 * 2.2 * TOUCH_DEGREES, 10);
  controls.scoped = true;
  touch(canvas, "touchmove", at(1, 780));
  expect(controls.takeLook()[0]).toBeCloseTo(hip * DEFAULT_ZOOM_RATIO, 10);
});
// --- the buttons on the pad, which are the same action names as the keys
/** A fake `[data-action]` button, and a root that hands it to attachButtons. */
function pad(...actions: string[]): {
  root: ParentNode;
  press(action: string): void;
  release(action: string): void;
  classes(action: string): string[];
} {
  const buttons = new Map<string, Canvas>();
  for (const action of actions) {
    const classes: string[] = [];
    buttons.set(action, target({
      dataset: { action },
      classList: {
        add: (name: string) => { if (!classes.includes(name)) classes.push(name); },
        remove: (name: string) => {
          const at = classes.indexOf(name);
          if (at >= 0) classes.splice(at, 1);
        },
        names: classes,
      },
    }));
  }
  const root = { querySelectorAll: () => Array.from(buttons.values()) };
  return {
    root: root as unknown as ParentNode,
    press: (action) => buttons.get(action)?.fire("pointerdown"),
    release: (action) => buttons.get(action)?.fire("pointerup"),
    classes: (action) => ((buttons.get(action)?.classList as { names: string[] }).names),
  };
}
test("the menu button pauses without pointer lock", () => {
  const { controls } = harness();
  const buttons = pad("menu");
  attachButtons(buttons.root, controls);
  let paused = 0;
  controls.onPause = () => { paused += 1; };
  expect(controls.locked).toBe(false);
  buttons.press("menu");
  expect(paused).toBe(1);
  buttons.release("menu");
  expect(paused).toBe(1); // the release is not a second pause
});
test("clear forgets the presses and the look a paused match never took", () => {
  // What a pause does with what arrived under the overlay: the Space that
  // pressed Resume is not a jump on the first frame back, and a drag the game
  // did not watch is not a flick of the aim.
  const { canvas, controls } = harness();
  const buttons = pad("jump");
  attachButtons(buttons.root, controls);
  buttons.press("jump");
  touch(canvas, "touchstart", at(1, 600));
  touch(canvas, "touchmove", at(1, 700));
  expect(controls.takeLook()[0]).not.toBe(0);
  buttons.press("jump");
  touch(canvas, "touchmove", at(1, 800));
  controls.clear();
  expect(controls.takeLook()).toEqual([0, 0]);
  expect(firstStep(controls, "jump")).toBe(false);
});
test("the pad's slot, scoreboard and buy buttons are the keyboard's actions", () => {
  const { controls } = harness();
  const buttons = pad("slot1", "slot2", "slot3", "slot4", "scoreboard", "buy");
  attachButtons(buttons.root, controls);
  let buys = 0;
  controls.onBuy = () => { buys += 1; };
  expect(controls.slotWanted).toBe(null);
  for (const [action, slot] of [["slot1", 1], ["slot2", 2], ["slot3", 3], ["slot4", 4]] as const) {
    buttons.press(action);
    expect(controls.slotWanted).toBe(slot);
    buttons.release(action);
  }
  expect(controls.slotWanted).toBe(null);
  expect(controls.scoreboard).toBe(false);
  buttons.press("scoreboard");
  expect(controls.scoreboard).toBe(true); // held, not a toggle
  expect(buttons.classes("scoreboard")).toEqual(["on"]); // and it looks held
  buttons.release("scoreboard");
  expect(controls.scoreboard).toBe(false);
  expect(buttons.classes("scoreboard")).toEqual([]);
  buttons.press("buy");
  expect(buys).toBe(1);
});
test("scope is a touch button, held like the mouse's right button", () => {
  const { controls } = harness();
  const buttons = pad("scope");
  attachButtons(buttons.root, controls);
  expect(controls.inputAt(controls.take(1), 0).scope).toBe(false);
  buttons.press("scope");
  expect(controls.inputAt(controls.take(1), 0).scope).toBe(true); // held, not a toggle
  expect(buttons.classes("scope")).toEqual(["on"]);
  buttons.release("scope");
  expect(controls.inputAt(controls.take(1), 0).scope).toBe(false);
  expect(buttons.classes("scope")).toEqual([]);
});
test("Q scopes from the keyboard the same way", () => {
  const { controls } = harness();
  const window = globals.window as Canvas;
  window.fire("keydown", { code: "KeyQ" });
  expect(controls.inputAt(controls.take(1), 0).scope).toBe(true);
  window.fire("keyup", { code: "KeyQ" });
  expect(controls.inputAt(controls.take(1), 0).scope).toBe(false);
});
test("the radio is one key and one pad button, and opens on the press", () => {
  const { controls } = harness();
  const buttons = pad("radio");
  attachButtons(buttons.root, controls);
  const window = globals.window as Canvas;
  let opened = 0;
  controls.onRadio = () => { opened += 1; };
  window.fire("keydown", { code: "KeyZ" });
  expect(opened).toBe(1);
  // The release is not a second opening, and neither is the key repeating.
  window.fire("keyup", { code: "KeyZ" });
  window.fire("keydown", { code: "KeyZ", repeat: true });
  expect(opened).toBe(1);
  buttons.press("radio");
  expect(opened).toBe(2);
  buttons.release("radio");
  expect(opened).toBe(2);
});
test("the radio is a binding like any other: rebound, it answers to the new key", () => {
  const { controls } = harness({ ...DEFAULT_BINDINGS, radio: "KeyG" });
  const window = globals.window as Canvas;
  let opened = 0;
  controls.onRadio = () => { opened += 1; };
  window.fire("keydown", { code: "KeyZ" });
  expect(opened).toBe(0);
  window.fire("keydown", { code: "KeyG" });
  expect(opened).toBe(1);
});
// --- bindings: a non-default map moves the game, not the printed letters
test("a non-default map moves on the bound key and does nothing on KeyW", () => {
  const { controls } = harness({ ...DEFAULT_BINDINGS, forward: "KeyG" });
  const window = globals.window as Canvas;
  window.fire("keydown", { code: "KeyW" });
  expect(controls.inputAt(controls.take(1), 0).forward).toBe(0);
  window.fire("keydown", { code: "KeyG" });
  expect(controls.inputAt(controls.take(1), 0).forward).toBe(1);
});
test("a rebind takes effect on the very next key event, with no detach or re-attach", () => {
  const { controls } = harness();
  const window = globals.window as Canvas;
  window.fire("keydown", { code: "KeyW" });
  expect(controls.inputAt(controls.take(1), 0).forward).toBe(1);
  window.fire("keyup", { code: "KeyW" });
  controls.setBindings({ ...DEFAULT_BINDINGS, forward: "KeyG" });
  window.fire("keydown", { code: "KeyW" });
  expect(controls.inputAt(controls.take(1), 0).forward).toBe(0);
  window.fire("keydown", { code: "KeyG" });
  expect(controls.inputAt(controls.take(1), 0).forward).toBe(1);
});
test("the arrow keys and C still move and crouch whatever forward is bound to", () => {
  const { controls } = harness({ ...DEFAULT_BINDINGS, forward: "KeyG", duck: "KeyU" });
  const window = globals.window as Canvas;
  window.fire("keydown", { code: "ArrowUp" });
  expect(controls.inputAt(controls.take(1), 0).forward).toBe(1);
  window.fire("keydown", { code: "KeyC" });
  expect(controls.inputAt(controls.take(1), 0).duck).toBe(true);
});
test("under pointer lock, an unbound key is still kept off the browser — Tab cannot walk focus off the canvas", () => {
  const { controls } = harness();
  const window = globals.window as Canvas;
  let prevented = 0;
  const press = (code: string): void => window.fire("keydown", { code, preventDefault: () => { prevented += 1; } });
  press("Backquote"); // unbound, and not locked yet
  expect(prevented).toBe(0);
  controls.locked = true;
  press("Backquote"); // unbound, but the lock claims every key
  expect(prevented).toBe(1);
});
test("preventDefault follows the action, not the code: a jump rebound off Space no longer eats it", () => {
  const { controls } = harness({ ...DEFAULT_BINDINGS, jump: "KeyJ" });
  const window = globals.window as Canvas;
  let prevented = 0;
  window.fire("keydown", { code: "Space", preventDefault: () => { prevented += 1; } });
  expect(prevented).toBe(0);
  expect(controls.inputAt(controls.take(1), 0).jump).toBe(false);
  window.fire("keydown", { code: "KeyJ", preventDefault: () => { prevented += 1; } });
  expect(prevented).toBe(1);
  expect(controls.inputAt(controls.take(1), 0).jump).toBe(true);
});
@@ -1,332 +0,0 @@
/**
 * Input: keyboard and mouse under pointer lock, and a thumb stick and buttons
 * on a touch screen. It collects intent into the same Input the simulation
 * takes from a bot, and hands over accumulated mouse movement once a frame.
 *
 * Events are edges, and the loop only looks once a frame, so press.ts holds
 * the edges in between: a tap that starts and ends between two frames still
 * fires, exactly once.
 *
 * `lookX`/`lookY` accumulate in exactly two places — a locked mouse move and a
 * touch whose role is `look` — and both go through `lookDelta`, which is where
 * a pointer's movement becomes degrees of turn and the only place the scope's
 * zoom touches the mouse. Buttons never touch them; they only ever name an
 * action.
 */
import { clamp } from "./math.ts";
import { createPress, downAt, type Frame } from "./press.ts";
import { NO_INPUT, type Input } from "./world.ts";
import { DEFAULT_ZOOM_RATIO, lookScale } from "./zoom.ts";
/** Degrees of turn per pixel of locked mouse movement, at sensitivity 1. */
export const MOUSE_DEGREES = 0.022;
/** The same for a dragging finger, which travels far less than a mouse does. */
export const TOUCH_DEGREES = 0.06;
/**
 * Pure: the degrees of turn one pointer movement is worth. `perPixel` says
 * which pointer moved, and `scoped` with `zoomRatio` is the scope's share of
 * it — zoom.ts owns that relationship, this only applies it.
 */
export function lookDelta(
  movement: number,
  sensitivity: number,
  scoped: boolean,
  zoomRatio: number,
  perPixel: number = MOUSE_DEGREES,
): number {
  return movement * sensitivity * perPixel * lookScale(scoped, zoomRatio);
}
/** The controls a press of counts even if the release beat the next frame. */
export const LATCHED = ["fire", "jump", "use", "reload"];
export type Controls = {
  takeLook(): [number, number];
  /** The frame's intent, taken once before the fixed steps it is about to run. */
  take(steps: number): Frame;
  /** The Input for one step of a taken frame. The object is reused. */
  inputAt(frame: Frame, step: number): Input;
  readonly scoreboard: boolean;
  /** 1 primary, 2 pistol, 3 knife, 4 grenade — main knows what they are. */
  readonly slotWanted: 1 | 2 | 3 | 4 | null;
  sensitivity: number;
  /** The scope's share of that sensitivity while it is up — see zoom.ts. */
  zoomRatio: number;
  /**
   * Whether the person is looking down a scope right now. The loop sets it from
   * the world once a frame; the events in between scale their look by it, so the
   * worst a scope going up or down costs is the one frame it happened on.
   */
  scoped: boolean;
  locked: boolean;
  setAction(action: string, down: boolean): void;
  /** A rebind takes hold on the very next key event — no detach, no reload. */
  setBindings(bindings: Record<Action, string>): void;
  /**
   * Forget every intent not yet taken — held controls, latched presses and the
   * look that has piled up. What the focus, the pointer lock and the pause
   * overlay all want: nothing a player did while the game was not listening
   * should arrive on the first frame it listens again.
   */
  clear(): void;
  onBuy: () => void;
  onRadio: () => void;
  onPause: () => void;
  detach(): void;
};
/**
 * Every action a key can drive, and precisely today's map — the default a
 * corrupt or missing setting falls back to. `settings.ts` validates a stored
 * map against this same list; nothing else should invent an action name.
 */
export const ACTIONS = [
  "forward", "back", "left", "right", "jump", "duck", "walk",
  "reload", "use", "buy", "radio", "scoreboard", "scope",
  "slot1", "slot2", "slot3", "slot4",
] as const;
export type Action = typeof ACTIONS[number];
export const DEFAULT_BINDINGS: Record<Action, string> = {
  forward: "KeyW", back: "KeyS", left: "KeyA", right: "KeyD",
  jump: "Space", duck: "ControlLeft", walk: "ShiftLeft",
  reload: "KeyR", use: "KeyE", buy: "KeyB", radio: "KeyZ", scoreboard: "Tab", scope: "KeyQ",
  slot1: "Digit1", slot2: "Digit2", slot3: "Digit3", slot4: "Digit4",
};
/**
 * Codes no binding can claim: the arrow keys and `C` are a fixed movement and
 * crouch fallback, wired below regardless of what a player has bound, so a
 * rebind gone wrong is never a player who cannot move.
 */
export const RESERVED_CODES: ReadonlySet<string> =
  new Set(["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "KeyC"]);
/** Code to action, the fixed fallback last so nothing bound can ever shadow it. */
function reverseBindings(bindings: Record<Action, string>): Record<string, Action | "duck"> {
  const map: Record<string, Action | "duck"> = {};
  for (const action of ACTIONS) map[bindings[action]] = action;
  map.ArrowUp = "forward";
  map.ArrowDown = "back";
  map.ArrowLeft = "left";
  map.ArrowRight = "right";
  map.KeyC = "duck";
  return map;
}
export function createControls(
  canvas: HTMLCanvasElement, sensitivity = 2.2, bindings: Record<Action, string> = DEFAULT_BINDINGS,
  zoomRatio = DEFAULT_ZOOM_RATIO,
): Controls {
  const press = createPress(LATCHED);
  const input: Input = { ...NO_INPUT };
  let lookX = 0, lookY = 0;
  let reverse = reverseBindings(bindings);
  const controls: Controls = {
    takeLook() {
      const out: [number, number] = [lookX, lookY];
      lookX = 0;
      lookY = 0;
      return out;
    },
    take: (steps) => press.take(steps),
    inputAt(frame, step) {
      const on = (action: string): boolean => downAt(frame, action, step);
      input.forward = clamp(
        (frame.held.has("forward") ? 1 : 0) - (frame.held.has("back") ? 1 : 0) + stick.y, -1, 1);
      input.side = clamp(
        (frame.held.has("right") ? 1 : 0) - (frame.held.has("left") ? 1 : 0) + stick.x, -1, 1);
      input.duck = frame.held.has("duck");
      input.walk = frame.held.has("walk");
      input.scope = frame.held.has("scope");
      input.jump = on("jump");
      input.reload = on("reload");
      input.use = on("use");
      input.fire = on("fire");
      input.switchTo = null;
      return input;
    },
    get scoreboard(): boolean {
      return press.isDown("scoreboard");
    },
    get slotWanted(): 1 | 2 | 3 | 4 | null {
      return press.isDown("slot4") ? 4 : press.isDown("slot3") ? 3
        : press.isDown("slot2") ? 2 : press.isDown("slot1") ? 1 : null;
    },
    sensitivity,
    zoomRatio,
    scoped: false,
    locked: false,
    setAction: (action, down) => {
      if (down) press.down(action);
      else press.up(action);
      if (!down) return;
      // The actions that are a menu rather than a movement. `menu` is how a
      // touch screen reaches the pause overlay at all: pointer lock is the only
      // other thing that calls onPause, and a finger never takes the lock.
      if (action === "buy") controls.onBuy();
      else if (action === "radio") controls.onRadio();
      else if (action === "menu") controls.onPause();
    },
    setBindings: (next) => {
      reverse = reverseBindings(next);
    },
    clear: () => {
      press.clear();
      lookX = 0;
      lookY = 0;
    },
    onBuy: () => {},
    onRadio: () => {},
    onPause: () => {},
    detach: () => {
      window.removeEventListener("keydown", onKeyDown);
      window.removeEventListener("keyup", onKeyUp);
      document.removeEventListener("pointerlockchange", onLockChange);
    },
  };
  const stick = { x: 0, y: 0 };
  function onKeyDown(event: KeyboardEvent): void {
    const action = reverse[event.code];
    // Under pointer lock every key is the game's, whatever it is bound to:
    // an unbound Tab still switches focus off the canvas otherwise, and once
    // it has, a locked mouse is aiming at nothing the player can see move.
    if (controls.locked) event.preventDefault();
    if (action === undefined) return;
    // Whatever is bound to these two actions gets the default the browser
    // would otherwise take even without a lock: a scoreboard key that also
    // switches tabs, or a jump key that also scrolls the page.
    if (action === "scoreboard" || action === "jump") event.preventDefault();
    if (event.repeat) return;
    controls.setAction(action, true);
  }
  function onKeyUp(event: KeyboardEvent): void {
    const action = reverse[event.code];
    if (action !== undefined) controls.setAction(action, false);
  }
  function onLockChange(): void {
    controls.locked = document.pointerLockElement === canvas;
    if (!controls.locked) {
      controls.clear();
      controls.onPause();
    }
  }
  window.addEventListener("keydown", onKeyDown);
  window.addEventListener("keyup", onKeyUp);
  document.addEventListener("pointerlockchange", onLockChange);
  canvas.addEventListener("mousedown", (event) => {
    if (!controls.locked) return;
    event.preventDefault();
    controls.setAction(event.button === 2 ? "scope" : "fire", true);
  });
  window.addEventListener("mouseup", (event) => {
    controls.setAction(event.button === 2 ? "scope" : "fire", false);
  });
  canvas.addEventListener("contextmenu", (event) => event.preventDefault());
  window.addEventListener("mousemove", (event) => {
    if (!controls.locked) return;
    lookX += lookDelta(event.movementX, controls.sensitivity, controls.scoped, controls.zoomRatio);
    lookY += lookDelta(event.movementY, controls.sensitivity, controls.scoped, controls.zoomRatio);
  });
  window.addEventListener("blur", () => {
    controls.clear();
  });
  // --- touch: the left third is a stick, the rest of the canvas looks around,
  // and a second finger on the looking side is the trigger. That is the whole
  // of firing while aiming: the touch that steers keeps its own target for its
  // whole life, so a shot never costs the aim the thumb already has. A touch
  // that fires does not steer — a trigger finger twitches, and the aim should
  // not follow it.
  type Role = "stick" | "look" | "fire";
  type Held = { startX: number; startY: number; x: number; y: number; role: Role };
  const touches = new Map<number, Held>();
  const anyRole = (role: Role): boolean => {
    for (const held of touches.values()) if (held.role === role) return true;
    return false;
  };
  canvas.addEventListener("touchstart", (event) => {
    for (const touch of Array.from(event.changedTouches)) {
      const role: Role = touch.clientX < canvas.clientWidth * 0.38
        ? "stick"
        : anyRole("look") ? "fire" : "look";
      touches.set(touch.identifier, {
        startX: touch.clientX, startY: touch.clientY, x: touch.clientX, y: touch.clientY, role,
      });
      if (role === "fire") controls.setAction("fire", true);
    }
    event.preventDefault();
  }, { passive: false });
  canvas.addEventListener("touchmove", (event) => {
    for (const touch of Array.from(event.changedTouches)) {
      const state = touches.get(touch.identifier);
      if (state === undefined) continue;
      if (state.role === "stick") {
        stick.x = clamp((touch.clientX - state.startX) / 60, -1, 1);
        stick.y = clamp((state.startY - touch.clientY) / 60, -1, 1);
      } else if (state.role === "look") {
        // The same scaling a mouse gets: a drag under a scope is the same
        // problem, and a thumb has less screen to give away than a mouse does.
        const look = (movement: number): number =>
          lookDelta(movement, controls.sensitivity, controls.scoped, controls.zoomRatio, TOUCH_DEGREES);
        lookX += look(touch.clientX - state.x);
        lookY += look(touch.clientY - state.y);
      }
      state.x = touch.clientX;
      state.y = touch.clientY;
    }
    event.preventDefault();
  }, { passive: false });
  const endTouch = (event: TouchEvent): void => {
    for (const touch of Array.from(event.changedTouches)) {
      const state = touches.get(touch.identifier);
      touches.delete(touch.identifier);
      if (state === undefined) continue;
      if (state.role === "stick") {
        stick.x = 0;
        stick.y = 0;
      }
      // The last finger off the trigger is the one that releases it: a stuck
      // trigger on a phone is unrecoverable without reloading the page.
      if (state.role === "fire" && !anyRole("fire")) controls.setAction("fire", false);
    }
  };
  canvas.addEventListener("touchend", endTouch);
  canvas.addEventListener("touchcancel", endTouch);
  return controls;
}
/**
 * The buttons a touch screen needs, wired to the same actions as the keys. A
 * thumb is quicker than a frame, so the press goes down on pointerdown and up
 * on pointerup and the latch sees to it that a step counts it.
 */
export function attachButtons(root: ParentNode, controls: Controls): void {
  for (const element of Array.from(root.querySelectorAll<HTMLElement>("[data-action]"))) {
    const action = element.dataset.action as string;
    // preventDefault keeps the browser from making a second event out of a
    // touch, which also costs the button its :active state — so the class is
    // the one that says "held", and a held control looks held.
    const down = (event: Event): void => {
      event.preventDefault();
      element.classList.add("on");
      controls.setAction(action, true);
    };
    const up = (event: Event): void => {
      event.preventDefault();
      element.classList.remove("on");
      controls.setAction(action, false);
    };
    element.addEventListener("pointerdown", down);
    element.addEventListener("pointerup", up);
    element.addEventListener("pointercancel", up);
    element.addEventListener("pointerleave", up);
  }
}
@@ -1,96 +0,0 @@
/**
 * The arithmetic of drawing between two ticks, on its own: no world, no GL.
 * What matters here is the seam in the circle, the two ends of the blend being
 * exactly the states they are blends of, and a teleport never being a slide.
 */
import { expect, test } from "bun:test";
import { TICK } from "./loop.ts";
import {
  alphaOf, between, drawnAt, lerpPos, lerpYaw, pose, remember, rememberPos, teleported, TELEPORT,
} from "./interpolate.ts";
import type { Vec3 } from "./math.ts";
test("alpha is the sub-tick remainder, clamped, and a nonsense clock draws the newest tick", () => {
  expect(alphaOf(TICK / 2, TICK)).toBeCloseTo(0.5, 12);
  expect(alphaOf(0, TICK)).toBe(0);
  // A backlog would draw a future the world has not simulated yet.
  expect(alphaOf(TICK * 3, TICK)).toBe(1);
  expect(alphaOf(-1, TICK)).toBe(0);
  expect(alphaOf(NaN, TICK)).toBe(1);
  expect(alphaOf(TICK / 2, 0)).toBe(1);
});
test("a position is lerped, and both ends are exactly the state they came from", () => {
  const prev: Vec3 = [0.1, -4, 10];
  const now: Vec3 = [0.2, 4, 12];
  const out: Vec3 = [0, 0, 0];
  expect(lerpPos(prev, now, 0.5, out)).toEqual([0.15000000000000002, 0, 11]);
  // Exact, not "close to": a frame at the end of a tick draws the tick, and a
  // renderer must not wobble by a float's last bit for interpolating at all.
  expect(lerpPos(prev, now, 1, out)).toEqual(now);
  expect(lerpPos(prev, now, 0, out)).toEqual(prev);
  // It writes into what it was given and returns it — no tuple is allocated.
  expect(lerpPos(prev, now, 0.5, out)).toBe(out);
});
test("a yaw goes the short way round the circle, not the long way", () => {
  // The seam: −170° to +170° is 20° through south, and the midpoint is 180°.
  expect(lerpYaw(-170, 170, 0.5)).toBeCloseTo(-180, 9);
  expect(lerpYaw(170, -170, 0.5)).toBeCloseTo(180, 9);
  // A quarter of the way over the seam is five degrees, not eighty-five.
  expect(lerpYaw(-170, 170, 0.25)).toBeCloseTo(-175, 9);
  // And the ordinary case is the ordinary answer, both ends exact.
  expect(lerpYaw(10, 50, 0.5)).toBeCloseTo(30, 9);
  expect(lerpYaw(10, 50, 1)).toBe(50);
  expect(lerpYaw(10, 50, 0)).toBe(10);
});
test("a move is interpolated and a teleport snaps", () => {
  const walked: Vec3 = [0, 0, 0];
  const step: Vec3 = [4, 0, 0]; // a tick of running, about
  expect(teleported(walked, step)).toBe(false);
  // A spawn across the map, a respawn, anything further than a tick of walking.
  expect(teleported(walked, [0, 2000, 0])).toBe(true);
  expect(teleported(walked, [TELEPORT + 1, 0, 0])).toBe(true);
  expect(teleported(walked, [TELEPORT, 0, 0])).toBe(false);
  const out: Vec3 = [0, 0, 0];
  expect(lerpPos(walked, [0, 2000, 0], 0.5, out)).toEqual([0, 2000, 0]);
});
test("a pose blends both halves, and a teleport takes the newest of both", () => {
  const prev = pose([0, 0, 0], 0);
  const now = { pos: [10, 0, 0] as Vec3, yaw: 90 };
  const out = pose();
  expect(between(prev, now, 0.5, out)).toBe(out);
  expect(out.pos).toEqual([5, 0, 0]);
  expect(out.yaw).toBeCloseTo(45, 9);
  // Teleported: the yaw does not creep round either, because the body that
  // arrived is facing the way it is facing and was never turning to get there.
  const far = { pos: [900, 0, 0] as Vec3, yaw: 90 };
  between(prev, far, 0.5, out);
  expect(out.pos).toEqual([900, 0, 0]);
  expect(out.yaw).toBe(90);
});
test("remembering is written into the tuples that are already there", () => {
  const prev = pose([1, 2, 3], 45);
  const held = prev.pos;
  remember(prev, { pos: [9, 8, 7], yaw: -20 });
  expect(prev.pos).toEqual([9, 8, 7]);
  expect(prev.yaw).toBe(-20);
  expect(prev.pos).toBe(held); // the same array: a tick allocates nothing
  const spot: Vec3 = [0, 0, 0];
  rememberPos(spot, [5, 6, 7]);
  expect(spot).toEqual([5, 6, 7]);
});
test("the clock a frame is drawn on is behind the simulation, never ahead of it", () => {
  expect(drawnAt(10, 1, TICK)).toBe(10);
  expect(drawnAt(10, 0, TICK)).toBeCloseTo(10 - TICK, 12);
  expect(drawnAt(10, 0.5, TICK)).toBeCloseTo(10 - TICK / 2, 12);
  expect(drawnAt(10, NaN, TICK)).toBe(10);
});
@@ -1,117 +0,0 @@
/**
 * What is drawn between two ticks.
 *
 * The world steps at a fixed 64 Hz and a screen draws at 60, 120 or whatever
 * else it feels like, so most frames land partway between two states. This is
 * the arithmetic that puts them there: `alpha` is the sub-tick remainder the
 * loop already hands back, 0 being the state the previous tick left and 1 the
 * state the newest one did, and everything here is exact at both ends — a
 * frame drawn at `alpha` of 1 is the same numbers as no interpolation at all.
 *
 * Two rules it keeps:
 *
 * - A yaw goes the short way round the circle. −170° to +170° is 20° across
 *   the seam, not 340° the long way, so a player turning through south does
 *   not spin all the way back.
 * - A teleport snaps. A round start, a respawn or anything that moves further
 *   in one tick than a body could have walked is not a move to draw halfway
 *   through: past `TELEPORT` the newest state is drawn and nothing slides.
 *
 * It is pure — no world, no GL, no clock — and it writes into the tuples it is
 * given rather than returning new ones, because a renderer calls it once per
 * player per frame and nothing here may allocate.
 */
import { angleDelta, clamp, type Vec3 } from "./math.ts";
/** Where something was and which way it faced: everything a mesh is placed by. */
export type Pose = { pos: Vec3; yaw: number };
/**
 * Further apart than one tick of movement can be. A player runs at 250 u/s and
 * falls no faster than a grenade flies at 780, which is 12 units in a 64 Hz
 * tick; 64 units a tick is 4096 u/s, which nothing in this game does. Past it,
 * the two states are two places, not a path between them.
 */
export const TELEPORT = 64;
/** A fresh pose at the origin. Made once per thing that moves, never per tick. */
export const pose = (pos: Vec3 = [0, 0, 0], yaw = 0): Pose => ({ pos: [pos[0], pos[1], pos[2]], yaw });
/**
 * How far into the tick this frame is, from the accumulator `advance` returns.
 * Clamped to [0, 1]: a backlog would draw the future, which is worse than
 * drawing the past, and anything that is not a number draws the newest state.
 */
export function alphaOf(accumulator: number, tick: number): number {
  if (!Number.isFinite(accumulator) || !Number.isFinite(tick) || tick <= 0) return 1;
  return clamp(accumulator / tick, 0, 1);
}
/** Partway between two numbers, and exactly one of them at either end. */
const mix = (a: number, b: number, alpha: number): number =>
  alpha <= 0 ? a : alpha >= 1 ? b : a + (b - a) * alpha;
/** Is this a step, or a jump? Squared, so a frame never pays for a square root. */
export function teleported(a: Vec3, b: Vec3, limit: number = TELEPORT): boolean {
  const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
  return dx * dx + dy * dy + dz * dz > limit * limit;
}
/** Partway round the circle from `a` to `b`, the short way, in degrees. */
export const lerpYaw = (a: number, b: number, alpha: number): number =>
  alpha <= 0 ? a : alpha >= 1 ? b : a + angleDelta(a, b) * alpha;
/**
 * Partway from `prev` to `now`, written into `out` (which may be `out === now`
 * for a caller that has nowhere else to put it). A teleport is the newest
 * state and no blend at all.
 */
export function lerpPos(prev: Vec3, now: Vec3, alpha: number, out: Vec3): Vec3 {
  if (teleported(prev, now)) {
    out[0] = now[0];
    out[1] = now[1];
    out[2] = now[2];
    return out;
  }
  out[0] = mix(prev[0], now[0], alpha);
  out[1] = mix(prev[1], now[1], alpha);
  out[2] = mix(prev[2], now[2], alpha);
  return out;
}
/**
 * The pose to draw something at: its position lerped and its yaw turned the
 * short way, or the newest of both where it teleported. `now` is whatever
 * carries a `pos` and a `yaw` — a player is one already.
 */
export function between(prev: Pose, now: Pose, alpha: number, out: Pose): Pose {
  const jumped = teleported(prev.pos, now.pos);
  lerpPos(prev.pos, now.pos, alpha, out.pos);
  out.yaw = jumped ? now.yaw : lerpYaw(prev.yaw, now.yaw, alpha);
  return out;
}
/** Write `now` into the pose kept for it: the one copy a tick is allowed to make. */
export function remember(prev: Pose, now: Pose): void {
  prev.pos[0] = now.pos[0];
  prev.pos[1] = now.pos[1];
  prev.pos[2] = now.pos[2];
  prev.yaw = now.yaw;
}
/** The same for something with a position and no facing: a grenade, the bomb. */
export function rememberPos(prev: Vec3, now: Vec3): void {
  prev[0] = now[0];
  prev[1] = now[1];
  prev[2] = now[2];
}
/**
 * The clock a frame is drawn on: the previous tick's time plus `alpha` of a
 * tick. Animations measured off `world.time` — a body toppling, say — advance
 * by the frame rather than by the step when they use this, and it is never
 * ahead of the simulation, so nothing is drawn before it happened.
 */
export const drawnAt = (time: number, alpha: number, tick: number): number =>
  time - tick * (1 - clamp(Number.isFinite(alpha) ? alpha : 1, 0, 1));
@@ -0,0 +1,69 @@
/**
 * The map digest, held to the three things `replay.test.ts` leans on it for: a
 * level folds to the same number twice, a single cell somewhere else is a
 * different number, and the complaint names the band that cell is in.
 *
 * Nothing here plays a round — that is next door. This is the instrument, not
 * the claim: 40 rows of letters, folded, in a millisecond.
 */
import { expect, test } from "bun:test";
import { generateLevel } from "./generate.ts";
import { compare, layout, rowsOf, ROWS_PER_BAND, type MapPin } from "./layout.ts";
import { DE_FORGE } from "./map.ts";
import type { Cell, Level } from "./level.ts";
const pinOf = (level: Level): MapPin => {
  const folded = layout(level);
  return {
    label: level.name, constant: "A_MAP", list: "A_MAP_BANDS",
    digest: folded.digest, bands: folded.bands,
  };
};
/** The same level with one cell rubbed out, without touching the one it came from. */
const withCellAt = (level: Level, col: number, row: number, cell: Cell): Level => {
  const cells = [...level.grid.cells];
  cells[row * level.grid.width + col] = cell;
  return { ...level, grid: { ...level.grid, cells } };
};
test("a level folds to a digest, and the same level folds to the same one", () => {
  const a = layout(generateLevel(24));
  const b = layout(generateLevel(24));
  expect(a.digest).toBe(b.digest);
  expect(a.bands).toEqual(b.bands);
  expect(a.rows).toBe(generateLevel(24).grid.height);
  expect(a.bands.length).toBe(a.rows / ROWS_PER_BAND);
  expect(compare(a, pinOf(generateLevel(24)))).toBe(null);
});
test("two seeds are two digests, and de_forge is neither", () => {
  const seeds = [layout(generateLevel(24)).digest, layout(generateLevel(37)).digest, layout(DE_FORGE).digest];
  expect(new Set(seeds).size).toBe(3);
});
test("one cell moved is a digest moved, and the complaint says which band it is in", () => {
  const level = generateLevel(24);
  const pin = pinOf(level);
  // Row 30 is in the fourth band of ten rows; the cell is floor on this map.
  const moved = withCellAt(level, 20, 30, "#");
  const why = compare(layout(moved), pin) as string;
  expect(why).not.toBe(null);
  expect(why).toContain("band 4 of 4");
  expect(why).toContain("src/client/replay.test.ts");
  expect(why).toContain("const A_MAP = ");
  expect(why).toContain("const A_MAP_BANDS = ");
  // The bands the change is not in are the bands they were.
  expect(layout(moved).bands.slice(0, 3)).toEqual([...pin.bands].slice(0, 3));
  // And the file the digest is committed in is the caller's to say.
  expect(compare(layout(moved), pin, "src/client/generate.test.ts")).toContain("src/client/generate.test.ts");
});
test("a page of letters is one string a row, each as wide as the grid", () => {
  const level = generateLevel(37);
  const rows = rowsOf(level.grid);
  expect(rows.length).toBe(level.grid.height);
  for (const row of rows) expect(row.length).toBe(level.grid.width);
  expect(rows.join("")).toBe(level.grid.cells.join(""));
});
@@ -0,0 +1,93 @@
/**
 * A level folded into a digest: the place, pinned, the way `replay.ts` pins the
 * play on it.
 *
 * A match on a generated map is two claims at once — that this seed still
 * carves *this* place, and that the simulation on it still runs the way it ran.
 * A single digest over the round confuses them: the generator gains a crate,
 * every tick of the round moves, and the failure reads like the physics
 * changed. So the map gets a number of its own, taken first, and the round's
 * digest is only ever read on a map that still matches. `replay.test.ts` asks
 * them in that order and says which of the two moved.
 *
 * What is hashed is the letters, one row a line, and nothing else. Everything
 * else a `Level` carries — the boxes, the spawns, the sites, the walls a bullet
 * stops in — is `levelOf` reading those letters, so a grid that folds to the
 * same digest is the same place to play in. What the place is *painted* with is
 * not in here: a look is the seed's and is pinned beside the mesh in
 * `generate.test.ts`, and a repaint is not a map that plays differently.
 *
 * The arithmetic is the engine's `fold` and `compare`, the same instrument and
 * the same complaint the rounds are pinned with — rows of letters where they
 * hand it ticks of a world.
 */
import { compare as complain, fold as foldRows, type Grid } from "../engine/index.ts";
import type { Level } from "./level.ts";
/**
 * How many rows one checkpoint covers: four bands over a generated map, which
 * is forty rows on a side. The digest is of every row whatever the height; a
 * map whose height is not a whole number of bands has its last few rows in the
 * digest and in no band, which is the engine's rule for a part-checkpoint.
 */
export const ROWS_PER_BAND = 10;
/** A level's cells as a page of letters, one string a row. */
export const rowsOf = (grid: Grid<string>): string[] =>
  Array.from({ length: grid.height }, (_, r) => grid.cells.slice(r * grid.width, (r + 1) * grid.width).join(""));
export type Layout = {
  /** sha256 of every row of letters, hex. */
  digest: string;
  /** One short digest per band of `ROWS_PER_BAND` rows, for finding where two maps part. */
  bands: string[];
  rows: number;
};
/** A map digest committed in the repository, and what to call it when it moves. */
export type MapPin = {
  /** What this map is called in the first sentence of a complaint. */
  label: string;
  /** The constant the whole digest is committed as. */
  constant: string;
  /** The constant the bands are committed as, beside it. */
  list: string;
  digest: string;
  bands: readonly string[];
};
/** Fold a level's cells into a digest, checkpointing every `ROWS_PER_BAND` rows. */
export function layout(level: Level): Layout {
  const rows = rowsOf(level.grid);
  let at = 0;
  const run = foldRows({
    ticks: rows.length,
    step: (row) => void (at = row),
    // A row is a fixed number of cells, so the letters need no separator to be
    // read back apart: what goes in is exactly the page a terminal prints.
    line: () => rows[at] as string,
    every: ROWS_PER_BAND,
  });
  return { digest: run.digest, bands: run.checkpoints, rows: run.ticks };
}
/**
 * Why a map and its pin differ, or null if they do not. The engine finds the
 * band that first went another way and prints the constant to paste; what this
 * adds is what it cannot know — that a checkpoint here is ten rows of cells and
 * that what moved is the generator rather than the game.
 */
export function compare(map: Layout, pin: MapPin, file = "src/client/replay.test.ts"): string | null {
  return complain(
    { digest: map.digest, checkpoints: map.bands, ticks: map.rows },
    { label: `map ${pin.label}`, constant: pin.constant, digest: pin.digest, checkpoints: pin.bands },
    {
      file,
      list: pin.list,
      hashes: "every cell the generator carved, one row of letters a line",
      every: ROWS_PER_BAND,
      unit: "band",
    },
  );
}
@@ -0,0 +1,192 @@
/**
 * A level is a value, and this file is the proof: an eleven-by-nine box room,
 * written out here and nowhere else, is handed to `createWorld` and the game
 * plays on it. A bot paths from one spawn to the other, walks, and stays inside
 * walls de_forge has never heard of; a bullet stops in one of them. Nothing
 * under `src/client/` changed to allow it — the room only has to be a `Level`.
 *
 * The invariants every level owes are checked here once, over both levels: a
 * spawn you cannot stand on, a site off the edge of the grid or a box hanging
 * outside the floor are bugs in a map, and the test that catches them should
 * not have to be written again for the second one.
 */
import { expect, test } from "bun:test";
import { readdirSync, readFileSync } from "node:fs";
import { join } from "node:path";
import { traceBullet } from "./combat.ts";
import { mergeSolid, worldOf as gridWorldOf, type Grid, type Vec3 } from "../engine/index.ts";
import {
  colOf, findPath, openCells, rowOf, siteAt, walkable, worldOf, type Level,
} from "./level.ts";
import { DE_FORGE } from "./map.ts";
import { SHORT } from "./match.ts";
import { applyInput, createWorld, type Player } from "./world.ts";
import { botThink } from "./bots.ts";
// --- a second level, built here ------------------------------------------
const CELL = 128;
const WALL = 256;
/**
 * One room, drawn as it is played: `#` is wall, `t` and `c` are the two spawns,
 * `A` and `B` are the two bombsites a defusal level has by definition, and a
 * dot is floor. Eleven cells east by nine south, which is 1,408 by 1,152 units.
 */
const ROWS = [
  "###########",
  "#t.......A#",
  "#.........#",
  "#.........#",
  "#.........#",
  "#.........#",
  "#.........#",
  "#c.......B#",
  "###########",
];
const GRID: Grid<string> = {
  width: ROWS[0]!.length,
  height: ROWS.length,
  cell: CELL,
  cells: ROWS.flatMap((row) => [...row]),
};
/** The room's whole alphabet: everything that is not rock can be walked on. */
const passable = (cell: string): boolean => cell !== "#";
const halfX = (GRID.width / 2) * CELL;
const halfY = (GRID.height / 2) * CELL;
/**
 * Where the one cell carrying `letter` sits in the world. The four places are
 * read back off the grid rather than written twice, so the room cannot disagree
 * with the picture above — which is the same trick de_forge plays.
 */
function place(letter: string): Vec3 {
  const at = GRID.cells.indexOf(letter);
  return gridWorldOf(GRID, at % GRID.width, Math.floor(at / GRID.width));
}
const ROOM: Level = {
  name: "de_room",
  grid: GRID,
  passable,
  wallHeight: WALL,
  look: "room",
  materials: { FLOOR: 0, WALL: 1 },
  boxes: [
    { min: [-halfX, -halfY, -32], max: [halfX, halfY, 0], mat: 0 },
    ...mergeSolid(GRID, (cell) => cell === "#", 0, WALL, 1),
  ],
  spawns: { t: [place("t")], ct: [place("c")] },
  sites: { A: place("A"), B: place("B") },
  siteCells: { A: "A", B: "B" },
};
// --- what every level owes ------------------------------------------------
/** Why this level is not one, or nothing at all. Every level answers this. */
function problems(level: Level): string[] {
  const bad: string[] = [];
  for (const [team, spots] of Object.entries(level.spawns))
    for (const spot of spots)
      if (!walkable(level, colOf(level, spot[0]), rowOf(level, spot[1])))
        bad.push(`${level.name}: a ${team} spawn at ${spot} is not walkable`);
  for (const [name, site] of Object.entries(level.sites))
    if (siteAt(level, site) !== name) bad.push(`${level.name}: site ${name} at ${site} is not on ${name}`);
  const { width, height, cell } = level.grid;
  const edge: [number, number] = [(width / 2) * cell, (height / 2) * cell];
  for (const box of level.boxes)
    // `0 | 1` and not `number`: an axis of a Vec3 is one of two, and naming
    // them is what makes the reads below numbers rather than maybes.
    for (const axis of [0, 1] as const)
      if (box.min[axis] < -edge[axis] || box.max[axis] > edge[axis])
        bad.push(`${level.name}: a box runs from ${box.min} to ${box.max}, outside the grid`);
  return bad;
}
test("both levels keep the promises the type makes: spawns, sites, boxes", () => {
  expect(problems(DE_FORGE)).toEqual([]);
  expect(problems(ROOM)).toEqual([]);
  // And the check bites: a spawn in the wall and a box off the edge are named.
  const broken: Level = {
    ...ROOM,
    spawns: { t: [worldOf(ROOM, 0, 0)], ct: ROOM.spawns.ct },
    boxes: [{ min: [-9999, 0, 0], max: [0, 0, 0], mat: 0 }],
  };
  expect(problems(broken).length).toBe(2);
});
test("the room is a grid, a predicate and eleven boxes of geometry", () => {
  expect(ROOM.grid.cells.length).toBe(11 * 9);
  expect(walkable(ROOM, 1, 1)).toBe(true);
  expect(walkable(ROOM, 0, 0)).toBe(false);
  expect(walkable(ROOM, -1, 4)).toBe(false); // off the edge is not a cell
  expect(siteAt(ROOM, ROOM.sites.A)).toBe("A");
  expect(siteAt(ROOM, ROOM.sites.B)).toBe("B");
  expect(openCells(ROOM).length).toBe(9 * 7);
});
test("only the map and the entry name de_forge: everything else is handed a level", () => {
  // The whole point of the type. A module that reaches for `DE_FORGE` is a
  // module that has decided which map the game is on, and only the file that
  // builds it and the file that starts the game get to decide that.
  const mine = import.meta.dir;
  const allowed = new Set(["map.ts", "main.ts"]);
  const offenders = readdirSync(mine)
    .filter((file) => file.endsWith(".ts") && !file.includes(".test"))
    .filter((file) => !allowed.has(file) && readFileSync(join(mine, file), "utf8").includes("DE_FORGE"));
  expect(offenders).toEqual([]);
});
// --- and the game played on it --------------------------------------------
test("a path crosses the room, cell by cell, without leaving it", () => {
  const path = findPath(ROOM, ROOM.spawns.t[0]!, ROOM.spawns.ct[0]!);
  expect(path.length).toBeGreaterThan(4);
  for (let i = 1; i < path.length; i++)
    expect(Math.hypot(path[i]![0] - path[i - 1]![0], path[i]![1] - path[i - 1]![1])).toBeLessThan(CELL * 1.5);
  for (const step of path) expect(walkable(ROOM, colOf(ROOM, step[0]), rowOf(ROOM, step[1]))).toBe(true);
});
test("a world on the room is a world on the room, and its bot walks it", () => {
  const world = createWorld(ROOM, SHORT, "me", "ct", 1, 5);
  expect(world.level).toBe(ROOM);
  // The bot spawns on the room's T spawn, not on de_forge's.
  const bot = world.players.find((p) => p.bot) as Player;
  expect([bot.pos[0], bot.pos[1]]).toEqual([ROOM.spawns.t[0]![0], ROOM.spawns.t[0]![1]]);
  expect(siteAt(ROOM, bot.pos)).toBe(null);
  // Three seconds of it thinking and moving, with nobody to shoot at: the round
  // rules are left out on purpose, because a lone bot ends the round at once.
  world.match.phase = "live";
  world.me.alive = false;
  const from: [number, number] = [bot.pos[0], bot.pos[1]];
  for (let tick = 0; tick < 64 * 3; tick++) {
    world.time += 1 / 64;
    applyInput(world, bot, botThink(world, bot, 1 / 64), 1 / 64);
  }
  // It walked, on a path made of this room's cells, and this room's walls —
  // not de_forge's — are what kept it inside.
  expect(Math.hypot(bot.pos[0] - from[0], bot.pos[1] - from[1])).toBeGreaterThan(200);
  const path = (bot.brain as { path: Vec3[] }).path;
  expect(path.length).toBeGreaterThan(1);
  for (const step of path)
    expect(walkable(ROOM, colOf(ROOM, step[0]), rowOf(ROOM, step[1]))).toBe(true);
  expect(Math.abs(bot.pos[0])).toBeLessThan(halfX);
  expect(Math.abs(bot.pos[1])).toBeLessThan(halfY);
});
test("a bullet fired across the room stops in the room's own wall", () => {
  const world = createWorld(ROOM, SHORT, "me", "ct", 1, 9);
  const from: [number, number, number] = [0, 0, 64];
  // Due east: the east wall's inner face is the west side of column 10, at
  // (10 - 5.5 + 0.5) * 128 - 64 = 576 units.
  const hit = traceBullet(from, [8192, 0, 64], world.level.boxes, [], -1);
  expect(hit.kind).toBe("world");
  if (hit.kind !== "world") return;
  expect(hit.point[0]).toBeCloseTo(576, 6);
  expect(hit.normal).toEqual([-1, 0, 0]);
});
@@ -0,0 +1,107 @@
/**
 * What a level is, as one value: a grid of lettered cells, what a letter means,
 * the boxes that grid merges into, where each side spawns, where the two sites
 * are, and the numbers it was built at. `map.ts` builds de_forge as one of
 * these and `createWorld` is handed it, so a second map, a second mode or a
 * four-cell test room is a second value rather than a second module.
 *
 * Nothing here knows de_forge's alphabet. A cell is a letter; which letters
 * exist and which of them a player may stand on is the level's own `passable`,
 * and the arithmetic and the algorithms under it — cell to world, meshing, A* —
 * are the engine's `src/engine/grid.ts`, which knows less still.
 *
 * Everything below takes the level first and reads it once. These are the
 * questions the simulation asks every tick, so they stay flat: a lookup here is
 * a bounds check and a multiply, never a search.
 */
import * as g from "../engine/index.ts";
import type { Box, Grid, Vec3 } from "../engine/index.ts";
/** The tracer owns the box; a level hands it out, because that is what a level is made of. */
export type { Box } from "../engine/index.ts";
/** A cell is a letter. What the letters are, and what each one means, is a level's own. */
export type Cell = string;
export type Level = {
  /** What to call it in a log or a test failure. */
  readonly name: string;
  /** The cells, row-major, with the world arithmetic that goes with them. */
  readonly grid: Grid<Cell>;
  /** May a player stand on this cell? The whole of what the search knows about the alphabet. */
  readonly passable: (cell: Cell) => boolean;
  /** How tall a wall stands, in world units. */
  readonly wallHeight: number;
  /**
   * What this level is dressed in: the name of the set of materials below, out
   * of `looks.ts`. A level carries it rather than a global holding it, so two
   * levels in one process — the menu's preview and the match's map — can wear
   * different ones, and a name that says "gen_14u5j6g looks like this" is the
   * level's own word rather than a lookup somebody has to repeat.
   */
  readonly look: string;
  /**
   * The material ids this level's boxes are tagged with, by name: which layer
   * of the atlas its floor, its walls, its cover and its sites are painted
   * from. Every box in `boxes` is already tagged with one of these — this is
   * the reader's index to them, not a second source of truth.
   */
  readonly materials: Readonly<Record<string, number>>;
  /** Everything solid, in one list: the renderer draws it and bullets stop in it. */
  readonly boxes: Box[];
  /** Where each side starts a round, one point per spawn cell. */
  readonly spawns: { readonly t: Vec3[]; readonly ct: Vec3[] };
  /** The middle of each bombsite. */
  readonly sites: { readonly A: Vec3; readonly B: Vec3 };
  /** Which letter each site is paved with, so a point can be asked which site it stands in. */
  readonly siteCells: { readonly A: Cell; readonly B: Cell };
};
/** The cell at (col, row), or `undefined` off the edge — what is out there is the level's business. */
export const cellAt = (level: Level, col: number, row: number): Cell | undefined =>
  g.cellAt(level.grid, col, row);
/**
 * Can a player stand in this cell? Off the edge of a level is not a cell and so
 * is never walkable, whatever the level's border is made of.
 */
export function walkable(level: Level, col: number, row: number): boolean {
  const { width, height, cells } = level.grid;
  if (col < 0 || row < 0 || col >= width || row >= height) return false;
  return level.passable(cells[row * width + col] as Cell);
}
/** Grid coordinates are north-down; the world is Y-north, centred on zero. */
export const worldOf = (level: Level, col: number, row: number, z = 0): Vec3 =>
  g.worldOf(level.grid, col, row, z);
export const colOf = (level: Level, x: number): number => g.colOf(level.grid, x);
export const rowOf = (level: Level, y: number): number => g.rowOf(level.grid, y);
/** Which bombsite a point stands in, if any. */
export function siteAt(level: Level, pos: Vec3): "A" | "B" | null {
  const cell = cellAt(level, colOf(level, pos[0]), rowOf(level, pos[1]));
  if (cell === undefined) return null;
  if (cell === level.siteCells.A) return "A";
  if (cell === level.siteCells.B) return "B";
  return null;
}
/**
 * A* over the cells this level calls walkable, eight ways, no corner-cutting:
 * the search is the engine's and what a bot may stand on is the level's answer.
 * de_forge is 1936 cells, and 100 searches between random walkable cells average
 * 0.10 ms each, so a bot changing its goal mid-tick costs a tenth of what it has.
 */
export const findPath = (level: Level, from: Vec3, to: Vec3): Vec3[] =>
  g.findPath(level.grid, level.passable, from, to);
/** Every point a player can stand in, in reading order: what a spawn picker chooses from. */
export function openCells(level: Level, z = 0): Vec3[] {
  const out: Vec3[] = [];
  for (let row = 0; row < level.grid.height; row++)
    for (let col = 0; col < level.grid.width; col++)
      if (walkable(level, col, row)) out.push(worldOf(level, col, row, z));
  return out;
}
@@ -0,0 +1,136 @@
/**
 * The wallet's memory: what a round bought, what the round after buys back, and
 * the sentence it says about it. No page and no frame — a `Rounds` is a phase
 * and a round number, and a `Buyer` is the kit and the wallet, the way
 * `economy.test.ts` and `buy.test.ts` write them.
 */
import { expect, test } from "bun:test";
import { emptyAmmo, type Buyer } from "./economy.ts";
import { atRound, createLoadout, noteBuy, rebuy, saidRebuy, type Rounds } from "./loadout.ts";
import { ARMOR_PRICE, HELMET_PRICE, WEAPONS } from "./weapons.ts";
const round = (n: number, phase: "freeze" | "live" = "freeze"): Rounds => ({ match: { phase, round: n } });
const buyer = (over: Partial<Buyer> = {}): Buyer => ({
  team: "t", alive: true, money: 5000,
  armor: 0, helmet: false, defuseKit: false,
  weapon: "glock", primary: null, secondary: "glock",
  ammo: { knife: { mag: 0, reserve: 0 }, glock: emptyAmmo("glock") },
  pocket: { he: 0, flash: 0, smoke: 0 },
  ...over,
});
test("a round's purchases become the next round's rebuy, in the order they were made", () => {
  const loadout = createLoadout();
  atRound(loadout, 1);
  noteBuy(loadout, "ak47");
  noteBuy(loadout, "armor");
  noteBuy(loadout, "smoke");
  // Nothing to buy back yet: round one is the first round anybody bought in.
  expect(loadout.last).toEqual([]);
  atRound(loadout, 2);
  expect(loadout.last).toEqual(["ak47", "armor", "smoke"]);
  expect(loadout.bought).toEqual([]);
});
test("a round nobody bought anything in is a rebuy of nothing, not of two rounds ago", () => {
  const loadout = createLoadout();
  atRound(loadout, 1);
  noteBuy(loadout, "ak47");
  atRound(loadout, 2);
  atRound(loadout, 3);
  expect(loadout.last).toEqual([]);
  expect(saidRebuy(rebuy(round(3), buyer(), loadout), "t"))
    .toBe("Nothing to rebuy: you bought nothing last round.");
});
test("a rebuy buys last round's loadout again, through the shop, and says what it bought", () => {
  const loadout = createLoadout();
  atRound(loadout, 1);
  noteBuy(loadout, "ak47");
  noteBuy(loadout, "helmet");
  atRound(loadout, 2);
  const me = buyer({ money: WEAPONS.ak47.price + ARMOR_PRICE + HELMET_PRICE });
  const done = rebuy(round(2), me, loadout);
  expect(done.bought).toEqual(["ak47", "helmet"]);
  expect(done.short).toBeNull();
  // The kit is the kit the shop hands over, because the shop is what handed it:
  // the gun in your hands, the vest on, the helmet on, and nothing left.
  expect(me.primary).toBe("ak47");
  expect(me.helmet).toBe(true);
  expect(me.money).toBe(0);
  expect(saidRebuy(done, "t")).toBe("Rebought AK-47, Kevlar + Helmet.");
  // And it is this round's loadout now, so the round after buys the same again.
  expect(loadout.bought).toEqual(["ak47", "helmet"]);
});
test("a rebuy stops where the money runs out, and says what it could not afford", () => {
  const loadout = createLoadout();
  atRound(loadout, 1);
  noteBuy(loadout, "ak47");
  noteBuy(loadout, "helmet");
  atRound(loadout, 2);
  const me = buyer({ money: WEAPONS.ak47.price + 100 });
  const done = rebuy(round(2), me, loadout);
  expect(done.bought).toEqual(["ak47"]);
  expect(done.short).toBe("helmet");
  expect(me.money).toBe(100);
  expect(me.helmet).toBe(false);
  expect(saidRebuy(done, "t")).toBe("Rebought AK-47 — not enough for Kevlar + Helmet.");
  // And a wallet that cannot reach the first thing on the list buys none of it.
  const broke = buyer({ money: 10 });
  const none = rebuy(round(2), broke, createLoadoutWith(["ak47", "armor"]));
  expect(none.bought).toEqual([]);
  expect(broke.money).toBe(10);
  expect(saidRebuy(none, "t")).toBe("Nothing rebought — not enough for AK-47.");
});
/** A loadout that has already played a round: `last` is this list. */
function createLoadoutWith(last: ("ak47" | "armor")[]) {
  const loadout = createLoadout();
  atRound(loadout, 1);
  for (const item of last) noteBuy(loadout, item);
  atRound(loadout, 2);
  return loadout;
}
test("a gun you survived the round with is not bought twice", () => {
  const loadout = createLoadoutWith(["ak47", "armor"]);
  // Still holding the rifle, still wearing the vest: a rebuy is a no-op that
  // spends nothing, and it says so rather than pretending it bought something.
  const me = buyer({ money: 5000, primary: "ak47", armor: 100 });
  const done = rebuy(round(2), me, loadout);
  expect(done.bought).toEqual([]);
  expect(done.short).toBeNull();
  expect(me.money).toBe(5000);
  expect(saidRebuy(done, "t")).toBe("Nothing to rebuy: you still have last round's kit.");
});
test("armour you already have is stepped over rather than stopped at", () => {
  const loadout = createLoadout();
  atRound(loadout, 1);
  noteBuy(loadout, "armor");
  noteBuy(loadout, "ak47");
  atRound(loadout, 2);
  // The vest survived the round and the rifle did not: the vest is refused by
  // the shop, which is not the money running out, so the rifle is still bought.
  const me = buyer({ money: WEAPONS.ak47.price, armor: 100 });
  const done = rebuy(round(2), me, loadout);
  expect(done.bought).toEqual(["ak47"]);
  expect(me.primary).toBe("ak47");
});
test("a rebuy outside the freeze time, or dead, buys nothing at all", () => {
  const loadout = createLoadoutWith(["ak47"]);
  const me = buyer({ money: 5000 });
  expect(rebuy(round(2, "live"), me, loadout).bought).toEqual([]);
  expect(me.money).toBe(5000);
  const dead = buyer({ money: 5000, alive: false });
  expect(rebuy(round(2), dead, createLoadoutWith(["ak47"])).bought).toEqual([]);
  expect(dead.money).toBe(5000);
});
@@ -0,0 +1,115 @@
/**
 * What you bought, and buying it again. A round's purchases are written down in
 * the order they were made; the round after, that list is what one key buys
 * back — the same items in the same order, as far as the money goes.
 *
 * It spends through `buy()` in `economy.ts` and through nothing else: a rebuy is
 * the same purchases a player would have made by hand, made faster, so every
 * refusal the shop already has — the phase, the wallet, a pocket that is full, a
 * kit a T cannot carry — is the refusal a rebuy gets. What is added here is one
 * rule of its own: a gun you are still holding is not bought twice, because you
 * survived the round with it and money for a second copy of it is money burnt.
 *
 * It knows nothing about a page. The frame tells it which round it is on, the
 * panel tells it what was pressed, and what comes back is a plain result and a
 * sentence — which the frame shows in the HUD's message line and the panel
 * announces, and neither of them composes itself.
 */
import { labelOf } from "./buy.ts";
import { buy, canBuy, priceOf, type BuyItem, type Buyer, type Market } from "./economy.ts";
import type { Team } from "./match.ts";
/**
 * The round a rebuy happens in: whether the shop is open, which is `Market`, and
 * which round it is, which is what makes last round's list last round's. A
 * `World` satisfies it, and this file cannot reach back for one.
 */
export type Rounds = Market & { match: { round: number } };
/** What was bought this round, what was bought the round before, and which round that is. */
export type Loadout = {
  /** The round `bought` is being written for. */
  round: number;
  /** This round's purchases, oldest first. */
  bought: BuyItem[];
  /** The round before's, which is what a rebuy buys back. */
  last: BuyItem[];
};
export const createLoadout = (): Loadout => ({ round: 0, bought: [], last: [] });
/**
 * A round has begun. What was bought in the one before it becomes the rebuy and
 * the new round starts with an empty list — called every frame, because a round
 * where nothing was bought is a rebuy of nothing and a memory that rolled over
 * only when somebody bought something would hand out a two-round-old loadout.
 */
export function atRound(loadout: Loadout, round: number): void {
  if (round === loadout.round) return;
  loadout.last = loadout.bought;
  loadout.bought = [];
  loadout.round = round;
}
/** One purchase that went through, written down in the order it was made. */
export function noteBuy(loadout: Loadout, item: BuyItem): void {
  loadout.bought.push(item);
}
/** What a rebuy did: what it bought, what the money ran out on, and what it had to buy. */
export type Rebought = {
  /** The items bought back, in the order they were bought the first time. */
  bought: BuyItem[];
  /** The first item the wallet could not reach, which is where it stopped. */
  short: BuyItem | null;
  /** How many items last round's loadout held, so "nothing to rebuy" can say so. */
  had: number;
};
/** Do you already hold this gun? A second one of it is money for nothing. */
const holds = (player: Buyer, item: BuyItem): boolean =>
  player.primary === item || player.secondary === item;
/**
 * Buy last round's loadout again, in the order it was bought, and stop at the
 * first thing the money cannot reach — which is the order that gets the gun
 * before the vest, because that is the order a player bought them in.
 *
 * Anything else the shop refuses — armour already on, a pocket already holding
 * its grenade — is stepped over rather than stopped at: you have it, which is
 * not a reason to abandon the rest of the list.
 */
export function rebuy(market: Rounds, player: Buyer, loadout: Loadout): Rebought {
  atRound(loadout, market.match.round);
  const done: Rebought = { bought: [], short: null, had: loadout.last.length };
  if (!canBuy(market, player)) return done;
  for (const item of loadout.last) {
    if (holds(player, item)) continue;
    if (buy(market, player, item)) {
      loadout.bought.push(item);
      done.bought.push(item);
      continue;
    }
    // It did not happen. The wallet is why when the price is out of reach, and
    // that is where a rebuy stops; anything else is a thing you already have.
    if (priceOf(item, player) > player.money) {
      done.short = item;
      break;
    }
  }
  return done;
}
/** The one line a rebuy says: what it bought, or what it could not afford. */
export function saidRebuy({ bought, short, had }: Rebought, team: Team): string {
  const names = bought.map((item) => labelOf(item, team)).join(", ");
  if (short !== null)
    return bought.length === 0
      ? `Nothing rebought — not enough for ${labelOf(short, team)}.`
      : `Rebought ${names} — not enough for ${labelOf(short, team)}.`;
  if (bought.length > 0) return `Rebought ${names}.`;
  return had === 0
    ? "Nothing to rebuy: you bought nothing last round."
    : "Nothing to rebuy: you still have last round's kit.";
}
@@ -0,0 +1,84 @@
/**
 * The zoom compensation, against a hand calculation.
 *
 * The numbers below are worked out here rather than recomputed from the source
 * formula, which would only prove the code equals itself:
 *
 *   tan(20°) = 0.3639702342662024, tan(45°) = 1 (to a bit: 0.9999999999999999)
 *   scale    = tan(20°) / tan(45°) = 0.3639702342662024
 *
 * and a player at 2.2° of turn per count who moves the mouse 10 counts asks for
 * 22.0° of yaw unscoped, so scoped they get
 *
 *   22.0 × 0.3639702342662024 = 8.007345153856452°
 *
 * which is the same fraction of the screen: 22° is 22/90 = 24.4% of the
 * unscoped view's width in *angle*, but the screen is a tangent picture, and
 * what matches at both fields of view is the distance the crosshair moves
 * across it — checked below by projecting both turns onto their own screen.
 */
import { expect, test } from "bun:test";
import { FOV, fovFor, lookAt, SCOPED_FOV, zoomScale } from "./look.ts";
/** Degrees of turn per count, the menu's default and the number in the sums above. */
const SENSITIVITY = 2.2;
test("the default view is the sensitivity the player set, to the bit", () => {
  expect(zoomScale(FOV, FOV)).toBe(1);
  for (const delta of [0.123456789, -33.75, 1e-9, 1234.5678, 0]) {
    expect(lookAt(delta, FOV, FOV)).toBe(delta);
    expect(lookAt(delta, fovFor(false), FOV)).toBe(delta);
  }
});
test("the scope scales the turn by tan(fov/2) / tan(fovDefault/2)", () => {
  expect(zoomScale(SCOPED_FOV, FOV)).toBeCloseTo(0.3639702342662024, 15);
  // 10 counts × 2.2° each = 22°, and through the scope 8.0073°.
  const asked = 10 * SENSITIVITY;
  expect(lookAt(asked, FOV, FOV)).toBe(22);
  expect(lookAt(asked, SCOPED_FOV, FOV)).toBeCloseTo(8.007345153856452, 12);
  // The sign is the delta's: a turn left through a scope is still a turn left.
  expect(lookAt(-asked, SCOPED_FOV, FOV)).toBeCloseTo(-8.007345153856452, 12);
  // Twitchier, not calmer, was the bug: the scoped turn is under a third of
  // the way to the unscoped one, not more than twice as far.
  expect(lookAt(asked, SCOPED_FOV, FOV)).toBeLessThan(asked);
});
test("the same hand movement crosses the same fraction of the screen at either view", () => {
  // Where a turn of `deg` puts the crosshair on a screen of half-width
  // tan(fov/2), as a fraction of that half-width: tan(deg) / tan(fov/2).
  const acrossScreen = (deg: number, fov: number): number =>
    Math.tan((deg * Math.PI) / 180) / Math.tan((fov * Math.PI) / 360);
  // Small movements, where the tangent is near enough its angle that the ratio
  // of half-widths is the right scale: a quarter-count to two counts.
  for (const counts of [0.25, 0.5, 1, 2]) {
    const asked = counts * SENSITIVITY;
    const plain = acrossScreen(lookAt(asked, FOV, FOV), FOV);
    const scoped = acrossScreen(lookAt(asked, SCOPED_FOV, FOV), SCOPED_FOV);
    expect(scoped).toBeCloseTo(plain, 3);
  }
  // Without the scale it is the bug the ratio is for: the same 22° asked for
  // at 40° of view crosses 2.75 times as much screen as it does at 90°.
  expect(acrossScreen(22, SCOPED_FOV) / acrossScreen(22, FOV)).toBeCloseTo(2.747, 3);
});
test("it takes a field of view, not a flag, so a second zoom level is one number", () => {
  // A hypothetical second scope at 15°: nothing here has to change to scale it.
  // tan(7.5°) / tan(45°) = 0.13165249758739583.
  expect(zoomScale(15, FOV)).toBeCloseTo(0.13165249758739583, 15);
  expect(lookAt(22, 15, FOV)).toBeCloseTo(2.8963549469227083, 12);
  // Narrower is always slower, and the scale rises with the field of view.
  expect(zoomScale(15, FOV)).toBeLessThan(zoomScale(SCOPED_FOV, FOV));
  expect(zoomScale(SCOPED_FOV, FOV)).toBeLessThan(zoomScale(FOV, FOV));
  // And a wider view than the default is faster, which is the same formula
  // read the other way — a 120° view is tan(60°)/tan(45°) = 1.732.
  expect(zoomScale(120, FOV)).toBeCloseTo(Math.sqrt(3), 12);
});
test("the fields of view are the ones the camera uses", () => {
  expect(fovFor(true)).toBe(SCOPED_FOV);
  expect(fovFor(false)).toBe(FOV);
  expect([SCOPED_FOV, FOV]).toEqual([40, 90]);
});
@@ -0,0 +1,64 @@
/**
 * The look: the two fields of view this game is seen through, and what a
 * pointer movement is worth at each of them.
 *
 * The engine's controls hand back a turn in degrees, already scaled by the
 * player's sensitivity. They know nothing about scopes and must not — a scope
 * is this shooter's tuning, so the compensation lives here, beside the game's
 * other numbers, and is applied where the look is read.
 *
 * Pulling up the scope narrows the view from 90° to 40° across. With the same
 * degrees per count, the same hand movement then crosses more than twice as
 * much of the screen as it did unscoped — twitchy at exactly the moment a
 * player wants the opposite. Counter-Strike scales the sensitivity with the
 * zoom (`zoom_sensitivity_ratio`, 1.0 by default, which is this); `zoomScale`
 * below is that scale and `lookAt` is a turn taken through it.
 */
/** The field of view the game is played at: degrees, measured across the screen. */
export const FOV = 90;
/**
 * The one a scope brings on, in degrees across — the same 40 the AWP declares
 * as its `zoom` in `weapons.ts`, and the one `spectate.ts` eases the camera to.
 * A second zoom level is one more constant here and nothing else: everything
 * below takes a field of view, never a "scoped" flag, so a scope that is not
 * this one is a number passed to the camera and to `lookAt` together.
 */
export const SCOPED_FOV = 40;
/** Which of the two you are looking through. Degrees out, never a boolean on. */
export const fovFor = (scoped: boolean): number => (scoped ? SCOPED_FOV : FOV);
/**
 * How much of a turn survives the zoom — unitless, 1 at the default view:
 *
 *     scale = tan(fov / 2) / tan(fovDefault / 2)
 *
 * A half-angle's tangent is the half-width of what the screen shows at one unit
 * of depth, so the ratio is how much less world the zoomed screen holds. Turn
 * by that fraction of the degrees and a hand movement crosses the same fraction
 * of the screen at either field of view, which is the thing a player's muscle
 * memory is actually measured in. At 40° and 90°: tan20° / tan45° = 0.36397, so
 * a scoped turn is a little over a third of the unscoped one.
 *
 * Both angles are horizontal — the renderer derives the vertical one from the
 * aspect — so the same scale is right for pitch as for yaw.
 *
 * `fov` and `fovDefault` are degrees in (0, 180); the scale is a pure number.
 */
export const zoomScale = (fov: number, fovDefault: number): number =>
  Math.tan((fov * Math.PI) / 360) / Math.tan((fovDefault * Math.PI) / 360);
/**
 * The turn to take this frame: `delta` degrees of look asked for at the
 * player's sensitivity, taken through `fov` instead of the `fovDefault` that
 * sensitivity was set at. Degrees in, degrees out.
 *
 * At the default view this is the delta itself to the bit — `t / t` is exactly
 * 1 in IEEE 754 for any finite non-zero `t`, and a multiply by exactly 1 moves
 * nothing — so a player's sensitivity setting still means what it says when
 * they are not scoped.
 */
export const lookAt = (delta: number, fov: number, fovDefault: number): number =>
  delta * zoomScale(fov, fovDefault);
@@ -0,0 +1,119 @@
/**
 * The looks, measured rather than admired.
 *
 * A named set of materials is only worth having if a room dressed in it still
 * reads: cover has to stand off the floor and off the wall from across the
 * room, a bombsite has to read as painted ground rather than as more floor, and
 * a player has to be a shape against all three. Nine materials do not combine
 * freely, so every set in `looks.ts` is held to those distances here — against
 * the actual shaders in `materials.ts`, sampled, not against a colour somebody
 * wrote in a comment.
 *
 * The distance is a crude perceptual one: each material's mean colour over a
 * 32×32 sample of its shader, differenced with green weighted heaviest and blue
 * lightest, which is the order the eye weighs them in. It is not a colour
 * science; it is enough to tell "sand under wooden crates" (90) from "sand
 * under a sand crate" (0), which is the whole question being asked.
 */
import { expect, test } from "bun:test";
import { FORGE, LOOKS, lookFor, lookNamed, SKIN, FATIGUES, GEAR, type Look } from "./looks.ts";
import { LAYERS, MATERIALS } from "./materials.ts";
import { MAT } from "./cells.ts";
/** Each material's mean colour, its shader sampled over the square it is painted into. */
const MEAN: readonly [number, number, number][] = MATERIALS.map((shader) => {
  const N = 32;
  let r = 0, g = 0, b = 0;
  for (let i = 0; i < N; i++)
    for (let j = 0; j < N; j++) {
      const c = shader((i + 0.5) / N, (j + 0.5) / N);
      r += c[0]; g += c[1]; b += c[2];
    }
  return [r / (N * N), g / (N * N), b / (N * N)];
});
/** How far apart two materials look, 0 being the same surface. */
function apart(one: number, two: number): number {
  const a = MEAN[one] as [number, number, number], b = MEAN[two] as [number, number, number];
  return Math.hypot((a[0] - b[0]) * 0.6, (a[1] - b[1]) * 1.0, (a[2] - b[2]) * 0.4);
}
/**
 * The bars, and where they come from: de_forge is the map this game was tuned
 * on, and its own numbers are site/floor 70, cover/floor 90, cover/wall 63 and
 * floor/wall 31. A look may be quieter than de_forge but not by much — the
 * floors below are under every one of the eight and over every pairing that
 * failed to read when it was looked at.
 */
const SITE_OFF_FLOOR = 45;
const COVER_OFF_FLOOR = 45;
const COVER_OFF_WALL = 45;
const FLOOR_OFF_WALL = 30;
/** What a player is made of: the three materials `models.ts` builds one out of. */
const PLAYER = [SKIN, FATIGUES, GEAR];
test("every look is a set of materials this game has already painted", () => {
  expect(LOOKS.length).toBeGreaterThan(1);
  const names = LOOKS.map((look) => look.name);
  expect(new Set(names).size).toBe(names.length);
  for (const look of LOOKS) {
    expect(look.name).toMatch(/^[a-z]+$/);
    const roles = Object.keys(look.materials).sort();
    expect(roles).toEqual(["CRATE", "FLOOR", "METAL", "SITE", "WALL"]);
    for (const [role, mat] of Object.entries(look.materials)) {
      expect(Number.isInteger(mat)).toBe(true);
      expect(mat, `${look.name}.${role}`).toBeGreaterThanOrEqual(0);
      expect(mat, `${look.name}.${role}`).toBeLessThan(LAYERS);
    }
    expect(lookNamed(look.name)).toBe(look);
  }
  expect(lookNamed("nothing this game paints")).toBeUndefined();
});
test("whatever the look, a site reads as a site and cover reads as cover", () => {
  for (const look of LOOKS) {
    const { FLOOR, WALL, CRATE, SITE } = look.materials;
    const why = (what: string, d: number, bar: number): string =>
      `${look.name}: ${what} are ${d.toFixed(0)} apart, under the ${bar} a room needs to read`;
    expect(apart(SITE, FLOOR), why("its site and its floor", apart(SITE, FLOOR), SITE_OFF_FLOOR))
      .toBeGreaterThanOrEqual(SITE_OFF_FLOOR);
    expect(apart(CRATE, FLOOR), why("its cover and its floor", apart(CRATE, FLOOR), COVER_OFF_FLOOR))
      .toBeGreaterThanOrEqual(COVER_OFF_FLOOR);
    expect(apart(CRATE, WALL), why("its cover and its wall", apart(CRATE, WALL), COVER_OFF_WALL))
      .toBeGreaterThanOrEqual(COVER_OFF_WALL);
    expect(apart(FLOOR, WALL), why("its floor and its wall", apart(FLOOR, WALL), FLOOR_OFF_WALL))
      .toBeGreaterThanOrEqual(FLOOR_OFF_WALL);
  }
});
test("whatever the look, a player is a shape against it", () => {
  // A player is skin, fatigues and dark gear. A look may match one of the three
  // — a dark floor under a dark torso is a real place, and Counter-Strike is
  // full of them — but never two, or the silhouette a game is played on goes.
  for (const look of LOOKS)
    for (const [role, surface] of Object.entries(look.materials)) {
      if (role === "METAL") continue; // a name, not a surface: nothing is tagged with it
      const clear = PLAYER.filter((worn) => apart(worn, surface) >= 40);
      expect(clear.length, `${look.name}: a player is lost against its ${role.toLowerCase()}`)
        .toBeGreaterThanOrEqual(2);
    }
});
test("de_forge is dressed in exactly the materials it always was", () => {
  expect(FORGE.name).toBe("forge");
  expect(FORGE).toBe(LOOKS[0] as Look);
  expect(FORGE.materials).toEqual({ FLOOR: 0, WALL: 1, CRATE: 2, SITE: 3, METAL: 4 });
  expect(MAT).toEqual(FORGE.materials);
});
test("a seed is a look, for ever, and a run of seeds is not a run of looks", () => {
  for (const seed of [0, 1, 7, 4294967295]) expect(lookFor(seed)).toBe(lookFor(seed));
  // The seed is a uint32 and is treated as one, however it arrives.
  expect(lookFor(-1)).toBe(lookFor(4294967295));
  // Ten seeds in a row are not the table in order, which `seed % LOOKS.length`
  // would be: that is what the stirring in `lookFor` is for.
  const run = Array.from({ length: LOOKS.length }, (_, i) => lookFor(i).name);
  expect(run).not.toEqual(LOOKS.map((look) => look.name));
});
@@ -0,0 +1,90 @@
/**
 * What a map is dressed in: which of the nine materials in the atlas its floor,
 * its walls, its cover and its bombsites are painted with, as a handful of
 * named sets rather than an index per surface.
 *
 * The atlas is painted once at boot and never repainted, and a box in a level
 * mesh carries a layer number. So a generated map can *look* like its own place
 * for nothing: it picks one of the sets below from the same seed that carved
 * it, `cells.ts` tags its boxes with that set's numbers, and not one byte more
 * goes over the wire or into the texture. Nothing downstream learns anything —
 * the renderer has always drawn whatever layer a vertex names.
 *
 * (Issue #151 calls these palettes. The file is `looks.ts` because
 * `palette.ts` next door is already the colours the 2D is drawn in, and two
 * palettes in one directory is a file nobody can name.)
 *
 * Named, and not random per surface, for one reason: nine materials do not
 * combine freely. A map wants its cover to stand off its floor from across the
 * room, its bombsite to read as painted ground rather than as more floor, and
 * its players to stay legible against all three. `looks.test.ts` measures each
 * set below against the shaders in `materials.ts` and holds it to those three
 * distances, so a look added here without looking at it fails there.
 */
/** The jobs a level gives a material. `METAL` is a name, not a surface: nothing tags a box with it yet. */
export type Role = "FLOOR" | "WALL" | "CRATE" | "SITE" | "METAL";
/** One dressing of a map: what to call it, and the atlas layer each job is painted from. */
export type Look = {
  /** What this set is called, in a log, a terminal and a pull. */
  readonly name: string;
  /** The material id each job is tagged with. The whole of what a look is. */
  readonly materials: Readonly<Record<Role, number>>;
};
/** The nine materials by name, in the order `materials.ts` paints them. */
export const SAND = 0, PLASTER = 1, WOOD = 2, PAINT = 3, METAL = 4;
export const SKIN = 5, FATIGUES = 6, GEAR = 7, WARNING = 8;
const look = (name: string, FLOOR: number, WALL: number, CRATE: number, SITE: number): Look =>
  ({ name, materials: { FLOOR, WALL, CRATE, SITE, METAL } });
/**
 * The looks, written down. Eight of them, each one looked at in the preview and
 * measured in `looks.test.ts`; `forge` is first because it is de_forge's own,
 * the numbers this game shipped with, and the default every level gets unless
 * it asks for another.
 *
 * Read them as places: sand under plaster with wooden crates is the desert town
 * this game started as; metal under dark steel with a red-painted site is a
 * foundry floor; a timber deck inside plaster walls is a depot. The site is
 * either the painted ground it always was or the warning red — never the floor
 * it sits on, which is the one thing a player has to see from a doorway.
 */
export const LOOKS: readonly Look[] = [
  look("forge", SAND, PLASTER, WOOD, PAINT),
  look("foundry", METAL, GEAR, WOOD, WARNING),
  look("quarry", SAND, GEAR, METAL, WARNING),
  look("depot", WOOD, PLASTER, GEAR, WARNING),
  look("bunker", GEAR, METAL, WOOD, WARNING),
  look("kiln", SAND, METAL, GEAR, PAINT),
  look("plaza", PAINT, PLASTER, GEAR, WARNING),
  look("hangar", METAL, PLASTER, GEAR, WARNING),
];
/** de_forge's own, and what a level is dressed in when it does not choose. */
export const FORGE = LOOKS[0] as Look;
/** The look of that name, or `undefined`: what a terminal or a test looks one up with. */
export const lookNamed = (name: string): Look | undefined => LOOKS.find((l) => l.name === name);
/**
 * A seed's thirty-two bits stirred into thirty-two others. The seed itself is
 * no good to index with — seeds arrive in runs (`gen_1`, `gen_2`, `gen_3` are a
 * person trying maps), and `seed % 8` would walk the table in order and make
 * the look look like a counter. This is murmur3's finaliser, which is one
 * multiply-xor-shift more than we need and costs nothing.
 */
const stir = (seed: number): number => {
  let h = Math.imul(seed ^ 0x9e3779b9, 0x85ebca6b) >>> 0;
  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
  return (h ^ (h >>> 16)) >>> 0;
};
/**
 * The look a seed wears. The same seed wears the same one on every machine, for
 * ever: a map name is a layout and a look together, which is what makes one
 * worth writing down and handing to somebody.
 */
export const lookFor = (seed: number): Look => LOOKS[stir(seed >>> 0) % LOOKS.length] as Look;
@@ -1,130 +0,0 @@
import { expect, test } from "bun:test";
import { advance, MAX_ELAPSED, MAX_STEPS, TICK, waiting } from "./loop.ts";
/** Run a sequence of frames, as the loop would, and total the steps. */
const run = (frames: number[], paused = false): { steps: number; accumulator: number } => {
  let accumulator = 0;
  let steps = 0;
  for (const elapsed of frames) {
    const frame = advance(accumulator, elapsed, paused);
    accumulator = frame.accumulator;
    steps += frame.steps;
  }
  return { steps, accumulator };
};
test("the pause overlay and the match-over card wait; nothing else is asked", () => {
  expect(waiting(true, false)).toBe(true);
  expect(waiting(false, true)).toBe(true);
  expect(waiting(true, true)).toBe(true);
  // No overlay of its own, and — the point of the pair — the buy panel is not
  // one of the arguments: it opens in the freeze time and the clock runs on.
  expect(waiting(false, false)).toBe(false);
  expect(waiting.length).toBe(2);
});
test("an ordinary frame buys the ticks it paid for and banks the remainder", () => {
  const frame = advance(0, 1 / 60, false);
  expect(frame.steps).toBe(1);
  expect(frame.accumulator).toBeCloseTo(1 / 60 - TICK, 12);
  expect(frame.elapsed).toBeCloseTo(1 / 60, 12);
  expect(frame.measured).toBe(true);
});
test("a paused frame runs no steps and banks nothing", () => {
  const frame = advance(0, 1 / 60, true);
  expect(frame.steps).toBe(0);
  expect(frame.accumulator).toBe(0);
  expect(frame.measured).toBe(false);
});
test("thirty seconds of pause is thirty seconds the world does not run", () => {
  // Paused at 60 fps with a tick's worth already half banked: the bank stays
  // where it was and not one step is run, however long the dialog is up.
  let accumulator = TICK / 2;
  for (let i = 0; i < 30 * 60; i += 1) {
    const frame = advance(accumulator, 1 / 60, true);
    expect(frame.steps).toBe(0);
    accumulator = frame.accumulator;
  }
  expect(accumulator).toBeCloseTo(TICK / 2, 12);
  // And the first frame back is an ordinary frame, not a flood.
  const resumed = advance(accumulator, 1 / 60, false);
  expect(resumed.steps).toBe(1);
});
test("the frame after a long pause runs at most one frame's worth of ticks", () => {
  // The worst case the caller can hand over: a gap of half a minute, with a
  // tick nearly banked. It costs the cap and no more, now or next frame.
  const first = advance(TICK * 0.99, 30, false);
  expect(first.steps).toBe(MAX_STEPS);
  expect(first.accumulator).toBeLessThan(TICK);
  // And the second after it is an ordinary second: about 64 ticks, not the
  // 8-per-frame flood a banked backlog would have made of it.
  let accumulator = first.accumulator;
  let steps = 0;
  for (let i = 0; i < 60; i += 1) {
    const frame = advance(accumulator, 1 / 60, false);
    accumulator = frame.accumulator;
    steps += frame.steps;
  }
  expect(steps).toBeLessThanOrEqual(1 / TICK + 1);
});
test("the eight-step clamp holds under a long frame, and the backlog is dropped", () => {
  const frame = advance(0, MAX_ELAPSED, false);
  expect(MAX_ELAPSED / TICK).toBeGreaterThan(MAX_STEPS); // the clamp is doing work
  expect(frame.steps).toBe(MAX_STEPS);
  expect(frame.accumulator).toBeLessThan(TICK);
  expect(frame.elapsed).toBe(MAX_ELAPSED);
});
test("a frame longer than the elapsed clamp is clamped to it", () => {
  const frame = advance(0, 5, false);
  expect(frame.elapsed).toBe(MAX_ELAPSED);
  expect(frame.steps).toBe(MAX_STEPS);
  expect(frame.measured).toBe(false);
});
test("a run of tiny frames accumulates into exactly one step, at the right moment", () => {
  const tiny = TICK / 4;
  let accumulator = 0;
  for (let i = 0; i < 3; i += 1) {
    const frame = advance(accumulator, tiny, false);
    expect(frame.steps).toBe(0);
    accumulator = frame.accumulator;
    expect(accumulator).toBeCloseTo(tiny * (i + 1), 12);
  }
  const fourth = advance(accumulator, tiny, false);
  expect(fourth.steps).toBe(1);
  expect(fourth.accumulator).toBeCloseTo(0, 12);
});
test("a steady 60 fps run spends every second of real time on ticks", () => {
  const frames = new Array(600).fill(1 / 60);
  const { steps, accumulator } = run(frames);
  // Ten seconds is 640 ticks; a tick of float drift either way is the
  // accumulator's, not a dropped second.
  expect(steps).toBeGreaterThanOrEqual(10 / TICK - 1);
  expect(steps).toBeLessThanOrEqual(10 / TICK);
  expect(accumulator).toBeLessThan(TICK);
});
test("the accumulator never goes negative and never carries a backlog", () => {
  for (const [banked, elapsed] of [[-5, 1 / 60], [Number.NaN, 1], [0, -1], [TICK, Number.NaN]]) {
    const frame = advance(banked as number, elapsed as number, false);
    expect(frame.accumulator).toBeGreaterThanOrEqual(0);
    expect(frame.accumulator).toBeLessThan(TICK);
    expect(frame.steps).toBeGreaterThanOrEqual(0);
    expect(frame.steps).toBeLessThanOrEqual(MAX_STEPS);
  }
});
test("a frame that is not a measurement says so, so the average is not poisoned", () => {
  expect(advance(0, 30, false).measured).toBe(false); // clamped: a resume
  expect(advance(0, 1 / 60, true).measured).toBe(false); // paused: drew nothing
  expect(advance(0, 0, false).measured).toBe(false); // two frames in one tick of the clock
  expect(advance(0, Number.NaN, false).measured).toBe(false);
  expect(advance(0, MAX_ELAPSED, false).measured).toBe(true); // exactly the cap is still real
  expect(advance(0, 1 / 30, false).measured).toBe(true); // slow, but honestly slow
});
@@ -1,76 +0,0 @@
/**
 * Loop: how much simulation one frame is worth.
 *
 * The world is stepped at a fixed 64 Hz, and a frame is however long the
 * browser took to come back, so the leftover time is banked in an accumulator
 * and spent a whole tick at a time. Three rules keep that honest:
 *
 * - A cap on the frame. A tab that was hidden, a machine that hitched or a
 *   laptop that slept comes back with a gap that is not a frame at all; past
 *   `MAX_ELAPSED` the gap is time the simulation will simply not run.
 * - A cap on the steps. `MAX_STEPS` ticks is the most work a frame may do, and
 *   the backlog beyond it is dropped rather than banked — a banked backlog is
 *   how one long frame becomes a minute of frames each running eight steps,
 *   each of them too slow, which never catches up.
 * - Paused is paused. A paused frame runs no steps and banks nothing, so a
 *   thirty-second pause costs the world nothing and the resume is an ordinary
 *   frame. The accumulator it keeps is the sub-tick remainder it already had,
 *   which is less than one tick and stays put.
 *
 * `measured` is the other half of a pause: a frame that drew nothing, or one
 * whose clock was clamped, is not a measurement of how fast this machine
 * draws, so it must not reach the smoothed frame time the render scale is
 * decided from. Nothing here knows about the DOM, the world or WebGL.
 */
/** The fixed step, in seconds. Everything in the simulation is this long. */
export const TICK = 1 / 64;
/** The most ticks one frame may run. Beyond this the backlog is dropped. */
export const MAX_STEPS = 8;
/** The longest a frame may claim to be, in seconds. */
export const MAX_ELAPSED = 0.25;
export type Advance = {
  /** Fixed steps to run now: never more than `MAX_STEPS`, zero when paused. */
  steps: number;
  /** The accumulator to keep for the next frame. Never negative, never a backlog. */
  accumulator: number;
  /** The frame's length in seconds, clamped: what animation should use. */
  elapsed: number;
  /** Is this frame an honest sample of how long drawing takes? */
  measured: boolean;
};
/**
 * Which overlays mean the match is waiting. The pause overlay and the
 * match-over card stop the world; the buy panel is not an argument here at
 * all, because it opens in the freeze time and a frozen freeze clock is a
 * round that never goes live. Two booleans in, one out: the caller looks at
 * the DOM, this decides what it means.
 */
export const waiting = (pauseUp: boolean, summaryUp: boolean): boolean => pauseUp || summaryUp;
/** A number that is not one is zero; time never runs backwards. */
const sane = (value: number): number => (Number.isFinite(value) && value > 0 ? value : 0);
/**
 * What a frame is worth, given the time banked so far, the seconds since the
 * last frame and whether the match is paused.
 */
export function advance(accumulator: number, elapsed: number, paused: boolean): Advance {
  const banked = sane(accumulator);
  const raw = sane(elapsed);
  const dt = Math.min(MAX_ELAPSED, raw);
  const measured = !paused && raw > 0 && raw <= MAX_ELAPSED;
  if (paused) return { steps: 0, accumulator: banked, elapsed: dt, measured };
  const total = banked + dt;
  const wanted = Math.floor(total / TICK);
  const steps = Math.min(MAX_STEPS, wanted);
  // Spend what was run; when the cap bit, the rest is time the world will
  // never run, so only the sub-tick phase survives.
  const kept = wanted > MAX_STEPS ? total % TICK : total - steps * TICK;
  return { steps, accumulator: Math.max(0, kept), elapsed: dt, measured };
}
@@ -1,94 +1,1731 @@
/**
 * main.ts reaches into the page by id forty-odd times, and by a handful of
 * querySelectors, and casts whatever it finds — nothing ties either list to
 * the markup gamePage() actually renders, so an id renamed on either side is
 * a TypeError on the first frame, not a test failure. This reads main.ts's
 * own source text for every `$("…")` lookup and every querySelector /
 * querySelectorAll / closest call with a literal selector, and checks each
 * one against gamePage()'s output — except the handful main.ts writes into
 * the page itself (the buy menu, the radio panel, the controls panel), which
 * are named here explicitly rather than inferred, since that is the one
 * place this test cannot check itself.
 * The frame itself, booted against the stub page in `stage.test-helper.ts`:
 * the ids it looks up, the match a click starts, how many fixed steps one frame
 * is worth, what the buy overlay does to the input, what losing the pointer
 * means, and what it posts to the leaderboard. Two of those concepts are not in
 * here any more: `buy.test.ts` holds the shelf and the prices, and
 * `report.test.ts` holds the round in the page's hand — the retry, the backoff
 * and the cap. What is left of both below is the wiring — the keys that open
 * and close the panel, the money a press costs the world, the frame that asks
 * for a post and the page the answer lands in. Nothing here is a browser and
 * nothing is timed by a real clock — the test decides when a frame happens and
 * how long it took.
 *
 * Nothing here is seeded by one either, since #170: a match takes its seed from
 * the id the page hands out, and this page hands out `…-000000000001` and
 * counts. So every run of this file plays the same world — the same bots on the
 * same spawns — and the assertions that read where a body stands (the camera in
 * the spectating test below, and whose eye it is exactly on) are a fixed fact
 * rather than a die rolled on each check.
 *
 * The first frames are the atlas: `boot` paints a layer per frame and builds
 * the renderer on the last of them, so a test that wants a match steps those
 * frames first — `painted` below — and two tests are about that window itself.
 *
 * The world is not reached for behind `boot`'s back: `boot` hands back the
 * running frame and that frame says what it is simulating, so a test that wants
 * a match that is nearly over says so on that world and steps another frame.
 * What the renderer is handed is a `Scene` now, and `draws` records those.
 */
import { expect, test } from "bun:test";
import { mkdtempSync, readFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { openDatabase } from "../db.ts";
import { credit } from "../player.ts";
import { gamePage } from "../pages/game.ts";
import { generateLevel, nameOf, seedFrom, seedOf } from "./generate.ts";
import type { Level } from "./level.ts";
import { boot, COPIED, gameMeshes, NOT_AN_ID, NOT_A_MAP, NOT_COPIED, type Frame } from "./main.ts";
import { NO_PICTURE } from "./support.ts";
import { HINT } from "./buy.ts";
import { DE_FORGE } from "./map.ts";
import { endRound, SHORT } from "./match.ts";
import { LAYERS, materialTextures } from "./materials.ts";
import { recorder } from "./paint.test-helper.ts";
import { drawPreview, previewText } from "./preview.ts";
import { FIRST_WAIT, LONGEST_WAIT, RETRYING, SAVED, SENDING } from "./pending.ts";
import { headshotShare, resultOf, scoreLine, yourLine } from "./summary.ts";
import { digest, snapshot, withoutEntropy } from "./replay.ts";
import { WEAPONS } from "./weapons.ts";
import { matchOf } from "../matchid.ts";
import { dailyOn, DAILY_LENGTH, saidToday } from "../daily.ts";
import { parseResult, type Result } from "../result.ts";
import { DRIVER, fakeStage, ORIGIN, type FakeStage } from "./stage.test-helper.ts";
import { parseSituation } from "../plan/situation.ts";
import { createWorld, type World } from "./world.ts";
const mainSource = readFileSync(join(import.meta.dir, "main.ts"), "utf8");
/** Every frame booted here, so a stage can be asked what world it is running. */
const running = new WeakMap<FakeStage, Frame>();
const db = openDatabase(mkdtempSync(join(tmpdir(), "main-dom-")));
const player = credit({ role: "anon" }, "1".repeat(32));
const html = gamePage(db, {
  env: "development", pull: undefined, commit: "", script: "/static/app.js", ssh: undefined, player,
/** Boot this stage and remember the frame it started. */
function start(stage: FakeStage): FakeStage {
  running.set(stage, boot(stage.host));
  return stage;
}
/** The world the frame booted on this stage is simulating, if there is one. */
const worldOf = (stage: FakeStage): World | null => running.get(stage)?.world() ?? null;
const TICK = 1 / 64;
const FRAME = 1000 / 30;
/**
 * Step the frames the atlas is painted over: one layer each, and the renderer
 * is built on the last of them. Nothing can be played before this is done, so
 * every test that plays goes through it.
 */
function painted(stage: FakeStage): FakeStage {
  for (let layer = 0; layer < LAYERS; layer++) stage.step(FRAME);
  return stage;
}
/** A booted page, its atlas painted, and the match already started on it. */
function playing(
  options: {
    webgl?: boolean; coarse?: boolean; fullscreen?: boolean; keyboardLock?: boolean; planEndpoint?: string;
  } = {},
): FakeStage {
  const stage = painted(start(fakeStage(options)));
  stage.by("play").fire("click");
  return stage;
}
/** How many 64 Hz steps the world has run, from the time it has simulated. */
const stepsRun = (stage: FakeStage): number => Math.round((worldOf(stage)?.time ?? 0) / TICK);
const button = (stage: FakeStage, action: string) =>
  stage.buttons.find((b) => b.dataset.action === action) as FakeStage["buttons"][number];
test("it boots on the page's ids, asks for a frame, and draws nothing until a match starts", () => {
  const stage = start(fakeStage());
  expect(stage.frames.length).toBe(1);
  expect(stage.by("menu").hidden).toBe(false);
  stage.step(FRAME);
  // The loop runs, but there is no world yet: nothing is drawn and nothing posted.
  expect(stage.draws.length).toBe(0);
  expect(stage.posts.length).toBe(0);
  expect(stage.frames.length).toBe(1);
});
// --- ids, from `$("id")` and `$<Type>("id")` — the only two shapes the file
// uses `$` in — plus the one dynamic shape: the crosshair panel, built once
// per prefix ("menu", "pause") and looked up with a template literal.
const ID_LOOKUP = /\$(?:<[^>]+>)?\("([a-z0-9-]+)"\)/g;
const PREFIXED_ID_LOOKUP = /\$(?:<[^>]+>)?\(`\$\{prefix\}([a-z0-9-]*)`\)/g;
const plainIds = [...mainSource.matchAll(ID_LOOKUP)].map((m) => m[1] as string);
const prefixedIds = [...mainSource.matchAll(PREFIXED_ID_LOOKUP)]
  .flatMap((m) => (["menu", "pause"] as const).map((prefix) => `${prefix}${m[1]}`));
const ids = [...plainIds, ...prefixedIds];
// Markup main.ts writes into the page itself — the buy panel and the radio
// panel are empty in gamePage() and filled in once main.ts runs — so these
// three ids never appear in gamePage()'s own output. Named here rather than
// inferred, since nothing can check this line against itself.
const WRITTEN_BY_MAIN_TS = ["buy-close", "buy-money", "buy-clock", "radio-close"];
test("main.ts still finds ids the way it always has", () => {
  // A regex that stopped matching `$("…")` at all would make the next test
  // vacuously pass on an empty list; this is the guard that catches that.
  expect(ids.length).toBeGreaterThan(30);
test("the menu's Motion starts where the system's prefers-reduced-motion is", () => {
  expect(start(fakeStage()).by("motion").value).toBe("full");
  expect(start(fakeStage({ reducedMotion: true })).by("motion").value).toBe("reduced");
});
test("every id main.ts looks up is on the page, or is markup main.ts wrote itself", () => {
  for (const id of ids) {
    if (WRITTEN_BY_MAIN_TS.includes(id)) continue;
    expect(html).toContain(`id="${id}"`);
test("the atlas is painted a layer a frame, and the menu says so while it is", () => {
  const stage = start(fakeStage());
  // Nothing was painted inside `boot`: the frame was asked for, the page has it
  // back, and the menu is up and honest about what it is doing.
  expect(stage.atlases.length).toBe(0);
  expect(stage.by("prep").hidden).toBe(false);
  expect(stage.by("play").disabled).toBe(true);
  expect(stage.frames.length).toBe(1);
  // Nine layers, nine frames: the renderer is not built until the last one, and
  // the menu is answering the whole way through — the buy panel's key, the
  // pointer, the fields all belong to the page between slices.
  for (let layer = 1; layer < LAYERS; layer++) {
    stage.step(FRAME);
    expect(stage.atlases.length).toBe(0);
    expect(stage.by("prep").hidden).toBe(false);
  }
  stage.step(FRAME);
  // One renderer, built once, out of the finished bytes — the same bytes the
  // one-call painter gives — and before anything has been drawn with it.
  expect(stage.atlases.length).toBe(1);
  expect(stage.atlases[0]).toEqual(materialTextures());
  expect(stage.draws.length).toBe(0);
  expect(stage.by("prep").hidden).toBe(true);
  expect(stage.by("play").disabled).toBe(false);
  // And it stays one: the frames keep coming and nothing is painted again.
  stage.step(FRAME);
  stage.step(FRAME);
  expect(stage.atlases.length).toBe(1);
});
test("a match cannot be started before the atlas is finished", () => {
  const stage = start(fakeStage());
  // The button is disabled, but a click that arrives anyway is not a match: no
  // world, no pointer asked for, no id handed out, nothing stored.
  stage.by("play").fire("click");
  expect(worldOf(stage)).toBeNull();
  expect(stage.scene.locks).toBe(0);
  expect(stage.ids.length).toBe(0);
  expect(stage.store.size).toBe(0);
  expect(stage.by("menu").hidden).toBe(false);
  // Eight of the nine layers in: still not a match.
  for (let layer = 1; layer < LAYERS; layer++) stage.step(FRAME);
  stage.by("play").fire("click");
  expect(worldOf(stage)).toBeNull();
  // The ninth lands, and the same click is one.
  stage.step(FRAME);
  stage.by("play").fire("click");
  expect(worldOf(stage)).not.toBeNull();
  expect(stage.by("menu").hidden).toBe(true);
  stage.step(FRAME);
  expect(stage.draws.length).toBe(1);
});
test("the name is remembered between visits, and a blank one is `you`", () => {
  const first = painted(start(fakeStage()));
  first.by("name").value = "Vesper";
  first.by("play").fire("click");
  expect(first.store.get("cs.name")).toBe("Vesper");
  const again = fakeStage();
  again.store.set("cs.name", "Vesper");
  start(again);
  expect(again.by("name").value).toBe("Vesper");
  const blank = playing();
  expect(blank.store.get("cs.name")).toBe("you");
});
test("clicking play starts a match: the menu goes, the pointer is asked for, the frame draws", () => {
  const stage = playing();
  expect(stage.by("menu").hidden).toBe(true);
  expect(stage.by("pause").hidden).toBe(true);
  expect(stage.scene.locks).toBe(1);
  // Raw counts, asked for by name. Without the dictionary Windows applies its
  // own pointer speed and "enhance pointer precision" to `movementX` before the
  // page sees it: the same flick of the same mouse is worth a different angle
  // depending on how fast it was flicked, and the sensitivity in the menu is
  // not the sensitivity you get.
  expect(stage.scene.lockOptions).toEqual([{ unadjustedMovement: true }]);
  expect(stage.ids.length).toBe(1);
  expect(stage.sounds).toContain("resume");
  stage.step(FRAME);
  expect(stage.draws.length).toBe(1);
  const drawn = stage.draws[0];
  // Ten players, nine of them drawable: the level, every living other, no me.
  expect(worldOf(stage)?.players.length).toBe(10);
  expect(drawn?.scene.instanceCount).toBe(10);
  expect(drawn?.scene.instances[0]?.mesh).toBe("level");
  expect(drawn?.scene.camera.fov).toBe(90);
  // The HUD was sized to its box and painted, and the counter says something.
  expect([stage.hud.width, stage.hud.height]).toEqual([800, 450]);
  expect(stage.hud.paint.calls[0]?.[0]).toBe("clearRect");
  expect(stage.hud.paint.texts.join(" ")).toContain("$800");
  expect(stage.by("fps").textContent).toContain("ms");
});
test("the HUD's backing store follows the screen's ratio, at 125% as well as at 100%", () => {
  // Windows at 125% is where #307 came from: the canvas box is still 800×450
  // CSS pixels and the backing store behind it is a quarter larger, so the HUD
  // and the scene under it are drawn on the same grid rather than two.
  const stage = playing();
  stage.window.devicePixelRatio = 1.25;
  stage.step(FRAME);
  expect([stage.hud.width, stage.hud.height]).toEqual([1000, 563]);
  // Every arm of the crosshair lands on a whole pixel: no smeared cross.
  const arms = stage.hud.paint.calls.filter((c) => c[0] === "fillRect" && Number(c[3]) < 250);
  expect(arms.length).toBeGreaterThanOrEqual(4);
  for (const arm of arms.slice(0, 4))
    for (const n of arm.slice(1, 5)) expect(Number.isInteger(Number(n))).toBe(true);
  // And a ratio past the cap is the cap: pixels past two cost and show nothing.
  stage.window.devicePixelRatio = 4;
  stage.step(FRAME);
  expect([stage.hud.width, stage.hud.height]).toEqual([1600, 900]);
});
test("nothing is heard before a match, and then your own boots are heard as your own", () => {
  const stage = painted(start(fakeStage()));
  // Nine frames of painting an atlas in front of a menu: the voice has not
  // been asked for a single thing, so no audio device has been opened.
  expect(stage.sounds).toEqual([]);
  stage.by("play").fire("click");
  const world = (stage.step(FRAME), worldOf(stage)) as World;
  world.match.phase = "live";
  world.match.timer = 60;
  stage.lock(true);
  stage.hold("KeyW", true);
  // A second and a bit of running: a stride is 85 units and the cap is 250 u/s,
  // so feet land, and they land as the ears' own — the frame plays every sound
  // from the eye it is drawing with.
  for (let frame = 0; frame < 40; frame++) stage.step(FRAME);
  // Both kinds arrive: the bots walking out of their spawns are somebody
  // else's feet, and the ones under the camera are marked as the ears' own.
  expect(stage.sounds).toContain("sound:step:own");
  expect(stage.sounds).toContain("sound:step");
});
test("every sound is placed from the ear's heading, not just its position", () => {
  const stage = painted(start(fakeStage()));
  stage.by("play").fire("click");
  const world = (stage.step(FRAME), worldOf(stage)) as World;
  world.match.phase = "live";
  world.match.timer = 60;
  stage.lock(true);
  // A heading nothing else in the game would produce, so a yaw that arrives by
  // accident — a zero, a bot's, the camera's own — is not this one.
  world.me.yaw = 137;
  stage.hold("KeyW", true);
  for (let frame = 0; frame < 40; frame++) stage.step(FRAME);
  expect(stage.sounds.length).toBeGreaterThan(0);
  // Running forward does not turn you, so every noise of that second was heard
  // from the same facing, and it is the one the player is holding.
  expect(new Set(stage.headings)).toEqual(new Set([137]));
});
test("one frame of 1/30 s runs two 64 Hz steps and no more, and banks the rest", () => {
  const stage = playing();
  stage.step(FRAME);
  expect(stepsRun(stage)).toBe(2);
  // 1/30 is 2.13 ticks: the .13 carries, and two frames are still four steps.
  stage.step(FRAME);
  expect(stepsRun(stage)).toBe(4);
  // A frame the clock slept through is clamped: a quarter second, sixteen ticks,
  // and the loop runs at most eight of them.
  stage.step(5000);
  expect(stepsRun(stage)).toBe(12);
});
test("the mouse turns the view, and while scoped it turns it by the zoom's share", () => {
  const stage = playing();
  stage.lock(true);
  const world = (stage.step(FRAME), worldOf(stage)) as World;
  world.match.phase = "live";
  world.match.timer = 60;
  // The one gun in this game with a scope, in this player's hands. Right mouse
  // is bound to "scope" in `binding.ts`, and the world only listens to it for a
  // weapon that has a `zoom`.
  world.me.primary = "awp";
  world.me.weapon = "awp";
  // 10 counts × 2.2 sensitivity × 0.022° each: 0.484° of yaw, and moving right
  // turns it down. This is the unscoped path, unchanged by #136.
  const start = world.me.yaw;
  stage.window.fire("mousemove", { movementX: 10, movementY: 0 });
  stage.step(FRAME);
  expect(world.me.scoped).toBe(false);
  expect(world.me.yaw).toBeCloseTo(start - 0.484, 9);
  // Scoped, by the button a player actually presses: this frame's steps set it.
  stage.scene.fire("mousedown", { button: 2 });
  stage.step(FRAME);
  expect(world.me.scoped).toBe(true);
  // The same hand movement through 40° of view instead of 90°:
  // 0.484° × tan(20°)/tan(45°) = 0.17616°, so the crosshair crosses the same
  // fraction of the screen it did unscoped rather than 2.7 times as much.
  const scopedFrom = world.me.yaw;
  stage.window.fire("mousemove", { movementX: 10, movementY: 0 });
  stage.step(FRAME);
  expect(world.me.yaw).toBeCloseTo(scopedFrom - 0.17616159338484194, 9);
  // Letting the button go unscopes on that frame's steps, and the next movement
  // is the plain sensitivity again — the view itself never jumps, because all
  // any of this scales is the delta a mouse asked for.
  stage.window.fire("mouseup", { button: 2 });
  stage.step(FRAME);
  expect(world.me.scoped).toBe(false);
  const plainFrom = world.me.yaw;
  stage.window.fire("mousemove", { movementX: 10, movementY: 0 });
  stage.step(FRAME);
  expect(world.me.yaw).toBeCloseTo(plainFrom - 0.484, 9);
});
test("the whole mouse plays the game: the wheel jumps and the thumb buttons do not navigate", () => {
  const stage = playing();
  stage.lock(true);
  const world = (stage.step(FRAME), worldOf(stage)) as World;
  world.match.phase = "live";
  world.match.timer = 60;
  expect(world.me.vel[2]).toBe(0);
  // A notch of the wheel is the jump a lot of people play with.
  stage.window.fire("wheel", { deltaY: -120 });
  stage.step(FRAME);
  expect(world.me.vel[2]).toBeGreaterThan(0);
  // And the two buttons under a thumb are Back and Forward in Edge on Windows:
  // pressed here they are bound actions and the browser is told to do nothing,
  // so a five-button mouse mid-round cannot take the page away from the match.
  let navigated = 0;
  stage.scene.fire("mousedown", { button: 3, preventDefault: () => void (navigated += 1) });
  expect(navigated).toBe(1);
  stage.scene.fire("auxclick", { button: 3, preventDefault: () => void (navigated += 1) });
  expect(navigated).toBe(2);
});
test("B opens the buy overlay: it is drawn, it keeps the pointer and the shelf takes the focus", () => {
  const stage = playing();
  stage.lock(true);
  stage.press("KeyB");
  const buy = stage.by("buy");
  const shelf = stage.by("buyshelf");
  expect(buy.hidden).toBe(false);
  // What is in the panel is `buy.test.ts`'s — the shelf, the prices, which tiles
  // are dead. Here it is that it was drawn at all, that the pointer is still the
  // game's, and that the focus is on the shelf rather than on a tile: a focused
  // tile is a tile Space presses, and Space is jump.
  const grid = shelf.querySelector(".grid");
  expect(grid?.children.length).toBeGreaterThan(4);
  expect(grid?.children[0]?.focused).toBe(0);
  expect(shelf.focused).toBe(1);
  expect(stage.document.pointerLockElement).toBe(stage.scene);
  // And the line under it says what opened and what the keys are, in the live
  // region the page renders: with no cursor to move into the panel, this is what
  // a screen reader is told instead.
  const world = (stage.step(FRAME), worldOf(stage));
  expect(stage.by("buysays").textContent).toContain(`$${world?.me.money}`);
  expect(stage.by("buysays").textContent).toContain(HINT);
  // A press is wired to the world this frame is simulating: the money goes, the
  // beep plays, and the panel is drawn again with what is left.
  const before = world?.me.money ?? 0;
  grid?.children[0]?.fire("click");
  expect(world?.me.money).toBeLessThan(before);
  expect(stage.sounds).toContain("beep");
  expect(shelf.innerHTML).toContain(`$${world?.me.money}`);
  // Escape closes it, and so does pressing B again — and neither touches the
  // pointer, which is still on the game it never left.
  stage.window.fire("keydown", { code: "Escape" });
  expect(buy.hidden).toBe(true);
  stage.press("KeyB");
  expect(buy.hidden).toBe(false);
  expect(stage.document.pointerLockElement).toBe(stage.scene);
  expect(stage.scene.locks).toBe(1);
});
test("a number key buys the tile it is printed on, and one the wallet cannot reach buys nothing", () => {
  const stage = playing();
  stage.lock(true);
  stage.step(FRAME);
  const world = worldOf(stage);
  if (world === null) throw new Error("the first frame drew nothing");
  stage.press("KeyB");
  const shelf = stage.by("buyshelf");
  const tiles = () => shelf.querySelector(".grid")?.children ?? [];
  // The fifth tile is the AWP at $4750 and the freeze-time wallet is $800: the
  // key for it is a key that does nothing, which is what a dead tile is.
  expect(tiles()[4]?.textContent).toContain("5 · ");
  const before = world.me.money;
  stage.press("Digit5");
  expect(world.me.money).toBe(before);
  expect(world.me.primary).toBeNull();
  // The first is this side's pistol, and the number buys exactly it: the same
  // money, the same kit and the same beep a click on that tile costs.
  const [key, name] = (tiles()[0]?.textContent ?? "").split(" · ");
  expect(key).toBe("1");
  stage.press("Digit1");
  expect(world.me.money).toBeLessThan(before);
  expect(stage.by("buysays").textContent).toBe(`Bought ${name}. $${world.me.money} left.`);
  expect(stage.sounds).toContain("beep");
  // And the key is the panel's only while the panel is up: with it closed the
  // same key is the weapon pocket it has always been, and buys nothing.
  const spent = world.me.money;
  stage.press("KeyB");
  expect(stage.by("buy").hidden).toBe(true);
  stage.press("Digit1");
  expect(world.me.money).toBe(spent);
});
test("X buys last round's loadout again, in order, and stops when the money runs out", () => {
  const stage = playing();
  stage.lock(true);
  stage.step(FRAME);
  const world = worldOf(stage);
  if (world === null) throw new Error("the first frame drew nothing");
  const me = world.me;
  // Round one: a rifle and a vest, bought with the keys, in that order.
  me.money = 10_000;
  stage.press("KeyB");
  const rifle = me.team === "t" ? "ak47" : "m4a4";
  stage.press("Digit4");
  stage.press("Digit9");
  expect(me.primary).toBe(rifle);
  expect(me.armor).toBeGreaterThan(0);
  stage.press("KeyB");
  // A round later, with nothing left of it: the same list, in the same order.
  // The round is scored through the match's own rules and the frames after it
  // carry the end delay, so the world under test sees a real next freeze time.
  endRound(world.match, me.team === "t" ? "ct" : "t", "elimination");
  for (let frame = 0; frame < 60 && world.match.round === 1; frame++) stage.step(250);
  expect(world.match.round).toBe(2);
  expect(world.match.phase).toBe("freeze");
  me.primary = null;
  me.armor = 0;
  me.money = WEAPONS[rifle].price + 100;
  stage.press("KeyX");
  expect(world.me.primary).toBe(rifle);
  // The vest was next and the wallet could not reach it, so the line says so —
  // in the HUD's message line, where a player who never opened the panel is
  // looking, and in the panel's own line.
  expect(me.armor).toBe(0);
  const said = world.messages[world.messages.length - 1]?.text ?? "";
  expect(said).toContain("Rebought");
  expect(said).toContain("not enough for Kevlar");
  expect(stage.by("buysays").textContent).toBe(said);
  expect(stage.sounds).toContain("beep");
  // And a rebuy outside the freeze time is not a rebuy: `canBuy` is the one
  // gate, whether the panel is open or the key was pressed on its own.
  world.match.phase = "live";
  const left = me.money;
  stage.press("KeyX");
  expect(me.money).toBe(left);
});
test("the buy overlay open suppresses fire, but not movement", () => {
  const stage = playing();
  stage.step(FRAME);
  const world = worldOf(stage);
  if (world === null) throw new Error("the first frame drew nothing");
  stage.press("KeyB");
  expect(stage.by("buy").hidden).toBe(false);
  // A thumb on the fire pad and a finger on W, and the round goes live under
  // both: the freeze time is what the buy panel needs, not what this is about.
  button(stage, "fire").fire("pointerdown");
  stage.hold("KeyW", true);
  world.match.phase = "live";
  world.match.timer = 60;
  const mag = world.me.ammo[world.me.weapon]?.mag ?? 0;
  stage.step(FRAME);
  expect(world.me.ammo[world.me.weapon]?.mag).toBe(mag);
  expect(Math.hypot(world.me.vel[0], world.me.vel[1])).toBeGreaterThan(0);
  // And the panel let itself out of the way as soon as buying stopped being legal.
  expect(stage.by("buy").hidden).toBe(true);
  // The same held input, one frame later, with nothing in front of it.
  stage.step(FRAME);
  expect(world.me.ammo[world.me.weapon]?.mag).toBe(mag - 1);
  expect(stage.sounds.some((s) => s.startsWith("shot:"))).toBe(true);
});
test("losing the pointer pauses a running match, buy panel open or not", async () => {
  const stage = playing();
  stage.lock(true);
  stage.lock(false);
  expect(stage.by("pause").hidden).toBe(false);
  // Resume asks for the pointer back — and the panel goes when the browser has
  // answered, which is a promise and so a turn of the loop later.
  stage.by("resume").fire("click");
  await settled();
  expect(stage.by("pause").hidden).toBe(true);
  expect(stage.scene.locks).toBe(2);
  // The buy menu no longer drops the lock, so a lock that goes while it is open
  // is a real loss — alt-tab, a browser policy — and the match stops behind the
  // panel, which closes rather than sitting over the pause.
  stage.lock(true);
  stage.press("KeyB");
  expect(stage.by("buy").hidden).toBe(false);
  expect(stage.document.pointerLockElement).toBe(stage.scene);
  stage.lock(false);
  expect(stage.by("buy").hidden).toBe(true);
  expect(stage.by("pause").hidden).toBe(false);
});
test("a refused Resume stays paused and says so, rather than a match with a dead mouse", async () => {
  const stage = playing();
  stage.lock(true);
  stage.lock(false);
  expect(stage.by("pause").hidden).toBe(false);
  // Chromium — Edge included — will not grant a lock for about a second after
  // one was released, which is exactly how fast a person presses Resume after
  // Escape. The old code hid the panel on the way out and never read the
  // answer: the match ran on with no look, no trigger and nothing to click.
  stage.scene.refuseLock = true;
  stage.by("resume").fire("click");
  await settled();
  expect(stage.by("pause").hidden).toBe(false);
  expect(stage.by("esc").textContent).toContain("press Resume again");
  expect(stage.by("resume").focused).toBeGreaterThan(0);
  // Pressed again a moment later, when the browser will give it: back in.
  stage.scene.refuseLock = false;
  stage.by("resume").fire("click");
  await settled();
  expect(stage.by("pause").hidden).toBe(true);
});
test("Escape pauses and keeps the screen where the browser hands the key over", async () => {
  const stage = playing();
  stage.press("KeyF");
  stage.lock(true);
  const box = stage.by("stage");
  expect(stage.document.fullscreenElement).toBe(box);
  // The keys were asked for on the way into full screen, and granted a microtask
  // later: from here on Escape is the page's and not the browser's — and so is
  // every key this game binds, because on Windows the browser's own shortcuts
  // are Ctrl and a letter, and Ctrl here is crouch: crouch-and-forward is
  // Ctrl+W, which closes the tab, and crouch-and-reload is Ctrl+R, which
  // reloads the match away.
  const locked = stage.keyboard.locked ?? [];
  expect(locked[0]).toBe("Escape");
  for (const code of ["KeyW", "KeyR", "KeyD", "Digit1", "Tab"]) expect(locked).toContain(code);
  // Asked for once each, however many tables name it.
  expect(new Set(locked).size).toBe(locked.length);
  await Promise.resolve();
  stage.window.fire("keydown", { code: "Escape" });
  // Paused, the pointer let go — under the lock the browser does not do that for
  // us — and the screen still ours, which is the whole point of holding the key.
  expect(stage.by("pause").hidden).toBe(false);
  expect(stage.document.pointerLockElement).toBe(null);
  expect(stage.document.fullscreenElement).toBe(box);
  expect(stage.by("esc").textContent).toContain("kept the screen");
  expect(stage.by("resume").focused).toBe(1);
  // And Resume goes back into the match without asking for a screen it already
  // has: one pointer lock, no second `requestFullscreen`.
  stage.by("resume").fire("click");
  await settled();
  expect(stage.by("pause").hidden).toBe(true);
  expect(box.fullscreens).toBe(1);
  expect(stage.scene.locks).toBe(2);
});
test("a browser that keeps Escape for itself pauses just the same, and Resume puts the screen back", () => {
  // Safari on a Mac: no Keyboard Lock API, so Escape leaves full screen whatever
  // the page asks — the window drops out of it with the whole animation, which is
  // what this test is about.
  const stage = playing({ keyboardLock: false });
  stage.press("KeyF");
  stage.lock(true);
  const box = stage.by("stage");
  expect(box.fullscreens).toBe(1);
  expect(stage.keyboard.grabs).toBe(0);
  // Escape, as that browser delivers it: the screen is gone before the page hears
  // the key, and the pointer goes with it.
  stage.document.fullscreenElement = null;
  stage.document.fire("fullscreenchange");
  stage.lock(false);
  stage.window.fire("keydown", { code: "Escape" });
  expect(stage.by("pause").hidden).toBe(false);
  expect(stage.by("esc").textContent).toContain("Resume puts it back");
  // Resume is a gesture, which is the only thing a browser will give a screen
  // back to: the stage goes full screen again and the pointer with it.
  stage.by("resume").fire("click");
  expect(stage.document.fullscreenElement).toBe(box);
  expect(box.fullscreens).toBe(2);
  expect(stage.scene.locks).toBe(2);
  // A player who left full screen on purpose is not dragged back into it.
  stage.press("KeyF");
  expect(stage.document.fullscreenElement).toBe(null);
  stage.lock(false);
  expect(stage.by("pause").hidden).toBe(false);
  stage.by("resume").fire("click");
  expect(stage.document.fullscreenElement).toBe(null);
  expect(box.fullscreens).toBe(2);
});
test("P pauses too, and a key no browser wants costs no screen", () => {
  const stage = playing({ keyboardLock: false });
  stage.press("KeyF");
  stage.lock(true);
  stage.press("KeyP");
  expect(stage.by("pause").hidden).toBe(false);
  expect(stage.document.fullscreenElement).toBe(stage.by("stage"));
  expect(stage.document.pointerLockElement).toBe(null);
  // Nothing was taken, and the line in the panel says as much rather than
  // promising to put a screen back that never went anywhere.
  expect(stage.by("esc").textContent).toContain("Esc or P pauses");
});
test("Escape closes the buy menu before it is a pause", () => {
  const stage = playing();
  stage.lock(true);
  stage.press("KeyB");
  expect(stage.by("buy").hidden).toBe(false);
  stage.window.fire("keydown", { code: "Escape" });
  expect(stage.by("buy").hidden).toBe(true);
  expect(stage.by("pause").hidden).toBe(true);
  // The next one is the pause, now that there is nothing in front of it.
  stage.window.fire("keydown", { code: "Escape" });
  expect(stage.by("pause").hidden).toBe(false);
  // A pause is not a second pause: the key held down does not stack panels or
  // steal the focus again.
  stage.window.fire("keydown", { code: "Escape", repeat: true });
  expect(stage.by("resume").focused).toBe(1);
});
test("leaving the match puts the menu back and stops the frame", () => {
  const stage = playing();
  stage.step(FRAME);
  expect(stage.draws.length).toBe(1);
  stage.by("quit").fire("click");
  expect(stage.by("menu").hidden).toBe(false);
  expect(stage.by("touch").hidden).toBe(true);
  stage.step(FRAME);
  expect(stage.draws.length).toBe(1);
});
// --- a match ends on a scoreboard ------------------------------------------
/**
 * Play the match out. The last round is scored through the match's own rules —
 * `endRound` is what an elimination or a defuse calls — and the frames after it
 * carry the end delay, which is the clock that turns a won round into
 * `match_over`. Nothing here writes a phase: the frame under test sees exactly
 * what a played-out match leaves.
 *
 * A quarter of a second a frame is the loop's own cap (eight 64 Hz steps), so
 * five seconds of end delay is forty frames rather than a hundred and fifty.
 */
function finish(stage: FakeStage, winner: "t" | "ct"): World {
  const world = worldOf(stage);
  if (world === null) throw new Error("no match is running");
  world.match.score[winner] = world.match.rules.winScore - 1;
  endRound(world.match, winner, "elimination");
  for (let frame = 0; frame < 60 && world.match.phase !== "match_over"; frame++) stage.step(250);
  if (world.match.phase !== "match_over") throw new Error("the match never ended");
  return world;
}
/** A match played to its end, with something on the player's own line to read. */
function ended(winner: "t" | "ct" = "ct"): { stage: FakeStage; world: World } {
  const stage = playing();
  stage.lock(true);
  stage.step(FRAME);
  const world = worldOf(stage);
  if (world === null) throw new Error("the first frame drew nothing");
  Object.assign(world.me, { kills: 7, deaths: 3, headshots: 2, damage: 1234.6 });
  return { stage, world: finish(stage, winner) };
}
test("a match ends on the summary, not the menu: the run stops and the way forward has the focus", () => {
  const { stage } = ended();
  expect(stage.by("summary").hidden).toBe(false);
  expect(stage.by("menu").hidden).toBe(true);
  expect(stage.by("pause").hidden).toBe(true);
  expect(stage.by("touch").hidden).toBe(true);
  // Play again is one press of Enter from wherever the pointer was, and the
  // pointer itself is given back: the match is over, so the mouse is the page's.
  expect(stage.by("again").focused).toBe(1);
  expect(stage.document.pointerLockElement).toBe(null);
  // The run stopped: the frames keep coming and nothing more is drawn.
  const drawn = stage.draws.length;
  stage.step(FRAME);
  stage.step(FRAME);
  expect(stage.draws.length).toBe(drawn);
});
/**
 * Let everything in flight settle and the frames send whatever is still
 * waiting, then hand back the last body that went to the server. A post is one
 * attempt at a time and a test's frames are all one synchronous block, so the
 * result of the last round leaves on the frame after the one before it lands.
 */
async function lastPost(stage: FakeStage): Promise<Result> {
  for (let attempt = 0; attempt < 4; attempt++) {
    await settled();
    stage.step(FRAME);
  }
  await settled();
  return JSON.parse(stage.posts[stage.posts.length - 1]?.body ?? "{}");
}
test("the summary is the final score, your own line and both teams' rows", async () => {
  const { stage, world } = ended("ct");
  // Who won and by how much, in the words `summary.ts` writes them, against the
  // world the match actually ended in.
  const posted = resultOf(world, "irrelevant", "you", true);
  expect(stage.by("sumtitle").textContent).toBe("Counter-Terrorists win");
  expect(stage.by("sumscore").textContent).toContain(`${posted.scoreMine}–${posted.scoreTheirs}`);
  expect(stage.by("sumscore").textContent).toContain("you won");
  expect(stage.by("sumscore").textContent).toContain("Counter-Terrorists");
  // Your own line, and it is the numbers the server was posted — the same
  // object built once, so the screen and the leaderboard cannot disagree.
  const body = await lastPost(stage);
  expect(body.finished).toBe(true);
  expect(parseResult(body)).not.toBeNull();
  const mine = stage.by("sumyou").textContent ?? "";
  expect(mine).toContain(`${body.kills} kills`);
  expect(mine).toContain(`${body.deaths} deaths`);
  expect(mine).toContain(`${body.damage} damage`);
  expect(mine).toContain(`${headshotShare(body.headshots, body.kills)} headshots`);
  expect(mine).toContain(`${body.scoreMine} rounds won`);
  // Rounded once, in `summary.ts`, so the page and the row carry one number.
  expect(body.damage).toBe(1235);
  expect(stage.by("sumyou").textContent).toBe(yourLine({
    result: resultOf(world, "irrelevant", "you", true), team: world.me.team,
    winner: world.match.matchWinner, won: true, lines: [],
  }));
  // And everybody's rows: ten players, both sides, yours marked, in the order
  // the HUD's board draws them — most kills first, which here is you.
  const board = stage.by("sumboard").innerHTML;
  for (const player of world.players) expect(board).toContain(player.name);
  expect(board).toContain("<b>(you)</b>");
  const rows = board.slice(board.indexOf("<tbody>")).split("<tr").slice(1);
  expect(rows.length).toBe(world.players.length);
  expect(rows[0]).toContain("(you)");
  expect(board).toContain(`>CT</span>`);
  expect(board).toContain(`>T</span>`);
});
test("a match lost says so, and the side that won is the side that won", () => {
  const { stage } = ended("t");
  expect(stage.by("sumtitle").textContent).toBe("Terrorists win");
  expect(stage.by("sumscore").textContent).toContain("you lost");
});
test("play again is another match on the same settings, and back to the page is the menu", () => {
  const { stage } = ended();
  stage.by("length").value = "long";
  stage.by("again").fire("click");
  // A match, not a menu: the summary is gone, the pointer is asked for again,
  // and it is a new match of its own — a fresh id, so a fresh row.
  expect(stage.by("summary").hidden).toBe(true);
  expect(stage.by("menu").hidden).toBe(true);
  expect(worldOf(stage)?.match.phase).not.toBe("match_over");
  expect(stage.ids.length).toBe(2);
  // The settings are the menu's, untouched and unread until Play again asks:
  // the field says thirteen rounds, so the new match is a thirteen-round one.
  expect(worldOf(stage)?.match.rules.winScore).toBe(13);
  // And the other way out is the page: the menu is back and nothing is running.
  const over = finish(stage, "ct");
  expect(over.match.phase).toBe("match_over");
  stage.by("leave").fire("click");
  expect(stage.by("summary").hidden).toBe(true);
  expect(stage.by("menu").hidden).toBe(false);
  expect(stage.by("play").focused).toBe(1);
  const drawn = stage.draws.length;
  stage.step(FRAME);
  expect(stage.draws.length).toBe(drawn);
});
test("the summary says whether the match reached the leaderboard, and says it once it has", async () => {
  const { stage } = ended();
  // Posted and not yet answered: the screen says it is on its way, never that
  // it landed. `settled` lets the fetch the last frame made come back.
  expect(stage.by("sumsaved").textContent).toBe(SENDING);
  // The round before it settles first — one attempt is ever in flight — and the
  // line still says the match is not on the board, because it is not.
  await settled();
  expect(stage.by("sumsaved").textContent).toBe(SENDING);
  stage.step(FRAME);
  await settled();
  expect(stage.by("sumsaved").textContent).toBe(SAVED);
});
test("dying moves the camera behind a teammate, and fire moves it behind the next", () => {
  const stage = playing();
  stage.lock(true);
  stage.step(FRAME);
  const world = worldOf(stage);
  if (world === null) throw new Error("the first frame drew nothing");
  // Alive, the camera is your own eye and every other living body is drawn.
  const mine = [...(stage.draws[0]?.scene.camera.pos ?? [])];
  expect(stage.draws[0]?.scene.instanceCount).toBe(10);
  world.me.alive = false;
  stage.step(FRAME);
  const watched = [...(stage.draws[1]?.scene.camera.pos ?? [])];
  // Somewhere else entirely, and one body fewer: the one the camera is inside.
  expect(watched).not.toEqual(mine);
  expect(stage.draws[1]?.scene.instanceCount).toBe(9);
  // And it is a teammate's eye, not a bot from the other side of the map.
  const mates = world.players.filter((p) => p.alive && p.team === world.me.team);
  expect(mates.some((p) => p.pos[0] === watched[0] && p.pos[1] === watched[1])).toBe(true);
  // The trigger is the only control a dead player has left: it walks along.
  button(stage, "fire").fire("pointerdown");
  stage.step(FRAME);
  const next = [...(stage.draws[2]?.scene.camera.pos ?? [])];
  expect(next).not.toEqual(watched);
  expect(mates.some((p) => p.pos[0] === next[0] && p.pos[1] === next[1])).toBe(true);
  // The HUD says whose eyes they are.
  expect(stage.hud.paint.texts.some((t) => t.startsWith("Watching "))).toBe(true);
});
test("a phone gets the touch pads, a mouse does not", () => {
  expect(playing({ coarse: true }).by("touch").hidden).toBe(false);
  expect(playing().by("touch").hidden).toBe(true);
});
test("one POST per round scored, in the shape the server accepts", async () => {
  const stage = playing();
  stage.step(FRAME);
  expect(stage.posts.length).toBe(1);
  const first = stage.posts[0];
  expect(first?.url).toBe("/api/match");
  expect(first?.method).toBe("POST");
  expect(first?.headers["content-type"]).toBe("application/json");
  const body = JSON.parse(first?.body ?? "{}");
  expect(parseResult(body)).not.toBeNull();
  expect(body.matchId).toBe(stage.ids[0]);
  expect(body.rounds).toBe(0);
  expect(body.finished).toBe(false);
  // The leaderboard the server sent back is written into the page.
  await Promise.resolve();
  await Promise.resolve();
  expect(stage.by("stats").innerHTML).toBe("<h2>Leaderboard</h2>");
  // Three more frames and nothing new to say: still one POST.
  stage.step(FRAME);
  stage.step(FRAME);
  stage.step(FRAME);
  expect(stage.posts.length).toBe(1);
  // A round goes on the board: exactly one more. The post before it is let
  // settle first, because there is at most one attempt in flight — in a browser
  // the answer is milliseconds away and the next round is minutes.
  const world = worldOf(stage);
  if (world === null) throw new Error("the first frame drew nothing");
  world.match.score.ct = 1;
  stage.step(FRAME);
  stage.step(FRAME);
  expect(stage.posts.length).toBe(2);
  await settled();
  const second = JSON.parse(stage.posts[1]?.body ?? "{}");
  expect(parseResult(second)).not.toBeNull();
  expect(second.rounds).toBe(1);
  expect(second.finished).toBe(false);
  // The last one says the match is over.
  world.match.score.ct = 2;
  world.match.phase = "match_over";
  stage.step(FRAME);
  expect(stage.posts.length).toBe(3);
  expect(JSON.parse(stage.posts[2]?.body ?? "{}").finished).toBe(true);
});
test("a leaderboard that cannot be reached is not a reason to stop playing", async () => {
  const stage = playing();
  stage.answer = () => Promise.reject(new Error("offline"));
  stage.step(FRAME);
  expect(stage.posts.length).toBe(1);
  await Promise.resolve();
  await Promise.resolve();
  // The page was not overwritten with anything, and the match ran on.
  expect(stage.by("stats").innerHTML).toBe("");
  const world = worldOf(stage);
  if (world === null) throw new Error("the first frame drew nothing");
  // A fetch that throws where it stands is the same kind of nothing.
  stage.answer = () => {
    throw new Error("blocked");
  };
  world.match.score.t = 1;
  stage.step(FRAME);
  stage.step(FRAME);
  expect(stage.posts.length).toBe(2);
  expect(stage.draws.length).toBe(3);
  expect(stepsRun(stage)).toBe(6);
  expect(stage.by("menu").hidden).toBe(true);
});
// --- a result that did not land says so and is tried again -----------------
//
// The queue itself is not in here: `report.test.ts` holds what one answer does
// to the round in the page's hand — the backoff, the cap, the newest round
// winning — against a fetch and a clock of its own. What is below is the
// wiring: that the frame is what asks, and that what comes back lands in the
// page's live region and in the leaderboard beside it.
/**
 * Answer the next posts with these statuses, in order; `"throw"` is a fetch
 * that never answered, and the last entry answers everything after it.
 */
function answering(stage: FakeStage, ...script: (number | "throw")[]): void {
  let at = 0;
  stage.answer = () => {
    const status = script[Math.min(at, script.length - 1)];
    at += 1;
    if (status === "throw" || status === undefined) return Promise.reject(new Error("offline"));
    return Promise.resolve({
      ok: status === 200,
      status,
      text: () => Promise.resolve("<h2>Leaderboard</h2>"),
    });
  };
}
/** Let the fetch behind the last post settle. Nothing here waits on a frame. */
const settled = (): Promise<void> => Bun.sleep(0);
/** What the line by the leaderboard says right now. */
const line = (stage: FakeStage): string | null => stage.by("saved").textContent;
test("the frame is what retries: the wait passes, the same round goes again, the page says so", async () => {
  const stage = playing();
  answering(stage, "throw", 200);
  stage.step(FRAME);
  expect(stage.posts.length).toBe(1);
  await settled();
  // Nothing was written into the page, and the line admits it in plain words.
  expect(stage.by("stats").innerHTML).toBe("");
  expect(line(stage)).toBe(RETRYING);
  // Frames keep coming and nothing is retried until the wait is up: a retry in
  // a game loop is exactly where a flood would be written by accident.
  stage.step(FRAME);
  stage.step(FRAME);
  expect(stage.posts.length).toBe(1);
  // The wait runs out and the same round goes again — once, byte for byte.
  stage.step(FIRST_WAIT);
  expect(stage.posts.length).toBe(2);
  expect(stage.posts[1]?.body).toBe(stage.posts[0]?.body);
  await settled();
  expect(line(stage)).toBe(SAVED);
  expect(stage.by("stats").innerHTML).toBe("<h2>Leaderboard</h2>");
  // And it is done: there is nothing pending, so nothing is posted again.
  stage.step(LONGEST_WAIT);
  stage.step(LONGEST_WAIT);
  expect(stage.posts.length).toBe(2);
});
test("F and the button put the stage on the whole screen, and take it back", () => {
  const stage = start(fakeStage());
  const full = stage.by("full");
  const box = stage.by("stage");
  // Shown by the entry, not by the server: a control that needs a script is
  // rendered hidden and revealed by the script that makes it work.
  expect(full.hidden).toBe(false);
  expect(full.getAttribute("aria-pressed")).toBe(null);
  stage.press("KeyF");
  expect(stage.document.fullscreenElement).toBe(box);
  expect(box.fullscreens).toBe(1);
  expect(full.getAttribute("aria-pressed")).toBe("true");
  expect(full.getAttribute("aria-label")).toBe("Leave full screen");
  stage.press("KeyF");
  expect(stage.document.fullscreenElement).toBe(null);
  expect(full.getAttribute("aria-pressed")).toBe("false");
  expect(full.getAttribute("aria-label")).toBe("Full screen");
  // The button says the same thing with a thumb, which is the only way in on a
  // phone: there is no keyboard there and the pointer cannot be locked either.
  full.fire("click");
  expect(stage.document.fullscreenElement).toBe(box);
  expect(box.fullscreens).toBe(2);
  full.fire("click");
  expect(stage.document.fullscreenElement).toBe(null);
});
test("the screen is the browser's: Escape is heard, and a browser that will not is not lied about", () => {
  const stage = start(fakeStage());
  stage.press("KeyF");
  // Escape, which no code of ours ran. The page hears it from the event.
  stage.document.fullscreenElement = null;
  stage.document.fire("fullscreenchange");
  expect(stage.by("full").getAttribute("aria-pressed")).toBe("false");
  // And a browser with no fullscreen at all keeps the button hidden rather than
  // showing one that does nothing.
  const cannot = start(fakeStage({ fullscreen: false }));
  expect(cannot.by("full").hidden).toBe(true);
  cannot.press("KeyF");
  expect(cannot.document.fullscreenElement).toBe(null);
  expect(cannot.by("stage").fullscreens).toBe(0);
});
test("no WebGL2 is a sentence on the page, not an exception", () => {
  const stage = start(fakeStage({ webgl: false }));
  expect(stage.by("menu").innerHTML).toContain("No WebGL2");
  expect(stage.by("menu").hidden).toBe(false);
  // Nothing was started: no frame was asked for and no listener attached.
  expect(stage.frames.length).toBe(0);
  expect(stage.window.listening.size).toBe(0);
  expect(stage.document.listening.size).toBe(0);
  expect(stage.draws.length).toBe(0);
  // And it cost no atlas: a browser that cannot draw pays for nothing.
  expect(stage.atlases.length).toBe(0);
});
test("a refused shader is a sentence and a line to paste, not a black canvas", () => {
  const log = "ERROR: 0:7: 'texture' : no matching overloaded function found";
  const stage = painted(start(fakeStage({ refuseShaders: log })));
  // The driver took the context and then refused the program, which is what
  // ANGLE on Direct3D does. The menu says so in words.
  expect(stage.by("menu").innerHTML).toContain(NO_PICTURE);
  expect(stage.by("menu").innerHTML).toContain("Nothing else on the page is affected");
  // And the line under it carries the browser, the driver and what it said —
  // which is the whole of what a bug report from a Windows machine was missing.
  const line = stage.by("supportline").textContent ?? "";
  expect(line).toContain("Edge 128 on Windows");
  expect(line).toContain("Direct3D11");
  expect(line).toContain("no matching overloaded function found");
  // The page is alive: nothing is drawn, nothing throws on the next frame, and
  // the atlas that was paid for is the one that was painted.
  expect(stage.draws.length).toBe(0);
  stage.step(FRAME);
  expect(stage.by("menu").hidden).toBe(false);
});
test("the line says what this browser is, and says so before anything is built", () => {
  const stage = start(fakeStage());
  const line = stage.by("supportline").textContent ?? "";
  expect(line).toBe("Edge 128 on Windows · " + DRIVER + " · 960×540 at 1× dpr");
  // A browser that refuses `WEBGL_debug_renderer_info` is named as one.
  const quiet = start(fakeStage({ driver: null }));
  expect(quiet.by("supportline").textContent).toContain("driver not named");
  // Even a browser with no WebGL2 at all has the line: it is the report that
  // says which of the two happened.
  const none = start(fakeStage({ webgl: false }));
  expect(none.by("supportline").textContent).toContain("Edge 128 on Windows");
});
test("the copy control copies the line it is under, and hides where there is no clipboard", () => {
  const stage = start(fakeStage());
  const button = stage.by("copysupport");
  expect(button.hidden).toBe(false);
  button.fire("click");
  expect(stage.copied).toEqual([stage.by("supportline").textContent ?? ""]);
});
test("every mesh name a scene of this game can place is handed in at construction", () => {
  // The renderer keeps what it is given and resolves nothing, so a name this
  // table misses is an exception on the frame a player first holds that gun.
  const meshes = gameMeshes();
  expect(Object.keys(meshes).sort()).toEqual([
    "bomb", "cloud", "flash", "grenade", "knife", "level", "pistol", "player", "rifle", "smg",
    "smoke", "sniper",
  ]);
  // Every kind a weapon can be, and the kind `scene.ts` falls back to.
  for (const weapon of Object.values(WEAPONS)) expect(meshes[weapon.kind]).toBeDefined();
  expect(meshes["rifle"]).toBeDefined();
  // And each one is geometry, not an empty buffer.
  for (const [name, mesh] of Object.entries(meshes)) {
    expect(mesh.index.length).toBeGreaterThan(0);
    expect(mesh.position.length).toBe((mesh.index.length / 6) * 4 * 3);
    expect(name).toMatch(/^[a-z]+$/);
  }
});
test("the ids main.ts writes into the page are ones it actually writes, not stray allowances", () => {
  for (const id of WRITTEN_BY_MAIN_TS) {
    expect(mainSource).toContain(`id="${id}"`);
    // Never on the page gamePage() renders — an id in both places would mean
    // the allow-list is hiding a real duplicate rather than excusing one.
    expect(html).not.toContain(`id="${id}"`);
test("the map field chooses the map, and a generated one costs one mesh", () => {
  const stage = painted(start(fakeStage()));
  // de_forge is what the meshes were built from, so nothing is swapped for it.
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe("de_forge");
  expect(stage.replaced).toEqual([]);
  expect(stage.by("onmap").textContent).toBe("Playing de_forge.");
  // Generated: the level is carved from this match's id, and the renderer is
  // handed that level's geometry under the name it already holds — one mesh,
  // not a second renderer.
  stage.by("quit").fire("click");
  (stage.by("map") as unknown as { value: string }).value = "generated";
  stage.by("play").fire("click");
  const level = worldOf(stage)?.level;
  expect(level?.name).toBe(nameOf(seedFrom(stage.ids[stage.ids.length - 1] as string)));
  expect(stage.replaced.map((r) => r.name)).toEqual(["level"]);
  expect(stage.replaced[0]?.mesh.index.length).toBe(gameMeshes(level as Level).level?.index.length);
  expect(stage.by("onmap").textContent).toBe(`Playing ${level?.name}.`);
  // And a value nobody rendered is de_forge, like an unknown anything here.
  stage.by("quit").fire("click");
  (stage.by("map") as unknown as { value: string }).value = "de_moon";
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe("de_forge");
  // The geometry went back to de_forge's with it: two swaps, both of the level.
  expect(stage.replaced.map((r) => r.name)).toEqual(["level", "level"]);
});
// --- a map you can keep ---------------------------------------------------
/** One map's name, base36 of a seed, the way the page hands them out. */
const MAP = "gen_14u5j6g";
test("the map Play will give you is named before Play, and named again as a link", () => {
  const stage = painted(start(fakeStage()));
  // Nothing touched: de_forge, named and linked, and no id drawn to name it.
  expect(stage.by("willplay").textContent).toBe("de_forge");
  expect(stage.by("copymap").attributes.href).toBe("/?map=de_forge");
  expect(stage.ids.length).toBe(0);
  // A new map every match: the id that map is carved from is drawn now, so the
  // name is on the screen *before* anything is played — and the link beside it
  // is that map by name, not another new one.
  stage.by("map").value = "generated";
  stage.by("map").fire("change");
  expect(stage.ids.length).toBe(1);
  const name = nameOf(seedFrom(stage.ids[0] as string));
  expect(stage.by("willplay").textContent).toBe(name);
  expect(stage.by("copymap").attributes.href).toBe(`/?map=${name}`);
  // And it is the map that is played: the promise the menu made is kept, out of
  // the id it had already drawn rather than a second one.
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe(name);
  expect(stage.ids.length).toBe(1);
  expect(stage.by("mapname").textContent).toBe(name);
  expect(stage.by("mapname").attributes.href).toBe(`/?map=${name}`);
  // Back at the menu, the line is about the next match again: another map, its
  // own name, its own link, and the one just played still named under the stage.
  stage.by("quit").fire("click");
  expect(stage.ids.length).toBe(2);
  const next = nameOf(seedFrom(stage.ids[1] as string));
  expect(next).not.toBe(name);
  expect(stage.by("willplay").textContent).toBe(next);
  expect(stage.by("mapname").textContent).toBe(name);
});
test("a map by name is that map, and a name that is not one is de_forge and says so", () => {
  const stage = painted(start(fakeStage()));
  stage.by("mapseed").value = MAP;
  stage.by("mapseed").fire("input");
  expect(stage.by("willplay").textContent).toBe(MAP);
  expect(stage.by("copymap").attributes.href).toBe(`/?map=${MAP}`);
  // A name needs no id: the map is the seed the name means and nothing else.
  expect(stage.ids.length).toBe(0);
  stage.by("play").fire("click");
  const level = worldOf(stage)?.level;
  expect(level?.name).toBe(MAP);
  // The same cells `generateLevel` carves from that seed — the field is a seed,
  // not a label put on whatever the match would have made anyway.
  expect(level?.grid.cells).toEqual(generateLevel(seedOf(MAP) as number).grid.cells);
  // The match is still the match: a fresh id seeded the round it was played in.
  expect(stage.ids.length).toBe(1);
  expect(worldOf(stage)?.level.name).toBe(MAP);
  // The name wins over the select, because a person who typed one meant it.
  stage.by("quit").fire("click");
  stage.by("map").value = "generated";
  stage.by("map").fire("change");
  expect(stage.by("willplay").textContent).toBe(MAP);
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe(MAP);
  // And junk is de_forge with a line saying so: `gen_0ya` is `gen_ya` written
  // badly, which is a typo and not a map. Never an error, never a refusal.
  stage.by("quit").fire("click");
  stage.by("mapseed").value = "gen_0ya";
  stage.by("mapseed").fire("input");
  expect(stage.by("onmap").textContent).toBe(NOT_A_MAP);
  expect(stage.by("willplay").textContent).toBe("de_forge");
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe("de_forge");
  expect(stage.by("onmap").textContent).toBe(NOT_A_MAP);
  expect(stage.by("menu").hidden).toBe(true);
});
test("what is posted says which map it was played on", async () => {
  // The leaderboard's rows used to mix layouts silently. The body the page
  // sends now names the map, and it is the map the world was carved from —
  // whatever the Map control was left on afterwards.
  const stage = painted(start(fakeStage()));
  stage.by("mapseed").value = MAP;
  stage.by("mapseed").fire("input");
  stage.by("play").fire("click");
  stage.lock(true);
  stage.step(FRAME);
  finish(stage, "ct");
  const named = await lastPost(stage);
  expect(named.map).toBe(MAP);
  expect(parseResult(named)?.map).toBe(MAP);
  // And a match on de_forge says de_forge rather than nothing.
  const plain = await lastPost(ended().stage);
  expect(plain.map).toBe("de_forge");
  expect(parseResult(plain)?.map).toBe("de_forge");
});
test("copy this map is a link first and a clipboard second", async () => {
  const LABEL = "Copy this map's link";
  const stage = fakeStage();
  // The label the page renders, so the control can be put back to it.
  stage.by("copymap").textContent = LABEL;
  painted(start(stage));
  stage.by("mapseed").value = MAP;
  stage.by("mapseed").fire("input");
  // A click with a clipboard behind it copies the whole URL — origin and all,
  // because a link is pasted into a message and not into this page — and the
  // navigation is the one thing it takes back.
  let prevented = 0;
  const click = (): void => stage.by("copymap").fire("click", { preventDefault: () => void (prevented += 1) });
  click();
  expect(prevented).toBe(1);
  expect(stage.copied).toEqual([`${ORIGIN}/?map=${MAP}`]);
  await settled();
  expect(stage.by("copymap").textContent).toBe(COPIED);
  // A browser that refuses the write says so rather than pretending.
  stage.refuseCopy = true;
  click();
  await settled();
  expect(stage.by("copymap").textContent).toBe(NOT_COPIED);
  // Choosing another map puts the label back: it is a control, not a log.
  stage.refuseCopy = false;
  stage.by("map").fire("change");
  expect(stage.by("copymap").textContent).toBe(LABEL);
  // And a browser with no clipboard at all leaves the click alone: nothing is
  // prevented, so the anchor navigates, which is this page on that map.
  stage.host.copy = undefined;
  click();
  expect(prevented).toBe(2);
  expect(stage.copied.length).toBe(2);
});
// --- the map you can see before you play it -------------------------------
/**
 * How long a choice has to stand still before the plan of it is drawn, in
 * frames of this test's clock. It is `PLAN_WAIT` in `main.ts` — 200 ms — and it
 * is written as a count of frames because that is the only clock a test has.
 */
const SETTLE = Math.ceil(200 / FRAME) + 1;
/** The stub canvas's size, which is what a browser reports before any CSS. */
const PLAN_WIDTH = 800;
const PLAN_HEIGHT = 450;
/** Every 2D call the menu's plan canvas has been given, oldest first. */
const planCalls = (stage: FakeStage): [string, ...unknown[]][] => stage.plan.paint.calls;
/** What `drawPreview` puts on a canvas this size, for a level this test names. */
function planFor(level: Level): [string, ...unknown[]][] {
  const paint = recorder();
  drawPreview(paint, level, PLAN_WIDTH, PLAN_HEIGHT);
  return paint.calls.map((call) => [call.op, ...call.args] as [string, ...unknown[]]);
}
test("the menu draws the map Play would start, once the choice has stood still", () => {
  const stage = painted(start(fakeStage()));
  // Nothing is drawn while the atlas is being painted: the menu is answerable
  // and the frames belong to the browser.
  expect(planCalls(stage).length).toBe(0);
  expect(stage.by("planalt").textContent).toBe("");
  // One frame past the wait and the plan of de_forge is on the canvas, at the
  // size the browser is giving us of it, with the sentence beside it.
  for (let frame = 0; frame < SETTLE; frame++) stage.step(FRAME);
  expect([stage.plan.width, stage.plan.height]).toEqual([PLAN_WIDTH, PLAN_HEIGHT]);
  expect(planCalls(stage)).toEqual(planFor(DE_FORGE));
  expect(stage.by("planalt").textContent).toBe(previewText(DE_FORGE));
  // Once per choice and not once a frame: the frames after it draw nothing.
  const drawn = planCalls(stage).length;
  for (let frame = 0; frame < 10; frame++) stage.step(FRAME);
  expect(planCalls(stage).length).toBe(drawn);
  // A new map every match: the plan is the map that id carves, which is the map
  // the menu just named and the map Play is about to start.
  stage.by("map").value = "generated";
  stage.by("map").fire("change");
  const level = generateLevel(seedFrom(stage.ids[0] as string));
  expect(stage.by("willplay").textContent).toBe(level.name);
  for (let frame = 0; frame < SETTLE; frame++) stage.step(FRAME);
  expect(planCalls(stage).slice(drawn)).toEqual(planFor(level));
  expect(stage.by("planalt").textContent).toBe(previewText(level));
  // And it is that map that is played, with no second id drawn for it.
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe(level.name);
  expect(stage.ids.length).toBe(1);
});
test("a name typed a character at a time costs one map, and none while a match runs", () => {
  const stage = painted(start(fakeStage()));
  for (let frame = 0; frame < SETTLE; frame++) stage.step(FRAME);
  const drawn = planCalls(stage).length;
  // Typing: a keystroke a frame, which is faster than the wait, so no map is
  // carved for any of the prefixes — `gen_1` is a map, and not the one meant.
  for (const upto of [5, 6, 7, 8, 9, 10, 11]) {
    stage.by("mapseed").value = MAP.slice(0, upto);
    stage.by("mapseed").fire("input");
    stage.step(FRAME);
  }
  expect(planCalls(stage).length).toBe(drawn);
  // Hands off the keyboard, and the map they named is on the screen.
  for (let frame = 0; frame < SETTLE; frame++) stage.step(FRAME);
  const named = generateLevel(seedOf(MAP) as number);
  expect(planCalls(stage).slice(drawn)).toEqual(planFor(named));
  // A name that is not one is de_forge on the plan too, like everywhere else.
  const typed = planCalls(stage).length;
  stage.by("mapseed").value = "gen_0ya";
  stage.by("mapseed").fire("input");
  for (let frame = 0; frame < SETTLE; frame++) stage.step(FRAME);
  expect(planCalls(stage).slice(typed)).toEqual(planFor(DE_FORGE));
  // Nothing is drawn while a match is running: the menu is not on the screen
  // and the frame belongs to the round.
  const before = planCalls(stage).length;
  stage.by("mapseed").value = MAP;
  stage.by("mapseed").fire("input");
  stage.by("play").fire("click");
  for (let frame = 0; frame < SETTLE + 10; frame++) stage.step(FRAME);
  expect(planCalls(stage).length).toBe(before);
  // Back at the menu it is drawn again, for the map the next Play would start.
  stage.by("quit").fire("click");
  for (let frame = 0; frame < SETTLE; frame++) stage.step(FRAME);
  expect(planCalls(stage).slice(before)).toEqual(planFor(named));
});
// --- querySelectors, the same way: every call with a literal selector,
// against markup main.ts did not write.
const SELECTOR_CALL = /\.(?:querySelector|querySelectorAll|closest)(?:<[^>]+>)?\("([^"]+)"\)/g;
const selectors = [...new Set([...mainSource.matchAll(SELECTOR_CALL)].map((m) => m[1] as string))];
/**
 * A match played from one id: the page hands that id out instead of a fresh
 * one, Play is pressed, and `frames` frames are stepped. The id is the only
 * thing that differs between two calls, so two worlds that disagree disagree
 * because of it — and `withoutEntropy` is what says so, because a frame that
 * reached past the seed for `Math.random` or a clock would throw here rather
 * than quietly make the comparison below a coin toss.
 */
function fromId(id: string, frames: number): World {
  return withoutEntropy(() => {
    const stage = painted(start(fakeStage()));
    stage.host.randomUUID = () => id;
    stage.by("play").fire("click");
    for (let frame = 0; frame < frames; frame++) stage.step(FRAME);
    const world = worldOf(stage);
    if (world === null) throw new Error(`the id ${id} started no match`);
    return world;
  });
}
// Selectors main.ts runs against markup it wrote into the page itself: the
// controls panel's own buttons, the buy grid it builds, the radio panel's
// call buttons. `.grid` inside `#buy` is its own the same way these are.
const SELF_WRITTEN_SELECTORS = [
  "button.bind", ".bind-status", ".reset-bindings", ".grid", "button", ".buy-line", ".buy-why", ".radio-call",
];
test("a match is its id: the same id is the same match, and another id is another", () => {
  const ID = "3d9b7c1e-0000-4000-8000-5a2f6b4c8d11";
  // The world the page started is the world `createWorld` makes from this id —
  // not one the wall clock picked. Same roster out of the same draws, same bomb
  // in the same hands, and every number `snapshot` hashes identical.
  const booted = fromId(ID, 0);
  const mirror = createWorld(DE_FORGE, SHORT, "you", "ct", 5, seedFrom(ID));
  expect(booted.players.map((p) => p.name)).toEqual(mirror.players.map((p) => p.name));
  expect(booted.players.find((p) => p.hasBomb)?.name).toBe(mirror.players.find((p) => p.hasBomb)?.name);
  expect(snapshot(booted)).toBe(snapshot(mirror));
test("main.ts still finds selectors the way it always has", () => {
  expect(selectors.length).toBeGreaterThan(5);
  // And it stays that match as it is played: two seconds of frames from one id
  // agree tick for tick, and one character of a different id is a different
  // match — different spawns, different bots, a different round.
  const played = (id: string): string => snapshot(fromId(id, 60));
  const other = `${ID.slice(0, -1)}2`;
  expect(played(ID)).toBe(played(ID));
  expect(played(ID)).not.toBe(played(other));
});
test("every selector main.ts runs against the page it did not write matches something there", () => {
  for (const selector of selectors) {
    if (SELF_WRITTEN_SELECTORS.includes(selector)) continue;
    // The only shape left reaching into the page is a bare tag name —
    // `details` and `summary`, the structure crosshairControls and the
    // Controls panel both use.
    expect(selector).toMatch(/^[a-z]+$/);
    expect(html).toContain(`<${selector}`);
// --- a match you can play again -------------------------------------------
/** A match id shaped like the ones `crypto.randomUUID` hands out. */
const PASTED = "7f1c2a4e-1111-4000-8000-9b3d5e7a2c64";
/**
 * A stage with `id` pasted into the menu's field, played from there. The page
 * still hands out its own fresh ids — this is the id a *person* supplied, which
 * is the whole point — so what the world is seeded with is the field and not
 * the uuid behind it.
 */
function pasted(id: string, options: { map?: string } = {}): FakeStage {
  const stage = painted(start(fakeStage()));
  stage.by("matchid").value = id;
  if (options.map !== undefined) stage.by("map").value = options.map;
  stage.by("play").fire("click");
  return stage;
}
test("a pasted id is the match: the same id is the same world, a typo is a fresh one", () => {
  const world = worldOf(pasted(PASTED));
  const mirror = createWorld(DE_FORGE, SHORT, "you", "ct", 5, seedFrom(PASTED));
  expect(world).not.toBeNull();
  // The id came from the field, not from the page's own source of ids: the
  // uuid it drew is the row key, and the match is the one that was pasted.
  expect(snapshot(world as World)).toBe(snapshot(mirror));
  // Junk is not an error and not a refusal to play: a fresh match, and a line
  // under the field saying which of the two happened.
  const typo = pasted("not a match id");
  expect(typo.by("onid").textContent).toBe(NOT_AN_ID);
  expect(typo.by("menu").hidden).toBe(true);
  expect(snapshot(worldOf(typo) as World))
    .toBe(snapshot(createWorld(DE_FORGE, SHORT, "you", "ct", 5, seedFrom(typo.ids[0] as string))));
  // Fix the typo and the warning goes: the line under the field is about the
  // match that is being played now, not about one that was mistyped earlier.
  typo.by("quit").fire("click");
  typo.by("matchid").value = PASTED;
  typo.by("play").fire("click");
  expect(typo.by("onid").textContent).not.toBe(NOT_AN_ID);
  // And an empty field is what it always was: the id the page drew, nothing
  // said, and the world seeded from it.
  const fresh = playing();
  expect(fresh.by("onid").textContent).not.toBe(NOT_AN_ID);
  expect(snapshot(worldOf(fresh) as World))
    .toBe(snapshot(createWorld(DE_FORGE, SHORT, "you", "ct", 5, seedFrom(fresh.ids[0] as string))));
});
test("two worlds from one id fold to the same digest, and another id folds elsewhere", () => {
  // The claim the id makes, end to end and through the engine's `digest` door:
  // fourteen seconds — the whole freeze and two seconds of a live round, so the
  // bots have decided something — of the same fixed script over a world the
  // *page* started from a pasted id. Same id, same hash, to the tick; one
  // character away, another hash. `withoutEntropy` is what makes that a fact
  // rather than a coincidence: a frame that reached for `Math.random` or a
  // clock on the way would throw here instead.
  const TICKS = 14 * 64;
  const run = (id: string): string =>
    withoutEntropy(() => {
      const world = worldOf(pasted(id));
      if (world === null) throw new Error(`the id ${id} started no match`);
      return digest(world, TICKS).digest;
    });
  expect(run(PASTED)).toBe(run(PASTED));
  expect(run(PASTED)).not.toBe(run(`${PASTED.slice(0, -1)}5`));
});
test("a rematch is a new row: the id is the match, the posted key is this playing of it", async () => {
  const stage = pasted(PASTED);
  stage.step(FRAME);
  await settled();
  const first = JSON.parse(stage.posts[0]?.body ?? "{}");
  // The row key is not the id: it is the id with this play's nonce on it, so
  // the leaderboard cannot fold two games of one match into one row — and it
  // still reads back as the match it was a playing of.
  expect(first.matchId).not.toBe(PASTED);
  expect(matchOf(first.matchId)).toBe(PASTED);
  expect(parseResult(first)).not.toBeNull();
  // Play it again from the same menu: the same match, a different row.
  stage.by("quit").fire("click");
  stage.by("play").fire("click");
  // The same match over again — the same world the first click started —
  // written to a key of its own.
  expect(snapshot(worldOf(stage) as World))
    .toBe(snapshot(createWorld(DE_FORGE, SHORT, "you", "ct", 5, seedFrom(PASTED))));
  stage.step(FRAME);
  const second = JSON.parse(stage.posts[1]?.body ?? "{}");
  expect(second.matchId).not.toBe(first.matchId);
  expect(matchOf(second.matchId)).toBe(PASTED);
  // A match nobody asked for is its own row key, exactly as before today.
  const plain = playing();
  plain.step(FRAME);
  expect(JSON.parse(plain.posts[0]?.body ?? "{}").matchId).toBe(plain.ids[0]);
});
test("the match being played is on the page: the id, the map, the link and the pause line", () => {
  const stage = pasted(PASTED, { map: "generated" });
  const level = worldOf(stage)?.level;
  const mapName = nameOf(seedFrom(PASTED));
  expect(level?.name).toBe(mapName);
  expect(stage.by("playing").textContent).toBe(PASTED);
  expect(stage.by("mapname").textContent).toBe(mapName);
  // A real href, to this match on this map: following it is the rematch.
  expect(stage.by("share").attributes.href).toBe(`/?match=${PASTED}&map=generated`);
  // The pause panel says the same thing in words, because on a full screen
  // there is no page under the stage to read.
  expect(stage.by("pauseid").textContent).toBe(`Match ${PASTED} on ${level?.name}.`);
  // de_forge is not a map the id carves, and the link says so rather than
  // handing a friend a different map.
  stage.by("quit").fire("click");
  stage.by("map").value = "de_forge";
  stage.by("play").fire("click");
  expect(stage.by("mapname").textContent).toBe("de_forge");
  expect(stage.by("share").attributes.href).toBe(`/?match=${PASTED}&map=de_forge`);
});
// --- a pasted link ----------------------------------------------------------
/** Type this into the Match id field, the way a person pastes and the DOM tells us. */
function type(stage: FakeStage, text: string): FakeStage {
  stage.by("matchid").value = text;
  stage.by("matchid").fire("input");
  return stage;
}
test("a pasted link fills both controls, and the map named above Play is the map played", () => {
  const stage = painted(start(fakeStage()));
  type(stage, `${ORIGIN}/?match=${PASTED}&map=${MAP}`);
  // What is left on the screen is what will be played: the bare id in the id
  // field and the map in the Map control, both validated again on the way in.
  expect(stage.by("matchid").value).toBe(PASTED);
  expect(stage.by("mapseed").value).toBe(MAP);
  expect(stage.by("map").value).toBe("de_forge");
  expect(stage.by("willplay").textContent).toBe(MAP);
  expect(stage.by("onid").textContent).not.toBe(NOT_AN_ID);
  // And Play gives that: that match's spawns and bots on that layout, not on
  // whatever the Map control happened to be left on — which is the whole bug.
  stage.by("play").fire("click");
  const world = worldOf(stage) as World;
  expect(world.level.name).toBe(MAP);
  expect(snapshot(world))
    .toBe(snapshot(createWorld(generateLevel(seedOf(MAP) as number), SHORT, "you", "ct", 5, seedFrom(PASTED))));
  // Copying still gives the complete thing: both halves, as before today.
  expect(stage.by("share").attributes.href).toBe(`/?match=${PASTED}&map=${MAP}`);
  expect(stage.by("mapname").attributes.href).toBe(`/?map=${MAP}`);
  // A link asking for a map carved from its own id says so in the select, and
  // the name above Play is the map that id carves — before Play, as ever.
  stage.by("quit").fire("click");
  type(stage, `${ORIGIN}/?match=${PASTED}&map=generated`);
  expect(stage.by("map").value).toBe("generated");
  expect(stage.by("mapseed").value).toBe("");
  expect(stage.by("willplay").textContent).toBe(nameOf(seedFrom(PASTED)));
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe(nameOf(seedFrom(PASTED)));
  expect(stage.by("share").attributes.href).toBe(`/?match=${PASTED}&map=generated`);
});
test("a link pasted without a keystroke is still read when Play is pressed", () => {
  // A value set in code — a browser filling the field, a script, this test —
  // fires no event, so the link is taken apart at Play as well.
  const stage = pasted(`${ORIGIN}/?match=${PASTED}&map=${MAP}`);
  expect(worldOf(stage)?.level.name).toBe(MAP);
  expect(stage.by("playing").textContent).toBe(PASTED);
  expect(stage.by("matchid").value).toBe(PASTED);
});
test("a bare id leaves the Map control exactly where the player left it", () => {
  const stage = painted(start(fakeStage()));
  stage.by("mapseed").value = MAP;
  stage.by("mapseed").fire("input");
  type(stage, PASTED);
  // An id carries no map, and nothing pretends it does: the field a person set
  // is untouched and the line above Play still names their map.
  expect(stage.by("mapseed").value).toBe(MAP);
  expect(stage.by("willplay").textContent).toBe(MAP);
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe(MAP);
  // And the same for the select: a bare id on `generated` is that id's map.
  stage.by("quit").fire("click");
  stage.by("mapseed").value = "";
  stage.by("mapseed").fire("input");
  stage.by("map").value = "generated";
  stage.by("map").fire("change");
  type(stage, PASTED);
  expect(stage.by("map").value).toBe("generated");
  expect(stage.by("willplay").textContent).toBe(nameOf(seedFrom(PASTED)));
});
test("a link that is not ours is not followed and not a match: the sentence, and de_forge", () => {
  const stage = painted(start(fakeStage()));
  const untouched = stage.by("map").value;
  for (const text of [
    `https://evil.example/?match=${PASTED}&map=${MAP}`,
    `javascript:alert(1)?match=${PASTED}&map=${MAP}`,
    `${ORIGIN}/?utm=x`,
  ]) {
    type(stage, text);
    // The existing sentence, not an error — and the Map control is untouched,
    // because nothing of that URL was believed.
    expect(stage.by("onid").textContent).toBe(NOT_AN_ID);
    expect(stage.by("mapseed").value).toBe("");
    expect(stage.by("map").value).toBe(untouched);
    expect(stage.by("matchid").value).toBe(text);
  }
  // Play is a fresh match on de_forge, which is what a bad id has always been.
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe("de_forge");
  expect(stage.by("onid").textContent).toBe(NOT_AN_ID);
  expect(snapshot(worldOf(stage) as World))
    .toBe(snapshot(createWorld(DE_FORGE, SHORT, "you", "ct", 5, seedFrom(stage.ids[0] as string))));
  // And a link of ours that carried a match nobody could play says the same
  // thing, while still keeping the map it did carry.
  stage.by("quit").fire("click");
  type(stage, `${ORIGIN}/?match=nope&map=${MAP}`);
  expect(stage.by("onid").textContent).toBe(NOT_AN_ID);
  expect(stage.by("matchid").value).toBe("");
  expect(stage.by("willplay").textContent).toBe(MAP);
});
// --- the round's plan -------------------------------------------------------
test("a round is planned in the page, and the bots are a team from the first tick", () => {
  const stage = playing();
  stage.step(FRAME);
  const world = worldOf(stage) as World;
  const plan = world.plan;
  expect(plan).not.toBeNull();
  expect(plan?.source).toBe("local");
  expect(plan?.round).toBe(world.match.round);
  // The call is on the screen where a round's call belongs.
  expect(world.messages[world.messages.length - 1]?.text).toContain(world.me.team.toUpperCase());
  // A page that named no endpoint asks nobody: the only post is the result.
  expect(stage.posts.filter((post) => post.url === "/api/plan")).toHaveLength(0);
});
test("a page that names a planner asks it, with the situation and nothing else", async () => {
  const stage = playing({ planEndpoint: "/api/plan" });
  stage.step(FRAME);
  const posted = stage.posts.filter((post) => post.url === "/api/plan");
  expect(posted).toHaveLength(1);
  const sent = JSON.parse(String(posted[0]?.body)) as Record<string, unknown>;
  expect(parseSituation(sent)).not.toBeNull();
  expect(sent.round).toBe(1);
  expect(Object.keys(sent).sort()).toEqual(["lastWinner", "map", "money", "round", "score"]);
  expect(JSON.stringify(sent)).not.toContain("matchId");
  // The stage answers every post with the leaderboard, which is not a plan: the
  // local plan stays in force and the round is played on it.
  await Promise.resolve();
  stage.step(FRAME);
  const world = worldOf(stage) as World;
  expect(world.plan?.source).toBe("local");
  expect(stepsRun(stage)).toBeGreaterThan(0);
});
// --- the match of the day -------------------------------------------------
test("today's match fills the menu's own controls, and is the match that is played", () => {
  const stage = painted(start(fakeStage()));
  const daily = dailyOn(stage.wall);
  // The line is the browser's own day from the first frame: the server rendered
  // the same sentence, and this page derived it again rather than believing it.
  expect(stage.by("ontoday").textContent).toBe(saidToday(daily));
  // One press fills the three controls that say what a match is — the id, the
  // Map control, the length — so what is about to be played is on the screen.
  stage.by("today").fire("click");
  expect(stage.by("matchid").value).toBe(daily.match);
  expect(stage.by("map").value).toBe("generated");
  expect(stage.by("mapseed").value).toBe("");
  expect(stage.by("length").value).toBe(DAILY_LENGTH);
  // And the map is named before Play, out of the id, like every other match on
  // `generated` — without drawing an id of its own, because the day is the id.
  expect(stage.by("willplay").textContent).toBe(daily.map);
  expect(stage.by("copymap").attributes.href).toBe(`/?map=${daily.map}`);
  expect(stage.ids.length).toBe(0);
  // Play is that match: that id, that map, that length, and the link under the
  // stage plays it again.
  stage.by("play").fire("click");
  expect(worldOf(stage)?.level.name).toBe(daily.map);
  expect(worldOf(stage)?.match.rules).toEqual(SHORT);
  expect(stage.by("playing").textContent).toBe(daily.match);
  expect(stage.by("share").attributes.href).toBe(`/?match=${daily.match}&map=generated`);
  // What a round will be posted under is a *playing* of today's match, so a
  // second run is a second row and the match inside the key is still today's.
  expect(matchOf(String(stage.by("pauseid").textContent).split(" ")[1] ?? "")).toBe(daily.match);
});
test("a browser that crosses midnight picks up the new day's match, not yesterday's", () => {
  const stage = painted(start(fakeStage()));
  const before = dailyOn(stage.wall);
  stage.by("today").fire("click");
  expect(stage.by("matchid").value).toBe(before.match);
  // The tab was left open. The day is derived from the clock on every press,
  // so the next one is the match of the day it is now.
  stage.wall += 86_400_000;
  const after = dailyOn(stage.wall);
  expect(after.match).not.toBe(before.match);
  stage.by("today").fire("click");
  expect(stage.by("matchid").value).toBe(after.match);
  expect(stage.by("ontoday").textContent).toBe(saidToday(after));
  expect(stage.by("willplay").textContent).toBe(after.map);
});
@@ -1,99 +1,39 @@
/**
 * de_forge, pinned. Everything this file asserted when the map was a module of
 * singletons it asserts now about `DE_FORGE`, the one value `map.ts` exports:
 * the same cells, the same fifty boxes, the same thirty-three waypoints from T
 * spawn to A. What a *level* is, and what is true of every one of them, is
 * `level.test.ts`; this is about this map.
 */
import { expect, test } from "bun:test";
import {
  buildMap, CELL, cellAt, colOf, DE_CINDER, DE_FORGE, DEFAULT_MAP, findPath, MAP_NAMES, mapFor, MAPS,
  placeAt, placeLabel, rowOf, siteAt, walkable, worldOf, type Layout, type MapDef,
} from "./map.ts";
import { cellAt, colOf, findPath, rowOf, siteAt, walkable, worldOf } from "./level.ts";
import { DE_FORGE, GRID_H, GRID_W } from "./map.ts";
import { levelMesh } from "./models.ts";
const { boxes, sites, spawns } = DE_FORGE;
/**
 * Every structural claim below holds for every map in the catalogue, not just
 * the one the game opens on. A layout is a table of numbers typed by hand; the
 * way it goes wrong is a site inside a crate or a room nothing can walk to,
 * and neither of those is visible in the table.
 * Where the Ts start, which half the tests below walk from. The map has more
 * than four of them — the test above says so — so the first one is there.
 */
const CATALOGUE: [string, MapDef][] = MAP_NAMES.map((name) => [name, MAPS[name]]);
const T_SPAWN = spawns.t[0]!;
/** Every cell the flood fill from `start` can reach, four ways, walking. */
function reachable(map: MapDef, start: [number, number]): Set<number> {
  const seen = new Set<number>([start[1] * map.gridW + start[0]]);
  const queue = [start[1] * map.gridW + start[0]];
  while (queue.length > 0) {
    const i = queue.pop() as number;
    const c = i % map.gridW, r = Math.floor(i / map.gridW);
    for (const [dc, dr] of [[1, 0], [-1, 0], [0, 1], [0, -1]] as [number, number][]) {
      if (!walkable(map, c + dc, r + dr)) continue;
      const j = (r + dr) * map.gridW + c + dc;
      if (seen.has(j)) continue;
      seen.add(j);
      queue.push(j);
    }
  }
  return seen;
}
test.each(CATALOGUE)("%s has two sites and two spawns", (_name, map) => {
  expect(map.spawns.t.length).toBeGreaterThan(4);
  expect(map.spawns.ct.length).toBeGreaterThan(4);
  expect(siteAt(map, map.sites.A)).toBe("A");
  expect(siteAt(map, map.sites.B)).toBe("B");
test("the map has two sites and two spawns", () => {
  expect(spawns.t.length).toBeGreaterThan(4);
  expect(spawns.ct.length).toBeGreaterThan(4);
  expect(siteAt(DE_FORGE, sites.A)).toBe("A");
  expect(siteAt(DE_FORGE, sites.B)).toBe("B");
});
// A site's `sites` point is where a bot walks to plant. A crate dropped on the
// middle of a site leaves the name in the grid and the point inside the box:
// the plant still happens, against a wall, and only a person standing there
// ever finds out.
test.each(CATALOGUE)("%s plants on floor, not inside a crate", (_name, map) => {
  for (const site of ["A", "B"] as const) {
    const at = map.sites[site];
    expect(walkable(map, colOf(map, at[0]), rowOf(map, at[1]))).toBe(true);
    expect(cellAt(map, colOf(map, at[0]), rowOf(map, at[1]))).toBe(site);
test("the border is solid all the way round", () => {
  for (let c = 0; c < GRID_W; c++) {
    expect(cellAt(DE_FORGE, c, 0)).toBe("#");
    expect(cellAt(DE_FORGE, c, GRID_H - 1)).toBe("#");
  }
});
// A crate is cover: a sightline broken, something to walk round and hold.
// One placed on a wall cell builds just as well — the grid takes the mark and
// the mesh takes the box — and the only sign is cover nobody can use, because
// a table of coordinates typed by hand says nothing about what was underneath.
test.each(CATALOGUE)("%s stands every crate on the floor, with room to walk round it", (_name, map) => {
  let crates = 0;
  for (let r = 0; r < map.gridH; r++)
    for (let c = 0; c < map.gridW; c++) {
      const cell = cellAt(map, c, r);
      if (cell !== "x" && cell !== "X") continue;
      crates++;
      let open = 0;
      for (const [dc, dr] of [[1, 0], [-1, 0], [0, 1], [0, -1]] as [number, number][])
        if (walkable(map, c + dc, r + dr)) open++;
      // Two open sides, not one: cover you can only reach head-on is a dead
      // end, and cover with none at all is a box inside a wall.
      expect(open).toBeGreaterThan(1);
    }
  expect(crates).toBeGreaterThan(10); // and the map really is furnished
});
test.each(CATALOGUE)("%s musters each side in its own spawn, on a cell you can walk to", (_name, map) => {
  for (const team of ["t", "ct"] as const) {
    const at = map.muster[team];
    expect(cellAt(map, colOf(map, at[0]), rowOf(map, at[1]))).toBe(team === "t" ? "t" : "c");
    expect(walkable(map, colOf(map, at[0]), rowOf(map, at[1]))).toBe(true);
    // And it is somewhere a bot can reach from either site, which is what
    // a counter-terrorist out of clock asks the pathfinder for.
    for (const site of [map.sites.A, map.sites.B]) {
      expect(findPath(map, site, at).length).toBeGreaterThan(0);
    }
  }
  // The two halves of the map really are two halves: T at the bottom of the
  // grid, CT at the top, the sites between them.
  expect(map.muster.t[1]).toBeLessThan(map.muster.ct[1]);
});
test.each(CATALOGUE)("%s is walled all the way round", (_name, map) => {
  for (let c = 0; c < map.gridW; c++) {
    expect(cellAt(map, c, 0)).toBe("#");
    expect(cellAt(map, c, map.gridH - 1)).toBe("#");
  }
  for (let r = 0; r < map.gridH; r++) {
    expect(cellAt(map, 0, r)).toBe("#");
    expect(cellAt(map, map.gridW - 1, r)).toBe("#");
  for (let r = 0; r < GRID_H; r++) {
    expect(cellAt(DE_FORGE, 0, r)).toBe("#");
    expect(cellAt(DE_FORGE, GRID_W - 1, r)).toBe("#");
  }
});
@@ -105,206 +45,108 @@
test("grid and world coordinates round-trip", () => {
  }
});
test.each(CATALOGUE)("every walkable cell of %s is reachable from T spawn", (_name, map) => {
test("every walkable cell is reachable from T spawn", () => {
  // A room nobody can reach is a bug you only find by walking into it.
  const start = map.spawns.t[0];
  const seen = reachable(map, [colOf(map, start[0]), rowOf(map, start[1])]);
  const start = T_SPAWN;
  const seen = new Set<number>();
  const queue = [rowOf(DE_FORGE, start[1]) * GRID_W + colOf(DE_FORGE, start[0])];
  seen.add(queue[0]!);
  while (queue.length > 0) {
    const i = queue.pop() as number;
    const c = i % GRID_W, r = Math.floor(i / GRID_W);
    for (const [dc, dr] of [[1, 0], [-1, 0], [0, 1], [0, -1]] as [number, number][]) {
      if (!walkable(DE_FORGE, c + dc, r + dr)) continue;
      const j = (r + dr) * GRID_W + c + dc;
      if (seen.has(j)) continue;
      seen.add(j);
      queue.push(j);
    }
  }
  let walkables = 0;
  for (let r = 0; r < map.gridH; r++)
    for (let c = 0; c < map.gridW; c++) if (walkable(map, c, r)) walkables++;
  for (let r = 0; r < GRID_H; r++)
    for (let c = 0; c < GRID_W; c++) if (walkable(DE_FORGE, c, r)) walkables++;
  expect(seen.size).toBe(walkables);
});
test.each(CATALOGUE)("greedy meshing collapses %s's walls into few boxes", (_name, map) => {
  expect(map.boxes.length).toBeGreaterThan(10);
  expect(map.boxes.length).toBeLessThan(300);
test("greedy meshing collapses the walls into few boxes", () => {
  expect(boxes.length).toBeGreaterThan(10);
  expect(boxes.length).toBeLessThan(300);
});
// Not "a path exists" but "a path exists from every cell a round can start on
// to both places it can be decided". One spawn cell walled off behind a crate
// is one bot in five standing still for a whole match.
test.each(CATALOGUE)("on %s every spawn cell reaches both sites", (_name, map) => {
  for (const team of ["t", "ct"] as const) {
    for (const spawn of map.spawns[team]) {
      for (const site of [map.sites.A, map.sites.B]) {
        const path = findPath(map, spawn, site);
        expect(path.length).toBeGreaterThan(4);
        // Consecutive waypoints are neighbouring cells, never a jump across a wall.
        for (let i = 1; i < path.length - 1; i++) {
          const step = Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]);
          expect(step).toBeLessThan(200);
        }
      }
test("de_forge is exactly where it was, to the unit", () => {
  // The whole level comes out of one function, so half a cell of drift in the
  // arithmetic moves every wall, every spawn and every bot with it and nothing
  // else in the suite would say so. These numbers are hand-checkable:
  // 44 cells of 128 units is 5632 across, so the floor runs -2816..2816.
  expect(boxes.length).toBe(50);
  expect(boxes[0]).toEqual({ min: [-2816, -2816, -32], max: [2816, 2816, 0], mat: 0 });
  // The last box is the last uncrossable crate in reading order, at (37, 26):
  // x = (37 - 22 + 0.5) * 128 = 1984, y = (22 - 26 - 0.5) * 128 = -576, and a
  // crate is one cell wide and 128 tall.
  expect(boxes[boxes.length - 1]).toEqual({
    min: [1920, -640, 0], max: [2048, -512, 128], mat: 2,
  });
});
test("the route from T spawn to A is the same route it was", () => {
  // A number a change to the search moves: 33 waypoints from the first T spawn
  // cell to the centre of A, 4506 units walked against 4142 as the crow flies.
  const path = findPath(DE_FORGE, T_SPAWN, sites.A);
  expect(T_SPAWN).toEqual([576, -1984, 0]);
  expect(path.length).toBe(33);
  expect(path[0]).toEqual([704, -1984, 0]);
  expect(path[path.length - 1]).toEqual(sites.A);
  let walked = 0;
  for (let i = 1; i < path.length; i++)
    walked += Math.hypot(path[i]![0] - path[i - 1]![0], path[i]![1] - path[i - 1]![1]);
  expect(walked).toBeCloseTo(4506.04, 1);
  const crow = Math.hypot(sites.A[0] - T_SPAWN[0], sites.A[1] - T_SPAWN[1]);
  expect(crow).toBeCloseTo(4141.87, 1);
});
test("a path from T spawn reaches both sites", () => {
  for (const site of [sites.A, sites.B]) {
    const path = findPath(DE_FORGE, T_SPAWN, site);
    expect(path.length).toBeGreaterThan(4);
    // Consecutive waypoints are neighbouring cells, never a jump across a wall.
    for (let i = 1; i < path.length - 1; i++) {
      const step = Math.hypot(path[i]![0] - path[i - 1]![0], path[i]![1] - path[i - 1]![1]);
      expect(step).toBeLessThan(200);
    }
  }
});
// Both sites reachable is not the same as both sites *approachable*: a site
// with one door is a site the defence holds by standing in the door. Each one
// here has two ways in that do not share their last step.
test.each(CATALOGUE)("%s lets each site be entered two ways", (_name, map) => {
  for (const site of ["A", "B"] as const) {
    // Every walkable cell that is not the site but touches it, grouped by
    // whether the cells themselves touch: one group is one doorway.
    const mouth = new Set<number>();
    for (let r = 0; r < map.gridH; r++)
      for (let c = 0; c < map.gridW; c++) {
        if (cellAt(map, c, r) !== site) continue;
        for (const [dc, dr] of [[1, 0], [-1, 0], [0, 1], [0, -1]] as [number, number][])
          if (walkable(map, c + dc, r + dr) && cellAt(map, c + dc, r + dr) !== site)
            mouth.add((r + dr) * map.gridW + c + dc);
      }
    const seen = new Set<number>();
    let doors = 0;
    for (const start of mouth) {
      if (seen.has(start)) continue;
      doors++;
      const queue = [start];
      seen.add(start);
      while (queue.length > 0) {
        const i = queue.pop() as number;
        const c = i % map.gridW, r = Math.floor(i / map.gridW);
        for (const [dc, dr] of [[1, 0], [-1, 0], [0, 1], [0, -1]] as [number, number][]) {
          const j = (r + dr) * map.gridW + c + dc;
          if (!mouth.has(j) || seen.has(j)) continue;
          seen.add(j);
          queue.push(j);
        }
      }
    }
    expect(doors).toBeGreaterThan(1);
  }
});
// One scale, one set of crates, one CELL: the shipped policy reads distances
// and the radar reads the grid, and neither is told which map it is on.
test("both maps are the same size, in the same cells", () => {
  expect(DE_CINDER.gridW).toBe(DE_FORGE.gridW);
  expect(DE_CINDER.gridH).toBe(DE_FORGE.gridH);
  expect(CELL).toBe(128);
});
test("a path into solid rock comes back empty rather than lying", () => {
  expect(findPath(DE_FORGE, DE_FORGE.spawns.t[0], worldOf(DE_FORGE, 0, 0))).toEqual([]);
  expect(findPath(DE_FORGE, T_SPAWN, worldOf(DE_FORGE, 0, 0))).toEqual([]);
});
/** A hand-written layout small enough to check by eye: one room, one crate, two sites. */
const TOY: Layout = {
  name: "toy",
  gridW: 6,
  gridH: 6,
  areas: [
    { name: "room", rect: [1, 1, 4, 4], fill: "." },
    { name: "t spawn", rect: [1, 4, 1, 4], fill: "t" },
    { name: "ct spawn", rect: [4, 1, 4, 1], fill: "c" },
    { name: "a site", rect: [3, 3, 3, 3], fill: "A" },
    { name: "b site", rect: [1, 1, 1, 1], fill: "B" },
  ],
  crates: [[2, 2, "x"]],
};
test("buildMap turns a layout into the cells, spawns and sites it describes", () => {
  const toy = buildMap(TOY);
  expect(toy.name).toBe("toy");
  expect(toy.gridW).toBe(6);
  expect(toy.gridH).toBe(6);
  // The border nobody carved is still solid rock.
  expect(cellAt(toy, 0, 0)).toBe("#");
  expect(cellAt(toy, 5, 5)).toBe("#");
  // The crate landed where it was placed, inside the room.
  expect(cellAt(toy, 2, 2)).toBe("x");
  expect(toy.spawns.t).toEqual([worldOf(toy, 1, 4)]);
  expect(toy.spawns.ct).toEqual([worldOf(toy, 4, 1)]);
  expect(siteAt(toy, toy.sites.A)).toBe("A");
  expect(siteAt(toy, toy.sites.B)).toBe("B");
test("de_forge carries its own alphabet, its numbers and its material table", () => {
  // The predicate is the level's: nobody outside this file knows what a crate is.
  expect(DE_FORGE.name).toBe("de_forge");
  expect(DE_FORGE.passable(".")).toBe(true);
  for (const solid of ["#", "x", "X"]) expect(DE_FORGE.passable(solid)).toBe(false);
  for (const open of ["A", "B", "t", "c"]) expect(DE_FORGE.passable(open)).toBe(true);
  expect(DE_FORGE.grid.cell).toBe(128);
  expect(DE_FORGE.grid.cells.length).toBe(GRID_W * GRID_H);
  expect(DE_FORGE.wallHeight).toBe(384);
  expect(DE_FORGE.materials).toEqual({ FLOOR: 0, WALL: 1, CRATE: 2, SITE: 3, METAL: 4 });
  expect(DE_FORGE.siteCells).toEqual({ A: "A", B: "B" });
  expect(DE_FORGE.look).toBe("forge");
});
test("the catalogue holds both maps, and nothing builds either twice", () => {
  expect(MAP_NAMES).toEqual(["de_forge", "de_cinder"]);
  expect(DEFAULT_MAP).toBe("de_forge");
  expect(MAPS.de_forge).toBe(DE_FORGE);
  expect(MAPS.de_cinder).toBe(DE_CINDER);
  expect(DE_CINDER).not.toBe(DE_FORGE);
  expect(DE_CINDER.grid).not.toEqual(DE_FORGE.grid);
});
// A key and its map's own `name` diverging is a silent 422 on every post — a
// second layout with a key that does not match `MapDef.name` would still
// build, still show up in the menu, and only fail the moment a match on it
// is saved.
test("every catalogue key names the map it holds", () => {
  for (const name of MAP_NAMES) expect(MAPS[name].name).toBe(name);
});
test("mapFor returns the map a valid name asks for", () => {
  expect(mapFor("de_forge")).toBe(DE_FORGE);
  expect(mapFor("de_cinder")).toBe(DE_CINDER);
});
test("mapFor falls back to the default map for anything unrecognised", () => {
  expect(mapFor("nonsense")).toBe(MAPS[DEFAULT_MAP]);
  expect(mapFor("")).toBe(MAPS[DEFAULT_MAP]);
  expect(mapFor("DE_FORGE")).toBe(MAPS[DEFAULT_MAP]); // case matters: this is not a stored name
});
test("two maps built from two layouts hold no state in common", () => {
  const a = buildMap({ ...TOY, name: "a" });
  const b = buildMap({ ...TOY, gridW: 8, gridH: 8, name: "b", crates: [] });
  expect(a).not.toBe(b);
  expect(a.grid).not.toBe(b.grid);
  expect(a.gridW).toBe(6);
  expect(b.gridW).toBe(8);
  expect(cellAt(a, 2, 2)).toBe("x"); // a has the crate
  expect(cellAt(b, 2, 2)).toBe("."); // b was built with none
  expect(a).not.toBe(DE_FORGE);
  expect(a.grid).not.toBe(DE_FORGE.grid);
});
// --- places, the vocabulary a callout is said in --------------------------
test.each(CATALOGUE)("%s names every place it can stand in, out of its own areas", (_name, map) => {
  expect(map.places.length).toBeGreaterThan(8);
  // Every walkable cell is inside some area: a layout that carved a room and
  // forgot to name it would leave a teammate saying "enemy" and nothing else.
  for (let r = 0; r < map.gridH; r++) {
    for (let c = 0; c < map.gridW; c++) {
      if (!walkable(map, c, r)) continue;
      expect(placeAt(map, worldOf(map, c, r))).not.toBeNull();
    }
  }
  // And nothing outside the grid is anywhere at all.
  expect(placeAt(map, [1e6, 1e6, 0])).toBeNull();
});
test.each(CATALOGUE)("%s says the sites and the spawns the way a person would", (_name, map) => {
  expect(placeAt(map, map.sites.A)).toBe("A site");
  expect(placeAt(map, map.sites.B)).toBe("B site");
  expect(placeAt(map, map.muster.t)).toBe("T spawn");
  expect(placeAt(map, map.muster.ct)).toBe("CT spawn");
});
test("a place is the area actually painted there, not the first one to claim it", () => {
  // Two rooms, the second painted over the first: a point in the overlap is
  // standing on the second one's cells, so that is what it is called.
  const map = buildMap({
    name: "overlap",
    gridW: 6,
    gridH: 6,
    areas: [
      { name: "long a", rect: [1, 1, 4, 4], fill: "." },
      { name: "ct mid", rect: [3, 3, 4, 4], fill: "." },
    ],
    crates: [],
  });
  expect(placeAt(map, worldOf(map, 1, 1))).toBe("long A");
  expect(placeAt(map, worldOf(map, 4, 4))).toBe("CT mid");
});
test("placeLabel says letters as letters and leaves every other word alone", () => {
  expect(placeLabel("a site")).toBe("A site");
  expect(placeLabel("long a")).toBe("long A");
  expect(placeLabel("b link")).toBe("B link");
  expect(placeLabel("ct spawn")).toBe("CT spawn");
  expect(placeLabel("lower tunnel")).toBe("lower tunnel");
  expect(placeLabel("catwalk")).toBe("catwalk");
/**
 * #151 lets a map choose which of the nine materials it is painted from. This
 * is the claim that de_forge did not choose: the same fifty boxes tagged with
 * the same layers they always were, and the mesh drawn from them the same
 * 1,200 vertices split the same way — 24 of floor, 600 of wall, 528 of crate
 * and 48 of site paint. A look applied to this map by accident lands here.
 */
test("de_forge is painted from exactly the layers it always was", () => {
  expect(boxes.map((box) => box.mat)).toEqual([
    0, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  ]);
  const counted: Record<number, number> = {};
  for (const layer of levelMesh(boxes).layer) counted[layer] = (counted[layer] ?? 0) + 1;
  expect(counted).toEqual({ 0: 24, 1: 600, 2: 528, 3: 48 });
});
@@ -1,414 +1,83 @@
/**
 * The map: a grid of 128-unit cells carved out of solid rock by named areas,
 * de_forge: a grid of 128-unit cells carved out of solid rock by named areas,
 * then merged back into as few boxes as possible. One piece of data feeds
 * everything — what you collide with, what gets drawn, where bots walk, where
 * the bomb can be planted — so the map can never disagree with itself.
 *
 * A map is a value, `MapDef`, built once by `buildMap` from a layout's areas
 * and crates. Two layouts are in the catalogue below; nothing here reaches for
 * a module-level grid, so a third is a third table and a third key.
 * Layout is dust-shaped and original: two sites, a mid, a long right-hand
 * corridor and a left-hand tunnel, T at the bottom of the grid, CT at the top.
 *
 * Both are original, both are 44 cells square, and both put T at the bottom of
 * the grid and CT at the top with the sites between them — that convention is
 * what the radar, the spawns and a counter-terrorist walking back to its own
 * half all read. `de_forge` is dust-shaped: two sites along the top, a mid, a
 * long right-hand corridor and a left-hand tunnel. `de_cinder` is not: the
 * sites are diagonally opposite, and the shortest way from one to the other
 * runs through the courtyard in the middle rather than behind it.
 * This file is one map and nothing else: the areas, the crates and nothing
 * about what a letter means. What the letters are and what a page of them
 * becomes is `src/client/cells.ts`, which `generate.ts` writes its maps in too;
 * what a level *is* — the grid, the boxes, the spawns, the sites and the
 * questions asked of them — is `src/client/level.ts`, and `DE_FORGE` below is
 * one value of that type, built once here and handed to `createWorld`. Nobody
 * imports this map to find out where they are standing; they read the level off
 * the world they are in.
 *
 * Everything in here is Counter-Strike. The grid itself — the cell arithmetic,
 * the greedy meshing and the A* — is `src/engine/grid.ts`, which knows nothing
 * about this alphabet: what counts as solid or walkable goes in as a predicate.
 */
import type { Vec3 } from "./math.ts";
import * as g from "../engine/index.ts";
import { CELL, levelOf, type Cell } from "./cells.ts";
import type { Level } from "./level.ts";
export const CELL = 128;
export const WALL_HEIGHT = 384;
export type Cell = "#" | "." | "x" | "X" | "A" | "B" | "t" | "c";
/** De_forge is 44 cells on a side: 5,632 Source units, a little under dust's. */
export const GRID_W = 44;
export const GRID_H = 44;
/** [col0, row0, col1, row1] inclusive, and what the cells become. */
export type Area = { name: string; rect: [number, number, number, number]; fill: Cell };
type Area = { name: string; rect: [number, number, number, number]; fill: Cell };
export type Layout = {
  name: string;
  gridW: number;
  gridH: number;
  areas: Area[];
  /** Cover, placed by hand: lower-case is jumpable, upper-case is not. */
  crates: [number, number, Cell][];
};
export const MAT = { FLOOR: 0, WALL: 1, CRATE: 2, SITE: 3, METAL: 4 } as const;
export type Box = { min: Vec3; max: Vec3; mat: number };
/**
 * One named piece of the map, as a person would say it out loud: the layout's
 * own area, with its grid rectangle and a label built once when the map is.
 * This is the whole vocabulary anything in the game has for saying *where* —
 * there is no second table of places to drift out of step with the areas that
 * actually carve the rock.
 */
export type Place = { name: string; rect: [number, number, number, number] };
/** A built map: the grid, its geometry, and the places bots and spawns care about. */
export type MapDef = {
  name: string;
  gridW: number;
  gridH: number;
  grid: Cell[];
  /** Everything solid, in one list: the renderer draws it and bullets stop in it. */
  boxes: Box[];
  spawns: { t: Vec3[]; ct: Vec3[] };
  /**
   * The middle of each side's spawn: one point to name the half of the map a
   * side comes from. A site is where the round is decided; this is where the
   * other side must be when it is not there yet, which is what a bot with a
   * running-out clock and nothing to shoot at wants to know.
   *
   * Both halves, because it is a fact about the map and `spawns` already has
   * both — the average of a list this file has built either way. Only `t` is
   * read today, by a counter-terrorist out of clock in `bots.ts`.
   */
  muster: { t: Vec3; ct: Vec3 };
  sites: { A: Vec3; B: Vec3 };
  /**
   * The layout's areas, last-painted first, so the first rectangle a point
   * falls in is the one whose cells it is actually standing on — the same
   * "a later area wins" rule `buildGrid` paints by. `placeAt` reads it.
   */
  places: Place[];
};
const DE_FORGE_LAYOUT: Layout = {
  name: "de_forge",
  gridW: 44,
  gridH: 44,
  areas: [
    { name: "ct spawn", rect: [18, 2, 27, 6], fill: "c" },
    { name: "ct mid", rect: [20, 6, 25, 11], fill: "." },
    { name: "a link", rect: [27, 3, 32, 7], fill: "." },
    { name: "a site", rect: [32, 3, 41, 11], fill: "A" },
    { name: "long a", rect: [35, 11, 39, 31], fill: "." },
    { name: "doors", rect: [30, 30, 39, 34], fill: "." },
    { name: "t long", rect: [28, 34, 35, 38], fill: "." },
    { name: "t spawn", rect: [16, 37, 28, 41], fill: "t" },
    { name: "t mid", rect: [19, 27, 25, 37], fill: "." },
    { name: "mid", rect: [19, 11, 25, 27], fill: "." },
    { name: "catwalk", rect: [25, 14, 32, 17], fill: "." },
    { name: "a ramp", rect: [30, 8, 33, 14], fill: "." },
    { name: "b site", rect: [2, 3, 11, 11], fill: "B" },
    { name: "b link", rect: [11, 5, 18, 9], fill: "." },
    { name: "tunnels", rect: [4, 11, 8, 30], fill: "." },
    { name: "lower tunnel", rect: [4, 30, 14, 35], fill: "." },
    { name: "t tunnel", rect: [14, 33, 18, 38], fill: "." },
    { name: "short", rect: [8, 20, 19, 23], fill: "." },
  ],
  crates: [
    [34, 5, "X"], [35, 5, "x"], [38, 8, "x"], [39, 4, "X"], [33, 9, "x"],
    [4, 5, "X"], [5, 5, "x"], [8, 8, "x"], [9, 4, "x"], [3, 9, "X"],
    [21, 18, "x"], [23, 18, "x"], [22, 24, "X"],
    [37, 20, "x"], [37, 26, "X"], [6, 18, "x"], [6, 25, "X"],
    [20, 3, "x"], [25, 3, "x"], [18, 39, "x"], [26, 39, "x"], [28, 15, "x"],
  ],
};
/**
 * The second place to play. Where de_forge hangs both sites off the top of the
 * grid and runs two long lanes down to the terrorists, de_cinder puts them on
 * a diagonal — A in the north-west, B halfway down the east wall — around a
 * courtyard the rotation between them has to cross. de_forge's counter-
 * terrorists swap sites along one corridor behind their own spawn; de_cinder's
 * walk through the middle, which is the whole difference in how it plays.
 *
 * Each site has the long way and the other way. A is the west long, a twenty-
 * cell climb up the left wall from the terrorist end; or the vents, three
 * cells tall, out of the courtyard's west side into the middle of that climb.
 * B is the ramp up from t long on the east; or the kiln door, straight out of
 * the courtyard into B's north-west shoulder. The counter-terrorists come down
 * the kiln walk to A and the balcony to B, and both of those cross a route the
 * terrorists can take, so no approach is anybody's private corridor.
 *
 * Areas are painted in order and a later one wins, which is how the doorways
 * are cut: `west long` takes a bite out of A's south edge, `kiln walk` takes
 * one out of its east edge. Crates in a spawn are placed in pairs either side
 * of its middle so `muster` stays where it looks like it is.
 */
const DE_CINDER_LAYOUT: Layout = {
  name: "de_cinder",
  gridW: 44,
  gridH: 44,
  areas: [
    { name: "ct spawn", rect: [24, 2, 34, 5], fill: "c" },
    { name: "ct mid", rect: [20, 6, 25, 13], fill: "." },
    { name: "b link", rect: [30, 6, 40, 9], fill: "." },
    { name: "balcony", rect: [36, 9, 40, 16], fill: "." },
    { name: "b site", rect: [32, 17, 40, 25], fill: "B" },
    { name: "kiln door", rect: [26, 18, 32, 21], fill: "." },
    { name: "ramp", rect: [27, 24, 31, 33], fill: "." },
    { name: "t long", rect: [22, 33, 31, 37], fill: "." },
    { name: "a site", rect: [3, 4, 11, 11], fill: "A" },
    { name: "kiln walk", rect: [11, 6, 20, 9], fill: "." },
    { name: "west long", rect: [3, 11, 7, 30], fill: "." },
    { name: "vents", rect: [8, 22, 16, 24], fill: "." },
    { name: "lower west", rect: [3, 30, 12, 35], fill: "." },
    { name: "t west", rect: [9, 34, 13, 36], fill: "." },
    { name: "mid", rect: [17, 13, 25, 26], fill: "." },
    { name: "t mid", rect: [17, 26, 22, 37], fill: "." },
    { name: "t spawn", rect: [9, 37, 20, 41], fill: "t" },
  ],
  crates: [
    [5, 6, "X"], [6, 6, "x"], [8, 5, "x"], [9, 9, "x"], [4, 10, "X"],
    [34, 19, "X"], [35, 19, "x"], [39, 18, "X"], [38, 23, "x"], [33, 24, "x"],
    [19, 17, "x"], [23, 17, "x"], [21, 23, "X"],
    [5, 16, "x"], [5, 27, "X"], [38, 12, "x"], [29, 29, "x"], [14, 23, "x"],
    [24, 35, "x"], [30, 7, "x"], [18, 7, "x"], [11, 39, "x"], [18, 39, "x"],
    [26, 3, "x"], [32, 3, "x"],
  ],
};
/**
 * The words a layout writes in lower case that a person says as letters: the
 * sites, and the two sides. "a site" is A site and "ct mid" is CT mid; every
 * other word of an area name is already the word you would say.
 */
const SPOKEN: Record<string, string> = { a: "A", b: "B", t: "T", ct: "CT" };
/** An area name as it is said out loud, built once per map and never per tick. */
export const placeLabel = (name: string): string =>
  name.split(" ").map((word) => SPOKEN[word] ?? word).join(" ");
/** The layout's areas as places, last-painted first (see `MapDef.places`). */
const buildPlaces = (layout: Layout): Place[] =>
  layout.areas.map((area) => ({ name: placeLabel(area.name), rect: area.rect })).reverse();
function buildGrid(layout: Layout): Cell[] {
  const g: Cell[] = new Array(layout.gridW * layout.gridH).fill("#");
  for (const area of layout.areas) {
    const [c0, r0, c1, r1] = area.rect;
    for (let r = r0; r <= r1; r++)
      for (let c = c0; c <= c1; c++) g[r * layout.gridW + c] = area.fill;
  }
  for (const [c, r, cell] of layout.crates) g[r * layout.gridW + c] = cell;
  return g;
}
export const cellAt = (map: MapDef, col: number, row: number): Cell =>
  col < 0 || row < 0 || col >= map.gridW || row >= map.gridH
    ? "#"
    : (map.grid[row * map.gridW + col] as Cell);
/** Solid to a walking bot: walls and both kinds of crate. */
export const walkable = (map: MapDef, col: number, row: number): boolean => {
  const c = cellAt(map, col, row);
  return c !== "#" && c !== "x" && c !== "X";
};
/** Grid coordinates are north-down; the world is Y-north, centred on zero. */
export const worldOf = (map: MapDef, col: number, row: number, z = 0): Vec3 => [
  (col - map.gridW / 2 + 0.5) * CELL,
  (map.gridH / 2 - row - 0.5) * CELL,
  z,
const AREAS: Area[] = [
  { name: "ct spawn", rect: [18, 2, 27, 6], fill: "c" },
  { name: "ct mid", rect: [20, 6, 25, 11], fill: "." },
  { name: "a link", rect: [27, 3, 32, 7], fill: "." },
  { name: "a site", rect: [32, 3, 41, 11], fill: "A" },
  { name: "long a", rect: [35, 11, 39, 31], fill: "." },
  { name: "doors", rect: [30, 30, 39, 34], fill: "." },
  { name: "t long", rect: [28, 34, 35, 38], fill: "." },
  { name: "t spawn", rect: [16, 37, 28, 41], fill: "t" },
  { name: "t mid", rect: [19, 27, 25, 37], fill: "." },
  { name: "mid", rect: [19, 11, 25, 27], fill: "." },
  { name: "catwalk", rect: [25, 14, 32, 17], fill: "." },
  { name: "a ramp", rect: [30, 8, 33, 14], fill: "." },
  { name: "b site", rect: [2, 3, 11, 11], fill: "B" },
  { name: "b link", rect: [11, 5, 18, 9], fill: "." },
  { name: "tunnels", rect: [4, 11, 8, 30], fill: "." },
  { name: "lower tunnel", rect: [4, 30, 14, 35], fill: "." },
  { name: "t tunnel", rect: [14, 33, 18, 38], fill: "." },
  { name: "short", rect: [8, 20, 19, 23], fill: "." },
];
export const colOf = (map: MapDef, x: number): number => Math.floor(x / CELL + map.gridW / 2);
export const rowOf = (map: MapDef, y: number): number => Math.floor(map.gridH / 2 - y / CELL);
/** Cover, placed by hand: lower-case is jumpable, upper-case is not. */
const CRATES: [number, number, Cell][] = [
  [34, 5, "X"], [35, 5, "x"], [38, 8, "x"], [39, 4, "X"], [33, 9, "x"],
  [4, 5, "X"], [5, 5, "x"], [8, 8, "x"], [9, 4, "x"], [3, 9, "X"],
  [21, 18, "x"], [23, 18, "x"], [22, 24, "X"],
  [37, 20, "x"], [37, 26, "X"], [6, 18, "x"], [6, 25, "X"],
  [20, 3, "x"], [25, 3, "x"], [18, 39, "x"], [26, 39, "x"], [28, 15, "x"],
];
// --- geometry -------------------------------------------------------------
function build(): g.Grid<Cell> {
  const cells: Cell[] = new Array(GRID_W * GRID_H).fill("#");
  for (const area of AREAS) {
    const [c0, r0, c1, r1] = area.rect;
    for (let r = r0; r <= r1; r++)
      for (let c = c0; c <= c1; c++) cells[r * GRID_W + c] = area.fill;
  }
  for (const [c, r, cell] of CRATES) cells[r * GRID_W + c] = cell;
  return { width: GRID_W, height: GRID_H, cell: CELL, cells };
}
const grid: g.Grid<Cell> = build();
/**
 * Greedy meshing: merge runs of identical solid cells across a row, then merge
 * rows below that match the run exactly. A few hundred boxes instead of a few
 * thousand, which is the difference between one buffer and a stutter.
 * de_forge, whole: the map this game was built on, as one value of `Level`.
 * The letters are `cells.ts`'s and so is the reading of them — this file is the
 * page they are written on and nothing else.
 */
function mergeSolid(map: MapDef, match: (c: Cell) => boolean, z0: number, z1: number, mat: number): Box[] {
  const used = new Uint8Array(map.gridW * map.gridH);
  const out: Box[] = [];
  for (let r = 0; r < map.gridH; r++) {
    for (let c = 0; c < map.gridW; c++) {
      const i = r * map.gridW + c;
      if (used[i] === 1 || !match(cellAt(map, c, r))) continue;
      let w = 1;
      while (c + w < map.gridW && used[i + w] === 0 && match(cellAt(map, c + w, r))) w++;
      let h = 1;
      grow: while (r + h < map.gridH) {
        for (let k = 0; k < w; k++) {
          const j = (r + h) * map.gridW + c + k;
          if (used[j] === 1 || !match(cellAt(map, c + k, r + h))) break grow;
        }
        h++;
      }
      for (let dr = 0; dr < h; dr++) for (let dc = 0; dc < w; dc++) used[(r + dr) * map.gridW + c + dc] = 1;
      const a = worldOf(map, c, r);
      const b = worldOf(map, c + w - 1, r + h - 1);
      out.push({
        min: [a[0] - CELL / 2, b[1] - CELL / 2, z0],
        max: [b[0] + CELL / 2, a[1] + CELL / 2, z1],
        mat,
      });
    }
  }
  return out;
}
function siteSlab(map: MapDef, fill: Cell): Box {
  let c0 = map.gridW, r0 = map.gridH, c1 = 0, r1 = 0;
  for (let r = 0; r < map.gridH; r++)
    for (let c = 0; c < map.gridW; c++)
      if (cellAt(map, c, r) === fill) {
        c0 = Math.min(c0, c); c1 = Math.max(c1, c);
        r0 = Math.min(r0, r); r1 = Math.max(r1, r);
      }
  const a = worldOf(map, c0, r0), b = worldOf(map, c1, r1);
  return {
    min: [a[0] - CELL / 2, b[1] - CELL / 2, 0],
    max: [b[0] + CELL / 2, a[1] + CELL / 2, 2],
    mat: MAT.SITE,
  };
}
function cellsOf(map: MapDef, fill: Cell): Vec3[] {
  const out: Vec3[] = [];
  for (let r = 0; r < map.gridH; r++)
    for (let c = 0; c < map.gridW; c++) if (cellAt(map, c, r) === fill) out.push(worldOf(map, c, r));
  return out;
}
function centre(list: Vec3[]): Vec3 {
  const s = list.reduce((a, p) => [a[0] + p[0], a[1] + p[1], 0] as Vec3, [0, 0, 0] as Vec3);
  return [s[0] / list.length, s[1] / list.length, 0];
}
const half = (w: number): number => (w / 2) * CELL;
/** Build one `MapDef` from a layout's areas and crates. */
export function buildMap(layout: Layout): MapDef {
  const map: MapDef = {
    name: layout.name,
    gridW: layout.gridW,
    gridH: layout.gridH,
    grid: buildGrid(layout),
    boxes: [],
    spawns: { t: [], ct: [] },
    muster: { t: [0, 0, 0], ct: [0, 0, 0] },
    sites: { A: [0, 0, 0], B: [0, 0, 0] },
    places: buildPlaces(layout),
  };
  const floor: Box = {
    min: [-half(map.gridW), -half(map.gridH), -32],
    max: [half(map.gridW), half(map.gridH), 0],
    mat: MAT.FLOOR,
  };
  map.boxes = [
    floor,
    siteSlab(map, "A"),
    siteSlab(map, "B"),
    ...mergeSolid(map, (c) => c === "#", 0, WALL_HEIGHT, MAT.WALL),
    ...mergeSolid(map, (c) => c === "x", 0, 64, MAT.CRATE),
    ...mergeSolid(map, (c) => c === "X", 0, 128, MAT.CRATE),
  ];
  map.spawns = { t: cellsOf(map, "t"), ct: cellsOf(map, "c") };
  map.muster = { t: centre(map.spawns.t), ct: centre(map.spawns.ct) };
  map.sites = { A: centre(cellsOf(map, "A")), B: centre(cellsOf(map, "B")) };
  return map;
}
/** The map de_forge plays on, built once from today's tables. */
export const DE_FORGE: MapDef = buildMap(DE_FORGE_LAYOUT);
/** The second map, built the same way from its own tables. */
export const DE_CINDER: MapDef = buildMap(DE_CINDER_LAYOUT);
// --- the catalogue ----------------------------------------------------------
/** Every map the game can be played on. A further layout is a further key. */
export type MapName = "de_forge" | "de_cinder";
/** Name to built map, each one built exactly once, above. */
export const MAPS: Record<MapName, MapDef> = { de_forge: DE_FORGE, de_cinder: DE_CINDER };
export const MAP_NAMES: readonly MapName[] = Object.keys(MAPS) as MapName[];
export const DEFAULT_MAP: MapName = "de_forge";
/** Whatever a select, a stored setting or a request body says, the map it names or the default. */
export function mapFor(name: string): MapDef {
  return Object.hasOwn(MAPS, name) ? MAPS[name as MapName] : MAPS[DEFAULT_MAP];
}
// --- places ---------------------------------------------------------------
/** Which bombsite a point stands in, if any. */
export function siteAt(map: MapDef, pos: Vec3): "A" | "B" | null {
  const c = cellAt(map, colOf(map, pos[0]), rowOf(map, pos[1]));
  return c === "A" || c === "B" ? c : null;
}
/**
 * What a person would call the place `pos` is in, or null for a point inside
 * the rock no area ever painted. A scan of a couple of dozen rectangles with
 * nothing allocated — the label itself was built with the map.
 */
export function placeAt(map: MapDef, pos: Vec3): string | null {
  const col = colOf(map, pos[0]);
  const row = rowOf(map, pos[1]);
  for (const place of map.places) {
    const [c0, r0, c1, r1] = place.rect;
    if (col >= c0 && col <= c1 && row >= r0 && row <= r1) return place.name;
  }
  return null;
}
// --- pathfinding ----------------------------------------------------------
/**
 * A* over the walkable cells, eight ways, no corner-cutting. de_forge's grid is
 * 1936 cells; a full search is well under a millisecond, and bots only ask for
 * one when their goal changes.
 */
export function findPath(map: MapDef, from: Vec3, to: Vec3): Vec3[] {
  const start = rowOf(map, from[1]) * map.gridW + colOf(map, from[0]);
  const goal = rowOf(map, to[1]) * map.gridW + colOf(map, to[0]);
  if (start === goal) return [to];
  const n = map.gridW * map.gridH;
  if (start < 0 || start >= n || goal < 0 || goal >= n) return [];
  const g = new Float32Array(n).fill(Infinity);
  const from_ = new Int32Array(n).fill(-1);
  const open: number[] = [start];
  const f = new Float32Array(n).fill(Infinity);
  const h = (i: number): number =>
    Math.hypot((i % map.gridW) - (goal % map.gridW), Math.floor(i / map.gridW) - Math.floor(goal / map.gridW));
  g[start] = 0;
  f[start] = h(start);
  const seen = new Uint8Array(n);
  while (open.length > 0) {
    let bestAt = 0;
    for (let i = 1; i < open.length; i++)
      if ((f[open[i] as number] as number) < (f[open[bestAt] as number] as number)) bestAt = i;
    const cur = open.splice(bestAt, 1)[0] as number;
    if (cur === goal) break;
    seen[cur] = 1;
    const cc = cur % map.gridW, cr = Math.floor(cur / map.gridW);
    for (let dr = -1; dr <= 1; dr++) {
      for (let dc = -1; dc <= 1; dc++) {
        if (dc === 0 && dr === 0) continue;
        const nc = cc + dc, nr = cr + dr;
        if (!walkable(map, nc, nr)) continue;
        if (dc !== 0 && dr !== 0 && (!walkable(map, cc + dc, cr) || !walkable(map, cc, cr + dr))) continue;
        const ni = nr * map.gridW + nc;
        if (seen[ni] === 1) continue;
        const step = dc !== 0 && dr !== 0 ? 1.414 : 1;
        const cost = (g[cur] as number) + step;
        if (cost < (g[ni] as number)) {
          g[ni] = cost;
          f[ni] = cost + h(ni);
          from_[ni] = cur;
          if (!open.includes(ni)) open.push(ni);
        }
      }
    }
  }
  if (from_[goal] === -1) return [];
  const out: Vec3[] = [];
  for (let i = goal; i !== start && i !== -1; i = from_[i] as number)
    out.unshift(worldOf(map, i % map.gridW, Math.floor(i / map.gridW)));
  out.push(to);
  return out;
}
export const DE_FORGE: Level = levelOf("de_forge", grid);
		@@ -1,4 +1,6 @@
1	1	node_modules/
	2	dist/
	3	static/
2	4	*.db
3	5	*.db-wal
4	6	*.db-shm
		@@ -9,9 +9,8 @@ preview at its own address, deployed from your branch as you push.
9	9	- Work on the branch you were given. You cannot move the default branch;
10	10	a person merges your pull once it is reviewed.
11	11	- Keep state under `FORGE_APP_DATA`. Never write elsewhere at runtime.
12		- Run `bun run check` before you push — types, then tests. It is the check
13		the pull shows, and every behaviour you add gets a test that would fail
14		without it. `bun test` alone is the fast loop while you work.
	12	- Run `bun test` before you push. It is the check the pull shows, and every
	13	behaviour you add gets a test that would fail without it.
15	14	- `src/tty.ts` is the app's terminal interface. The exact command that
16	15	reaches it is `FORGE_APP_SSH` at runtime; print that verbatim wherever the
17	16	app tells people how to connect. Keep it working and keep it useful: what
		@@ -34,7 +33,7 @@ preview at its own address, deployed from your branch as you push.
34	33	come from the environment, never the repository; no `eval`, no shell
35	34	built from user text; a private thing needs a session in an HttpOnly cookie.
36	35	Every request body is capped by the bytes actually read (`readBody` in
37		`src/server.ts`) — never by a Content-Length, which a chunked request does
	36	`src/gate.ts`) — never by a Content-Length, which a chunked request does
38	37	not have and a lie does not honour. `HEAD` answers like `GET`.
39	38	An app with an owner or admin is never claimed by whoever visits first:
40	39	the first sign-in needs a secret only the operator holds — a password from
		@@ -3,7 +3,10 @@
3	3	"configVersion": 1,
4	4	"workspaces": {
5	5	"": {
6		"name": "cs",
	6	"name": "cs-engine",
	7	"dependencies": {
	8	"@typesafe-ai/sdk": "^0.6.0",
	9	},
7	10	"devDependencies": {
8	11	"@types/bun": "^1.4.2",
9	12	"typescript": "^7.0.2",
		@@ -15,6 +18,8 @@
15	18
16	19	"@types/node": ["@types/[email protected]", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-X1P21scMv4zGKLYqjdGjaKa7COa0RKVYYZZN/NfvLQ1JegxFhdhpZG/Lyn8AXx6CDUavKAd11v6BvfpkDByK8g=="],
17	20
	21	"@typesafe-ai/sdk": ["@typesafe-ai/[email protected]", "", {}, "sha512-IddX+Q0XM+VagOUZFeP7wZjaO4SHMdvnh2zEBdrZZnXedWI3BNK1lKhMx3ayrkFWvVLbVcUHJy6AVZlY+e6Jaw=="],
	22
18	23	"@typescript/typescript-aix-ppc64": ["@typescript/[email protected]", "", { "os": "aix", "cpu": "ppc64" }, "sha512-MTKKkWB7p/0E9xi1d1tHtZ5PiLkGEMIq88pK2CubZjOsLtYTLqhgIgi6zepFa+9GHZ6h05NMCkQxGKiPXMxXtQ=="],
19	24
20	25	"@typescript/typescript-darwin-arm64": ["@typescript/[email protected]", "", { "os": "darwin", "cpu": "arm64" }, "sha512-gowzar9MwS/aRWp6f3a4KUqzRjAZjOsmGNCM6LcTgXum+dBfgsBVMN+AgvOCCbguXyick6LJhpBszxMebJ8syA=="],
		@@ -1,7 +1,7 @@
1	1	{
2	2	"app": {
3	3	"run": "bun run src/server.ts",
4		"test": "bun run check",
	4	"test": "bun run test",
5	5	"tty": "bun run src/tty.ts"
6	6	}
7	7	}
		@@ -1,16 +1,18 @@
1	1	{
2		"name": "cs",
	2	"name": "cs-engine",
3	3	"private": true,
4	4	"type": "module",
5	5	"scripts": {
6	6	"start": "bun run src/server.ts",
7	7	"build": "bun run scripts/build.ts",
8		"test": "bun test --timeout 20000",
9	8	"typecheck": "tsc --noEmit",
10		"check": "tsc --noEmit && bun test --timeout 20000"
	9	"test": "bun run typecheck && bun test"
11	10	},
12	11	"devDependencies": {
13	12	"@types/bun": "^1.4.2",
14	13	"typescript": "^7.0.2"
	14	},
	15	"dependencies": {
	16	"@typesafe-ai/sdk": "^0.6.0"
15	17	}
16	18	}
		@@ -1,5 +0,0 @@
1		/** `--name value` off argv, or null if the flag is missing or has nothing after it. */
2		export const flagValue = (argv: string[], name: string): string \| null => {
3		const at = argv.indexOf(`--${name}`);
4		return at < 0 ? null : (argv[at + 1] ?? null);
5		};
		@@ -0,0 +1,430 @@
	1	import { expect, test } from "bun:test";
	2	import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
	3	import { tmpdir } from "node:os";
	4	import { join } from "node:path";
	5	import {
	6	ASSETS,
	7	assetOf,
	8	bundle,
	9	collect,
	10	differences,
	11	ENTRIES,
	12	isNamed,
	13	GZIP_LEVEL,
	14	isBundleOf,
	15	NOTE,
	16	overshoot,
	17	row,
	18	sizes,
	19	table,
	20	weigh,
	21	write,
	22	type Built,
	23	type Ceiling,
	24	type Entry,
	25	} from "./build.ts";
	26	import { GAMES } from "../src/games.ts";
	27
	28	/** What a built file looks like whatever it is: a plain name, its content hash, an extension. */
	29	const STAMPED = /^[a-z][a-z0-9-]*\.[0-9a-f]{10}\.[a-z0-9]+$/;
	30
	31	/** Room enough that the fixture's two-line bundles are never the thing failing. */
	32	const ROOMY = { raw: 100_000, gzip: 100_000 };
	33
	34	/** A throwaway pair of entries: two sources and a directory to write them to. */
	35	function fixture(): { dir: string; entries: Entry[]; source: (n: string, t: string) => void } {
	36	const dir = mkdtempSync(join(tmpdir(), "build-"));
	37	const source = (name: string, text: string): void => writeFileSync(join(dir, `${name}.ts`), text);
	38	source("app", `export const game = "app";\nconsole.log(game);\n`);
	39	source("sandbox", `export const game = "sandbox";\nconsole.log(game);\n`);
	40	return {
	41	dir,
	42	entries: [
	43	{ name: "app", entry: join(dir, "app.ts"), ceiling: ROOMY },
	44	{ name: "sandbox", entry: join(dir, "sandbox.ts"), ceiling: ROOMY },
	45	],
	46	source,
	47	};
	48	}
	49
	50	test("the entry table is what the app ships today, each with the size it may not pass", () => {
	51	expect(ENTRIES).toEqual([
	52	{ name: "app", entry: "src/client/main.ts", ceiling: { raw: 132_000, gzip: 51_500 } },
	53	{ name: "range", entry: "src/range/main.ts", ceiling: { raw: 44_000, gzip: 18_200 } },
	54	{ name: "example", entry: "src/example/main.ts", ceiling: { raw: 26_800, gzip: 11_400 } },
	55	]);
	56	// And it is the registry projected, not a second list beside it: a game's
	57	// source and its ceiling are written down once, in `src/games.ts`.
	58	expect(ENTRIES).toEqual(GAMES.map(({ name, entry, ceiling }) => ({ name, entry, ceiling })));
	59	// Nothing else of a game comes along: this file has no idea what path any of
	60	// them answers on.
	61	for (const entry of ENTRIES) expect(Object.keys(entry).sort()).toEqual(["ceiling", "entry", "name"]);
	62	});
	63
	64	test("every entry is bundled to its own name and its own content hash", async () => {
	65	const { dir, entries } = fixture();
	66	const built = await write(entries, dir, []);
	67	expect(built.map((b) => b.name)).toEqual(["app", "sandbox"]);
	68	for (const { name, file, code } of built) {
	69	expect(file).toMatch(new RegExp(`^${name}\\.[0-9a-f]{10}\\.js$`));
	70	const hash = new Bun.CryptoHasher("sha256").update(code).digest("hex").slice(0, 10);
	71	expect(file).toBe(`${name}.${hash}.js`);
	72	expect(existsSync(join(dir, file))).toBe(true);
	73	}
	74	expect(built[0]?.file).not.toBe(built[1]?.file);
	75	});
	76
	77	test("rebuilding one entry sweeps up its own stale bundle and leaves the other game alone", async () => {
	78	const { dir, entries, source } = fixture();
	79	const first = await write(entries, dir, []);
	80	const [staleApp, sandbox] = first;
	81	writeFileSync(join(dir, "keep.txt"), "not a bundle");
	82
	83	source("app", `export const game = "app";\nconsole.log(game, "again");\n`);
	84	const second = await write(entries, dir, []);
	85	const [freshApp, sandboxAgain] = second;
	86
	87	expect(freshApp?.file).not.toBe(staleApp?.file);
	88	expect(existsSync(join(dir, staleApp?.file as string))).toBe(false);
	89	expect(existsSync(join(dir, freshApp?.file as string))).toBe(true);
	90	// The trap: the other game's bundle did not change and must still be there.
	91	expect(sandboxAgain?.file).toBe(sandbox?.file as string);
	92	expect(existsSync(join(dir, sandbox?.file as string))).toBe(true);
	93	expect(readdirSync(dir)).toContain("keep.txt");
	94	});
	95
	96	test("a bundle belongs to one entry by exact name", () => {
	97	expect(isBundleOf("app", "app.6864d577a4.js")).toBe(true);
	98	expect(isBundleOf("app", "sandbox.6864d577a4.js")).toBe(false);
	99	expect(isBundleOf("sandbox", "app.6864d577a4.js")).toBe(false);
	100	expect(isBundleOf("app", "app.js")).toBe(false);
	101	expect(isBundleOf("app", "app.6864d577a4.js.map")).toBe(false);
	102	expect(isBundleOf("app", "appx6864d577a4.js")).toBe(false);
	103	// A name that is not a plain name never becomes a pattern.
	104	expect(isBundleOf("a.p", "axp.6864d577a4.js")).toBe(false);
	105	expect(isBundleOf(".*", "app.6864d577a4.js")).toBe(false);
	106	});
	107
	108	test("two entries cannot share a name, and a name is plain", async () => {
	109	const { dir } = fixture();
	110	const entry = join(dir, "app.ts");
	111	const of = (name: string): Entry => ({ name, entry, ceiling: ROOMY });
	112	expect(bundle([of("app"), of("app")])).rejects.toThrow(/share a name/);
	113	expect(bundle([of("../app")])).rejects.toThrow(/plain name/);
	114	});
	115
	116	test("a size is bytes on disk and bytes gzipped at one fixed level", () => {
	117	const code = `console.log(${JSON.stringify("é".repeat(1000))});\n`;
	118	const bytes = new TextEncoder().encode(code);
	119	// Raw counts bytes, not characters: "é" is two of them.
	120	expect(sizes(code).raw).toBe(bytes.byteLength);
	121	expect(sizes(code).raw).toBeGreaterThan(code.length);
	122	expect(sizes(code)).toEqual(sizes(bytes));
	123	// The level is pinned, so the number is the same on every machine that runs
	124	// this. A different level is a different number, which is why it is pinned.
	125	expect(GZIP_LEVEL).toBe(9);
	126	expect(sizes(code).gzip).toBe(Bun.gzipSync(bytes, { level: GZIP_LEVEL }).byteLength);
	127	expect(sizes(code).gzip).not.toBe(Bun.gzipSync(bytes, { level: 1 }).byteLength);
	128	expect(sizes(code)).toEqual(sizes(code));
	129	});
	130
	131	test("a bundle that fits says nothing, and one that does not names the overshoot", () => {
	132	const ceiling = { raw: 1000, gzip: 500 };
	133	expect(overshoot("app", { raw: 1000, gzip: 500 }, ceiling)).toBeNull();
	134	expect(overshoot("app", { raw: 999, gzip: 499 }, ceiling)).toBeNull();
	135
	136	const raw = overshoot("app", { raw: 1100, gzip: 400 }, ceiling) as string;
	137	expect(raw).toContain("app is too big");
	138	expect(raw).toContain("raw 1100 bytes over the 1000 byte ceiling by 100 bytes (10.0%)");
	139	expect(raw).not.toContain("gzip");
	140
	141	const gzip = overshoot("range", { raw: 900, gzip: 750 }, ceiling) as string;
	142	expect(gzip).toContain("range is too big");
	143	expect(gzip).toContain("gzip 750 bytes over the 500 byte ceiling by 250 bytes (50.0%)");
	144	expect(gzip).not.toContain("raw");
	145
	146	// Both at once is one sentence, not two failures to chase.
	147	const both = overshoot("app", { raw: 1001, gzip: 501 }, ceiling) as string;
	148	expect(both).toContain("raw 1001 bytes over");
	149	expect(both).toContain("gzip 501 bytes over");
	150	});
	151
	152	test("a build in another process is the same names and the same bytes as this one", async () => {
	153	// Nothing is committed any more, so this is what makes a deploy reproducible:
	154	// every process that boots this tree serves files under the same names, and a
	155	// browser's year-long cache of `app.<hash>.js` stays correct across deploys
	156	// that changed nothing. Two builds in one process would share whatever Bun
	157	// caches between them, so the second one is a child process with its own
	158	// start-up — the same thing a deploy does — and the whole `code` is compared,
	159	// not just the hash of it. If Bun's output ever stops being byte-stable this
	160	// fails here, with the file and the two sizes in hand, rather than in a
	161	// preview that serves a name nobody else builds.
	162	const dir = mkdtempSync(join(tmpdir(), "elsewhere-"));
	163	try {
	164	const run = Bun.spawnSync(["bun", "run", join(import.meta.dir, "build.ts"), dir], {
	165	stdout: "pipe",
	166	stderr: "pipe",
	167	});
	168	expect(run.stderr.toString().trim()).toBe("");
	169	expect(run.exitCode).toBe(0);
	170
	171	const built = [...(await bundle()), ...collect()];
	172	// Every difference this build has from that one, as sentences: none.
	173	expect(differences(built, dir)).toEqual([]);
	174	// And that directory holds one file per game and per asset and nothing
	175	// else — a second shooter bundle beside the first is the outage this is
	176	// about, and it would be both an extra name here and a sentence above.
	177	expect(readdirSync(dir).sort()).toEqual(built.map((b) => b.file).sort());
	178	expect(built.map((b) => b.name)).toEqual([...ENTRIES.map((e) => e.name), ...ASSETS.map((a) => a.name)]);
	179	} finally {
	180	rmSync(dir, { recursive: true, force: true });
	181	}
	182	}, 60_000);
	183
	184	test("a directory that is not what the sources build says which file, and what to run", async () => {
	185	const { dir, entries } = fixture();
	186	try {
	187	const built = await write(entries, dir, []);
	188	const [app, sandbox] = built as [Built, Built];
	189	// What a build just wrote is what the build builds: nothing to say. The
	190	// fixture's own `.ts` sources sit in this directory too, and are not the
	191	// build's business — neither is the database beside the bundles in
	192	// FORGE_APP_DATA.
	193	expect(differences(built, dir)).toEqual([]);
	194	writeFileSync(join(dir, "keep.txt"), "not a bundle");
	195	expect(differences(built, dir)).toEqual([]);
	196
	197	// The loud half of the outage: two bundles of one game, and nothing says
	198	// which is the tree.
	199	writeFileSync(join(dir, "app.0123456789.js"), app.code);
	200	const two = differences(built, dir);
	201	expect(two.length).toBe(1);
	202	expect(two[0]).toContain("1 stale file");
	203	expect(two[0]).toContain("app.0123456789.js");
	204	expect(two[0]).toContain(`beside ${app.file}`);
	205	expect(two[0]).toContain("bun run scripts/build.ts");
	206
	207	// The quiet half, which used to pass without a word: one valid-looking
	208	// file, and it is not this tree's.
	209	rmSync(join(dir, app.file));
	210	const stale = differences(built, dir);
	211	expect(stale.length).toBe(1);
	212	expect(stale[0]).toContain(`has no ${app.file}`);
	213	expect(stale[0]).toContain("app.0123456789.js");
	214	expect(stale[0]).toContain("bun run scripts/build.ts");
	215
	216	// Nothing at all under that name says so in its own words.
	217	rmSync(join(dir, "app.0123456789.js"));
	218	expect(differences(built, dir)[0]).toContain("nothing there is named app.<hash>.js");
	219	expect(differences(built, dir).length).toBe(1);
	220
	221	// And a file edited in place keeps its name and is caught on its bytes,
	222	// which is the one thing a content hash cannot notice by itself.
	223	writeFileSync(join(dir, sandbox.file), `${sandbox.code}// and more\n`);
	224	const edited = differences([sandbox], dir);
	225	expect(edited.length).toBe(1);
	226	expect(edited[0]).toContain(`${join(dir, sandbox.file)} is not what this tree builds`);
	227	expect(edited[0]).toContain(`${sizes(`${sandbox.code}// and more\n`).raw} bytes there`);
	228	expect(edited[0]).toContain(`${sizes(sandbox.code).raw} bytes built`);
	229	} finally {
	230	rmSync(dir, { recursive: true, force: true });
	231	}
	232	});
	233
	234	test("no generated file is in git: the repository tracks nothing named by its own hash", () => {
	235	const root = join(import.meta.dir, "..");
	236	// A source export with no `.git` beside it cannot be asked; a checkout can,
	237	// and that is where this class of outage was born, so it is asked there.
	238	if (!existsSync(join(root, ".git"))) return;
	239	const ls = Bun.spawnSync(["git", "ls-files"], { cwd: root, stdout: "pipe", stderr: "pipe" });
	240	expect(ls.exitCode).toBe(0);
	241	const said = ls.stdout
	242	.toString()
	243	.split("\n")
	244	.filter((path) => path !== "")
	245	.filter((path) => path.startsWith("static/") \|\| STAMPED.test(path.split("/").pop() as string))
	246	.map(
	247	(path) =>
	248	`${path} is a generated file and it is committed: run \`git rm --cached ${path}\` — ` +
	249	`the bundles are built at boot into FORGE_APP_DATA/static, and an artifact in no branch cannot collide in a merge`,
	250	);
	251	expect(said).toEqual([]);
	252	// The reason nobody adds one by accident: a build into the repository's own
	253	// static/ is ignored where it lands.
	254	expect(readFileSync(join(root, ".gitignore"), "utf8").split("\n")).toContain("static/");
	255	});
	256
	257	test("a fresh build of every entry is under its ceiling", async () => {
	258	// The sources as they are now: a fat import fails here on the first build,
	259	// before anyone has deployed the bundle it produced.
	260	for (const { name, code, ceiling } of await bundle()) {
	261	expect(overshoot(`${name} (fresh build)`, sizes(code), ceiling)).toBeNull();
	262	}
	263	}, 60_000);
	264
	265	test("the bundle every entry is written as is under its ceiling, weighed on disk", async () => {
	266	// The bytes a browser downloads: the file, not the string the bundler handed
	267	// back. Nothing is committed any more, so this writes the build to a
	268	// directory of its own — exactly as a boot writes it to FORGE_APP_DATA — and
	269	// weighs what landed there.
	270	const dir = mkdtempSync(join(tmpdir(), "ceilings-"));
	271	try {
	272	await write(ENTRIES, dir, []);
	273	for (const { name, ceiling } of ENTRIES) {
	274	const files = readdirSync(dir).filter((file) => isBundleOf(name, file));
	275	expect(files.length).toBe(1);
	276	const bytes = readFileSync(join(dir, files[0] as string));
	277	expect(overshoot(`${files[0]} (on disk)`, sizes(bytes), ceiling)).toBeNull();
	278	}
	279	} finally {
	280	rmSync(dir, { recursive: true, force: true });
	281	}
	282	}, 60_000);
	283
	284	test("weighing a committed bundle reads the file and builds nothing", async () => {
	285	const { dir, entries } = fixture();
	286	const [built] = await write(entries, dir, []);
	287	const file = readFileSync(join(dir, built?.file as string));
	288	// The same ruler `sizes` is: on disk, and gzipped at the pinned level.
	289	expect(weigh("app", dir)).toEqual(sizes(file));
	290	expect(weigh("app", dir).raw).toBe(file.byteLength);
	291	// And it is the artifact, not a fresh build: a file edited in place weighs
	292	// what it now is, which is the point of quoting it on a page.
	293	writeFileSync(join(dir, built?.file as string), `${built?.code as string}// and more\n`);
	294	expect(weigh("app", dir).raw).toBeGreaterThan(file.byteLength);
	295	// A game with nothing in static/ is the sentence `bundleOf` writes, not a zero.
	296	expect(() => weigh("nowhere", dir)).toThrow(/has no bundle/);
	297	});
	298
	299	test("the asset table is what the app downloads beside its bundles", () => {
	300	// The shooter's weights, and nothing else: the registry projected again.
	301	expect(ASSETS).toEqual([
	302	{ name: "weights", source: "src/client/weights.json", ceiling: { raw: 12_300, gzip: 9_100 } },
	303	]);
	304	expect(ASSETS).toEqual(GAMES.flatMap((game) => game.assets.map((asset) => ({ ...asset }))));
	305	});
	306
	307	test("an asset is copied verbatim, stamped by its own contents, and swept when it changes", () => {
	308	const dir = mkdtempSync(join(tmpdir(), "assets-"));
	309	writeFileSync(join(dir, "w.json"), `{"a":1}`);
	310	const asset = { name: "weights", source: join(dir, "w.json"), ceiling: ROOMY };
	311	const [first] = collect([asset], dir);
	312	// The bytes in static/ are the bytes the file holds: an asset is a copy.
	313	expect(first?.code).toBe(`{"a":1}`);
	314	expect(first?.file).toMatch(/^weights\.[0-9a-f]{10}\.json$/);
	315	expect(isNamed("weights", "json", first?.file as string)).toBe(true);
	316	expect(isBundleOf("weights", first?.file as string)).toBe(false);
	317	// The hash is the contents', so a retrain is a new name and a sweep.
	318	writeFileSync(join(dir, "w.json"), `{"a":2}`);
	319	const [second] = collect([asset], dir);
	320	expect(second?.file).not.toBe(first?.file);
	321	// And the finder reads one back by name, or says what to run.
	322	expect(assetOf(asset, [second?.file as string], dir)).toBe(second?.file as string);
	323	expect(() => assetOf(asset, [], dir)).toThrow(/has no asset.*run `bun run scripts\/build\.ts`/);
	324	expect(() => assetOf(asset, [first?.file as string, second?.file as string], dir)).toThrow(/has 2 assets/);
	325	});
	326
	327	test("the asset every game declares is under its ceiling, and is what its source holds", async () => {
	328	const dir = mkdtempSync(join(tmpdir(), "assets-ceilings-"));
	329	try {
	330	await write([], dir);
	331	const files = readdirSync(dir);
	332	for (const asset of ASSETS) {
	333	const file = assetOf(asset, files, dir);
	334	const bytes = readFileSync(join(dir, file));
	335	expect(overshoot(`${file} (on disk)`, sizes(bytes), asset.ceiling)).toBeNull();
	336	// Byte for byte the file the trainer wrote: a copy that is not the source
	337	// is a policy nobody trained, served to every player.
	338	expect(bytes.toString("utf8")).toBe(collect([asset])[0]?.code as string);
	339	}
	340	} finally {
	341	rmSync(dir, { recursive: true, force: true });
	342	}
	343	});
	344
	345	/** A built file of known contents, for the table below: sizes nobody has to guess at. */
	346	const builtFile = (name: string, code: string, ceiling: Ceiling): Built => ({
	347	name,
	348	ext: "js",
	349	file: `${name}.6864d577a4.js`,
	350	code,
	351	ceiling,
	352	});
	353
	354	test("a row is one file weighed once: what it measured, what it may not pass, what is left", () => {
	355	const code = `console.log("hi");\n`;
	356	const { raw, gzip } = sizes(code);
	357	const measured = row(builtFile("app", code, { raw: 400, gzip: 300 }));
	358	expect(measured.measured).toEqual({ raw, gzip });
	359	expect(measured.headroom).toEqual({ raw: 400 - raw, gzip: 300 - gzip });
	360	// Over the ceiling the headroom is negative, in the same column a reader is
	361	// already scanning — not a row that quietly looks like the others.
	362	const over = row(builtFile("app", code, { raw: 4, gzip: 3 }));
	363	expect(over.headroom).toEqual({ raw: 4 - raw, gzip: 3 - gzip });
	364	expect(over.headroom.raw).toBeLessThan(0);
	365	});
	366
	367	test("the build prints a table of what it built: the sizes and the headroom under each ceiling", () => {
	368	const code = `console.log("hi");\n`;
	369	const long = `console.log(${JSON.stringify("x".repeat(500))});\n`;
	370	const { raw, gzip } = sizes(code);
	371	const big = sizes(long);
	372	const printed = table([
	373	builtFile("app", code, { raw: 400, gzip: 300 }),
	374	builtFile("range", long, { raw: 900, gzip: 400 }),
	375	]);
	376
	377	const [head, rule, app, range] = printed as [string, string, string, string];
	378	expect(head.split(/\s+/)).toEqual(["file", "raw", "ceiling", "left", `gzip-${GZIP_LEVEL}`, "ceiling", "left"]);
	379	expect(rule).toMatch(/^-+( +-+)+$/);
	380	// Each row is its file and the six numbers, in the order the heading names
	381	// them: measured, ceiling and what is left, on both rulers.
	382	expect(app.split(/\s+/)).toEqual([
	383	"static/app.6864d577a4.js",
	384	String(raw),
	385	"400",
	386	String(400 - raw),
	387	String(gzip),
	388	"300",
	389	String(300 - gzip),
	390	]);
	391	expect(range.split(/\s+/)).toEqual([
	392	"static/range.6864d577a4.js",
	393	String(big.raw),
	394	"900",
	395	String(900 - big.raw),
	396	String(big.gzip),
	397	"400",
	398	String(400 - big.gzip),
	399	]);
	400	// The columns line up, so two rows can be compared by eye.
	401	expect(rule.length).toBe(head.length);
	402	expect(app.length).toBe(rule.length);
	403	expect(range.length).toBe(rule.length);
	404	// And the directory it wrote into is the one named in the rows.
	405	expect(table([builtFile("app", code, { raw: 400, gzip: 300 })], "/tmp/out")[2]).toContain(
	406	"/tmp/out/app.6864d577a4.js",
	407	);
	408	// The note under it carries the units and the ruler, so a pasted table means
	409	// something away from this file.
	410	expect(NOTE).toContain("Bytes");
	411	expect(NOTE).toContain(`gzip-${GZIP_LEVEL}`);
	412	expect(NOTE).toContain("src/games.ts");
	413	});
	414
	415	test("a file over its ceiling prints a negative headroom, and is still the failure it is", async () => {
	416	const { dir, entries } = fixture();
	417	const tight = entries.map((entry) => ({ ...entry, ceiling: { raw: 10, gzip: 10 } }));
	418	const built = await bundle(tight);
	419	const printed = table(built);
	420	expect(printed[0]).toContain("left");
	421	const app = (printed[2] as string).split(/\s+/);
	422	expect(Number(app[3])).toBeLessThan(0);
	423	expect(Number(app[6])).toBeLessThan(0);
	424	// Printing it is not forgiving it: the same numbers are what the ceiling
	425	// tests above fail on, with the sentence naming the overshoot.
	426	for (const { name, code, ceiling } of built) {
	427	expect(overshoot(name, sizes(code), ceiling)).toContain("is too big");
	428	}
	429	rmSync(dir, { recursive: true, force: true });
	430	});
		@@ -1,26 +1,353 @@
1	1	/**
2		* `bun run build` writes the client bundle to static/, for anyone who wants
3		* a file on disk to inspect. The server does not read it: it builds its own
4		* copy into memory at start-up (see src/bundle.ts), so this file is never
5		* committed and never served.
	2	* The build: every game in the registry, bundled to `<name>.<hash>.js` in a
	3	* directory, and every asset a game declares beside it, copied to
	4	* `<name>.<hash>.<ext>` the same way.
	5	*
	6	* Nothing it writes is committed. `src/server.ts` calls `write` at start-up,
	7	* into `FORGE_APP_DATA/static` (`src/bundles.ts` says where), and serves what
	8	* came out; `bun run scripts/build.ts` runs the same build into the repository's
	9	* own `static/` — ignored by git — for a person who wants the files on disk to
	10	* read, weigh or serve another way. Each entry carries the size it may not pass,
	11	* and `build.test.ts` builds and weighs it.
	12	*
	13	* Run as a program it prints a table of what it built — every file, raw and
	14	* gzipped, against its ceiling and the headroom left under it — so the sizes a
	15	* pull states are copied from a run rather than remembered.
	16	*
	17	* A bundle and an asset are the same thing here — bytes filed under a name and
	18	* their own content hash, swept when they change and held to a ceiling — and
	19	* they differ only in where the bytes come from: a bundler, or a file. That is
	20	* why `write` returns one list of both.
6	21	*/
7	22
8		import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
9		import { join } from "node:path";
10		import { bundle } from "../src/bundle.ts";
	23	import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
	24	import { extname, join, resolve } from "node:path";
	25	import { type Asset, type Ceiling, GAMES } from "../src/games.ts";
11	26
12		export const STATIC_DIR = join(import.meta.dir, "..", "static");
	27	const ROOT = join(import.meta.dir, "..");
	28	/**
	29	* Where `bun run scripts/build.ts` writes when nobody says otherwise: the
	30	* repository's own `static/`, which git ignores. The server never uses it — it
	31	* passes the directory it wants, under `FORGE_APP_DATA` — and every function
	32	* here that takes a `dir` or a `where` takes it for the same reason.
	33	*/
	34	export const STATIC_DIR = join(ROOT, "static");
13	35
14		export async function write(): Promise<string> {
15		const { name, code } = await bundle();
16		mkdirSync(STATIC_DIR, { recursive: true });
17		for (const file of readdirSync(STATIC_DIR))
18		if (/^app\.[0-9a-f]+\.js$/.test(file) && file !== name) rmSync(join(STATIC_DIR, file));
19		writeFileSync(join(STATIC_DIR, name), code);
20		return name;
	36	export type { Asset, Ceiling };
	37
	38	/**
	39	* One bundle: the name it is filed under, the source it starts from, and the
	40	* size it may not pass. It is the part of a game this file cares about —
	41	* nothing here knows what path a game answers on or what the header calls it.
	42	*/
	43	export type Entry = { name: string; entry: string; ceiling: Ceiling };
	44
	45	/**
	46	* What is built, projected from the registry in `src/games.ts`: a game is
	47	* bundled because it is a game, not because it is also written down here. The
	48	* ceilings live beside the entries there, with the rule for moving one.
	49	*/
	50	export const ENTRIES: Entry[] = GAMES.map(({ name, entry, ceiling }) => ({ name, entry, ceiling }));
	51
	52	/**
	53	* And what is copied, projected the same way: every game's assets, flattened,
	54	* because static/ is one directory and a name in it belongs to one file
	55	* whichever game declared it.
	56	*/
	57	export const ASSETS: Asset[] = GAMES.flatMap((game) => game.assets.map((asset) => ({ ...asset })));
	58
	59	/** The extension an asset is filed under, taken from the file it is copied from. */
	60	export const extOf = (asset: Asset): string => extname(asset.source).replace(/^\./, "");
	61
	62	/**
	63	* The one level gzip is ever measured at here. Compression level is the knob
	64	* that moves the number between machines, so it is pinned: `bun test` on a
	65	* laptop and on the forge weigh the same bundle the same way. It is not a claim
	66	* about what a CDN sends — it is a stable ruler.
	67	*/
	68	export const GZIP_LEVEL = 9;
	69
	70	/** What a bundle weighs: bytes on disk, and bytes after gzip at `GZIP_LEVEL`. */
	71	// `Uint8Array<ArrayBuffer>` and not a plain `Uint8Array`: the gzip below will
	72	// not read a view onto a `SharedArrayBuffer`, and saying so here is how a
	73	// caller that holds one finds out at the call rather than at the call inside.
	74	export function sizes(code: string \| Uint8Array<ArrayBuffer>): Ceiling {
	75	const bytes = typeof code === "string" ? new TextEncoder().encode(code) : code;
	76	return { raw: bytes.byteLength, gzip: Bun.gzipSync(bytes, { level: GZIP_LEVEL }).byteLength };
21	77	}
22	78
	79	/**
	80	* A sentence naming the bundle, what it measured, what it may not pass and by
	81	* how much it passed it — in bytes and in percent — or `null` when it fits.
	82	*/
	83	export function overshoot(name: string, measured: Ceiling, ceiling: Ceiling): string \| null {
	84	const over = (["raw", "gzip"] as const)
	85	.filter((kind) => measured[kind] > ceiling[kind])
	86	.map((kind) => {
	87	const by = measured[kind] - ceiling[kind];
	88	const percent = ((by / ceiling[kind]) * 100).toFixed(1);
	89	return `${kind} ${measured[kind]} bytes over the ${ceiling[kind]} byte ceiling by ${by} bytes (${percent}%)`;
	90	});
	91	return over.length === 0 ? null : `${name} is too big: ${over.join("; ")}`;
	92	}
	93
	94	// A name becomes part of a file name and part of a regular expression: keep it
	95	// plain, so neither can be surprised by it.
	96	const NAME = /^[a-z][a-z0-9-]*$/;
	97
	98	/** Is this file filed under that name and extension — `app.3f2a9c1b04.js` of `app`? */
	99	export function isNamed(name: string, ext: string, file: string): boolean {
	100	return NAME.test(name) && NAME.test(ext) && new RegExp(`^${name}\\.[0-9a-f]+\\.${ext}$`).test(file);
	101	}
	102
	103	/** Is this file a bundle of that entry — `app.3f2a9c1b04.js` of `app`? */
	104	export const isBundleOf = (name: string, file: string): boolean => isNamed(name, "js", file);
	105
	106	/**
	107	* The one `<name>.<hash>.<ext>` among a directory's `files`, or a sentence
	108	* saying what to do about it: none means nothing built it, and two means a
	109	* stale one was left behind and whoever picks between them picks at random.
	110	* `what` is the word the message uses for it — a bundle, an asset — and `where`
	111	* is the directory those names came from, read out in the message and nowhere
	112	* else.
	113	*
	114	* It is here rather than beside either caller because both — the server, which
	115	* refuses to boot without every game's files, and the tests, which boot the
	116	* built ones — are asking the same question of the same directory, and one
	117	* answer cannot drift from itself.
	118	*/
	119	export function oneNamed(
	120	name: string,
	121	ext: string,
	122	files: readonly string[],
	123	where = STATIC_DIR,
	124	what = "bundle",
	125	): string {
	126	const mine = files.filter((file) => isNamed(name, ext, file));
	127	const first = mine[0];
	128	if (mine.length === 1 && first !== undefined) return first;
	129	const build = "run `bun run scripts/build.ts` to write them there";
	130	throw new Error(
	131	mine.length === 0
	132	? `the game ${JSON.stringify(name)} has no ${what}: nothing in ${where} is named ${name}.<hash>.${ext} — ${build}`
	133	: `the game ${JSON.stringify(name)} has ${mine.length} ${what}s in ${where}: ${mine.join(", ")} — ` +
	134	`all but one are stale, so ${build}`,
	135	);
	136	}
	137
	138	/** The one `<name>.<hash>.js` in a directory, or the sentence saying what to do. */
	139	export const bundleOf = (name: string, files: readonly string[], where = STATIC_DIR): string =>
	140	oneNamed(name, "js", files, where);
	141
	142	/** The one `<name>.<hash>.<ext>` of a declared asset, or the same sentence. */
	143	export const assetOf = (asset: Asset, files: readonly string[], where = STATIC_DIR): string =>
	144	oneNamed(asset.name, extOf(asset), files, where, "asset");
	145
	146	/**
	147	* What the built bundle of `name` weighs right now: the one
	148	* `<name>.<hash>.js` in `dir`, on disk and gzipped at `GZIP_LEVEL`. It builds
	149	* nothing itself — this is the file a browser downloads, already written,
	150	* weighed by the same ruler the ceilings are held to, so a page that quotes a
	151	* size and a test that checks a ceiling are reading one number.
	152	*
	153	* A missing or duplicated bundle throws here, through `bundleOf`, with the
	154	* sentence that says what to run about it.
	155	*/
	156	export function weigh(name: string, dir = STATIC_DIR): Ceiling {
	157	return sizes(readFileSync(join(dir, bundleOf(name, readdirSync(dir), dir))));
	158	}
	159
	160	export type Built = { name: string; ext: string; file: string; code: string; ceiling: Ceiling };
	161
	162	/** `app` and its contents into `app.3f2a9c1b04.js`: the one naming rule here. */
	163	function stamp(name: string, ext: string, code: string, ceiling: Ceiling): Built {
	164	if (!NAME.test(name)) throw new Error(`entry name ${JSON.stringify(name)} is not a plain name`);
	165	const hash = new Bun.CryptoHasher("sha256").update(code).digest("hex").slice(0, 10);
	166	return { name, ext, file: `${name}.${hash}.${ext}`, code, ceiling };
	167	}
	168
	169	/** Bundle every entry and give each the file name its own contents deserve. */
	170	export async function bundle(entries: Entry[] = ENTRIES): Promise<Built[]> {
	171	if (new Set(entries.map((e) => e.name)).size !== entries.length)
	172	throw new Error("two entries share a name; each bundle needs its own");
	173	const built: Built[] = [];
	174	for (const { name, entry, ceiling } of entries) {
	175	if (!NAME.test(name)) throw new Error(`entry name ${JSON.stringify(name)} is not a plain name`);
	176	const out = await Bun.build({
	177	entrypoints: [resolve(ROOT, entry)],
	178	target: "browser",
	179	minify: true,
	180	format: "esm",
	181	});
	182	if (!out.success) throw new Error(out.logs.map(String).join("\n"));
	183	const output = out.outputs[0];
	184	if (output === undefined) throw new Error(`the bundle for ${name} produced no output`);
	185	built.push(stamp(name, "js", await output.text(), ceiling));
	186	}
	187	return built;
	188	}
	189
	190	/**
	191	* Every declared asset, read off disk and stamped with its own content hash —
	192	* verbatim, because the bytes served are the bytes the file holds. A
	193	* source that is not there throws here, naming the file, rather than deploying
	194	* a page that links to nothing.
	195	*/
	196	export function collect(assets: Asset[] = ASSETS, root = ROOT): Built[] {
	197	if (new Set(assets.map((a) => a.name)).size !== assets.length)
	198	throw new Error("two assets share a name; each one needs its own");
	199	return assets.map((asset) => {
	200	const ext = extOf(asset);
	201	if (ext === "") throw new Error(`the asset ${JSON.stringify(asset.name)} has no extension: ${asset.source}`);
	202	return stamp(asset.name, ext, readFileSync(resolve(root, asset.source), "utf8"), asset.ceiling);
	203	});
	204	}
	205
	206	/**
	207	* Write every bundle and every asset, and sweep up after each name and
	208	* extension only: a stale `app.*.js` goes, another game's bundle beside it
	209	* stays, and so does `weights.*.json`. Anything else in the directory is left
	210	* where it is.
	211	*/
	212	export async function write(
	213	entries: Entry[] = ENTRIES,
	214	dir = STATIC_DIR,
	215	assets: Asset[] = ASSETS,
	216	root = ROOT,
	217	): Promise<Built[]> {
	218	const built = [...(await bundle(entries)), ...collect(assets, root)];
	219	mkdirSync(dir, { recursive: true });
	220	const present = readdirSync(dir);
	221	for (const { name, ext, file, code } of built) {
	222	for (const old of present) if (old !== file && isNamed(name, ext, old)) rmSync(join(dir, old));
	223	writeFileSync(join(dir, file), code);
	224	}
	225	return built;
	226	}
	227
	228	/**
	229	* Every way a directory is not what these sources build, as sentences a person
	230	* can act on: a file this tree builds that is not there, a file filed under a
	231	* built name whose bytes are not the built bytes, and a second file under a
	232	* name that belongs to one — the shape of three outages, where two branches
	233	* each rebuilt the shooter and git kept both.
	234	*
	235	* It ignores everything it was not asked about: the database beside the
	236	* bundles in `FORGE_APP_DATA`, a note somebody left in `static/`. `write`
	237	* sweeps by name and extension and nothing else, so this reads the same
	238	* directory the same way.
	239	*
	240	* Empty is the only good answer, and it is what `build.test.ts` asserts of a
	241	* build made in another process: the same names and the same bytes, which is
	242	* what a year-long `immutable` cache of `app.<hash>.js` is a promise about.
	243	*/
	244	export function differences(built: readonly Built[], dir: string): string[] {
	245	const present = readdirSync(dir);
	246	const said: string[] = [];
	247	const rebuild = `run \`bun run scripts/build.ts ${dir}\` and compare again`;
	248	for (const { name, ext, file, code } of built) {
	249	const mine = present.filter((old) => isNamed(name, ext, old));
	250	const stale = mine.filter((old) => old !== file);
	251	if (!mine.includes(file)) {
	252	const instead =
	253	mine.length === 0 ? `nothing there is named ${name}.<hash>.${ext}` : `it holds ${mine.join(", ")}`;
	254	said.push(
	255	`${dir} has no ${file}, which is what this tree builds for ${JSON.stringify(name)}: ` +
	256	`${instead} — ${rebuild}`,
	257	);
	258	} else {
	259	const there = readFileSync(join(dir, file), "utf8");
	260	if (there !== code)
	261	said.push(
	262	`${join(dir, file)} is not what this tree builds under that name: ` +
	263	`${sizes(there).raw} bytes there, ${sizes(code).raw} bytes built — ${rebuild}`,
	264	);
	265	}
	266	// Only beside the built file: when that one is missing the sentence above
	267	// already read out what is there instead, and one name deserves one
	268	// sentence.
	269	if (mine.includes(file) && stale.length > 0)
	270	said.push(
	271	`${dir} holds ${stale.length} stale file${stale.length === 1 ? "" : "s"} for ${JSON.stringify(name)} ` +
	272	`beside ${file}: ${stale.join(", ")} — whoever picks between them picks at random, so ${rebuild}`,
	273	);
	274	}
	275	return said;
	276	}
	277
	278	/**
	279	* One row of the build's table: what was built, what it weighs on both rulers,
	280	* what it may not pass and what is left under that — negative when it passed it,
	281	* because a row that is over says so in the same column the others are read in.
	282	*/
	283	export type Row = { name: string; file: string; measured: Ceiling; ceiling: Ceiling; headroom: Ceiling };
	284
	285	/** What one built file measured, weighed once and reported as a row. */
	286	export function row({ name, file, code, ceiling }: Built): Row {
	287	const measured = sizes(code);
	288	return {
	289	name,
	290	file,
	291	measured,
	292	ceiling,
	293	headroom: { raw: ceiling.raw - measured.raw, gzip: ceiling.gzip - measured.gzip },
	294	};
	295	}
	296
	297	/** What the table is a table of, printed under it so a pasted table carries its units. */
	298	export const NOTE = [
	299	"",
	300	`Bytes. Every row is one file in static/: a game's bundle, or an asset it`,
	301	`downloads beside one. "raw" is the file on disk and "gzip-${GZIP_LEVEL}" is it compressed`,
	302	`at the one level the ceilings are measured at; "left" is the headroom under`,
	303	`that ceiling, and a negative one is a bundle over it, which fails`,
	304	`scripts/build.test.ts. The ceilings are in src/games.ts, with the rule for`,
	305	`moving one. Run: bun run scripts/build.ts`,
	306	].join("\n");
	307
	308	/**
	309	* The whole table, as lines a person reads and a pull quotes: one built file a
	310	* row, in the order they were built. It is the reason no pull has to remember a
	311	* size — the numbers a reviewer is given are copied from a run of this.
	312	*/
	313	export function table(built: readonly Built[], where = "static"): string[] {
	314	const rows = built.map(row);
	315	const width = Math.max(4, ...rows.map((r) => `${where}/${r.file}`.length));
	316	const cell = (text: string, size = 8): string => text.padStart(size);
	317	const head =
	318	`${"file".padEnd(width)} ${cell("raw")} ${cell("ceiling")} ${cell("left")} ` +
	319	`${cell(`gzip-${GZIP_LEVEL}`)} ${cell("ceiling")} ${cell("left")}`;
	320	return [
	321	head,
	322	`${"-".repeat(width)} ${"-".repeat(8)} ${"-".repeat(8)} ${"-".repeat(8)} ${"-".repeat(8)} ${"-".repeat(8)} ${"-".repeat(8)}`,
	323	...rows.map(
	324	(r) =>
	325	`${`${where}/${r.file}`.padEnd(width)} ${cell(String(r.measured.raw))} ${cell(String(r.ceiling.raw))} ` +
	326	`${cell(String(r.headroom.raw))} ${cell(String(r.measured.gzip))} ${cell(String(r.ceiling.gzip))} ` +
	327	`${cell(String(r.headroom.gzip))}`,
	328	),
	329	];
	330	}
	331
	332	/**
	333	* Run as a program: build into the directory named on the command line, or into
	334	* the repository's `static/` when none is. Nothing needs this to deploy — the
	335	* server builds its own — and it is here for a person who wants the files where
	336	* they can read them, and for `src/engine/bundles.test.ts`, which asks a child
	337	* process for the bundles because the engine may import nothing outside itself.
	338	*
	339	* The sizes are printed, not enforced: the ceiling is a test, so a build that
	340	* overshoots still writes the file a reviewer can then weigh — and says so
	341	* under the table, in the sentence the test would fail with.
	342	*/
23	343	if (import.meta.main) {
24		const name = await write();
25		console.log(`static/${name}`);
	344	const asked = process.argv[2];
	345	const dir = asked === undefined ? STATIC_DIR : resolve(asked);
	346	const built = await write(ENTRIES, dir);
	347	for (const printed of table(built, asked === undefined ? "static" : dir)) console.log(printed);
	348	console.log(NOTE);
	349	for (const { name, measured, ceiling } of built.map(row)) {
	350	const over = overshoot(name, measured, ceiling);
	351	if (over !== null) console.log(over);
	352	}
26	353	}
		@@ -0,0 +1,71 @@
	1	/**
	2	* This tree's bundle, built and imported. All three games boot their minified
	3	* file in a test — `src/client/bundle.test.ts`, `src/range/bundle.test.ts` and
	4	* `src/example/bundle.test.ts` — and this is the step they share: where this
	5	* game's bundle is, and how to import it more than once when the entry boots
	6	* itself on the way in.
	7	*
	8	* It builds, once, into a directory of its own, because there is no committed
	9	* bundle to read any more: `src/server.ts` builds into `FORGE_APP_DATA` at
	10	* start-up and nothing generated is in the repository. So the artifact under
	11	* test is the one this tree produces, which is what a browser downloads from a
	12	* deploy of this tree — the question `scripts/build.test.ts` used to ask of a
	13	* committed file, answered by not having one.
	14	*
	15	* The build happens at import, once per test process (about 70 ms for all three
	16	* games), and every game's bundle comes out of that one build: three test files
	17	* sharing this module share the directory it wrote.
	18	*
	19	* It ships in no bundle: only `.test.ts` files import it, which is why
	20	* `src/independence.test.ts` lets a range test reach for it and a range module
	21	* not.
	22	*/
	23
	24	import { copyFileSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
	25	import { tmpdir } from "node:os";
	26	import { join } from "node:path";
	27	import { pathToFileURL } from "node:url";
	28	import { bundleOf, write } from "./build.ts";
	29
	30	/** Where this process's build went: a throwaway directory, never the repository. */
	31	export const BUILT_DIR = mkdtempSync(join(tmpdir(), "built-"));
	32
	33	// Top level, so `bundlePath` below can stay the synchronous name lookup its
	34	// callers read a file with: by the time any of them runs, the files are there.
	35	await write(undefined, BUILT_DIR);
	36
	37	/**
	38	* Where the one `<name>.<hash>.js` in `dir` is. Which file that is — and what is
	39	* said when there is no such file, or two of them — is `bundleOf` in
	40	* `./build.ts`: the test boots the file the server would refuse to boot without.
	41	*/
	42	export function bundlePath(name: string, dir = BUILT_DIR): string {
	43	return join(dir, bundleOf(name, readdirSync(dir), dir));
	44	}
	45
	46	// An import is cached per specifier, so an entry would boot itself once and
	47	// every later boot would come out of the module cache. Two defences: a
	48	// cache-busting query, and — because Bun keys that cache by path and ignores
	49	// the query — a copy of the built bytes at a path of its own each time.
	50	// The copies go to a throwaway directory, never into the repository.
	51	let copies: string \| null = null;
	52	let loads = 0;
	53
	54	/**
	55	* Import the bundle of `name` as if for the first time: the entry runs, which
	56	* for every game here means it looks for a page and boots on it. Install the
	57	* stub page before awaiting this.
	58	*/
	59	export async function importBundle(name: string): Promise<unknown> {
	60	if (copies === null) copies = mkdtempSync(join(tmpdir(), "bundle-"));
	61	const load = (loads += 1);
	62	const copy = join(copies, `${name}.${load}.js`);
	63	copyFileSync(bundlePath(name), copy);
	64	return import(`${pathToFileURL(copy).href}?load=${load}`);
	65	}
	66
	67	/** Throw the copies away. A test file calls this in `afterAll`; the next one remakes them. */
	68	export function discardBundleCopies(): void {
	69	if (copies !== null) rmSync(copies, { recursive: true, force: true });
	70	copies = null;
	71	}
		@@ -1,88 +1,281 @@
	1	/**
	2	* The cost table, held against the guide. `scripts/cost.ts` measures what each
	3	* group behind the door adds to a bundle; `src/engine/GUIDE.md` prints those
	4	* numbers beside the paragraph a game author is already reading. A number on a
	5	* page is a number that rots, so this file measures again and fails when the
	6	* page and the bundler disagree.
	7	*
	8	* Three rules, and they are the whole of the honesty here:
	9	*
	10	* 1. Every group the door exports carries a `Weight` line under its
	11	* heading, so a group that lands behind the door arrives with a number or it
	12	* fails here.
	13	* 2. Every `Weight` line in the guide is under a heading that is a group, so
	14	* a renamed module cannot leave a stray measurement on the page.
	15	* 3. Every line's numbers are within `TOLERANCE` of what the script measures
	16	* today, and the modules it says come along are exactly the ones that do.
	17	*
	18	* The tolerance, written here rather than left for a reader to guess: a
	19	* number passes when it is within 10% of what was measured, or within
	20	* `GRAIN` — 100 bytes — whichever is wider. The floor is the page's own
	21	* resolution: the guide writes tenths of a kilobyte, so rounding alone moves a
	22	* number by up to 50 bytes and must never fail a run. The band above it is for
	23	* the minifier: a bun release that renames a few identifiers differently, or
	24	* shortens a helper, moves a bundle by a few percent and is nobody's bug. A
	25	* group that doubled is far outside both — the smallest measurement on the
	26	* table is under half a kilobyte, so doubling it moves it by more than 300
	27	* bytes — which is the drift this test exists to catch.
	28	*
	29	* It measures for real: the script's own builds, in a temporary directory of
	30	* its own that it removes. That is forty-odd `Bun.build` calls and takes well
	31	* under a second, which is cheaper than a stale page.
	32	*/
	33
1	34	import { expect, test } from "bun:test";
2		import { COMPETITIVE, SHORT } from "../src/client/match.ts";
	35	import { readFileSync } from "node:fs";
	36	import { join } from "node:path";
3	37	import {
4		TICK_BUDGET_MS, parseArgs, reportLines, rulesFor, sampleTicks, summarize,
	38	type Cost,
	39	DOOR,
	40	FLOOR,
	41	SLACK,
	42	WHOLE_DOOR,
	43	costs,
	44	entryFor,
	45	groupsOf,
	46	guideLine,
	47	headingOf,
	48	kb,
	49	listed,
	50	moduleOf,
	51	pullsOf,
	52	sharesOf,
	53	table,
	54	vlq,
5	55	} from "./cost.ts";
6	56
7		test("no flags fall back to a short, quick, seeded default", () => {
8		expect(parseArgs([])).toEqual({ ticks: 7680, seed: 20260917, rulesName: "short", difficulty: "normal" });
9		});
	57	const GUIDE = join(import.meta.dir, "..", "src", "engine", "GUIDE.md");
	58	const guide = (): string => readFileSync(GUIDE, "utf8");
10	59
11		test("ticks, seed, rules and difficulty are read off the command line", () => {
12		expect(parseArgs(["--ticks", "30000", "--seed", "7", "--rules", "long", "--difficulty", "hard"])).toEqual({
13		ticks: 30000, seed: 7, rulesName: "long", difficulty: "hard",
14		});
15		});
	60	/** How far a written number may sit from a measured one before it is drift. */
	61	export const TOLERANCE = 0.1;
16	62
17		test("a malformed or missing value falls back to the default rather than NaN", () => {
18		expect(parseArgs(["--ticks", "nope"]).ticks).toBe(7680);
19		expect(parseArgs(["--ticks", "-3"]).ticks).toBe(7680);
20		expect(parseArgs(["--ticks"]).ticks).toBe(7680);
21		expect(parseArgs(["--rules", "medium"]).rulesName).toBe("short");
22		expect(parseArgs(["--seed"]).seed).toBe(20260917);
23		expect(parseArgs(["--seed", "-3"]).seed).toBe(20260917);
24		expect(parseArgs(["--seed", "1.5"]).seed).toBe(20260917);
25		expect(parseArgs(["--seed", "0"]).seed).toBe(0); // zero is a fine seed, not a falsy one
26		expect(parseArgs(["--difficulty", "extreme"]).difficulty).toBe("normal");
27		expect(parseArgs(["--difficulty"]).difficulty).toBe("normal");
28		});
	63	/** The page's own resolution in bytes: a tenth of a kilobyte, either way. */
	64	export const GRAIN = 100;
29	65
30		test("rulesFor maps the two names the same way measure.ts does", () => {
31		expect(rulesFor("short")).toBe(SHORT);
32		expect(rulesFor("long")).toBe(COMPETITIVE);
33		});
	66	/** Is this written number still the measured one? The rule in the docstring, once. */
	67	export const near = (written: number, measured: number): boolean =>
	68	Math.abs(written - measured) <= Math.max(GRAIN, measured * TOLERANCE);
34	69
35		test("an empty sample summarizes to zeros, not NaN or a thrown error", () => {
36		expect(summarize([])).toEqual({
37		ticks: 0, meanMs: 0, p50Ms: 0, p95Ms: 0, p99Ms: 0, maxMs: 0, ticksPerSecond: 0, budgetShare: 0,
38		});
39		});
40
41		test("percentiles of a known list are nearest-rank, and order does not matter", () => {
42		// 1..100 shuffled by a fixed stride, so the list arrives out of order.
43		const values = Array.from({ length: 100 }, (_, i) => ((i * 37) % 100) + 1);
44		const cost = summarize(values);
45		expect(cost.ticks).toBe(100);
46		expect(cost.meanMs).toBeCloseTo(50.5, 10);
47		expect(cost.p50Ms).toBe(50);
48		expect(cost.p95Ms).toBe(95);
49		expect(cost.p99Ms).toBe(99);
50		expect(cost.maxMs).toBe(100);
51		});
52
53		test("a single tick is its own mean, median and max", () => {
54		const cost = summarize([4]);
55		expect(cost).toMatchObject({ ticks: 1, meanMs: 4, p50Ms: 4, p95Ms: 4, p99Ms: 4, maxMs: 4 });
56		});
57
58		test("ticks a second and the budget share come off the mean", () => {
59		const cost = summarize([1, 3]); // mean 2 ms
60		expect(cost.ticksPerSecond).toBe(500);
61		expect(cost.budgetShare).toBeCloseTo(2 / TICK_BUDGET_MS, 10);
62		expect(TICK_BUDGET_MS).toBeCloseTo(15.625, 10);
63		});
64
65		test("a Float64Array summarizes the same as the plain list of the same numbers", () => {
66		expect(summarize(new Float64Array([3, 1, 2]))).toEqual(summarize([3, 1, 2]));
67		});
68
69		test("the report says the ticks, the mean, the spread and the share of the budget", () => {
70		const lines = reportLines(summarize([1, 3]));
71		expect(lines[0]).toBe("ticks sampled 2");
72		expect(lines[1]).toContain("2.000 ms a tick (500 ticks/s)");
73		expect(lines[2]).toContain("p50 1.000 ms · p95 3.000 ms");
74		expect(lines[3]).toContain("12.8% of the 15.6 ms");
75		});
	70	/** A weight the guide carries: the heading it sits under, and the line itself. */
	71	export type Written = { heading: string; line: string };
76	72
77	73	/**
78		* The one wall-clock assertion in the repository. 2 ms is roughly fourteen
79		* times what a tick costs today (about 0.13 ms on the box that runs the
80		* check), so this is a regression alarm rather than a target: it fails when
81		* a change to `bots.ts`, `trace.ts` or `world.ts` makes a tick an order of
82		* magnitude dearer, and survives a CI box under load.
	74	* Every `Weight` line in the guide, under the heading it belongs to — the
	75	* whole heading, hashes and all, because the whole door's line sits under a
	76	* `##` and a group's under a `###`. A line before any heading comes back under
	77	* the empty name, which the tests below turn into a sentence rather than
	78	* passing quietly.
83	79	*/
84		test("a tick of the shipped simulation costs well under its 64 Hz budget", () => {
85		const cost = summarize(sampleTicks({ ticks: 600, seed: 20260917, rulesName: "short", difficulty: "normal" }));
86		expect(cost.ticks).toBe(600);
87		expect(cost.meanMs).toBeLessThan(2);
	80	export function weightsOf(markdown: string): Written[] {
	81	const out: Written[] = [];
	82	let heading = "";
	83	for (const line of markdown.split("\n")) {
	84	const found = /^#{2,3} .+$/.exec(line.trim());
	85	if (found !== null) heading = line.trim();
	86	else if (line.startsWith("Weight")) out.push({ heading, line: line.trim() });
	87	}
	88	return out;
	89	}
	90
	91	/** The numbers and the tail of one written line, or null when it is not one. */
	92	export function readWeight(line: string): { raw: number; gzip: number; tail: string } \| null {
	93	const m = /^\\Weight\\: ([0-9.]+) kB raw, ([0-9.]+) kB gzipped — (.+)$/.exec(line);
	94	if (m === null) return null;
	95	return {
	96	raw: Number(m[1]) * 1000,
	97	gzip: Number(m[2]) * 1000,
	98	tail: (m[3] as string).trim(),
	99	};
	100	}
	101
	102	/** The measurement, made once and shared by every test below it. */
	103	const measured: Cost[] = await costs();
	104	const groups = measured.filter((cost) => cost.name !== FLOOR && cost.name !== WHOLE_DOOR);
	105	/** What the page prints a number for: every group, and all of them together. */
	106	const priced = measured.filter((cost) => cost.name !== FLOOR);
	107	const byName = new Map(measured.map((cost) => [cost.name, cost]));
	108
	109	test("the door's groups are the modules behind it, values only, in the door's order", () => {
	110	const F = "fr" + "om";
	111	const source = [
	112	`export { a, b as c } ${F} "./one.ts";`,
	113	`export type { D } ${F} "./one.ts";`,
	114	`export { e, type G } ${F} "./two.ts";`,
	115	`export { f } ${F} "./one.ts";`,
	116	].join("\n");
	117	expect(groupsOf(source)).toEqual([
	118	{ name: "one", names: ["a", "c", "f"] },
	119	{ name: "two", names: ["e"] },
	120	]);
	121	// And the real door: one group a module, every one of them measured.
	122	const real = groupsOf(readFileSync(DOOR, "utf8"));
	123	expect(real.length).toBeGreaterThan(15);
	124	expect(real.map((group) => group.name)).toEqual(groups.map((cost) => cost.name));
	125	expect(new Set(real.map((group) => group.name)).size).toBe(real.length);
	126	});
	127
	128	test("the generated entry imports exactly its group and holds on to every name", () => {
	129	const entry = entryFor({ name: "mesh", names: ["builder", "finish"] }, "/engine/index.ts", "/tmp/x");
	130	expect(entry).toContain('import { builder, finish } from "../../engine/index.ts";');
	131	expect(entry).toContain("globalThis.__cost = [builder, finish];");
	132	// A group with no names is still an import, because the floor is a measurement.
	133	expect(entryFor({ name: FLOOR, names: [] }, "/engine/index.ts", "/tmp/x")).toContain(
	134	'import "../../engine/index.ts";',
	135	);
	136	});
	137
	138	test("a base64 VLQ segment is the signed numbers it packs", () => {
	139	expect(vlq("A")).toEqual([0]);
	140	expect(vlq("C")).toEqual([1]);
	141	expect(vlq("D")).toEqual([-1]);
	142	expect(vlq("AAAA")).toEqual([0, 0, 0, 0]);
	143	expect(vlq("gB")).toEqual([16]);
	144	expect(vlq("hB")).toEqual([-16]);
	145	expect(() => vlq("!")).toThrow(/base64 VLQ/);
	146	});
	147
	148	test("a source is an engine module, or it is not one", () => {
	149	expect(moduleOf("src/engine/math.ts", "/repo", "/repo/src/engine")).toBe("math");
	150	expect(moduleOf("../tmp/cost-1/math.entry.ts", "/repo", "/repo/src/engine")).toBeNull();
	151	// The door itself holds no code, so nothing is ever charged to it.
	152	expect(moduleOf("src/engine/index.ts", "/repo", "/repo/src/engine")).toBeNull();
	153	});
	154
	155	test("the bytes of a bundle are charged to the module the mappings name", () => {
	156	// Three segments on one generated line of ten bytes: the first owns columns
	157	// 0..3 and is the first source, the second owns 4..7 and steps on to the
	158	// second source, and the third is one field — generated code that belongs to
	159	// no source, so the last two bytes are charged to nobody.
	160	const map = JSON.stringify({
	161	sources: ["src/engine/math.ts", "src/engine/mesh.ts", "entry.ts"],
	162	mappings: "AAAA,ICAA,I",
	163	});
	164	const shares = sharesOf(map, "0123456789", "/repo", "/repo/src/engine");
	165	expect(shares.get("math")).toBe(4);
	166	expect(shares.get("mesh")).toBe(4);
	167	expect(shares.has("entry")).toBe(false);
	168	expect(() => sharesOf("{}", "x")).toThrow(/sources and mappings/);
	169	});
	170
	171	test("a module counts as brought along when it beats the floor, not when it jitters", () => {
	172	const floor = new Map([["net", 31]]);
	173	const shares = new Map([
	174	["mesh", 800],
	175	["net", 32],
	176	["math", 120],
	177	]);
	178	// `net` is a byte heavier than the floor's copy of it: that is the minifier,
	179	// not a dependency. `math` is not in the floor at all, so any of it counts.
	180	expect(pullsOf("mesh", shares, floor)).toEqual([{ module: "math", raw: 120 }]);
	181	expect(pullsOf("mesh", new Map([...shares, ["net", 31 + SLACK + 1]]), floor)).toEqual([
	182	{ module: "net", raw: 48 },
	183	{ module: "math", raw: 120 },
	184	].sort((a, b) => b.raw - a.raw));
	185	// The floor keeps everything it holds, because that is what it is for.
	186	expect(pullsOf(FLOOR, floor, floor)).toEqual([{ module: "net", raw: 31 }]);
	187	});
	188
	189	test("the units and the prose are the units and the prose", () => {
	190	expect(kb(1814)).toBe("1.8 kB");
	191	expect(kb(53)).toBe("0.1 kB");
	192	expect(listed([])).toBe("");
	193	expect(listed(["math"])).toBe("math");
	194	expect(listed(["math", "mesh"])).toBe("math and mesh");
	195	expect(listed(["math", "mesh", "scene"])).toBe("math, mesh and scene");
	196	expect(guideLine({ name: "trace", raw: 1008, gzip: 599, pulls: [{ module: "math", raw: 83 }] })).toBe(
	197	"Weight: 1.0 kB raw, 0.6 kB gzipped — including math, which comes with it.",
	198	);
	199	expect(guideLine({ name: "mesh", raw: 916, gzip: 496, pulls: [] })).toBe(
	200	"Weight: 0.9 kB raw, 0.5 kB gzipped — this module alone.",
	201	);
	202	expect(readWeight("Weight: 1.0 kB raw, 0.6 kB gzipped — this module alone.")).toEqual({
	203	raw: 1000,
	204	gzip: 600,
	205	tail: "this module alone.",
	206	});
	207	expect(readWeight("a paragraph")).toBeNull();
	208	});
	209
	210	test("the measurement is a bundle per group, the floor and the whole door", () => {
	211	expect(byName.get(FLOOR)?.raw).toBeGreaterThan(0);
	212	expect(byName.get(FLOOR)?.raw).toBeLessThan(500);
	213	const whole = byName.get(WHOLE_DOOR);
	214	expect(whole?.raw).toBeGreaterThan(20_000);
	215	// Every group is smaller than all of them together, and none is empty.
	216	for (const cost of groups) {
	217	expect(cost.raw).toBeGreaterThan(200);
	218	expect(cost.raw).toBeLessThan(whole?.raw ?? 0);
	219	expect(cost.gzip).toBeLessThan(cost.raw);
	220	expect(cost.pulls.map((pull) => pull.module)).not.toContain(cost.name);
	221	}
	222	// Tree-shaking is the point: a game that wants the arithmetic does not get
	223	// the WebGL, and one that wants the renderer does get the arithmetic.
	224	expect(byName.get("math")?.pulls).toEqual([]);
	225	expect(byName.get("renderer")?.pulls.map((pull) => pull.module)).toContain("math");
	226	expect((byName.get("math")?.raw ?? 0) * 3).toBeLessThan(byName.get("renderer")?.raw ?? 0);
	227	});
	228
	229	test("the table a person reads has a row for every group and its units under it", () => {
	230	const lines = table(measured);
	231	expect(lines[0]).toContain("raw");
	232	expect(lines[0]).toContain("gzip-9");
	233	expect(lines.length).toBe(measured.length + 2);
	234	for (const cost of measured) expect(lines.some((line) => line.startsWith(cost.name))).toBe(true);
	235	});
	236
	237	test("every group the door offers carries its weight in the guide, and nothing else does", () => {
	238	const written = weightsOf(guide());
	239	const under = new Set(written.map((weight) => weight.heading));
	240	const offences: string[] = [];
	241	for (const cost of priced)
	242	if (!under.has(headingOf(cost.name)))
	243	offences.push(
	244	`GUIDE.md has no "Weight" line under "${headingOf(cost.name)}": ` +
	245	`run \`bun run scripts/cost.ts --guide\` and put the line it prints there`,
	246	);
	247	const headings = new Set(priced.map((cost) => headingOf(cost.name)));
	248	for (const weight of written)
	249	if (!headings.has(weight.heading))
	250	offences.push(
	251	`GUIDE.md writes a weight under "${weight.heading}", which is not a group the door exports`,
	252	);
	253	expect(offences).toEqual([]);
	254	expect(written.length).toBe(priced.length);
	255	});
	256
	257	test("every weight the guide writes is what the bundler measures today", () => {
	258	const written = new Map(weightsOf(guide()).map((weight) => [weight.heading, weight.line]));
	259	const offences: string[] = [];
	260	for (const cost of priced) {
	261	const line = written.get(headingOf(cost.name));
	262	if (line === undefined) continue; // the test above is the one that says so
	263	const read = readWeight(line);
	264	if (read === null) {
	265	offences.push(`GUIDE.md's weight for ${cost.name} is not in the shape "${guideLine(cost)}"`);
	266	continue;
	267	}
	268	const fresh = readWeight(guideLine(cost));
	269	if (fresh === null) throw new Error("the generated line no longer reads as one");
	270	if (!near(read.raw, cost.raw) \|\| !near(read.gzip, cost.gzip))
	271	offences.push(
	272	`GUIDE.md says ${cost.name} is ${line} — it measures ${cost.raw} B raw and ` +
	273	`${cost.gzip} B gzipped today, so the line is \`${guideLine(cost)}\``,
	274	);
	275	if (read.tail !== fresh.tail)
	276	offences.push(
	277	`GUIDE.md says ${cost.name} brings "${read.tail}" and it brings "${fresh.tail}"`,
	278	);
	279	}
	280	expect(offences).toEqual([]);
88	281	});