@wenathlan/stealthhead 0.0.0-stage → 2.0.94

package/tests/spawner.test.ts

@@ -0,0 +1,210 @@
+// # spawner.test — honest unit tests for the spawn selection and respawn
+// pacing, runnable with the vitest runner:
+//   pnpm test
+// The prng is seeded, the seed rows are the real catalog, and every case
+// checks exact replayable output — no mocks, no randomness, no dom.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import {
+  buildwave,
+  campscore,
+  DEFAULTSPAWNCONFIG,
+  distance,
+  duewaves,
+  filterbymindistance,
+  isprotected,
+  makerng,
+  nearestdistance,
+  pickspawn,
+  protectionuntil,
+  respawnwait,
+  SPAWNSEED,
+  type SpawnPick,
+  type SpawnQuery,
+  scorepoints,
+  selectspawn,
+  shortlist,
+  spawnpointsformap,
+  spawnpointsforteam,
+  withdeath,
+} from "../spawner.ts";
+
+/** a plain spawn query over steelhead dam for team ember. */
+function damquery(extra: Partial<SpawnQuery> = {}): SpawnQuery {
+  return { map: "steelhead dam", team: "ember", enemies: [], occupied: [], deaths: [], tick: 0, ...extra };
+}
+
+describe("seeded prng", () => {
+  it("replays the same sequence for the same seed", () => {
+    const a = makerng(7);
+    const b = makerng(7);
+    const seqa = [a(), a(), a()];
+    const seqb = [b(), b(), b()];
+    assert.deepEqual(seqa, seqb);
+    assert.equal(makerng(7)(), seqa[0]);
+  });
+
+  it("stays inside [0, 1) and diverges across seeds", () => {
+    const a = makerng(1);
+    const b = makerng(2);
+    for (let i = 0; i < 16; i++) {
+      const va = a();
+      assert.ok(va >= 0 && va < 1);
+      assert.notEqual(va, b());
+    }
+  });
+});
+
+describe("catalog filters", () => {
+  it("filters points by map and by team with neutral flow", () => {
+    assert.equal(spawnpointsformap(SPAWNSEED, "steelhead dam").length, 4);
+    assert.equal(spawnpointsforteam(SPAWNSEED, "steelhead dam", "ember").length, 2);
+    assert.equal(spawnpointsforteam(SPAWNSEED, "rift yard", "tide").length, 4);
+    assert.equal(spawnpointsformap(SPAWNSEED, "no such map").length, 0);
+  });
+
+  it("drops points inside the hard radius of blocked positions", () => {
+    const dam = spawnpointsforteam(SPAWNSEED, "steelhead dam", "ember");
+    const kept = filterbymindistance(dam, [dam[0].position], DEFAULTSPAWNCONFIG.mindistance);
+    assert.deepEqual(
+      kept.map((point) => point.id),
+      ["sd-e2"],
+    );
+    assert.equal(filterbymindistance(dam, [], 12).length, 2);
+  });
+
+  it("measures distances and the nearest of a cloud", () => {
+    assert.ok(Math.abs(distance({ x: 0, y: 0, z: 0 }, { x: 3, y: 0, z: 4 }) - 5) < 1e-9);
+    assert.equal(nearestdistance({ x: 0, y: 0, z: 0 }, []), Infinity);
+    assert.equal(
+      nearestdistance({ x: 0, y: 0, z: 0 }, [
+        { x: 3, y: 0, z: 4 },
+        { x: 1, y: 0, z: 0 },
+      ]),
+      1,
+    );
+  });
+});
+
+describe("scoring and lottery", () => {
+  it("decays camp pressure by the half-life inside the radius", () => {
+    const point = SPAWNSEED[0];
+    assert.equal(campscore(point, [], 0, DEFAULTSPAWNCONFIG), 0);
+    const fresh = campscore(point, [{ position: point.position, tick: 400 }], 400, DEFAULTSPAWNCONFIG);
+    assert.equal(fresh, 1);
+    const aged = campscore(point, [{ position: point.position, tick: 0 }], 400, DEFAULTSPAWNCONFIG);
+    assert.ok(Math.abs(aged - 0.5) < 1e-9);
+    const far = campscore(point, [{ position: { x: 500, y: 0, z: 500 }, tick: 400 }], 400, DEFAULTSPAWNCONFIG);
+    assert.equal(far, 0);
+  });
+
+  it("scores full weight when enemies are far and sorts descending", () => {
+    const picks = scorepoints(spawnpointsforteam(SPAWNSEED, "steelhead dam", "ember"), damquery(), DEFAULTSPAWNCONFIG);
+    assert.equal(picks.length, 2);
+    assert.equal(picks[0].score, 1);
+    assert.equal(picks[1].score, 0.8);
+    assert.equal(picks[0].point.id, "sd-e1");
+  });
+
+  it("discounts the score when an enemy camped the point", () => {
+    const point = SPAWNSEED[0];
+    const query = damquery({ deaths: [{ position: point.position, tick: 100 }], tick: 100 });
+    const picks = scorepoints([point], query, DEFAULTSPAWNCONFIG);
+    assert.ok(picks[0].score < 0.01);
+  });
+
+  it("shortlists and runs the score-proportional lottery", () => {
+    const picks: SpawnPick[] = [
+      { point: SPAWNSEED[0], score: 1 },
+      { point: SPAWNSEED[2], score: 3 },
+      { point: SPAWNSEED[4], score: 0.5 },
+    ];
+    assert.equal(shortlist(picks, 2).length, 2);
+    assert.equal(pickspawn(picks, () => 0.1).point.id, "sd-e1");
+    assert.equal(pickspawn(picks, () => 0.5).point.id, "sd-t1");
+    assert.equal(pickspawn(picks, () => 0.999).point.id, "ch-e1");
+  });
+});
+
+describe("the spawn pipeline", () => {
+  it("picks deterministically for the same seed", () => {
+    const first = selectspawn(SPAWNSEED, damquery(), DEFAULTSPAWNCONFIG, makerng(7));
+    const second = selectspawn(SPAWNSEED, damquery(), DEFAULTSPAWNCONFIG, makerng(7));
+    assert.ok(first);
+    assert.equal(first.point.id, second?.point.id);
+    assert.ok(SPAWNSEED.some((point) => point.id === first.point.id));
+  });
+
+  it("returns null when safety or stacking filters wipe the map", () => {
+    const dam = spawnpointsforteam(SPAWNSEED, "steelhead dam", "ember");
+    const stacked = selectspawn(
+      SPAWNSEED,
+      damquery({ occupied: dam.map((point) => point.position) }),
+      DEFAULTSPAWNCONFIG,
+      makerng(7),
+    );
+    assert.equal(stacked, null);
+    const unsafe = selectspawn(
+      SPAWNSEED,
+      damquery({ enemies: dam.map((point) => point.position) }),
+      DEFAULTSPAWNCONFIG,
+      makerng(7),
+    );
+    assert.equal(unsafe, null);
+  });
+
+  it("hard-filters enemies near a point even when others survive", () => {
+    const near = SPAWNSEED[0].position;
+    const pick = selectspawn(
+      SPAWNSEED,
+      damquery({ enemies: [{ x: near.x + 5, y: 0, z: near.z }] }),
+      DEFAULTSPAWNCONFIG,
+      makerng(7),
+    );
+    assert.ok(pick);
+    assert.notEqual(pick.point.id, "sd-e1");
+  });
+});
+
+describe("respawn pacing", () => {
+  it("prunes death marks older than the window", () => {
+    const marks = withdeath(
+      [
+        { position: { x: 0, y: 0, z: 0 }, tick: 0 },
+        { position: { x: 1, y: 0, z: 0 }, tick: 500 },
+      ],
+      { position: { x: 2, y: 0, z: 0 }, tick: 600 },
+      400,
+    );
+    assert.equal(marks.length, 2);
+    assert.equal(marks[marks.length - 1].tick, 600);
+  });
+
+  it("escalates the respawn wait 1.5x per death and caps it", () => {
+    assert.equal(respawnwait(1, DEFAULTSPAWNCONFIG), 50);
+    assert.equal(respawnwait(3, DEFAULTSPAWNCONFIG), 113);
+    assert.equal(respawnwait(10, DEFAULTSPAWNCONFIG), 400);
+  });
+
+  it("grants and expires spawn protection", () => {
+    assert.equal(protectionuntil(100, DEFAULTSPAWNCONFIG), 160);
+    assert.equal(isprotected(protectionuntil(100, DEFAULTSPAWNCONFIG), 159), true);
+    assert.equal(isprotected(protectionuntil(100, DEFAULTSPAWNCONFIG), 160), false);
+  });
+});
+
+describe("wave scheduling", () => {
+  it("schedules waves on the interval grid", () => {
+    const config = { waves: 3, countperwave: 5, intervalticks: 100 };
+    assert.deepEqual(buildwave(config, 2, 50), { wave: 2, startat: 150, count: 5 });
+    assert.deepEqual(buildwave(config, 1, 50), { wave: 1, startat: 50, count: 5 });
+  });
+
+  it("lists only the waves due inside the window", () => {
+    const config = { waves: 3, countperwave: 5, intervalticks: 100 };
+    assert.equal(duewaves(config, 0, 250).length, 3);
+    assert.equal(duewaves(config, 0, 150).length, 2);
+    assert.equal(duewaves(config, 0, 0).length, 1);
+    assert.deepEqual(duewaves(config, 1000, 0), []);
+  });
+});

