Files
plan2code/scripts/test-web-console-activities-ghoul-bog.mjs

1726 lines
85 KiB
JavaScript

// Web console tests, Ghoul Rush's Gallows Bog stage: the pack skeleton (the
// lurker, the leech swarm, the will-o'-wisp, the bog body and Old Mother Bog
// joined to the game's tables), the stage row and its five rooms' shapes, the
// mud spans that slow and sink you, the Bog Runner's stub and the Drowning
// Pool's boss spec. The monsters' rules, the fight and the ride land in
// later phases.
import "./seed-random.mjs";
import { test } from "node:test";
import { readFileSync } from "node:fs";
import assert from "node:assert/strict";
import * as ghoul from "../src/web-console/public/activities/ghoul-rush/ghoul.js";
import * as bog from "../src/web-console/public/activities/ghoul-rush/stages/bog/ghoul-bog.js";
import * as ghoulSfx from "../src/web-console/public/activities/ghoul-rush/sfx/ghoul-sfx.js";
import { LOSE_SOUNDS, LOSE_WORDS, VOICES } from "../src/web-console/public/activities/ghoul-rush/stages/bog/ghoul-bog-draw.js";
import { BOG_SFX } from "../src/web-console/public/activities/ghoul-rush/stages/bog/ghoul-sfx-bog.js";
import { BOSS_INTROS, bossIntroFor } from "../src/web-console/public/activities/ghoul-rush/story/ghoul-boss-intros.js";
import { INTROS, introFor } from "../src/web-console/public/activities/ghoul-rush/story/ghoul-intros.js";
import { react } from "../src/web-console/public/activities/ghoul-rush/draw/ghoul-draw.js";
const steady = () => 0.5;
const events = (round, type) => round.events.filter((e) => e.type === type);
const ROOM_IDS = ["boardwalk", "hollow", "stilts", "lantern", "drowning"];
function through(round) {
round.phase = "clear";
round.phaseMs = 1;
ghoul.advance(round, 4, steady);
}
// A round in the Gallows Bog room `id`, reached the way play reaches it (out
// of the hall, the stage picked, the rooms before it gone through), nothing
// woken.
function bogRound(id) {
const round = ghoul.newRound(5);
round.dice = 0;
through(round);
assert.equal(round.phase, "pick");
round.offer = ["bog"];
round.phaseMs = 0;
ghoul.pickStage(round, 0);
while (round.spec.id !== id) through(round);
round.phase = "play";
for (const st of round.spawns) st.over = true;
round.monsters.length = 0;
round.hordeMs = Infinity;
round.items.fill(true);
round.candy.fill(true);
round.sky.fill(true);
round.events.length = 0;
return round;
}
function standAt(round, x, shelf = -1) {
const y = shelf >= 0 ? round.spec.shelves[shelf][2] : ghoul.groundAt(round.spec, x);
Object.assign(round.you, { x, y, vx: 0, vy: 0, state: "run", shelf, coyote: 0, drop: -1, cuttable: false, out: 0, safeMs: 0 });
round.camX = Math.max(0, Math.min(round.spec.length - ghoul.FIELD_W, x - 36));
}
function run(round, ms, keys = {}, random = steady) {
Object.assign(round.input, keys);
for (let t = 0; t < ms; t += 4) ghoul.advance(round, 4, random);
for (const k of Object.keys(keys)) round.input[k] = false;
}
/* ------------------------------------------------------------ the stage */
test("Ghoul Rush's Gallows Bog is a stage of five rooms ending on the Drowning Pool, its kinds and boss joined to the game's, last in the list", () => {
const st = ghoul.stageById("bog");
assert.deepEqual(st.rooms, ROOM_IDS);
assert.equal(st.boss, "motherbog");
assert.equal(st.title, "Gallows Bog");
assert.equal(st.sub, "The mud does not like to let go");
assert.equal(ghoul.STAGES.at(-1), st, "the last stage in the list");
for (const kind of Object.keys(bog.MONSTERS)) assert.equal(ghoul.MONSTERS[kind], bog.MONSTERS[kind], `${kind} is a monster`);
assert.deepEqual(Object.keys(bog.MONSTERS).sort(), ["bogbody", "leech", "lurker", "wisp"]);
assert.equal(ghoul.BOSSES.motherbog, bog.BOSSES.motherbog);
assert.equal(bog.BOSSES.motherbog.name, "Old Mother Bog");
assert.equal(bog.BOSSES.motherbog.sub, "Keep to the planks, she owns the water");
assert.equal(bog.BOG.id, "bog");
for (const key of ["walkers", "zombies", "act", "swoops", "solid", "unseen", "move", "kill", "horde", "tick", "bosses", "boss", "weak", "cause", "hazards"]) assert.ok(key in bog.BOG, `the pack carries ${key}`);
assert.deepEqual(bog.BOG.zombies, ["bogbody"], "the bog body counts as a zombie");
for (const id of ROOM_IDS) {
assert.ok(ghoul.roomById(id), `${id} resolves`);
assert.ok(ghoul.ROOM_MUSIC[id], `${id} has music`);
assert.ok(Object.hasOwn(ghoulSfx.default.music, ghoul.ROOM_MUSIC[id]), `${id}'s track exists`);
}
});
test("Ghoul Rush's bog rooms carry the usual pieces: a key, sky treasures, candy, items and a horde in each walked room, mud spans frozen, the ride its own course, the arena the hag's", () => {
const [boardwalk, hollow, stilts, lantern, drowning] = ROOM_IDS.map((id) => ghoul.roomById(id));
assert.deepEqual([boardwalk.title, hollow.title, stilts.title, lantern.title, drowning.title], ["Sunken Boardwalk", "Cypress Hollow", "Stilt House", "The Drowned Lantern", "The Drowning Pool"]);
assert.deepEqual([boardwalk.sub, hollow.sub, stilts.sub, drowning.sub], ["Mind the gaps. Something lives in them", "The moss is breathing", "She has been expecting you", "Keep to the planks, she owns the water"]);
for (const room of [boardwalk, hollow, stilts]) {
assert.ok(room.key, `${room.id}: a key`);
assert.ok(room.door > room.length - 14, `${room.id}: the door at the end`);
assert.ok(room.sky.length && room.candy.length && room.items.length && room.horde.length, `${room.id}: sky treasures, candy, items and a horde`);
const wings = room.items.find((i) => i[0] === "wings");
assert.ok(wings && wings[1] < Math.min(...room.sky.map(([, x]) => x)), `${room.id}: wings on the way to the sky`);
assert.ok(room.mud.length >= 1, `${room.id}: mud spans`);
for (const span of room.mud) assert.ok(Object.isFrozen(span), `${room.id}: a mud span is frozen`);
for (const kind of room.horde) assert.ok(ghoul.MONSTERS[kind], `${room.id}: ${kind} is a monster`);
assert.equal(room.boss, null, `${room.id}: no boss`);
assert.equal(room.dark, null, `${room.id}: dark or lit by the roll`);
}
assert.ok(hollow.water.length && stilts.water.length, "the hollow and the stilts keep pools beside the mud");
assert.ok(boardwalk.shelves.some((s) => s[3] === "crumble") && hollow.shelves.some((s) => s[3] === "crumble") && stilts.shelves.some((s) => s[3] === "crumble"), "rotting boards that give way");
// The Bog Runner is a stub: a bonus ride with empty obstacle arrays that
// Phase 4's deterministic generator fills in.
assert.equal(lantern.bonus, true);
assert.equal(lantern.dark, false);
assert.equal(lantern.key, null);
assert.equal(lantern.boss, null);
assert.equal(lantern.horde.length, 0);
assert.equal(lantern.ride.runner, "lantern");
assert.equal(lantern.ride.how, "ARROWS walk, SPACE flares. Light 5 shrines, then run to the boat");
assert.ok(lantern.ride.time >= 70000 && lantern.ride.time <= 120000);
assert.ok(lantern.ride.shrines.length === 5 && lantern.ride.hummocks.length > 5, "an island with five shrines");
assert.ok(Object.isFrozen(lantern.ride), "the room is frozen");
// The Bog Runner (the fan-boat ride this room replaced) is still defined but no stage lists it.
assert.equal(ghoul.roomById("bogboat"), null, "the retired boat is gone");
assert.equal(drowning.boss, "motherbog");
assert.equal(drowning.key, null);
assert.equal(drowning.horde.length, 0);
assert.equal(drowning.dark, null, "the arena rolls dark or lit");
assert.ok(drowning.length - ghoul.FIELD_W > 30, "room to walk into the arena");
});
/* ---------------------------------------------------------- the mud */
test("Ghoul Rush's mud slows a run the longer you stand in it, down to a crawl, and lets go on dry floor", () => {
const round = bogRound("boardwalk");
const inMud = round.spec.mud[0][0] + 2;
standAt(round, inMud);
round.you.safeMs = 1e9;
run(round, 200, { right: true });
assert.equal(round.you.mud, true, "in the span you are muddy");
// Fresh mud drags like water; the run crawls as the sink deepens.
standAt(round, inMud);
const x0 = round.you.x;
run(round, 1000, { right: true });
const early = round.you.x - x0;
assert.ok(round.you.mudMs > 900, `sunk a second (${round.you.mudMs} ms)`);
run(round, 1800, { right: true });
const x1 = round.you.x;
run(round, 1000, { right: true });
const late = round.you.x - x1;
assert.ok(late < early * 0.6, `deeper is slower (${early.toFixed(1)} then ${late.toFixed(1)})`);
// Out of the mud it drains away.
round.you.mudMs = 2000;
standAt(round, 290);
run(round, 500, { right: true });
assert.equal(round.you.mud, false);
assert.ok(round.you.mudMs < 2000, `it lets go (${round.you.mudMs} ms)`);
});
test("Ghoul Rush's mud cuts a jump lower the deeper you sink, and a shelf keeps you out of it", () => {
const round = bogRound("boardwalk");
const inMud = round.spec.mud[0][0] + 2;
// A fresh jump in mud leaves near WATER_JUMP of full speed; a sunk one nears MUD_JUMP_MIN.
const jumpV = (ms) => {
standAt(round, inMud);
round.you.mudMs = ms;
run(round, 4, {});
round.input.jump = ghoul.JUMP_BUFFER_MS;
ghoul.advance(round, 4, steady);
return round.you.vy;
};
const fresh = jumpV(0);
const sunk = jumpV(ghoul.MUD_MS);
// The vy read is one gravity slice after the jump itself.
assert.ok(Math.abs(fresh - ghoul.JUMP_V * ghoul.WATER_JUMP) < 2, `fresh mud jumps near water height (${fresh.toFixed(1)})`);
assert.ok(Math.abs(sunk - ghoul.JUMP_V * ghoul.MUD_JUMP_MIN) < 2, `sunk jumps near the floor of it (${sunk.toFixed(1)})`);
assert.ok(sunk < fresh, "the deeper the sink, the lower the jump");
// On a shelf over the mud there is no sinking.
const shelf = round.spec.shelves.findIndex(([a, b]) => round.spec.mud.some(([m0, m1]) => a < m1 && b > m0));
assert.ok(shelf >= 0, "a board over the mud to stand on");
const [a, b] = round.spec.shelves[shelf];
standAt(round, (a + b) / 2, shelf);
run(round, 300, {});
assert.equal(round.you.mud, false, "a board over the mud is dry");
});
test("Ghoul Rush's wisp lure pulls the dead inside a bright wisp's light and lets go when it dims, and never touches another stage's lure", () => {
const round = bogRound("boardwalk");
standAt(round, 20);
round.you.safeMs = 60000;
const wisp = ghoul.spawnMonster(round, "wisp", 24, 10);
const risen = ghoul.spawnMonster(round, "bogbody", 28, ghoul.groundAt(round.spec, 28));
run(round, 40, {});
assert.ok(risen.lure > 0 && risen.hasteMs > 0 && risen.haste === bog.WISP_HASTE, "in the light it is pulled, a step quicker");
wisp.act = "dim";
run(round, 8, {});
assert.equal(risen.lure, 0, "a shot-out wisp lets it go");
// In any other stage the same fields belong to another pack (the moth's call).
const hall = ghoul.newRound(5);
const moth = ghoul.spawnMonster(hall, "zombie", 20, 6);
moth.lure = 500;
moth.hasteMs = 500;
ghoul.advance(hall, 4, steady);
assert.equal(moth.lure, 500, "the hall's lure is not the wisp's to clear");
});
/* ------------------------------------------------------ monsters */
const put = (round, kind, x, over = {}) => ghoul.spawnMonster(round, kind, x, over.y ?? ghoul.groundAt(round.spec, x), over);
// Runs until `done()` (or `ms` have passed), 4 ms at a time.
function until(round, done, ms = 4000) {
for (let t = 0; t < ms && !done(); t += 4) ghoul.advance(round, 4, steady);
}
const tx2 = (e) => e.tx2;
// A bolt arriving from the left at height `y` on the monster `m`.
const bolt = (round, m, y, extra = {}) => round.shots.push({ x: m.x - m.w / 2 - 0.3, y, vx: 80, vy: 0, gone: 0, ...extra });
// A hollow x on dry floor with open floor to either side.
const dry = (round, x) => {
assert.ok(Number.isFinite(ghoul.groundAt(round.spec, x)), `floor at ${x}`);
return x;
};
test("Ghoul Rush's lurker is eyes you cannot touch or shoot until you cross it, then snaps out of the water solid and sinks back", () => {
const round = bogRound("hollow");
standAt(round, dry(round, 20));
round.you.safeMs = 1e9;
const m = put(round, "lurker", 60);
assert.equal(m.act, "eyes");
run(round, 8);
assert.equal(m.unseen, true, "eyes are unseen");
assert.equal(ghoul.solid(m), false, "nothing to stomp or hit");
bolt(round, m, m.y + 1);
run(round, 40);
assert.equal(m.hp, m.max, "a bolt goes through the eyes");
assert.equal(events(round, "lurkerSnap").length, 0, "far away it stays down");
// Cross into its range: it snaps, solid and lunging at you.
standAt(round, m.x - bog.SNAP_RANGE + 2);
round.you.safeMs = 1e9;
run(round, 8);
assert.equal(m.act, "snap");
assert.equal(events(round, "lurkerSnap").length, 1);
assert.equal(ghoul.solid(m), true, "snapping it is solid");
const x0 = m.x;
run(round, 200);
assert.ok(Math.abs(m.x - x0) > 1, "it lunges");
// The snap ends in a sink, then eyes again.
run(round, bog.SNAP_MS);
assert.equal(events(round, "lurkerSink").length, 1);
assert.ok(m.act === "sink" || m.act === "eyes");
run(round, bog.LURKER_SINK_MS + 40);
assert.ok(m.act === "eyes" || m.act === "snap", "back to eyes (or snapping again if you are still near)");
// Eyes at the waterline do no harm when you walk through them with the shield down.
const calm = bogRound("hollow");
standAt(calm, 20);
calm.you.safeMs = 0;
const e = put(calm, "lurker", 20, { act: "eyes" });
calm.you.out = 1000;
run(calm, 30);
assert.equal(events(calm, "lose").length, 0);
assert.equal(e.act, "eyes", "a player who is out never wakes it");
});
test("Ghoul Rush's leech swarm latches for one heart on touch, drops off and cannot latch again at once, and a hit disperses it", () => {
const round = bogRound("hollow");
standAt(round, dry(round, 30));
round.you.safeMs = 0;
const hearts = round.lives;
const m = put(round, "leech", 30);
run(round, 8);
assert.equal(events(round, "leechLatch").length, 1, "one latch");
assert.equal(events(round, "lose")[0]?.cause, "leeches", "it costs a heart, named for the leeches");
assert.equal(m.act, "drop");
assert.equal(round.lives, hearts - 1, "exactly one heart");
// It drops off for LEECH_DROP_MS, then drifts again; a second latch waits LEECH_AGAIN_MS.
const lives = round.lives;
round.you.safeMs = 0;
run(round, bog.LEECH_DROP_MS + 20);
assert.equal(m.act === "drift" || m.act === "drop", true);
assert.ok(m.latchIn > 0, "cannot latch again yet");
assert.equal(events(round, "leechLatch").length, 1, "still the one latch");
assert.equal(round.lives, lives);
// Stomp-free dispersal: a bolt takes LEECH hp, the swarm comes apart.
const swarm = put(round, "leech", 60);
standAt(round, 30);
round.you.safeMs = 1e9;
ghoul.hurt(round, swarm, 99, "shot");
assert.equal(events(round, "leechDie").length, 1, "the swarm comes apart");
});
test("Ghoul Rush's will-o'-wisp is hit only while bright: a bolt puts it out, it stays dim, glows where it will return, then burns again", () => {
const round = bogRound("boardwalk");
standAt(round, 20);
round.you.safeMs = 1e9;
const m = put(round, "wisp", 40, { y: 10 });
assert.equal(m.act, "bright");
assert.equal(ghoul.solid(m), true);
bolt(round, m, m.y + m.h / 2);
run(round, 4);
assert.equal(m.act, "dim", "a bolt puts it out");
assert.equal(events(round, "wispOut").length, 1);
assert.equal(ghoul.solid(m), false, "a dim wisp is no target and no threat");
assert.ok(m.relight && Number.isFinite(m.relight.x), "the spot it returns to is seeded");
run(round, bog.WISP_RELIGHT_MS - 100);
assert.equal(m.act, "dim", "stays dim for the relight time");
run(round, 200);
assert.equal(m.act, "rekindle");
assert.equal(events(round, "wispRelight").length, 1);
assert.equal(ghoul.solid(m), false, "glowing is not yet burning");
run(round, bog.WISP_REKINDLE_MS + 20);
assert.equal(m.act, "bright");
assert.equal(events(round, "wispOn").length, 1);
// A dim wisp is a dip you can pass through: touching it costs nothing.
const pass = bogRound("boardwalk");
standAt(pass, 20);
pass.you.safeMs = 0;
put(pass, "wisp", 20, { y: pass.you.y + 1, act: "dim", wait: 5000 });
run(pass, 40);
assert.equal(events(pass, "lose").length, 0);
});
test("Ghoul Rush's bog body climbs out of the mud harmless, then shambles toward you", () => {
const round = bogRound("boardwalk");
standAt(round, 20);
round.you.safeMs = 1e9;
const m = put(round, "bogbody", 50);
assert.equal(m.act, "rise");
run(round, 8);
assert.ok(m.rise > 0, "climbing out");
assert.equal(ghoul.solid(m), false, "harmless while it rises");
assert.equal(events(round, "bogRise").length, 1);
const x0 = m.x;
run(round, 300);
assert.equal(m.x, x0, "it does not walk while it climbs");
run(round, bog.BOG_RISE_MS);
assert.equal(m.act, "walk");
assert.equal(ghoul.solid(m), true);
const x1 = m.x;
run(round, 400);
assert.ok(m.x < x1 - 1, "it walks toward you");
// One that comes in with the horde is already up.
const up = put(round, "bogbody", 80, { horde: true });
run(round, 8);
assert.equal(up.act, "walk");
assert.equal(events(round, "bogRise").length, 1, "no second climb");
});
/* ------------------------------------------------------ the lure */
test("Ghoul Rush's bright wisp lures monsters inside WISP_LURE toward you at WISP_HASTE times their speed, and shot out the pull ends", () => {
const walked = (withWisp) => {
const round = bogRound("boardwalk");
standAt(round, 20);
round.you.safeMs = 1e9;
const m = put(round, "bogbody", 70, { rise: 0, act: "walk" });
if (withWisp) put(round, "wisp", 70, { y: 10 });
const x0 = m.x;
run(round, 1000);
return { m, round, dx: x0 - m.x };
};
const plain = walked(false);
const lured = walked(true);
assert.equal(plain.m.lure || 0, 0);
assert.ok(lured.m.lure > 0, "pulled");
assert.ok(lured.m.haste <= bog.WISP_HASTE, "never past the cap");
const ratio = lured.dx / plain.dx;
assert.ok(ratio > 1.1 && ratio < bog.WISP_HASTE + 0.05, `about ${bog.WISP_HASTE}x, not more (${ratio.toFixed(2)})`);
assert.equal(events(lured.round, "wispLure").length, 1, "the pull is announced once");
// Out of reach of a bright light it is no quicker.
const round = bogRound("boardwalk");
standAt(round, 20);
round.you.safeMs = 1e9;
const far = put(round, "bogbody", 75, { rise: 0, act: "walk" });
const w = put(round, "wisp", 75 - bog.WISP_LURE - 6, { y: 10 });
run(round, 100);
assert.equal(w.act, "bright", "the wisp is burning");
assert.equal(far.lure || 0, 0, "a bright wisp out of reach lures nobody");
assert.equal(far.haste || 1, 1);
// Shot out, the pull ends at once; a monster beyond the radius is not drawn.
const shot = bogRound("boardwalk");
standAt(shot, 20);
shot.you.safeMs = 1e9;
const walker = put(shot, "bogbody", 70, { rise: 0, act: "walk" });
const light = put(shot, "wisp", 72, { y: 10 });
run(shot, 60);
assert.ok(walker.lure > 0);
light.act = "dim";
light.wait = 1e9;
run(shot, 8);
assert.equal(walker.lure, 0);
assert.equal(walker.hasteMs, 0);
assert.equal(walker.haste, 1);
});
test("Ghoul Rush's wisp lure stays fair in a horde: every monster in the light is capped at WISP_HASTE, a wisp never lures another wisp, and shooting the wisp out frees the lot", () => {
const round = bogRound("boardwalk");
standAt(round, 20);
round.you.safeMs = 1e9;
const pack = [put(round, "bogbody", 70, { rise: 0, act: "walk" }), put(round, "bogbody", 75, { rise: 0, act: "walk" }), put(round, "leech", 72), put(round, "bogbody", 78, { rise: 0, act: "walk" })];
const lights = [put(round, "wisp", 74, { y: 10 }), put(round, "wisp", 76, { y: 11 })];
run(round, 120);
for (const m of pack) {
assert.ok(m.lure > 0, `${m.kind} is lured`);
assert.ok(m.haste <= bog.WISP_HASTE + 1e-9, `${m.kind} at ${m.haste}x`);
}
for (const w of lights) assert.equal(w.lure || 0, 0, "a wisp is never lured by a wisp");
// Two lights do not stack: the cap is the cap.
assert.equal(new Set(pack.map((m) => m.haste)).size, 1);
for (const w of lights) {
bolt(round, w, w.y + w.h / 2);
run(round, 8);
}
run(round, 20);
for (const m of pack) assert.equal(m.lure, 0, `${m.kind} is let go`);
});
/* ---------------------------------------------------------- mud, boots, harpoon */
test("Ghoul Rush's mud holds you only on its spans and on the ground: a jump lets go of the sink, mudMs builds and drains, and the speed bottoms out at MUD_SPEED_MIN", () => {
const round = bogRound("boardwalk");
const [a, b] = round.spec.mud[0];
standAt(round, a + 3);
round.you.safeMs = 1e9;
run(round, 4);
assert.equal(round.you.mud, true, "on the span");
standAt(round, a - 3);
run(round, 4);
assert.equal(round.you.mud, false, "just off it");
standAt(round, b + 3);
run(round, 4);
assert.equal(round.you.mud, false, "past it");
// In the air over the mud nothing sinks.
standAt(round, a + 3);
round.you.y += 4;
round.you.vy = 0;
round.you.state = "fall";
run(round, 4);
assert.equal(round.you.mud, false, "airborne is dry");
// mudMs builds one-for-one and drains the same way, never below zero.
standAt(round, a + 3);
round.you.mudMs = 0;
run(round, 400);
assert.ok(round.you.mudMs >= 380 && round.you.mudMs <= 440, `built (${round.you.mudMs})`);
standAt(round, a - 20);
run(round, 10000);
assert.equal(round.you.mudMs, 0, "never below zero");
// At full sink the run is a crawl: MUD_SPEED_MIN of a dry run's reach over the same time.
const reach = (mudMs, x) => {
standAt(round, x);
round.you.mudMs = mudMs;
const x0 = round.you.x;
run(round, 160, { right: true });
return round.you.x - x0;
};
const dryReach = reach(0, 270);
const fresh = reach(0, a + 3);
const sunk = reach(ghoul.MUD_MS, a + 3);
assert.ok(sunk < fresh && fresh < dryReach, `dry ${dryReach.toFixed(1)} > fresh ${fresh.toFixed(1)} > sunk ${sunk.toFixed(1)}`);
assert.ok(sunk / dryReach < ghoul.MUD_SPEED_MIN + 0.12, `crawls (${(sunk / dryReach).toFixed(2)} of dry)`);
assert.ok(ghoul.MUD_SPEED_MIN < ghoul.WATER_SPEED && ghoul.MUD_JUMP_MIN < ghoul.WATER_JUMP, "mud is always worse than water");
});
test("Ghoul Rush's Stilt Boots let the mud go while they last, and the mud takes hold again after", () => {
const round = bogRound("boardwalk");
const [a] = round.spec.mud[0];
standAt(round, a + 3);
round.you.safeMs = 1e9;
round.effects.boots = 300;
run(round, 100);
assert.equal(round.you.mud, false, "boots neutralize it");
assert.equal(round.you.mudMs, 0);
const x0 = round.you.x;
run(round, 100, { right: true });
const booted = round.you.x - x0;
assert.ok(booted > 0);
round.effects.boots = 0;
standAt(round, a + 3);
run(round, 8);
assert.equal(round.you.mud, true, "the mud takes hold again");
assert.equal(ghoul.POWERS.boots.stage, "bog");
});
test("Ghoul Rush's harpoon pierces everything in its line, reaches a lurker's eyes under the water that any other bolt passes through, and a plain bolt does not", () => {
const round = bogRound("hollow");
standAt(round, dry(round, 20));
round.you.safeMs = 1e9;
const near = put(round, "lurker", 50);
const far = put(round, "lurker", 70);
run(round, 8);
assert.equal(near.unseen && far.unseen, true);
const harpoon = () => ({ arm: "harpoon", x: 30, y: near.y + 1, vx: 84, vy: 0, gone: 0, t: 0, spin: 0, dmg: 14, bossDmg: 8, pierce: true });
// A plain bolt flies through both pairs of eyes.
round.shots.push({ x: 30, y: near.y + 1, vx: 80, vy: 0, gone: 0 });
run(round, 600);
assert.equal(near.hp, near.max);
assert.equal(far.hp, far.max);
assert.equal(events(round, "harpoonHit").length, 0);
// A harpoon finds the first, goes on through it and finds the second.
round.shots.push(harpoon());
run(round, 800);
assert.equal(events(round, "harpoonHit").length, 2, "one hit for each, none twice");
assert.ok(near.dead || near.hp < near.max, "the near lurker is hurt");
assert.ok(far.dead || far.hp < far.max, "the far one too");
assert.equal(events(round, "kill").length, 2, "14 damage is enough for a lurker");
});
/* ------------------------------------------------------ Old Mother Bog */
// The Drowning Pool with the hag awake and fighting, nothing else on the field.
function motherFight() {
const round = bogRound("drowning");
standAt(round, round.spec.arena + ghoul.BOSS_LOCK + 2);
ghoul.advance(round, 4, steady);
ghoul.advance(round, ghoul.BOSS_INTRO_MS + 8, steady);
assert.equal(round.boss.state, "fight");
round.you.safeMs = 0;
round.events.length = 0;
return round;
}
// Straight to her next move, as if her wait had run out.
const hurry = (b) => (b.wait = 0);
test("Old Mother Bog's mud wave winds up, rolls down the planks at you, and is jumped: standing in it costs a heart (swamped), a jump clears it", () => {
const round = motherFight();
const b = round.boss;
assert.equal(b.kind, "motherbog");
assert.equal(b.hp, bog.BOSSES.motherbog.hp);
standAt(round, 150);
b.act = "idle";
hurry(b);
run(round, 8);
assert.equal(b.act, "wind", "the first move is the wave");
assert.equal(events(round, "motherWind").length, 1, "a wind-up to read");
assert.equal(round.waves.length, 0, "nothing rolls during the wind-up");
run(round, bog.MOTHER_WIND_MS + 20);
assert.equal(events(round, "mudWave").length, 1);
assert.equal(round.waves[0]?.cause, "mudwave");
assert.equal(b.act, "rest");
// Stand still: it arrives and swamps you.
const stand = round.you.x;
until(round, () => events(round, "lose").length > 0, 3000);
assert.equal(events(round, "lose")[0]?.cause, "mudwave");
assert.equal(round.you.x, stand);
// The same wave, jumped at the edge, goes by.
const jumper = motherFight();
standAt(jumper, 150);
jumper.boss.act = "rest";
jumper.boss.wait = 1e9;
jumper.waves.push({ x: 170, y: 6, dir: -1, life: 6000, kind: "mudwave", cause: "mudwave" });
let jumped = false;
until(jumper, () => {
const w = jumper.waves[0];
if (!jumped && w && w.x - jumper.you.x < 9) {
jumper.input.jump = ghoul.JUMP_BUFFER_MS;
jumped = true;
}
return !jumper.waves.length || jumper.waves[0].x < jumper.you.x - 3;
}, 3000);
assert.ok(jumped, "it came at me");
assert.equal(events(jumper, "lose").length, 0, "a jump clears the wave");
});
test("Old Mother Bog's cauldron opens late in each rest, and a shot into her then counts triple, any other time one", () => {
const round = motherFight();
const b = round.boss;
const hit = (act, wait) => {
Object.assign(b, { act, wait });
round.shots.push({ x: b.x - b.w / 2 - 0.2, y: b.y + b.h * 0.35, vx: 80, vy: 0, gone: 0 });
const hp = b.hp;
ghoul.advance(round, 4, steady);
return hp - b.hp;
};
assert.equal(hit("idle", 1e9), 1, "shut: one");
assert.equal(hit("rest", bog.MOTHER_REST_MS), 1, "early in the rest: one");
assert.equal(b.lit, false);
round.events.length = 0;
assert.equal(hit("rest", bog.MOTHER_OPEN_MS - 100), 3, "open: triple");
assert.equal(b.lit, true);
assert.equal(events(round, "cauldronOpen").length, 1, "the opening is announced");
assert.equal(round.events.filter((e) => e.type === "bossHit").at(-1).weak, true, "and the hit says it was a weak spot");
assert.equal(hit("wind", 400), 1, "mid-wind-up: one");
assert.equal(b.lit, false, "closed again");
});
test("Old Mother Bog's cauldron spit lands a muck patch where you stand after a wind-up, warns before it burns, burns for MUCK_MS and hurts only while live", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
round.you.safeMs = 1e9;
b.act = "idle";
b.plan = "spit";
hurry(b);
run(round, 8);
assert.equal(b.act, "throwWind");
assert.equal(events(round, "spitWind").length, 1);
assert.equal(round.hazards.length, 0, "the glob is not thrown during the wind-up");
run(round, bog.SPIT_WIND_MS + 20);
const spit = events(round, "cauldronSpit");
assert.equal(spit.length, 1);
assert.equal(round.hazards.length, 1, "one patch before she is angry");
const patch = round.hazards[0];
assert.equal(patch.kind, "muck");
assert.equal(patch.cause, "muck");
assert.ok(Math.abs(patch.x - 150) <= 6, "where you stood");
assert.equal(spit[0].tx, patch.x);
assert.equal(tx2(spit[0]), undefined, "no second patch yet");
// It warns first: standing in the glob's shadow is safe.
round.you.safeMs = 0;
standAt(round, patch.x);
run(round, bog.MUCK_LAND_MS - 100);
assert.equal(events(round, "lose").length, 0, "still in the air");
run(round, 200);
assert.equal(events(round, "muckLand").length, 1);
assert.equal(events(round, "lose")[0]?.cause, "muck", "burning, it hurts");
// It burns out MUCK_MS after it lands.
const out = motherFight();
out.boss.act = "rest";
out.boss.wait = 1e9;
out.hazards.push({ kind: "muck", x: 150, y: 6, w: bog.MUCK_W, h: bog.MUCK_H, warn: 0, live: bog.MUCK_MS, cause: "muck" });
standAt(out, 100);
out.you.safeMs = 1e9;
run(out, bog.MUCK_MS - 100);
assert.equal(out.hazards.length, 1);
run(out, 200);
assert.equal(out.hazards.length, 0, "burnt out");
});
test("Old Mother Bog goes meaner at half her hp: waits shrink to MOTHER_QUICK of themselves and the spit leaves a second patch ahead of your feet", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
round.you.safeMs = 1e9;
Object.assign(b, { raged: true, sank: true, act: "idle", plan: "spit", y: 6, x: 176 });
b.wait = 0;
round.you.vx = 20;
run(round, 8);
assert.equal(b.act, "throwWind");
assert.ok(b.wait <= bog.SPIT_WIND_MS * bog.MOTHER_QUICK + 1, `quicker wind-up (${b.wait})`);
run(round, bog.SPIT_WIND_MS);
const spit = events(round, "cauldronSpit")[0];
assert.ok(spit, "spat");
assert.equal(round.hazards.length, 2, "two patches");
assert.ok(tx2(spit) !== undefined && Math.abs(tx2(spit) - spit.tx) >= bog.MUCK_W, "the second is a patch away from the first");
assert.ok(b.wait <= bog.MOTHER_REST_MS * bog.MOTHER_QUICK + 1, "and her rest is shorter");
// Calm, the same spit is one patch.
const calm = motherFight();
standAt(calm, 150);
calm.you.safeMs = 1e9;
Object.assign(calm.boss, { act: "throwWind", wait: 0 });
run(calm, 8);
assert.equal(calm.hazards.length, 1);
});
test("Old Mother Bog sinks at half her hp, bubbles where she will rise, rises near you on a plank and is hittable the instant she does", () => {
const calm = motherFight();
assert.equal(calm.boss.sank || false, false);
calm.boss.act = "idle";
calm.boss.wait = 1e9;
calm.boss.hp = calm.boss.max * bog.MOTHER_RAGE + 1;
run(calm, 40);
assert.equal(calm.boss.sank || false, false, "above half she stays up");
standAt(calm, 150);
calm.you.safeMs = 1e9;
calm.boss.hp = calm.boss.max * bog.MOTHER_RAGE;
run(calm, 8);
const h = calm.boss;
assert.equal(h.sank, true);
assert.equal(h.act, "sink");
assert.equal(h.raged, true);
assert.equal(h.hidden, true, "gone at once");
assert.equal(events(calm, "motherSink").length, 1);
// Under the water nothing she is hurts and nothing hurts her: a bolt meets water.
const hp = h.hp;
calm.shots.push({ x: h.x - 2, y: 6.5, vx: 80, vy: 0, gone: 0 });
Object.assign(calm.you, { x: h.x - 1 });
calm.you.safeMs = 0;
run(calm, 40);
assert.equal(h.hp, hp, "no damage while she is under");
assert.equal(events(calm, "lose").length, 0, "and she cannot hurt you from the water");
// She bubbles where she will come up: a plank near you, never on top of you.
standAt(calm, 150);
calm.you.safeMs = 1e9;
until(calm, () => h.act === "under", 2000);
const bubble = events(calm, "motherBubble")[0];
assert.ok(bubble, "bubbles show");
assert.equal(h.act, "under");
assert.equal(bubble.x, h.sinkX);
assert.ok(Number.isFinite(ghoul.groundAt(calm.spec, h.sinkX)), "on a plank");
assert.ok(Math.abs(h.sinkX - calm.you.x) >= 6, "never on top of you");
// She rises exactly there, touchable and hittable at once.
until(calm, () => h.act === "resurface", 2000);
assert.equal(h.x, bubble.x);
assert.equal(h.hidden, false);
assert.equal(h.y, h.home);
assert.equal(events(calm, "motherRise").length, 1);
const before = h.hp;
calm.shots.push({ x: h.x - h.w / 2 - 0.2, y: h.y + h.h * 0.35, vx: 80, vy: 0, gone: 0 });
ghoul.advance(calm, 4, steady);
assert.ok(before - h.hp >= 1, "never unhittable once she is up");
until(calm, () => h.act === "rest", 2000);
assert.ok(h.wait <= bog.MOTHER_REST_MS * bog.MOTHER_QUICK + 1, "and her next wait is the quick one");
});
test("Old Mother Bog is not a pattern: the wave opens, then a weighted pick by phase that never makes one move three times running, keeps the slow moves on a cooldown and summons only under the cap", () => {
// A long run of picks, as she would make them.
const rolls = (b, n, random, round = null) => Array.from({ length: n }, () => bog.pickAttack(b, random, round));
const three = (list) => list.some((m, i) => i > 1 && m === list[i - 1] && m === list[i - 2]);
const lcg = (seed) => () => ((seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff);
assert.equal(bog.pickAttack({ hp: 100, max: 100 }, () => 0.99), "wave", "the first move is always the wave");
const P1 = ["dive", "hands", "shell", "spit", "surge", "wave"];
const MORE = [...P1, "brood", "double", "volley"];
const P2 = [...MORE, "drowned", "pull", "stomp", "tide"];
const P3 = [...P2, "wisps"];
const phases = [
[{ hp: 100, max: 100 }, P1, "full health: six moves"],
[{ hp: 70, max: 100 }, MORE, "under three quarters: the double wave, the volley and the brood join"],
[{ hp: 45, max: 100, raged: true, sank: true }, P2, "under half: the stomp, the tide, the pull and the drowned join"],
[{ hp: 20, max: 100, raged: true, sank: true, fury: true, sank2: true }, P3, "under a quarter: the wisp lantern joins"],
];
for (const [b, want, what] of phases) {
const seen = rolls(b, 600, lcg(17));
assert.deepEqual([...new Set(seen)].sort(), [...want].sort(), what);
assert.ok(!three(seen), `never three in a row (${what})`);
// A slow move sits out its cooldown.
for (const [move, n] of Object.entries(bog.COOLDOWN)) {
const at = seen.flatMap((m, i) => (m === move ? [i] : []));
assert.ok(at.every((i, j) => j === 0 || i - at[j - 1] > n), `${move} waits ${n} picks (${what})`);
}
}
assert.equal(bog.phaseOf({}), 0);
assert.equal(bog.phaseOf({ raged: true }), 1);
assert.equal(bog.phaseOf({ raged: true, fury: true }), 2);
// At the cap a summon is never picked.
const crowd = { monsters: [] };
for (let i = 0; i < bog.BROOD_CAP; i++) crowd.monsters.push({ kind: "leech", hag: true });
for (let i = 0; i < bog.BODIES_CAP; i++) crowd.monsters.push({ kind: "bogbody", hag: true });
for (let i = 0; i < bog.WISPS_CAP; i++) crowd.monsters.push({ kind: "wisp", hag: true });
const capped = rolls({ hp: 20, max: 100, raged: true, fury: true, picks: 1 }, 400, lcg(5), crowd);
for (const move of ["brood", "drowned", "wisps"]) assert.equal(capped.includes(move), false, `no ${move} at the cap`);
const forced = { hp: 100, max: 100, picks: 3, plan: "volley" };
assert.equal(bog.pickAttack(forced, () => 0), "volley", "a plan is taken");
assert.equal(forced.plan, null, "once");
});
test("Old Mother Bog's double wave sends a second wave DOUBLE_GAP_MS behind the first, and her volley lands three staggered patches", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
round.you.safeMs = 1e9;
Object.assign(b, { act: "idle", plan: "double", attacks: 2 });
hurry(b);
run(round, 8);
assert.equal(b.act, "wind");
run(round, bog.MOTHER_WIND_MS + 20);
assert.equal(events(round, "mudWave").length, 1, "one wave to start");
run(round, bog.DOUBLE_GAP_MS + 30);
const waves = events(round, "mudWave");
assert.equal(waves.length, 2, "and a second behind it");
assert.equal(waves[1].echo, true);
const volley = motherFight();
standAt(volley, 150);
volley.you.safeMs = 1e9;
Object.assign(volley.boss, { act: "idle", plan: "volley", attacks: 2 });
hurry(volley.boss);
run(volley, 8);
assert.equal(volley.boss.act, "throwWind");
run(volley, bog.SPIT_WIND_MS + 20);
assert.ok(volley.hazards.length >= 2 && volley.hazards.length <= 3, `a spread of patches (${volley.hazards.length})`);
const warns = volley.hazards.map((h) => h.warn).sort((a, c) => a - c);
assert.ok(warns.at(-1) - warns[0] >= bog.VOLLEY_STAGGER_MS - 30, "landing a beat apart");
});
test("Old Mother Bog never stands half out over the water (only a dive, a charge or a leap takes her off the boards), and goes under a second time at a quarter of her hp and comes back furious", () => {
const round = motherFight();
const b = round.boss;
const half = (x) => [-0.45, 0, 0.45].every((f) => ghoul.groundAt(round.spec, x + f * b.w) === b.y);
// Put down over the gap between the planks, she walks onto one that holds her.
standAt(round, 160);
round.you.safeMs = 1e9;
Object.assign(b, { act: "idle", x: 131, wait: 1e9 });
until(round, () => half(b.x), 4000);
assert.ok(half(b.x), `she settled on the planks (x=${b.x})`);
// However she wanders in a long fight, her body is on the boards.
Object.assign(b, { act: "idle", wait: 0, plan: "spit" });
for (let i = 0; i < 400; i++) {
standAt(round, 112 + ((i * 7) % 80));
round.you.safeMs = 1e9;
if (b.act === "idle") b.wait = Math.min(b.wait, 400);
run(round, 50);
if (b.hidden || bog.UNSTOOD.includes(b.act)) continue;
assert.ok(half(b.x), `on the planks at step ${i} (x=${b.x}, act ${b.act})`);
}
// A second dive at a quarter.
const fight = motherFight();
const h = fight.boss;
standAt(fight, 150);
fight.you.safeMs = 1e9;
Object.assign(h, { raged: true, sank: true, act: "idle", wait: 1e9, hp: h.max * bog.MOTHER_FURY_AT - 1 });
run(fight, 8);
assert.equal(h.sank2, true);
assert.equal(h.fury, true);
assert.equal(h.act, "sink");
assert.equal(h.hidden, true);
until(fight, () => h.act === "rest", 4000);
assert.ok(h.wait <= bog.MOTHER_REST_MS * bog.MOTHER_FURY + 1, "her waits are the furious ones");
assert.equal(events(fight, "motherSink").length, 1);
});
test("Old Mother Bog: her guard and weak spot are what the pack says, her touch is the motherbog cause, and her fall clears the field of every hazard and add she made", () => {
assert.equal(bog.BOG.guard.motherbog({ hidden: true }), true);
assert.equal(bog.BOG.guard.motherbog({ hidden: false }), false);
assert.equal(bog.BOG.guard.motherbog({ hidden: false, act: "shell" }), true, "shelled");
assert.equal(bog.BOG.guard.motherbog({ hidden: false, act: "stagger" }), false, "reeling, she is open");
assert.equal(bog.BOG.weak.motherbog({ lit: true }), 3);
assert.equal(bog.BOG.weak.motherbog({ lit: false }), 1);
assert.equal(bog.BOG.cause.motherbog(), "motherbog");
const touch = motherFight();
touch.boss.act = "idle";
touch.boss.wait = 1e9;
Object.assign(touch.you, { x: touch.boss.x - 3 });
run(touch, 20);
assert.equal(events(touch, "lose")[0]?.cause, "motherbog");
const round = motherFight();
const b = round.boss;
b.hp = 1;
b.sank = true;
b.sank2 = true;
round.hazards.push({ kind: "muck", x: 150, y: 6, w: bog.MUCK_W, h: bog.MUCK_H, warn: 0, live: 2000, cause: "muck" });
round.waves.push({ x: 140, y: 6, dir: -1, life: 6000, kind: "mudwave", cause: "mudwave" });
round.hazards.push({ kind: "boghand", x: 160, y: 6, w: bog.HAND_W, h: bog.HAND_H, warn: 0, live: 400, cause: "boghand" });
round.hazards.push({ kind: "tide", x: 152, y: 5, w: 104, h: 1.6, x0: 104, x1: 200, warn: 0, live: 2000, cause: "tide" });
put(round, "leech", 150, { hag: true });
put(round, "bogbody", 160, { hag: true });
put(round, "wisp", 150, { hag: true, y: 14 });
Object.assign(b, { act: "rest", wait: bog.MOTHER_OPEN_MS - 100 });
standAt(round, 120);
round.you.safeMs = 1e9;
round.shots.push({ x: b.x - b.w / 2 - 0.2, y: b.y + b.h * 0.35, vx: 80, vy: 0, gone: 0 });
ghoul.advance(round, 4, steady);
assert.equal(b.state, "down");
assert.equal(round.hasKey, true);
assert.equal(round.hazards.length, 0, "the muck, the hands and the tide are gone");
assert.equal(round.waves.length, 0);
assert.equal(round.monsters.length, 0, "and so are her adds");
});
// Her next move forced, from idle, as if her wait had run out; `over` sets
// her phase or her place first.
function force(round, move, over = {}) {
const b = round.boss;
Object.assign(b, { act: "idle", plan: move, picks: Math.max(3, b.picks || 0) }, over);
b.wait = 0;
run(round, 8);
}
const RAGED = { raged: true, sank: true };
const FURY = { raged: true, sank: true, fury: true, sank2: true };
// A bolt from the left into her middle, one slice later.
function shoot(round) {
const b = round.boss;
round.shots.push({ x: b.x - b.w / 2 - 0.2, y: b.y + b.h * 0.35, vx: 80, vy: 0, gone: 0 });
ghoul.advance(round, 4, steady);
}
// Runs `ms`, jumping whenever `near()` says the threat is about to arrive.
function hop(round, ms, near) {
for (let t = 0; t < ms; t += 4) {
const you = round.you;
if (you.state === "run" && near(round) && round.input.jump <= 0) round.input.jump = ghoul.JUMP_BUFFER_MS;
ghoul.advance(round, 4, steady);
}
}
// A mud wave rolling at you, within `d`.
const waveAt = (round, d = 7.5) => round.waves.some((w) => (round.you.x - w.x) * w.dir > 0 && (round.you.x - w.x) * w.dir < d);
const losses = (round) => events(round, "lose");
test("Old Mother Bog's bog hands: her arms go into the water, ripples warn where you stand and a step either side, a hand bursts up from each (a heart, grabbed), and a step between them costs nothing", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
const lives = round.lives;
force(round, "hands");
assert.equal(b.act, "hands", "her arms in the water");
const wind = events(round, "handsWind")[0];
assert.ok(wind, "a wind-up to read");
const hands = round.hazards.filter((h) => h.kind === "boghand");
assert.equal(hands.length, bog.HANDS_N[0], "two at full health");
assert.deepEqual(wind.xs, hands.map((h) => h.x), "the event names every ripple");
assert.ok(hands.some((h) => Math.abs(h.x - 150) <= 2), "one where you stand");
assert.ok(hands.every((h) => h.live === 0 && h.warn >= bog.HANDS_WIND_MS + bog.HAND_WARN_MS - 10 && h.cause === "boghand"), "each warns first");
assert.ok(hands.every((h) => Number.isFinite(ghoul.groundAt(round.spec, h.x))), "out of the planks");
run(round, bog.HANDS_WIND_MS + bog.HAND_WARN_MS - 40);
assert.equal(losses(round).length, 0, "a ripple does not hurt");
run(round, 80);
assert.ok(events(round, "handsUp").length >= 1, "up it comes");
assert.equal(losses(round)[0]?.cause, "boghand", "standing in it, you are grabbed");
assert.equal(round.lives, lives - 1, "a heart");
// A step between the ripples, and every hand goes by.
const dodge = motherFight();
standAt(dodge, 150);
force(dodge, "hands");
const spots = dodge.hazards.map((h) => h.x).sort((a, c) => a - c);
standAt(dodge, spots[0] - 4.5);
run(dodge, bog.HANDS_WIND_MS + bog.HAND_WARN_MS + bog.HAND_STAGGER_MS * 3 + bog.HAND_UP_MS + 50);
assert.equal(losses(dodge).length, 0, "a clean dodge costs nothing");
assert.equal(dodge.hazards.filter((h) => h.kind === "boghand").length, 0, "the hands are gone again");
assert.equal(dodge.boss.act, "idle");
// More of them as she weakens.
for (const [phase, over] of [[1, RAGED], [2, FURY]]) {
const more = motherFight();
standAt(more, 145);
force(more, "hands", over);
assert.equal(more.hazards.filter((h) => h.kind === "boghand").length, bog.HANDS_N[phase], `phase ${phase}`);
}
});
test("Old Mother Bog's surge: a crouch behind a bow wave, then a waist-deep charge along and past you; standing costs a heart, a jump over her or a shelf costs nothing, and she stops on the planks", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
const lives = round.lives;
force(round, "surge");
const from = b.x;
assert.equal(b.act, "surgeWind");
assert.equal(events(round, "surgeWind").length, 1, "a wind-up to read");
run(round, bog.SURGE_WIND_MS - 40);
assert.equal(b.x, from, "she holds still while she crouches");
run(round, 60);
assert.equal(b.act, "surge");
assert.equal(events(round, "motherSurge").length, 1);
assert.equal(b.y, b.floor - bog.SURGE_SINK, "waist deep");
assert.ok((150 - b.surgeTo) >= 6, `past you (${b.surgeTo})`);
until(round, () => losses(round).length > 0, 2000);
assert.equal(losses(round)[0]?.cause, "motherbog", "run down");
assert.equal(round.lives, lives - 1);
// A jump as she comes clears her.
const jumper = motherFight();
standAt(jumper, 150);
force(jumper, "surge");
run(jumper, bog.SURGE_WIND_MS + 20);
const jb = jumper.boss;
hop(jumper, 1500, () => jb.act === "surge" && jb.x - jb.w / 2 - jumper.you.x - ghoul.HIT_W / 2 < 7.5);
assert.equal(losses(jumper).length, 0, "jumped clean");
assert.equal(jb.act === "rest" || jb.act === "idle", true, "the charge is over");
assert.ok([-0.45, 0, 0.45].every((f) => ghoul.groundAt(jumper.spec, jb.x + f * jb.w) === jb.y), "she stopped on the planks");
assert.ok(jb.x < 150, "on your other side: she moved");
// Up on a shelf she charges underneath.
const shelf = motherFight();
standAt(shelf, 118, 0);
force(shelf, "surge");
run(shelf, bog.SURGE_WIND_MS + 1500);
assert.equal(losses(shelf).length, 0, "the shelf is out of her reach");
});
test("Old Mother Bog's mud shell: bolts chip it and not her, SHELL_HP of them break it and leave her reeling with the cauldron open (triple), and left alone she feeds and heals", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
round.you.safeMs = 1e9;
force(round, "shell");
assert.equal(b.act, "shellWind");
assert.equal(events(round, "shellWind").length, 1, "a wind-up to read");
run(round, bog.SHELL_WIND_MS + 10);
assert.equal(b.act, "shell");
assert.equal(bog.BOG.guard.motherbog(b), true, "guarded");
assert.equal(b.shell, bog.SHELL_HP[0]);
const hp = b.hp;
for (let i = 0; i < bog.SHELL_HP[0] - 1; i++) shoot(round);
assert.equal(b.hp, hp, "the shell takes the bolts");
assert.equal(events(round, "shellChip").length, bog.SHELL_HP[0] - 1, "each a chip");
assert.equal(b.act, "shell", "still up");
shoot(round);
assert.equal(events(round, "shellBreak").length, 1, "broken");
assert.equal(b.act, "stagger");
shoot(round);
assert.equal(b.lit, true, "the cauldron is open while she reels");
assert.equal(hp - b.hp, 3, "and a bolt counts triple");
assert.ok(events(round, "cauldronOpen").length >= 1);
run(round, bog.STAGGER_MS + 20);
assert.equal(b.act, "idle");
// Ignored, she ladles herself a feed.
const feed = motherFight();
standAt(feed, 150);
feed.you.safeMs = 1e9;
feed.boss.hp = feed.boss.max - 40;
force(feed, "shell");
run(feed, bog.SHELL_WIND_MS + bog.SHELL_MS + 20);
const fed = events(feed, "motherFeed")[0];
assert.ok(fed, "she feeds");
assert.equal(fed.heal, bog.SHELL_HEAL);
assert.equal(feed.boss.hp, feed.boss.max - 40 + bog.SHELL_HEAL, "and heals");
const full = motherFight();
full.you.safeMs = 1e9;
full.boss.hp = full.boss.max - 3;
force(full, "shell");
run(full, bog.SHELL_WIND_MS + bog.SHELL_MS + 20);
assert.equal(full.boss.hp, full.boss.max, "never past her max");
// A stomp on the shell glances off.
const stomp = motherFight();
stomp.you.safeMs = 1e9;
force(stomp, "shell");
run(stomp, bog.SHELL_WIND_MS + 10);
const sb = stomp.boss;
const before = sb.hp;
Object.assign(stomp.you, { x: sb.x, y: sb.y + sb.h + 0.3, vy: -20, state: "air", shelf: -1 });
run(stomp, 20);
assert.equal(sb.hp, before, "a stomp does nothing to the shell");
assert.ok(events(stomp, "bossBlock").length >= 1);
});
test("Old Mother Bog's dive: she goes under (shots meet water), bubbles show a new spot on the planks away from you, she rises there hittable, and meaner the rise sends a mud wave each way", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
round.you.safeMs = 1e9;
force(round, "dive");
assert.equal(b.act, "sink");
assert.equal(b.hidden, true);
assert.equal(b.raged || false, false, "a dive of her own is not the rage");
assert.equal(events(round, "motherSink")[0]?.relocate, true);
const hp = b.hp;
round.shots.push({ x: b.x - 2, y: 7, vx: 80, vy: 0, gone: 0 });
run(round, 40);
assert.equal(b.hp, hp, "no damage under the water");
until(round, () => b.act === "under", 2000);
const bubble = events(round, "motherBubble")[0];
assert.ok(bubble);
assert.ok(Math.abs(b.sinkX - round.you.x) >= 6, "never on top of you");
assert.ok([-0.45, 0, 0.45].every((f) => ghoul.groundAt(round.spec, b.sinkX + f * b.w) === b.floor), "on a plank that holds her");
until(round, () => b.act === "resurface", 2000);
assert.equal(b.x, bubble.x);
shoot(round);
assert.ok(hp - b.hp >= 1, "hittable once she is up");
until(round, () => b.act === "rest", 2000);
assert.equal(events(round, "mudWave").length, 0, "calm, no waves");
// Meaner, two waves come off her as she stands.
const mean = motherFight();
standAt(mean, 150);
mean.you.safeMs = 1e9;
force(mean, "dive", RAGED);
until(mean, () => mean.boss.act === "rest", 4000);
const waves = events(mean, "mudWave").filter((e) => e.rise);
assert.deepEqual(waves.map((w) => w.dir).sort(), [-1, 1], "a wave each way");
});
test("Old Mother Bog's leech brood: she tips the cauldron, a swarm or two pours onto the planks and creeps at you, never more than BROOD_CAP of hers alive; a latch is a heart and two bolts see one off", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 140 + 10);
round.you.safeMs = 1e9;
force(round, "brood");
assert.equal(b.act, "broodWind");
assert.equal(events(round, "broodWind").length, 1, "a wind-up to read");
assert.equal(bog.hagAdds(round, "leech"), 0, "nothing out during the tip");
run(round, bog.BROOD_WIND_MS + 10);
assert.equal(events(round, "broodPour")[0]?.n, bog.BROOD_N);
assert.equal(bog.hagAdds(round, "leech"), bog.BROOD_N);
const brood = round.monsters.filter((m) => m.hag);
assert.ok(brood.every((m) => m.kind === "leech" && Number.isFinite(ghoul.groundAt(round.spec, m.x))), "on the planks");
const x0 = brood[0].x;
run(round, 300);
assert.ok(brood[0].x < x0, "creeping at you");
force(round, "brood");
run(round, bog.BROOD_WIND_MS + 10);
force(round, "brood");
run(round, bog.BROOD_WIND_MS + 10);
assert.equal(bog.hagAdds(round, "leech"), bog.BROOD_CAP, "capped");
// A latch costs a heart.
const latch = motherFight();
const lives = latch.lives;
standAt(latch, 150);
put(latch, "leech", 150.5, { hag: true });
run(latch, 40);
assert.equal(losses(latch)[0]?.cause, "leeches");
assert.equal(latch.lives, lives - 1);
// Two bolts see one off.
const shot = motherFight();
standAt(shot, 150);
shot.you.safeMs = 1e9;
shot.boss.wait = 1e9;
const m = put(shot, "leech", 160, { hag: true });
bolt(shot, m, m.y + 0.9);
bolt(shot, m, m.y + 0.9);
shot.shots[1].x -= 3;
run(shot, 200);
assert.equal(bog.hagAdds(shot, "leech"), 0, "dispersed");
});
test("Old Mother Bog's stomp: a shadow where you stand, a leap and a slam there (a heart if you stayed), then a mud wave each way; out of the shadow and over the wave costs nothing", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
const lives = round.lives;
force(round, "stomp", RAGED);
assert.equal(b.act, "stompWind");
const wind = events(round, "stompWind")[0];
assert.ok(wind, "a wind-up to read");
assert.ok(Math.abs(wind.landX - 150) <= 1, "the shadow is on you");
run(round, bog.STOMP_WIND_MS * bog.MOTHER_QUICK + 10);
assert.equal(b.act, "stompAir");
assert.equal(events(round, "motherLeap").length, 1);
until(round, () => losses(round).length > 0, 2000);
assert.equal(losses(round)[0]?.cause, "motherbog", "landed on");
assert.equal(round.lives, lives - 1);
// Out of the shadow, then over the wave.
const dodge = motherFight();
standAt(dodge, 150);
force(dodge, "stomp", RAGED);
standAt(dodge, 185);
const db = dodge.boss;
until(dodge, () => events(dodge, "motherSlam").length > 0, 3000);
assert.equal(db.x, db.landX, "down where the shadow was");
assert.ok([-0.45, 0, 0.45].every((f) => ghoul.groundAt(dodge.spec, db.x + f * db.w) === db.y), "on the planks");
assert.equal(dodge.waves.length, 0, "the waves wait a beat");
hop(dodge, 1300, (r) => waveAt(r));
const slams = events(dodge, "mudWave").filter((e) => e.slam);
assert.deepEqual(slams.map((w) => w.dir).sort(), [-1, 1], "a wave each way");
assert.equal(losses(dodge).length, 0, "a clean dodge costs nothing");
});
test("Old Mother Bog's tide: a long warning, then the water over every plank for TIDE_MS (a heart, drowned); a shelf keeps you dry and it drains away after", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
const lives = round.lives;
force(round, "tide", RAGED);
assert.equal(b.act, "tideWind");
assert.equal(events(round, "tideWarn").length, 1, "a warning to read");
const tide = round.hazards.find((h) => h.kind === "tide");
assert.ok(tide && tide.warn > bog.TIDE_WARN_MS - 10 && tide.live === 0, "it warns first");
run(round, bog.TIDE_WARN_MS - 40);
assert.equal(losses(round).length, 0, "the warning does not hurt");
run(round, 80);
assert.equal(events(round, "tideRise").length, 1);
assert.equal(losses(round)[0]?.cause, "tide", "drowned on the planks");
assert.equal(round.lives, lives - 1);
// On a shelf you stay dry the whole time, and it drains.
for (const shelf of [0, 2]) {
const dry = motherFight();
const [x0, x1] = dry.spec.shelves[shelf];
standAt(dry, (x0 + x1) / 2, shelf);
force(dry, "tide", RAGED);
run(dry, bog.TIDE_WARN_MS + bog.TIDE_MS + 60);
assert.equal(losses(dry).length, 0, `shelf ${shelf} is dry`);
assert.equal(dry.hazards.filter((h) => h.kind === "tide").length, 0, "the water is gone");
assert.notEqual(dry.boss.act, "tideHold");
}
// Every spot on the arena's planks is near enough a shelf to reach in the warning.
const spec = round.spec;
const tops = spec.shelves.filter((s) => s[2] === 12);
for (let x = spec.arena + ghoul.BOSS_LOCK + 2; x < spec.length - 2; x += 2) {
if (!Number.isFinite(ghoul.groundAt(spec, x))) continue;
const far = Math.min(...tops.map(([a, c]) => (x < a ? a + 1 - x : x > c ? x - c + 1 : 0)));
assert.ok(far / ghoul.RUN_SPEED + 0.35 < bog.TIDE_WARN_MS / 1000, `a shelf within reach of ${x}`);
}
});
test("Old Mother Bog's drowning pull: she stirs, then the water drags you along the planks toward her (a heart at her touch); running away, a shelf or the air beats it, and it never drags you off a plank's end", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
const lives = round.lives;
force(round, "pull", RAGED);
assert.equal(b.act, "pullWind");
assert.equal(events(round, "pullWind").length, 1, "a wind-up to read");
run(round, bog.PULL_WIND_MS * bog.MOTHER_QUICK - 30);
assert.equal(round.you.x, 150, "nothing pulls during the stir");
run(round, 40);
assert.equal(b.act, "pull");
assert.equal(events(round, "motherPull").length, 1);
run(round, 400);
assert.ok(round.you.x > 150 + 4, `dragged toward her (${round.you.x.toFixed(1)})`);
until(round, () => losses(round).length > 0, 3000);
assert.equal(losses(round)[0]?.cause, "motherbog");
assert.equal(round.lives, lives - 1);
// Running away from her beats it.
const runner = motherFight();
Object.assign(runner.boss, { x: 150 });
standAt(runner, 172);
force(runner, "pull", RAGED);
run(runner, bog.PULL_WIND_MS + bog.PULL_MS + 40, { right: true });
assert.equal(losses(runner).length, 0, "outrun");
// A shelf is out of its reach.
const shelf = motherFight();
standAt(shelf, 166, 2);
force(shelf, "pull", RAGED);
run(shelf, bog.PULL_WIND_MS + 600);
assert.equal(shelf.you.x, 166, "not moved on a shelf");
// The boards hold you at a plank's end.
const edge = motherFight();
Object.assign(edge.boss, { x: 120 });
standAt(edge, 142);
edge.you.safeMs = 1e9;
force(edge, "pull", RAGED);
run(edge, bog.PULL_WIND_MS + bog.PULL_MS);
assert.ok(edge.you.x >= 140 && edge.you.y === 6, `held on the plank (${edge.you.x.toFixed(1)})`);
});
test("Old Mother Bog calls the drowned: mud boils away from you and her, bog bodies climb out (harmless till up), never more than BODIES_CAP of hers alive", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
round.you.safeMs = 1e9;
force(round, "drowned", RAGED);
assert.equal(b.act, "callWind");
const wind = events(round, "callWind")[0];
assert.ok(wind && wind.xs.length === bog.BODIES_CAP, "a wind-up naming where they come");
for (const x of wind.xs) {
assert.ok(Math.abs(x - 150) >= 6 && Math.abs(x - b.x) >= b.w, `away from you and her (${x})`);
assert.ok(Number.isFinite(ghoul.groundAt(round.spec, x)), "on a plank");
}
assert.equal(bog.hagAdds(round, "bogbody"), 0, "nothing yet");
run(round, bog.CALL_WIND_MS * bog.MOTHER_QUICK + 10);
assert.equal(events(round, "motherCall").length, 1);
assert.equal(bog.hagAdds(round, "bogbody"), bog.BODIES_CAP);
run(round, 20);
assert.equal(events(round, "bogRise").length, bog.BODIES_CAP, "they climb out");
assert.ok(round.monsters.every((m) => !ghoul.solid(m)), "harmless while they rise");
force(round, "drowned", RAGED);
assert.deepEqual(events(round, "callWind").at(-1).xs, [], "at the cap nothing boils");
run(round, bog.CALL_WIND_MS + 10);
assert.equal(bog.hagAdds(round, "bogbody"), bog.BODIES_CAP, "capped");
});
test("Old Mother Bog's wisp lantern, furious only: she raises it and two wisps of hers drift at you; a bolt puts one out for good, never more than WISPS_CAP", () => {
const round = motherFight();
const b = round.boss;
standAt(round, 150);
round.you.safeMs = 1e9;
force(round, "wisps", FURY);
assert.equal(b.act, "lanternWind");
assert.equal(events(round, "lanternWind").length, 1, "a wind-up to read");
run(round, bog.LANTERN_WIND_MS * bog.MOTHER_FURY + 10);
assert.equal(events(round, "motherLantern").length, 1);
assert.equal(bog.hagAdds(round, "wisp"), bog.WISPS_N);
const w = round.monsters.find((m) => m.hag && m.kind === "wisp");
bolt(round, w, w.y + w.h / 2);
round.shots.at(-1).x = w.x - 0.5;
run(round, 20);
assert.equal(bog.hagAdds(round, "wisp"), bog.WISPS_N - 1, "one put out for good");
force(round, "wisps", FURY);
run(round, bog.LANTERN_WIND_MS + 10);
force(round, "wisps", FURY);
run(round, bog.LANTERN_WIND_MS + 10);
assert.equal(bog.hagAdds(round, "wisp"), bog.WISPS_CAP, "capped");
});
test("Old Mother Bog's combo, furious only: a move that ends in an idle may go straight into the next after her eye flares, never twice running; calm she never does", () => {
const low = () => 0.1;
const MOVE = /Wind$|^tideWarn$|^motherSink$/;
// Runs `ms`, noting when each combo and each move's telegraph came.
const log = (round, ms) => {
const out = [];
for (let t = 0; t < ms; t += 4) {
ghoul.advance(round, 4, low);
for (const e of round.events) if (e.type === "motherCombo" || MOVE.test(e.type)) out.push([e.type, t]);
round.events.length = 0;
}
return out;
};
const round = motherFight();
standAt(round, 120);
round.you.safeMs = 1e9;
force(round, "hands", FURY);
const seen = log(round, 6000);
const i = seen.findIndex(([type]) => type === "motherCombo");
assert.ok(i >= 0, "a combo");
assert.ok(seen[i + 1] && MOVE.test(seen[i + 1][0]), "and straight into a move");
assert.ok(seen[i + 1][1] - seen[i][1] <= bog.COMBO_GAP_MS + 8, `with only the short gap between (${seen[i + 1][1] - seen[i][1]} ms)`);
const types = seen.map(([type]) => type);
assert.ok(!types.some((t, j) => t === "motherCombo" && types[j + 2] === "motherCombo"), "never two combos running");
const calm = motherFight();
standAt(calm, 120);
calm.you.safeMs = 1e9;
force(calm, "hands");
assert.equal(log(calm, 6000).filter(([type]) => type === "motherCombo").length, 0, "calm, never");
});
test("Old Mother Bog's phases: the moves she uses change at half and a quarter of her hp, and a long fight goes through them all", () => {
const round = motherFight();
const b = round.boss;
round.infinite = true;
let seed = 3;
const random = () => ((seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff);
const seen = [new Set(), new Set(), new Set()];
for (let t = 0; t < 150000 && b.state === "fight"; t += 4) {
round.you.safeMs = 1e9;
// Her hp falls steadily, so every phase gets its turn.
if (t % 400 === 0 && b.hp > 1 && !b.hidden && b.act !== "shell") b.hp -= 1;
const before = b.picks || 0;
ghoul.advance(round, 4, random);
if ((b.picks || 0) > before) seen[bog.phaseOf(b)].add(b.last);
round.events.length = 0;
}
for (const m of ["stomp", "tide", "pull", "drowned", "wisps"]) assert.equal(seen[0].has(m), false, `no ${m} at full health`);
assert.equal(seen[1].has("wisps"), false, "no wisps before she is furious");
assert.ok(["stomp", "tide", "pull", "drowned"].filter((m) => seen[1].has(m) || seen[2].has(m)).length >= 3, `the second phase's moves (${[...seen[1]]})`);
assert.ok(seen[0].size >= 5 && seen[1].size >= 6, `a varied fight (${[...seen[0]]} / ${[...seen[1]]} / ${[...seen[2]]})`);
});
/* ------------------------------------------------------ the whole fight */
// A player who plays the fight sensibly: keeps a fair distance facing her,
// fires in bursts that keep the blaster cool, steps off ripples, shadows and
// muck, jumps waves and her charge, climbs a shelf for the tide and the pull,
// and hops a leech rather than walking into it.
function skilledKeys(round, mem) {
const you = round.you;
const b = round.boss;
const spec = round.spec;
const k = { left: false, right: false, fire: false, down: false, jump: false };
const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
const onGround = you.state === "run" && you.shelf < 0;
const lo = spec.arena + ghoul.BOSS_LOCK + 2;
const hi = spec.length - 3;
let goal = null;
const climb = () => {
if (you.shelf >= 0) {
const s = spec.shelves[you.shelf];
goal = clamp(you.x, s[0] + 1.5, s[1] - 1.5);
return;
}
const tops = spec.shelves.filter((s) => s[2] === 12);
const s = tops.reduce((a, c) => (Math.abs((c[0] + c[1]) / 2 - you.x) < Math.abs((a[0] + a[1]) / 2 - you.x) ? c : a));
goal = (s[0] + s[1]) / 2;
if (onGround && you.x > s[0] + 1 && you.x < s[1] - 1) k.jump = true;
};
const danger = (x) => {
for (const h of round.hazards) {
if (h.kind === "muck" && (h.live > 0 || h.warn < 500) && Math.abs(x - h.x) < (h.w + ghoul.HIT_W) / 2 + 0.6) return true;
if (h.kind === "boghand" && Math.abs(x - h.x) < (h.w + ghoul.HIT_W) / 2 + 0.6) return true;
}
if ((b.act === "stompWind" || b.act === "stompAir") && Math.abs(x - b.landX) < (b.w + ghoul.HIT_W) / 2 + 2) return true;
if (!b.hidden && b.act !== "stompAir" && Math.abs(x - b.x) < (b.w + ghoul.HIT_W) / 2 + 1.5) return true;
return !Number.isFinite(ghoul.groundAt(spec, x));
};
if (b && b.state === "fight") {
const side = Math.sign(you.x - b.x) || 1;
goal = clamp(b.x + side * 15, lo, hi);
if (Math.abs(goal - b.x) < 10) goal = clamp(b.x - side * 15, lo, hi);
if (round.hazards.some((h) => h.kind === "tide") || b.act === "pull" || b.act === "pullWind") climb();
else if (danger(you.x) && onGround) {
for (let d = 0.5; d < 16; d += 0.5) {
const c = [you.x + d, you.x - d].find((x) => x > lo && x < hi && !danger(x));
if (c !== undefined) {
goal = c;
break;
}
}
} else if (danger(goal)) goal = you.x;
for (const w of round.waves) {
const d = (you.x - w.x) * w.dir;
if (onGround && d > 0 && d < 7.5 && Math.abs(w.y - you.y) < 1) k.jump = true;
}
if (b.act === "surge" || b.act === "surgeWind") goal = you.x;
if (b.act === "surge") {
const d = (you.x - b.x) * Math.sign(b.surgeTo - b.x) - b.w / 2 - ghoul.HIT_W / 2;
if (onGround && d > -1 && d < 7.5) k.jump = true;
}
for (const m of round.monsters) if (m.kind === "leech" && onGround && Math.abs(m.x - you.x) < 4.5 && Math.abs(m.y - you.y) < 2) k.jump = true;
}
if (goal !== null && Math.abs(goal - you.x) > 0.6) {
const dir = goal > you.x ? 1 : -1;
dir > 0 ? (k.right = true) : (k.left = true);
if (onGround && !Number.isFinite(ghoul.groundAt(spec, you.x + dir * 2.2))) k.jump = true;
} else if (b && b.state === "fight") {
const want = Math.sign(b.x - you.x) || 1;
if (you.face !== want) want > 0 ? (k.right = true) : (k.left = true);
}
// Up where bolts fly over her head (and no tide to wait out): drop down.
const tide = round.hazards.some((h) => h.kind === "tide");
if (b && b.state === "fight" && you.state === "run" && you.shelf >= 0 && !tide && b.act !== "pull" && you.y + ghoul.SHOT_Y > b.y + b.h - 0.5) {
k.left = false;
k.right = false;
k.down = true;
}
if (mem.cool && round.heat < 4) mem.cool = false;
if (!mem.cool && round.heat >= 28) mem.cool = true;
k.fire = !mem.cool;
return k;
}
// The whole fight from the arena door, real hearts and a seeded draw: how long
// it took (seconds from the fight's start) and how it went.
function wholeFight(keys, seed) {
const round = bogRound("drowning");
standAt(round, round.spec.arena + ghoul.BOSS_LOCK + 2);
const random = () => ((seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff);
const mem = {};
let start = -1;
const causes = [];
let t = 0;
for (; t < 240000 && !round.over; t += 4) {
// No Lucky dice: a die picked up off an add would stop the round to ask.
round.dice = 0;
const k = keys(round, mem);
Object.assign(round.input, { left: k.left, right: k.right, fire: k.fire, down: k.down });
if (k.jump && round.input.jump <= 0) round.input.jump = ghoul.JUMP_BUFFER_MS;
ghoul.advance(round, 4, random);
for (const e of round.events) {
if (e.type === "bossGo" && start < 0) start = t;
if (e.type === "lose") causes.push(e.cause);
}
const down = round.events.some((e) => e.type === "bossDown");
round.events.length = 0;
if (down) return { won: true, secs: (t - start) / 1000, causes, round };
}
return { won: false, secs: (t - start) / 1000, causes, round };
}
test("Old Mother Bog takes a skilled player a real fight: a bot that plays sensibly kills her in 60 to 120 seconds on every seed, losing a heart or a few, never all", () => {
const times = [];
for (const seed of [7, 11, 23, 71]) {
const fight = wholeFight(skilledKeys, seed);
assert.ok(fight.won, `seed ${seed}: she fell (${fight.causes}; ${fight.secs.toFixed(1)} s, ${fight.round.lives} lives, phase ${fight.round.phase}, hp ${fight.round.boss?.hp})`);
assert.ok(fight.secs >= 60 && fight.secs <= 120, `seed ${seed}: ${fight.secs.toFixed(1)} s of fight`);
assert.ok(fight.round.lives > 0, "with hearts to spare");
const known = new Set([...Object.keys(LOSE_WORDS), "pit", "zombie", "crawler"]);
for (const c of fight.causes) assert.ok(known.has(c), `${c} has words`);
times.push(fight.secs);
}
assert.ok(Math.max(...times) - Math.min(...times) > 3, `not the same fight every time (${times.map((t) => t.toFixed(1))})`);
});
test("Old Mother Bog kills a player who stands still: an idle bot loses every heart while she is barely scratched", () => {
const fight = wholeFight(() => ({}), 7);
assert.equal(fight.won, false);
assert.ok(fight.round.over, "game over");
assert.ok(fight.round.boss.hp > fight.round.boss.max * 0.9, "she is barely scratched");
assert.ok(fight.secs < 120, `down in ${fight.secs.toFixed(1)} s`);
assert.ok(new Set(fight.causes).size >= 2, `by more than one move (${fight.causes})`);
});
/* ------------------------------------------------------ voices, words, cards */
const heard = (e, extra = {}) => {
const played = [];
const noop = () => {};
const kit = { tone: (name) => played.push(name), burst: noop, float: noop, ring: noop, banner: () => null, shake: noop, flash: noop, glow: noop, splat: noop, fx: { clock: 1e6 }, monsters: ghoul.MONSTERS, powers: ghoul.POWERS, bosses: ghoul.BOSSES, g: {}, floorAt: () => 6, ...extra };
react(e, kit);
return played;
};
test("Ghoul Rush's bog: every new kind has a voice for every act, every new event plays exactly one picked sound, and the tones are the stage's own", () => {
const own = { lurker: ["appear", "snap", "sink", "hurt", "die"], leech: ["appear", "latch", "hurt", "die"], wisp: ["appear", "out", "relight", "on", "hurt", "die"], bogbody: ["appear", "rise", "hurt", "die"], motherbog: ["wake", "wind", "wave", "spitWind", "spit", "open", "sink", "bubble", "rise", "muck", "hurt", "weak", "die", "handsWind", "handsUp", "surgeWind", "surge", "shellWind", "chip", "shellBreak", "feed", "broodWind", "pour", "stompWind", "leap", "slam", "tideWarn", "tide", "pullWind", "pull", "callWind", "call", "lanternWind", "lantern", "combo"] };
assert.deepEqual(Object.keys(VOICES).sort(), Object.keys(own).sort(), "a voice table for each new kind and the boss");
for (const [kind, acts] of Object.entries(own)) assert.deepEqual(Object.keys(VOICES[kind]).sort(), [...acts].sort(), `${kind}: every act`);
const names = Object.values(VOICES).flatMap((v) => Object.values(v));
const at = { x: 10, y: 6, tx: 20, ty: 6 };
const cases = [
[{ type: "lurkerSnap", kind: "lurker" }, "lurker", "snap"],
[{ type: "lurkerSink", kind: "lurker" }, "lurker", "sink"],
[{ type: "leechLatch", kind: "leech" }, "leech", "latch"],
[{ type: "bogRise", kind: "bogbody" }, "bogbody", "rise"],
[{ type: "wispOut", kind: "wisp" }, "wisp", "out"],
[{ type: "wispRelight", kind: "wisp" }, "wisp", "relight"],
[{ type: "wispOn", kind: "wisp" }, "wisp", "on"],
[{ type: "motherWind", kind: "motherbog" }, "motherbog", "wind"],
[{ type: "mudWave", kind: "motherbog" }, "motherbog", "wave"],
[{ type: "spitWind", kind: "motherbog" }, "motherbog", "spitWind"],
[{ type: "cauldronSpit", kind: "motherbog" }, "motherbog", "spit"],
[{ type: "cauldronOpen", kind: "motherbog" }, "motherbog", "open"],
[{ type: "muckLand" }, "motherbog", "muck"],
[{ type: "motherSink", kind: "motherbog" }, "motherbog", "sink"],
[{ type: "motherBubble", kind: "motherbog" }, "motherbog", "bubble"],
[{ type: "motherRise", kind: "motherbog" }, "motherbog", "rise"],
[{ type: "handsWind", kind: "motherbog", xs: [12, 19] }, "motherbog", "handsWind"],
[{ type: "handsUp", kind: "motherbog" }, "motherbog", "handsUp"],
[{ type: "surgeWind", kind: "motherbog" }, "motherbog", "surgeWind"],
[{ type: "motherSurge", kind: "motherbog" }, "motherbog", "surge"],
[{ type: "shellWind", kind: "motherbog" }, "motherbog", "shellWind"],
[{ type: "shellChip", kind: "motherbog" }, "motherbog", "chip"],
[{ type: "shellBreak", kind: "motherbog" }, "motherbog", "shellBreak"],
[{ type: "motherFeed", kind: "motherbog", heal: 14 }, "motherbog", "feed"],
[{ type: "broodWind", kind: "motherbog" }, "motherbog", "broodWind"],
[{ type: "broodPour", kind: "motherbog", n: 2 }, "motherbog", "pour"],
[{ type: "stompWind", kind: "motherbog", landX: 14 }, "motherbog", "stompWind"],
[{ type: "motherLeap", kind: "motherbog" }, "motherbog", "leap"],
[{ type: "motherSlam", kind: "motherbog" }, "motherbog", "slam"],
[{ type: "tideWarn", kind: "motherbog" }, "motherbog", "tideWarn"],
[{ type: "tideRise", kind: "motherbog" }, "motherbog", "tide"],
[{ type: "pullWind", kind: "motherbog" }, "motherbog", "pullWind"],
[{ type: "motherPull", kind: "motherbog" }, "motherbog", "pull"],
[{ type: "callWind", kind: "motherbog", xs: [12, 30] }, "motherbog", "callWind"],
[{ type: "motherCall", kind: "motherbog", xs: [12, 30] }, "motherbog", "call"],
[{ type: "lanternWind", kind: "motherbog" }, "motherbog", "lanternWind"],
[{ type: "motherLantern", kind: "motherbog", n: 2 }, "motherbog", "lantern"],
[{ type: "motherCombo", kind: "motherbog" }, "motherbog", "combo"],
[{ type: "bossWake", kind: "motherbog" }, "motherbog", "wake"],
[{ type: "bossHit", kind: "motherbog", how: "shot" }, "motherbog", "hurt"],
[{ type: "bossHit", kind: "motherbog", how: "weak", weak: true }, "motherbog", "weak"],
[{ type: "bossDown", kind: "motherbog", points: 1 }, "motherbog", "die"],
[{ type: "hit", kind: "lurker" }, "lurker", "hurt"],
[{ type: "hit", kind: "leech" }, "leech", "hurt"],
[{ type: "hit", kind: "wisp" }, "wisp", "hurt"],
[{ type: "hit", kind: "bogbody" }, "bogbody", "hurt"],
[{ type: "kill", kind: "lurker", mult: 1, how: "shot", points: 1 }, "lurker", "die"],
[{ type: "kill", kind: "leech", mult: 1, how: "shot", points: 1 }, "leech", "die"],
[{ type: "kill", kind: "wisp", mult: 1, how: "shot", points: 1 }, "wisp", "die"],
[{ type: "kill", kind: "bogbody", mult: 1, how: "shot", points: 1 }, "bogbody", "die"],
[{ type: "spawn", kind: "lurker" }, "lurker", "appear"],
[{ type: "spawn", kind: "leech" }, "leech", "appear"],
[{ type: "spawn", kind: "wisp" }, "wisp", "appear"],
[{ type: "spawn", kind: "bogbody" }, "bogbody", "appear"],
];
for (const [e, kind, act] of cases) assert.ok(heard({ ...at, ...e }).includes(VOICES[kind][act]), `${e.type}: ${kind} ${act}`);
const reached = new Set(cases.map(([, kind, act]) => `${kind}.${act}`));
for (const [kind, acts] of Object.entries(own)) for (const act of acts) assert.ok(reached.has(`${kind}.${act}`), `${kind}.${act} is reached by an event`);
for (const e of cases.map((c) => c[0])) {
const picked = heard({ ...at, ...e }).filter((n) => names.includes(n));
assert.equal(picked.length, 1, `${e.type}${e.kind ? ` (${e.kind})` : ""} plays exactly one picked sound`);
}
const weakHit = heard({ ...at, type: "bossHit", kind: "motherbog", how: "weak", weak: true });
assert.equal(weakHit.includes(VOICES.motherbog.hurt), false, "weak replaces hurt");
assert.equal(heard({ ...at, type: "bossHit", kind: "motherbog", how: "shot" }).includes(VOICES.motherbog.weak), false, "a plain shot is not weak");
// Events that are only looks (the pull of the lure, a swarm coming apart) say nothing the voices own.
for (const type of ["wispLure", "leechDie"]) assert.equal(heard({ ...at, type, kind: "leech" }).filter((n) => names.includes(n)).length, 0, `${type} is visual`);
// Every event the hag's rules raise is one of the cases above (so none is left without a voice).
const raised = new Set();
const src = readFileSync(new URL("../src/web-console/public/activities/ghoul-rush/stages/bog/ghoul-bog.js", import.meta.url), "utf8");
for (const [, type] of src.matchAll(/type: "([a-zA-Z]+)"/g)) raised.add(type);
for (const [, type] of src.matchAll(/ev\("([a-zA-Z]+)"/g)) raised.add(type);
const covered = new Set([...cases.map(([e]) => e.type), "wispLure", "leechDie", "harpoonHit"]);
for (const type of raised) assert.ok(covered.has(type), `${type} has a reaction checked here`);
// Every picked tone exists in the merged tones, lives in the stage's file, is short and is named by kind and act.
const merged = ghoulSfx.default.tones;
for (const [kind, acts] of Object.entries(VOICES)) {
for (const [act, name] of Object.entries(acts)) {
assert.ok(merged[name]?.layers?.length, `${kind}.${act}: ${name} is in the merged tones`);
assert.ok(BOG_SFX.tones[name], `${name} lives in ghoul-sfx-bog.js`);
for (const l of BOG_SFX.tones[name].layers) assert.ok(l.seconds > 0 && l.seconds + (l.delay || 0) <= 1.2 + 1e-9, `${name} is over within 1.2 s`);
assert.equal(name, `ghoul${kind === "motherbog" ? "Mother" : kind[0].toUpperCase() + kind.slice(1)}${act[0].toUpperCase()}${act.slice(1)}`, "named by kind and act");
}
}
});
test("Ghoul Rush's bog: every new way to die has its words and its own sound, and endless lives spare the heart for each", () => {
const causes = ["lurker", "leeches", "wisp", "bogbody", "mudwave", "muck", "boghand", "tide", "motherbog"];
assert.deepEqual(Object.keys(LOSE_WORDS).sort(), [...causes].sort(), "words for exactly these");
assert.deepEqual(Object.keys(LOSE_SOUNDS).sort(), [...causes].sort(), "a sound for exactly these");
for (const cause of causes) {
assert.ok(LOSE_WORDS[cause] && LOSE_SOUNDS[cause], `${cause} has its words and its sound`);
assert.ok(heard({ x: 10, y: 6, type: "lose", cause, lives: 2 }).includes(LOSE_SOUNDS[cause][0]), `${cause} plays its own sound`);
const round = motherFight();
round.infinite = true;
const lives = round.lives;
ghoul.lose(round, cause);
assert.equal(round.lives, lives, `${cause} costs none`);
const normal = motherFight();
const had = normal.lives;
ghoul.lose(normal, cause);
assert.equal(normal.lives, had - 1, `${cause} costs a heart otherwise`);
}
// The real causes the stage raises are all among them.
for (const cause of ["leeches", "mudwave", "muck", "boghand", "tide", "motherbog"]) assert.ok(LOSE_WORDS[cause]);
assert.equal(bog.BOG.cause.motherbog(), "motherbog");
});
test("Ghoul Rush's bog cards: the stage card names the stage, boss and no em dash, the boss card names Old Mother Bog, and both agree", () => {
const card = INTROS.bog;
assert.equal(card.title, "Gallows Bog");
assert.equal(card.boss, "Old Mother Bog");
assert.ok(card.lines.length >= 3 && card.lines.length <= 4);
assert.equal(card.kicker, ghoul.stageById("bog").sub, "the card's kicker is the stage's subtitle");
assert.ok(card.lines.some((l) => /YOU/.test(l)) && !card.lines.some((l) => /Planny/.test(l)), "addressed to YOU, never the hero's name");
assert.ok(![card.title, card.kicker, card.boss, ...card.lines].some((t) => t.includes("\u2014")), "no em dash");
const boss = BOSS_INTROS.motherbog;
assert.equal(boss.name, "Old Mother Bog");
assert.equal(boss.name, card.boss, "the two cards agree on the name");
assert.ok(boss.epithet && !boss.epithet.includes("\u2014") && !/Planny/.test(boss.epithet));
assert.equal(bossIntroFor("motherbog"), boss);
assert.equal(introFor("bog"), card);
});
/* ------------------------------------------------------ round flow */
test("Ghoul Rush's bog round flow: the stage card opens before the Sunken Boardwalk, the hag's card before the Drowning Pool (after the ride), and neither shows on a retry", () => {
const r = ghoul.newRound(5);
r.dice = 0;
through(r);
r.offer = ["bog"];
r.phaseMs = 0;
assert.equal(ghoul.pickStage(r, 0), true);
assert.equal(r.stage, "bog");
assert.equal(r.spec.id, "boardwalk");
assert.equal(r.phase, "intro", "the stage card first");
assert.deepEqual(r.events.filter((e) => e.type === "intro").map((e) => e.stage), ["bog"]);
assert.equal(r.events.some((e) => e.type === "room"), false, "the room waits for the card");
r.introMs = ghoul.INTRO_MIN_MS;
assert.equal(ghoul.takeIntro(r), true);
assert.equal(r.phase, "ready");
ghoul.advance(r, ghoul.READY_MS + 20, steady);
assert.equal(r.phase, "play");
for (const id of ["hollow", "stilts", "lantern"]) {
r.events.length = 0;
through(r);
assert.equal(r.spec.id, id);
assert.notEqual(r.phase, "bossintro", `${id}: no boss card`);
assert.equal(r.events.some((e) => e.type === "bossIntro"), false);
}
assert.ok(ghoul.roomById("lantern").bonus, "the bonus round comes right before the boss");
r.events.length = 0;
through(r);
assert.equal(r.spec.id, "drowning");
assert.equal(r.phase, "bossintro", "the boss card");
assert.deepEqual(r.events.filter((e) => e.type === "bossIntro").map((e) => [e.boss, e.stage]), [["motherbog", "bog"]]);
assert.equal(r.boss.kind, "motherbog");
assert.equal(r.boss.state, "sleep", "she sleeps behind the card");
r.introMs = ghoul.INTRO_MIN_MS;
assert.equal(ghoul.takeIntro(r), true);
assert.equal(r.phase, "ready");
ghoul.advance(r, ghoul.READY_MS + 20, steady);
assert.equal(r.phase, "play");
// Into the pool, the fight starts; a life lost there goes back without the card.
r.events.length = 0;
standAt(r, r.spec.arena + ghoul.BOSS_LOCK + 2);
ghoul.advance(r, 4, steady);
ghoul.advance(r, ghoul.BOSS_INTRO_MS + 8, steady);
assert.equal(r.boss.state, "fight");
ghoul.lose(r, "motherbog");
for (let t = 0; t < 6000 && r.phase !== "play" && !r.over; t += 4) ghoul.advance(r, 4, steady);
assert.notEqual(r.phase, "bossintro", "no card on a retry");
assert.equal(r.events.some((e) => e.type === "bossIntro"), false, "no card event on a retry");
});
test("Ghoul Rush's bog draws: every walked room and the arena, every monster in every act, the hag in each move above and under the water, the mud wave and the muck, in a lit room and a dark one", () => {
const ctx = new Proxy({}, { get: (t, name) => (name in t ? t[name] : () => {}), set: (t, name, value) => ((t[name] = value), true) });
const g = ghoul.default.create({ canvas: { width: 0, height: 0, getContext: () => ctx } });
g.resize(900, 900);
g.key("action");
g.tick(16);
const r = g.round;
through(r);
r.offer = ["bog"];
r.phaseMs = 0;
ghoul.pickStage(r, 0);
const acts = { lurker: ["eyes", "snap", "sink"], leech: ["drift", "drop"], wisp: ["bright", "dim", "rekindle"], bogbody: ["rise", "walk"] };
let drew = 0;
for (const id of ["boardwalk", "hollow", "stilts", "drowning"]) {
while (r.spec.id !== id) through(r);
for (const dark of [true, false]) {
r.dark = dark;
r.phase = "play";
r.lives = 99;
for (const st of r.spawns) st.over = true;
r.hordeMs = Infinity;
r.monsters.length = 0;
standAt(r, id === "drowning" ? r.spec.arena + ghoul.BOSS_LOCK + 2 : 40);
r.you.safeMs = 1e9;
for (const [kind, list] of Object.entries(acts)) list.forEach((act, i) => put(r, kind, r.you.x + 6 + i * 5, { act, wait: 300, rise: act === "rise" ? 300 : 0, y: kind === "wisp" ? 12 : undefined }));
r.monsters.at(-1).lurching = true;
if (r.boss) {
ghoul.advance(r, ghoul.BOSS_INTRO_MS + 16, steady);
for (const hidden of [false, true]) {
for (const act of ["idle", "wind", "rest", "throwWind", "sink", "under", "resurface", "hands", "surgeWind", "surge", "shellWind", "shell", "stagger", "broodWind", "stompWind", "stompAir", "tideWind", "tideHold", "pullWind", "pull", "callWind", "lanternWind"]) {
Object.assign(r.boss, { act, wait: 400, dir: -1, lit: act === "rest" || act === "stagger", hidden: hidden && (act === "sink" || act === "under"), sinkX: r.boss.x - 10, home: 6, floor: 6, y: act === "surge" ? 6 - bog.SURGE_SINK : act === "stompAir" ? 14 : 6, landX: r.boss.x - 12, airMs: 300, callXs: [r.boss.x - 12, r.boss.x - 24], shell: 5, shellMax: bog.SHELL_HP[0], comboMs: hidden ? 200 : 0 });
g.tick(16);
drew++;
}
Object.assign(r.boss, { y: 6, comboMs: 0 });
}
Object.assign(r.boss, { hidden: false, act: "rest", wait: 1e9 });
r.hazards.push({ kind: "muck", x: r.you.x + 10, y: 6, w: bog.MUCK_W, h: bog.MUCK_H, warn: 400, live: 0, cause: "muck", sx: r.boss.x, sy: 9 }, { kind: "muck", x: r.you.x + 20, y: 6, w: bog.MUCK_W, h: bog.MUCK_H, warn: 0, live: 1500, cause: "muck" });
r.waves.push({ x: r.you.x + 8, y: 6, dir: -1, life: 6000, kind: "mudwave", cause: "mudwave" });
r.hazards.push({ kind: "boghand", x: r.you.x + 14, y: 6, w: bog.HAND_W, h: bog.HAND_H, warn: 500, full: 1200, live: 0, cause: "boghand" }, { kind: "boghand", x: r.you.x + 18, y: 6, w: bog.HAND_W, h: bog.HAND_H, warn: 0, live: 300, cause: "boghand" });
r.hazards.push({ kind: "tide", x: 152, y: 5, w: 104, h: 1.6, x0: 104, x1: 200, warn: 600, live: 0, cause: "tide" }, { kind: "tide", x: 152, y: 5, w: 104, h: 1.6, x0: 104, x1: 200, warn: 0, live: 2000, cause: "tide" });
}
for (let k = 0; k < 20; k++) g.tick(16);
r.you.safeMs = 1e9;
drew++;
}
}
assert.ok(drew >= 8 + 44, "drew a lot");
assert.equal(r.spec.id, "drowning", "got to the pool and drew it");
});
test("Ghoul Rush's bog: a seeded bot, shielded and with endless lives, plays the Sunken Boardwalk on a draw that throws if the bog's own rules ask for a random number, and any life it loses is for a cause the stage names", () => {
// The engine rolls dice of its own (power-up drops, horde edges, variants), so the draw is a steady one that throws only when the call came out of the bog's pack file.
const boom = () => {
Error.stackTraceLimit = 20;
const stack = new Error().stack;
if (stack.includes("ghoul-bog.js")) throw new Error(`the bog pack drew a random number: ${stack}`);
return 0.5;
};
let seed = 7;
const next = () => ((seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff);
const causes = new Set();
const round = ghoul.newRound(5);
round.dice = 0;
round.infinite = true;
through(round);
round.offer = ["bog"];
round.phaseMs = 0;
ghoul.pickStage(round, 0);
round.introMs = ghoul.INTRO_MIN_MS;
ghoul.takeIntro(round);
ghoul.advance(round, ghoul.READY_MS + 20, steady);
assert.equal(round.phase, "play");
assert.equal(round.spec.id, "boardwalk");
round.hasKey = true;
round.effects.boots = 1e9;
let far = 0;
let wake = 0;
// Walking right, firing, jumping at a gap or a step and now and then at nothing: a bot with no sense of the lurkers, the leeches or the lights.
for (let t = 0; t < 90000 && !round.over; t += 4) {
const you = round.you;
you.safeMs = 1e9;
const ahead = ghoul.groundAt(round.spec, you.x + 3);
round.input.right = true;
round.input.fire = true;
if (!Number.isFinite(ahead) || ahead > you.y + 0.4 || next() < 0.02) round.input.jump = ghoul.JUMP_BUFFER_MS;
ghoul.advance(round, 4, boom);
for (const e of round.events) {
if (e.type === "lose") causes.add(e.cause);
if (/^(lurkerSnap|leechLatch|wispLure|wispOut|bogRise)$/.test(e.type)) wake++;
}
round.events.length = 0;
far = Math.max(far, you.x);
assert.ok(Number.isFinite(you.x), "the player stays on the map");
if (round.phase === "clear") break;
}
assert.ok(far > 150, `the bot got well into the room (${far.toFixed(0)} of ${round.spec.length})`);
assert.ok(wake > 0, "the stage's monsters woke and acted around it");
assert.equal(round.lives, ghoul.newRound(5).lives, "endless lives: not one heart spent");
const known = new Set([...Object.keys(LOSE_WORDS), "pit"]);
for (const cause of causes) assert.ok(known.has(cause), `${cause} has words`);
});