mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 04:45:33 -08:00
460 lines
20 KiB
JavaScript
460 lines
20 KiB
JavaScript
// Web console tests, Ghoul Rush's Old Rattlebones: his volley and slam, the skull he throws like a boomerang (and is headless without), the bone rain and the skeletons he raises once his rage begins, the double slam, and what each move looks and sounds like.
|
|
import "./seed-random.mjs";
|
|
import { test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import * as ghoul from "../src/web-console/public/activities/ghoul-rush/ghoul.js";
|
|
import * as bn from "../src/web-console/public/activities/ghoul-rush/stages/wing/ghoul-bones.js";
|
|
import { LOSE_SOUNDS, LOSE_WORDS } from "../src/web-console/public/activities/ghoul-rush/stages/wing/ghoul-bones-draw.js";
|
|
import { VOICES, 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);
|
|
|
|
function through(round) {
|
|
round.phase = "clear";
|
|
round.phaseMs = 1;
|
|
ghoul.advance(round, 4, steady);
|
|
}
|
|
|
|
// A round in the East Wing's Crypt with the boss awake and fighting, you
|
|
// safe, his next attack held off until a test starts one.
|
|
function crypt() {
|
|
const round = ghoul.newRound(5);
|
|
round.dice = 0;
|
|
through(round);
|
|
round.offer = ["wing"];
|
|
round.phaseMs = 0;
|
|
ghoul.pickStage(round, 0);
|
|
while (round.spec.id !== "crypt") through(round);
|
|
round.phase = "play";
|
|
for (const st of round.spawns) st.over = true;
|
|
round.monsters.length = 0;
|
|
round.hordeMs = Infinity;
|
|
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.events.length = 0;
|
|
round.boss.t = -1e9;
|
|
round.you.safeMs = 1e9;
|
|
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, out: 0, safeMs: 0, face: 1 });
|
|
round.camX = Math.max(0, Math.min(round.spec.length - ghoul.FIELD_W, x - 36));
|
|
}
|
|
|
|
// He stands `gap` to the right of you, in the middle of the arena.
|
|
function faceOff(round, gap = 18) {
|
|
const b = round.boss;
|
|
standAt(round, round.spec.arena + 30);
|
|
b.x = round.you.x + gap;
|
|
b.y = ghoul.groundAt(round.spec, b.x);
|
|
round.you.safeMs = 1e9;
|
|
return b;
|
|
}
|
|
|
|
// Starts his `act` at once, and runs it out of its windup.
|
|
function wind(round, act) {
|
|
const b = round.boss;
|
|
b.act = act;
|
|
b.windup = 1;
|
|
ghoul.advance(round, 4, steady);
|
|
}
|
|
|
|
const step = (round, ms = 4, random = steady) => ghoul.advance(round, ms, random);
|
|
|
|
test("Ghoul Rush: Old Rattlebones has 90 hp, attacks every 1250 ms (950 in his rage), and his hint tells you to jump the skull and then aim for it", () => {
|
|
assert.equal(ghoul.BOSSES.bones.hp, 90);
|
|
assert.equal(ghoul.BONES_MS, 1250);
|
|
assert.equal(ghoul.BONES_RAGE_MS, 950);
|
|
assert.match(ghoul.BOSSES.bones.sub, /skull/i);
|
|
const round = crypt();
|
|
assert.equal(round.boss.hp, round.spec.bossHp);
|
|
assert.ok(round.boss.hp >= 90);
|
|
});
|
|
|
|
test("Ghoul Rush: Old Rattlebones' first attack is a volley, then each is picked at random, never the same one three times running, and bone rain waits for his rage", () => {
|
|
const b = { attacks: 0, raged: false };
|
|
assert.equal(bn.pickAct(b, () => 0.99), "volley", "the first is always a volley");
|
|
const seen = new Set();
|
|
for (const r of [0, 0.34, 0.67, 0.99]) {
|
|
const act = bn.pickAct({ attacks: 1, raged: false, last: ["volley", "slam"] }, () => r);
|
|
seen.add(act);
|
|
}
|
|
assert.deepEqual([...seen].sort(), ["skull", "slam", "volley"], "all three, and no rain");
|
|
assert.ok(!bn.pickAct({ attacks: 1, raged: false }, () => 0.99).includes("rain"));
|
|
assert.notEqual(bn.pickAct({ attacks: 3, raged: true, last: ["slam", "slam"] }, () => 0.5), "slam", "not a third slam");
|
|
const rain = bn.pickAct({ attacks: 3, raged: true, last: ["slam", "volley"] }, () => 0.99);
|
|
assert.equal(rain, "rain", "bone rain is open in the rage");
|
|
// Run for real: a long fight never repeats an act three times in a row.
|
|
const round = crypt();
|
|
const b2 = faceOff(round);
|
|
b2.t = 0;
|
|
const acts = [];
|
|
let seed = 7;
|
|
const random = () => ((seed = (seed * 16807) % 2147483647) / 2147483647);
|
|
for (let ms = 0; ms < 120000; ms += 4) {
|
|
ghoul.advance(round, 4, random);
|
|
if (round.boss.state !== "fight") break;
|
|
for (const e of round.events) {
|
|
if (e.type === "windup" && e.boss) acts.push(e.act);
|
|
else if (e.type === "skullWind") acts.push("skull");
|
|
else if (e.type === "rainWind") acts.push("rain");
|
|
}
|
|
round.events.length = 0;
|
|
round.you.safeMs = 1e9;
|
|
b2.hp = b2.max;
|
|
}
|
|
assert.ok(acts.length > 30, `many attacks (${acts.length})`);
|
|
assert.equal(acts[0], "volley");
|
|
for (let i = 2; i < acts.length; i++) assert.ok(!(acts[i] === acts[i - 1] && acts[i] === acts[i - 2]), `no three ${acts[i]} in a row`);
|
|
assert.ok(["volley", "slam", "skull"].every((a) => acts.includes(a)), "and all three get thrown");
|
|
assert.ok(!acts.includes("rain"), "no rain before the rage");
|
|
});
|
|
|
|
test("Ghoul Rush: a volley throws one bone at each VOLLEY scale, and a slam sends a shockwave both ways that a jump clears", () => {
|
|
const round = crypt();
|
|
faceOff(round);
|
|
wind(round, "volley");
|
|
assert.equal(events(round, "throw").length, ghoul.VOLLEY.length, "a volley");
|
|
assert.ok(events(round, "throw").every((e) => e.by === "bones"));
|
|
round.bones.length = 0;
|
|
wind(round, "slam");
|
|
assert.deepEqual(round.waves.map((w) => w.dir).sort(), [-1, 1]);
|
|
assert.equal(events(round, "slam").length, 1, "one slam, no echo outside the rage");
|
|
step(round, 600);
|
|
assert.equal(round.waves.filter((w) => w.dir === 1).length > 0, true);
|
|
const wave = (jumped) => {
|
|
const r = crypt();
|
|
standAt(r, r.spec.arena + 30);
|
|
r.you.safeMs = 0;
|
|
r.waves.push({ x: r.you.x + 8, y: 6, dir: -1, life: 6000 });
|
|
let hit = false;
|
|
for (let ms = 0; ms < 1000 && !hit; ms += 4) {
|
|
if (jumped && Math.abs(r.waves[0]?.x - r.you.x) < 4 && r.you.state === "run" && r.you.vy === 0 && !r.input.jump) {
|
|
r.input.jump = ghoul.JUMP_BUFFER_MS;
|
|
r.input.up = true;
|
|
}
|
|
step(r);
|
|
hit = r.phase !== "play";
|
|
}
|
|
return hit;
|
|
};
|
|
assert.equal(wave(false), true, "standing still, the wave hits");
|
|
assert.equal(wave(true), false, "a jump clears it");
|
|
});
|
|
|
|
test("Ghoul Rush: his skull flies out level at your chest, turns past you and curves back to his neck, headless meanwhile", () => {
|
|
const round = crypt();
|
|
const b = faceOff(round);
|
|
b.act = "skull";
|
|
b.windup = bn.SKULL_WINDUP_MS;
|
|
step(round, bn.SKULL_WINDUP_MS - 20);
|
|
assert.equal(b.headless, undefined, "still has his head while he winds up");
|
|
assert.equal(round.hazards.length, 0);
|
|
step(round, 40);
|
|
const h = round.hazards.find((q) => q.kind === "skull");
|
|
assert.ok(h, "the skull is out");
|
|
assert.equal(b.headless, true);
|
|
assert.equal(events(round, "skullThrow").length, 1);
|
|
assert.ok(Math.abs(h.fy - (round.you.y + ghoul.SHOT_Y)) < 0.01, "at your chest");
|
|
assert.equal(h.dir, -1, "toward you");
|
|
let past = false;
|
|
let ys = [];
|
|
let turned = false;
|
|
let home = false;
|
|
for (let ms = 0; ms < 6000 && !home; ms += 4) {
|
|
step(round);
|
|
const s = round.hazards.find((q) => q.kind === "skull");
|
|
if (!s) {
|
|
home = true;
|
|
break;
|
|
}
|
|
if (s.state === "out") ys.push(s.fy);
|
|
if (s.state === "back") turned = true;
|
|
if (s.x < round.you.x - 1) past = true;
|
|
assert.equal(b.headless, true, "headless the whole flight");
|
|
}
|
|
assert.ok(past, "it goes past you");
|
|
assert.ok(turned, "and turns");
|
|
assert.ok(home, "and comes home");
|
|
assert.ok(ys.every((y) => Math.abs(y - ys[0]) < 1e-9), "level going out");
|
|
assert.equal(b.headless, false, "his head is back");
|
|
assert.equal(events(round, "skullBack").length, 1);
|
|
assert.equal(events(round, "skullTurn").length, 1);
|
|
assert.equal(b.t < 100, true, "his next attack waits a full beat from the catch");
|
|
});
|
|
|
|
test("Ghoul Rush: the skull hurts you if you stand, and a jump clears it going out and again coming back", () => {
|
|
const fly = (jump) => {
|
|
const round = crypt();
|
|
const b = faceOff(round);
|
|
round.you.safeMs = 0;
|
|
b.act = "skull";
|
|
b.windup = 1;
|
|
let lost;
|
|
let jumps = 0;
|
|
for (let ms = 0; ms < 8000; ms += 4) {
|
|
const s = round.hazards.find((q) => q.kind === "skull");
|
|
if (jump && s && Math.abs(s.x - round.you.x) < 7 && round.you.state === "run" && round.you.vy === 0 && !round.input.jump) {
|
|
round.input.jump = ghoul.JUMP_BUFFER_MS;
|
|
round.input.up = true;
|
|
jumps++;
|
|
}
|
|
step(round);
|
|
if (round.phase !== "play") {
|
|
lost = round.events.find((e) => e.type === "lose")?.cause;
|
|
break;
|
|
}
|
|
if (b.headless === false && ms > 400) break;
|
|
}
|
|
return { lost, jumps, back: b.headless === false };
|
|
};
|
|
assert.equal(fly(false).lost, "skull", "standing, the skull takes a life");
|
|
const done = fly(true);
|
|
assert.equal(done.lost, undefined, "jumping, it passes");
|
|
assert.ok(done.jumps >= 2 && done.jumps <= 3, `a jump going and a jump coming back (${done.jumps})`);
|
|
assert.equal(done.back, true);
|
|
});
|
|
|
|
test("Ghoul Rush: while the skull is out his body takes single shots with no weak spot, and a bolt to the skull does three, used up on it, with a beat before the next counts", () => {
|
|
const round = crypt();
|
|
const b = faceOff(round);
|
|
const head = () => ({ x: b.x - b.w / 2 - 0.3, y: b.y + b.h * 0.9, vx: 80, vy: 0, gone: 0 });
|
|
let hp = b.hp;
|
|
round.shots.push(head());
|
|
step(round);
|
|
assert.equal(b.hp, hp - 2, "his skull on his shoulders: double");
|
|
wind(round, "skull");
|
|
assert.equal(b.headless, true);
|
|
hp = b.hp;
|
|
b.x += 0;
|
|
round.shots.push(head());
|
|
step(round);
|
|
assert.equal(b.hp, hp - 1, "headless, the neck is just body");
|
|
// A bolt to the skull itself.
|
|
const sk = round.hazards.find((q) => q.kind === "skull");
|
|
hp = b.hp;
|
|
round.shots.push({ x: sk.x + 1, y: sk.fy, vx: -80, vy: 0, gone: 0 });
|
|
step(round);
|
|
assert.equal(b.hp, hp - bn.SKULL_HIT, "the skull takes SKULL_HIT");
|
|
assert.equal(round.shots.length, 0, "the bolt is used up");
|
|
assert.ok(events(round, "bossHit").some((e) => e.how === "skull" && e.kind === "bones"), "a hit event carrying kind");
|
|
hp = b.hp;
|
|
const again = round.hazards.find((q) => q.kind === "skull");
|
|
round.shots.push({ x: again.x + 1, y: again.fy, vx: -80, vy: 0, gone: 0 });
|
|
step(round);
|
|
assert.equal(b.hp, hp, "no second hit inside the stagger");
|
|
assert.equal(round.shots.length, 0, "but the bolt is still eaten");
|
|
step(round, bn.SKULL_STAGGER_MS + 20);
|
|
const later = round.hazards.find((q) => q.kind === "skull");
|
|
if (later) {
|
|
round.shots.push({ x: later.x + 1, y: later.fy, vx: -80, vy: 0, gone: 0 });
|
|
step(round);
|
|
assert.equal(b.hp, hp - bn.SKULL_HIT, "after the stagger it counts again");
|
|
}
|
|
});
|
|
|
|
test("Ghoul Rush: his skull in flight does not hurt a boss that is already down, and killing him with it out clears it", () => {
|
|
const round = crypt();
|
|
const b = faceOff(round);
|
|
wind(round, "skull");
|
|
b.hp = bn.SKULL_HIT;
|
|
const sk = round.hazards.find((q) => q.kind === "skull");
|
|
round.shots.push({ x: sk.x + 1, y: sk.fy, vx: -80, vy: 0, gone: 0 });
|
|
step(round);
|
|
assert.equal(b.state, "down");
|
|
assert.equal(round.hazards.length, 0);
|
|
step(round, 100);
|
|
assert.equal(round.hazards.length, 0);
|
|
});
|
|
|
|
test("Ghoul Rush: at half his hp he shakes and his eyes flare (one event), attacks faster, and a slam comes in a double with the second wave a beat behind", () => {
|
|
const round = crypt();
|
|
const b = faceOff(round);
|
|
b.hp = Math.ceil(b.max / 2) + 1;
|
|
step(round);
|
|
assert.ok(!b.raged);
|
|
b.hp = Math.floor(b.max / 2);
|
|
step(round);
|
|
assert.equal(b.raged, true);
|
|
assert.equal(events(round, "bonesRage").length, 1);
|
|
assert.ok(b.shake > 0, "he shakes");
|
|
step(round, bn.BONES_SHAKE_MS + 20);
|
|
step(round, 200);
|
|
assert.equal(events(round, "bonesRage").length, 1, "only the once");
|
|
// The cadence: the next attack winds up BONES_RAGE_MS after the shake.
|
|
b.t = 0;
|
|
round.events.length = 0;
|
|
step(round, bn.BONES_RAGE_MS - 20);
|
|
assert.equal(events(round, "windup").length + events(round, "skullWind").length + events(round, "rainWind").length, 0);
|
|
step(round, 40);
|
|
assert.equal(events(round, "windup").length + events(round, "skullWind").length + events(round, "rainWind").length, 1, "winds up on the rage beat");
|
|
// A double slam.
|
|
round.events.length = 0;
|
|
b.windup = 0;
|
|
b.t = -1e9;
|
|
round.waves.length = 0;
|
|
wind(round, "slam");
|
|
assert.equal(round.waves.length, 2, "the first pair");
|
|
const xs = round.waves.map((w) => w.x);
|
|
step(round, bn.DOUBLE_GAP_MS - 20);
|
|
assert.equal(round.waves.length, 2);
|
|
step(round, 40);
|
|
assert.equal(round.waves.length, 4, "the second pair a beat later");
|
|
assert.equal(events(round, "slam").length, 2);
|
|
assert.equal(events(round, "slam")[1].echo, true);
|
|
const gap = Math.abs(round.waves[0].x - round.waves[2].x);
|
|
assert.ok(gap > 10 && gap < 30, `waves ${gap.toFixed(1)} apart: ${xs.join()}`);
|
|
});
|
|
|
|
test("Ghoul Rush: in his rage bone rain throws bones up that come down at spots around you, each on a shadow first, and a bone landing on you costs a life unless lives are endless", () => {
|
|
const round = crypt();
|
|
const b = faceOff(round);
|
|
b.raged = true;
|
|
b.raiseIn = 1e9;
|
|
wind(round, "rain");
|
|
const bones = round.hazards.filter((h) => h.kind === "rain");
|
|
assert.equal(bones.length, bn.RAIN_N, "a handful");
|
|
assert.equal(events(round, "rainThrow").length, 1);
|
|
assert.ok(bones.every((h) => h.warn >= bn.RAIN_WARN_MS - 8 && h.live === 0 && h.cause === "rain"), "all in shadow");
|
|
assert.ok(bones.some((h) => Math.abs(h.x - round.you.x) < 2), "one near where you stand");
|
|
assert.ok(bones.every((h) => Math.abs(h.x - round.you.x) < bn.RAIN_SPREAD * 3), "all around you");
|
|
assert.equal(new Set(bones.map((h) => h.warn)).size, bn.RAIN_N, "landing one after another");
|
|
// Standing in a shadow when the bone lands costs a life.
|
|
const lives = round.lives;
|
|
const spot = bones.find((h) => Math.abs(h.x - round.you.x) < 2);
|
|
standAt(round, spot.x);
|
|
round.you.safeMs = 0;
|
|
step(round, bn.RAIN_WARN_MS - 100);
|
|
assert.equal(round.phase, "play", "the shadow alone does nothing");
|
|
step(round, bn.RAIN_STAGGER_MS * bn.RAIN_N + 200);
|
|
assert.equal(round.phase, "crash");
|
|
assert.equal(round.lives, lives - 1);
|
|
assert.equal(events(round, "lose")[0].cause, "rain");
|
|
assert.ok(events(round, "rainLand").length >= 1);
|
|
// Endless lives: the same bone, no life.
|
|
const inf = crypt();
|
|
inf.infinite = true;
|
|
const b2 = faceOff(inf);
|
|
b2.raged = true;
|
|
b2.raiseIn = 1e9;
|
|
wind(inf, "rain");
|
|
const mine = inf.hazards.find((h) => h.kind === "rain" && Math.abs(h.x - inf.you.x) < 2);
|
|
standAt(inf, mine.x);
|
|
inf.you.safeMs = 0;
|
|
const before = inf.lives;
|
|
step(inf, bn.RAIN_WARN_MS + bn.RAIN_STAGGER_MS * bn.RAIN_N);
|
|
assert.equal(inf.lives, before, "endless lives skip the loss");
|
|
assert.ok(events(inf, "lose").length >= 1);
|
|
// Moving off the spot in time is safe.
|
|
const safe = crypt();
|
|
const b3 = faceOff(safe);
|
|
b3.raged = true;
|
|
b3.raiseIn = 1e9;
|
|
wind(safe, "rain");
|
|
const xsAll = safe.hazards.filter((h) => h.kind === "rain").map((h) => h.x);
|
|
let free = safe.spec.arena + 3;
|
|
while (xsAll.some((x) => Math.abs(x - free) < bn.RAIN_W + 1)) free += 0.5;
|
|
standAt(safe, free);
|
|
safe.you.safeMs = 0;
|
|
step(safe, bn.RAIN_WARN_MS + bn.RAIN_STAGGER_MS * bn.RAIN_N + bn.RAIN_LIVE_MS * 2 + 100);
|
|
assert.equal(safe.phase, "play", "between the bones is safe");
|
|
assert.equal(safe.hazards.filter((h) => h.kind === "rain").length, 0, "and they are gone after");
|
|
});
|
|
|
|
test("Ghoul Rush: in his rage he has skeletons come up out of the floor, the floor cracking first, never more than two about", () => {
|
|
const round = crypt();
|
|
const b = faceOff(round);
|
|
b.raged = true;
|
|
b.raiseIn = 0;
|
|
step(round);
|
|
const crack = round.hazards.find((h) => h.kind === "raise");
|
|
assert.ok(crack, "the floor cracks");
|
|
assert.equal(events(round, "raiseWind").length, 1);
|
|
assert.ok(Math.abs(crack.x - round.you.x) >= 6 && Math.abs(crack.x - b.x) >= b.w / 2 + 2, "clear of you and of him");
|
|
step(round, bn.RAISE_WARN_MS - 20);
|
|
assert.equal(round.monsters.length, 0, "not yet");
|
|
step(round, 40);
|
|
assert.equal(round.monsters.filter((m) => m.kind === "skeleton").length, 1, "up it comes");
|
|
assert.equal(events(round, "raised").length, 1);
|
|
// Over a long fight, never more than two.
|
|
round.events.length = 0;
|
|
let most = 0;
|
|
let raised = 0;
|
|
for (let ms = 0; ms < 60000; ms += 8) {
|
|
step(round, 8);
|
|
round.you.safeMs = 1e9;
|
|
b.t = -1e9;
|
|
const alive = round.monsters.filter((m) => m.kind === "skeleton" && !m.dead).length + round.hazards.filter((h) => h.kind === "raise").length;
|
|
most = Math.max(most, alive);
|
|
raised += events(round, "raised").length;
|
|
round.events.length = 0;
|
|
}
|
|
assert.equal(most, bn.MAX_BONY, "two at most, and he gets to two");
|
|
assert.equal(raised, 1, "a second came up, and none past the cap");
|
|
// Shoot one down and he raises another after a beat.
|
|
round.monsters.length = 0;
|
|
b.raiseIn = 0;
|
|
step(round, 8);
|
|
assert.ok(round.hazards.some((h) => h.kind === "raise"), "a freed place is filled");
|
|
// Not before the rage.
|
|
const calm = crypt();
|
|
faceOff(calm);
|
|
calm.boss.raiseIn = 0;
|
|
step(calm, 3000);
|
|
assert.equal(calm.hazards.filter((h) => h.kind === "raise").length + calm.monsters.length, 0);
|
|
});
|
|
|
|
test("Ghoul Rush: his fall clears the skull, the rain and the cracks, and a life lost mid-fight puts his head back on", () => {
|
|
const round = crypt();
|
|
const b = faceOff(round);
|
|
b.raged = true;
|
|
b.raiseIn = 0;
|
|
step(round);
|
|
wind(round, "rain");
|
|
assert.ok(round.hazards.length > 3);
|
|
b.hp = 1;
|
|
round.shots.push({ x: b.x - b.w / 2 - 0.3, y: b.y + 5, vx: 80, vy: 0, gone: 0 });
|
|
step(round);
|
|
assert.equal(b.state, "down");
|
|
assert.equal(round.hazards.length, 0);
|
|
const lost = crypt();
|
|
const b2 = faceOff(lost);
|
|
b2.hp = 60;
|
|
wind(lost, "skull");
|
|
assert.equal(lost.boss.headless, true);
|
|
ghoul.lose(lost, "skull");
|
|
step(lost, ghoul.CRASH_MS + 10);
|
|
assert.equal(lost.hazards.length, 0);
|
|
assert.ok(!lost.boss.headless, "a new boss in the arena");
|
|
assert.equal(lost.boss.hp, 60, "with the hp kept");
|
|
});
|
|
|
|
test("Ghoul Rush: Old Rattlebones' new moves each play one sound, and the new deaths have their words and sounds", () => {
|
|
const names = new Set(Object.values(VOICES).flatMap((v) => Object.values(v)));
|
|
const heard = (e) => {
|
|
const played = [];
|
|
const floats = [];
|
|
const noop = () => {};
|
|
const kit = { tone: (name) => played.push(name), burst: noop, float: (x, y, text) => floats.push(text), 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 };
|
|
react(e, kit);
|
|
return { played, voices: played.filter((n) => names.has(n)), floats };
|
|
};
|
|
const at = { x: 10, y: 6, kind: "bones" };
|
|
for (const type of ["skullWind", "skullThrow", "rainWind", "bonesRage"]) assert.equal(heard({ ...at, type }).voices.length, 1, `${type}: one voice`);
|
|
for (const type of ["skullBack", "skullTurn", "rainThrow", "rainLand", "raiseWind", "raised"]) {
|
|
const { played } = heard({ ...at, type });
|
|
assert.ok(played.length <= 2 && played.length >= (type === "raised" ? 0 : 1), `${type}: ${played.join()}`);
|
|
assert.equal(heard({ ...at, type }).voices.length, 0, `${type}: no cry on top`);
|
|
}
|
|
// A bolt to the skull plays the boss's hurt cry once, like any boss hit.
|
|
assert.equal(heard({ type: "bossHit", kind: "bones", x: 1, y: 1, how: "skull" }).voices.length, 1);
|
|
// Every cause that can take a life here has its words and a sound.
|
|
for (const cause of ["skull", "rain"]) assert.ok(LOSE_WORDS[cause] && LOSE_SOUNDS[cause], cause);
|
|
assert.ok(!/\u2014/.test(Object.values(LOSE_WORDS).join("")), "no em dash");
|
|
});
|