package/tests/weaponstats.test.ts

@@ -0,0 +1,148 @@
+// # weaponstats.test — honest unit tests for the armory terminal ballistics
+// (falloff, shots, ttk, balance), runnable with the vitest runner:
+//   pnpm test
+// The falloff specs and balance bounds arrive as parameters — the tests pass
+// their own catalog config, exactly as a season would.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { WEAPONCATALOG, type Weapon } from "../weapons.ts";
+import {
+  damageatmeters,
+  type FalloffSpec,
+  shotstokill,
+  timetokill,
+  ttkbydistance,
+  validatebalance,
+  weaponstatserror,
+} from "../weaponstats.ts";
+
+/** the catalog falloff: full damage to 20 m, 60% at 60 m, linear. */
+const LINEAR: FalloffSpec = { startmeters: 20, endmeters: 60, retainfraction: 0.6, curve: 1 };
+
+/** the competitor style quadratic falloff (claude-of-duty curve). */
+const QUADRATIC: FalloffSpec = { startmeters: 20, endmeters: 60, retainfraction: 0.6, curve: 2 };
+
+/** the standard target health model of the tests. */
+const HEALTH = 100;
+
+/** finds one catalog row by id. */
+function weapon(id: string): Weapon {
+  const row = WEAPONCATALOG.find((candidate) => candidate.id === id);
+  assert.ok(row, `catalog weapon ${id} missing`);
+  return row;
+}
+
+describe("weapon stats damage falloff", () => {
+  const rifle = weapon("w-1"); // 28 damage
+
+  it("keeps the full damage up to the falloff start", () => {
+    assert.equal(damageatmeters(rifle, 0, LINEAR), 28);
+    assert.equal(damageatmeters(rifle, 20, LINEAR), 28);
+  });
+
+  it("settles at the retained fraction past the end", () => {
+    assert.equal(damageatmeters(rifle, 60, LINEAR), 28 * 0.6);
+    assert.equal(damageatmeters(rifle, 200, LINEAR), 28 * 0.6);
+  });
+
+  it("fades linearly between start and end", () => {
+    const mid = damageatmeters(rifle, 40, LINEAR); // t 0.5
+    assert.ok(Math.abs(mid - 28 * (1 - 0.4 * 0.5)) < 1e-9, `expected 22.4, got ${mid}`);
+  });
+
+  it("bends the fade with the curve exponent", () => {
+    const linear = damageatmeters(rifle, 30, LINEAR);
+    const quad = damageatmeters(rifle, 30, QUADRATIC);
+    assert.ok(quad > linear, "a quadratic curve keeps more damage near the start");
+    assert.ok(Math.abs(linear - 28 * (1 - 0.4 * 0.25)) < 1e-9, `expected 25.2, got ${linear}`);
+    assert.ok(
+      Math.abs(quad - 28 * (1 - 0.4 * 0.25 ** 2)) < 1e-9,
+      `expected ${28 * (1 - 0.4 * 0.25 ** 2)}, got ${quad}`,
+    );
+  });
+
+  it("refuses a bad distance, a bad spec and a bad row", () => {
+    assert.throws(() => damageatmeters(rifle, -1, LINEAR), weaponstatserror);
+    assert.throws(
+      () => damageatmeters(rifle, 10, { ...LINEAR, endmeters: 10 }),
+      (error: unknown) => {
+        assert.ok(error instanceof weaponstatserror);
+        assert.equal(error.code, "bad-falloff");
+        return true;
+      },
+    );
+    assert.throws(() => damageatmeters({ ...rifle, damage: 0 }, 10, LINEAR), weaponstatserror);
+  });
+});
+
+describe("weapon stats shots and ttk", () => {
+  const rifle = weapon("w-1"); // 28 dmg, 660 rpm, 30 mag, 2.1 s reload
+
+  it("asks more shots as the distance fades the damage", () => {
+    const close = shotstokill(rifle, 10, HEALTH, LINEAR);
+    const mid = shotstokill(rifle, 40, HEALTH, LINEAR);
+    const far = shotstokill(rifle, 200, HEALTH, LINEAR);
+    assert.equal(close, 4); // 100 / 28
+    assert.ok(mid > close && far > mid, `expected the shots to grow, got ${close}/${mid}/${far}`);
+  });
+
+  it("counts the headshot multiplier before the division", () => {
+    const body = shotstokill(rifle, 10, HEALTH, LINEAR, { vitalmultiplier: 1 });
+    const head = shotstokill(rifle, 10, HEALTH, LINEAR, { vitalmultiplier: 2 });
+    assert.equal(head, Math.ceil(body / 2));
+  });
+
+  it("computes the ttk from the inter shot gaps and never mutates the row", () => {
+    const result = timetokill(rifle, 10, HEALTH, LINEAR);
+    assert.equal(result.shots, 4);
+    assert.equal(result.reloads, 0);
+    const gap = 60 / 660;
+    assert.ok(Math.abs(result.seconds - 3 * gap) < 0.0005, `expected ${3 * gap}, got ${result.seconds}`);
+    assert.equal(rifle.damage, 28);
+  });
+
+  it("charges one reload when the burst outgrows the magazine", () => {
+    const shotgun = weapon("w-4"); // 96 dmg, 70 rpm, 6 mag, 2.8 s reload
+    const result = timetokill(shotgun, 10, 600, LINEAR); // 600 hp asks 7 shots
+    assert.equal(result.shots, 7);
+    assert.equal(result.reloads, 1);
+    const gap = 60 / 70;
+    assert.ok(Math.abs(result.seconds - (6 * gap + 2.8)) < 0.0005, `expected ${6 * gap + 2.8}, got ${result.seconds}`);
+  });
+
+  it("sweeps a distance ladder in order for the armory curve", () => {
+    const curve = ttkbydistance(rifle, [10, 40, 120], HEALTH, LINEAR);
+    assert.equal(curve.length, 3);
+    assert.ok(curve[0].seconds < curve[1].seconds && curve[1].seconds < curve[2].seconds);
+  });
+
+  it("refuses a bad health pool", () => {
+    assert.throws(
+      () => shotstokill(rifle, 10, 0, LINEAR),
+      (error: unknown) => {
+        assert.ok(error instanceof weaponstatserror);
+        assert.equal(error.code, "bad-health");
+        return true;
+      },
+    );
+  });
+});
+
+describe("weapon stats balance validation", () => {
+  it("accepts every catalog row inside the season bounds", () => {
+    const bounds = { damage: { min: 10, max: 100 }, firerate: { min: 60, max: 1000 }, recoil: { min: 10, max: 90 } };
+    const violations = WEAPONCATALOG.flatMap((row) => validatebalance(row, bounds));
+    assert.equal(violations.length, 0);
+  });
+
+  it("reports each field that leaves the configured bounds", () => {
+    const bounds = { damage: { min: 20, max: 80 }, reloadseconds: { min: 1, max: 3 } };
+    const violations = validatebalance(weapon("w-2"), bounds); // 88 dmg, 3.2 s reload
+    assert.equal(violations.length, 2);
+    assert.deepEqual(violations.map((violation) => violation.field).sort(), ["damage", "reloadseconds"]);
+  });
+
+  it("skips the fields without bounds and passes an empty bounds table", () => {
+    assert.deepEqual(validatebalance(weapon("w-4"), {}), []);
+  });
+});