mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 04:45:33 -08:00
510 lines
21 KiB
JavaScript
510 lines
21 KiB
JavaScript
// Web console tests, Ghoul Rush's Lucky die: it comes only from a kill, stacks to nine and lasts the run; when a life would be lost one rolls: a 4 to 6 brings Planny back (the monsters in view blown apart in an ordinary room, a boss's room untouched; a 5 adds a heart, a 6 a heart and a Garlic shield), a 3 or 2 costs the life and leaves a gift for the respawn, a 1 only laughs.
|
|
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 { pickPower } from "../src/web-console/public/activities/ghoul-rush/core/ghoul-powers.js";
|
|
import { react } from "../src/web-console/public/activities/ghoul-rush/draw/ghoul-draw.js";
|
|
import { toneNames } from "../src/web-console/public/tones.js";
|
|
|
|
const steady = () => 0.5;
|
|
// Answer "Use a Lucky Die?" once the guard is past (nothing happens when no question is up).
|
|
const accept = (round, yes = true) => {
|
|
if (round.phase !== "ask") return false;
|
|
round.ask.t = ghoul.ASK_GUARD_MS;
|
|
return ghoul.answerDie(round, yes);
|
|
};
|
|
// A life lost, the question answered Yes: the old automatic roll.
|
|
const lose = (round, cause) => {
|
|
const r = ghoul.lose(round, cause);
|
|
accept(round);
|
|
return r;
|
|
};
|
|
const events = (round, type) => round.events.filter((e) => e.type === type);
|
|
// A random that plays `values` in order, then 0.5.
|
|
const rolls = (...values) => {
|
|
const rest = values.slice();
|
|
return () => (rest.length ? rest.shift() : 0.5);
|
|
};
|
|
const SIX = 0.99;
|
|
const FIVE = 0.7;
|
|
const FOUR = 0.55;
|
|
const THREE = 0.4;
|
|
const TWO = 0.2;
|
|
const ONE = 0;
|
|
|
|
function through(round) {
|
|
round.phase = "clear";
|
|
round.phaseMs = 1;
|
|
ghoul.advance(round, 4, steady);
|
|
}
|
|
|
|
function stand(round, x) {
|
|
Object.assign(round.you, { x, y: ghoul.groundAt(round.spec, x), vx: 0, vy: 0, state: "run", shelf: -1, coyote: 0, drop: -1, out: 0, safeMs: 0 });
|
|
round.camX = Math.max(0, Math.min(round.spec.length - ghoul.FIELD_W, x - 30));
|
|
}
|
|
|
|
// A quiet round in the hall, Planny standing at x = 100, nothing awake.
|
|
function hall(dice = 0) {
|
|
const round = ghoul.newRound(5);
|
|
round.lives = 3;
|
|
for (const st of round.spawns) st.over = true;
|
|
round.monsters.length = 0;
|
|
round.hordeMs = Infinity;
|
|
stand(round, 100);
|
|
round.dice = dice;
|
|
round.events.length = 0;
|
|
return round;
|
|
}
|
|
|
|
function zombie(round, x) {
|
|
return ghoul.spawnMonster(round, "zombie", x, ghoul.groundAt(round.spec, x), { rise: 0, awake: true });
|
|
}
|
|
|
|
// Into the stage `id`, up to its room `room`, quiet, Planny safe.
|
|
function inRoom(round, id, room) {
|
|
through(round);
|
|
round.offer = [id];
|
|
round.phaseMs = 0;
|
|
ghoul.pickStage(round, 0);
|
|
while (round.spec.id !== room) through(round);
|
|
round.phase = "play";
|
|
for (const st of round.spawns) st.over = true;
|
|
round.monsters.length = 0;
|
|
round.hordeMs = Infinity;
|
|
round.events.length = 0;
|
|
return round;
|
|
}
|
|
|
|
test("Ghoul Rush: a Lucky die is as common as a 1UP, comes only as a drop, and is never placed in a room or swapped in for a placed power-up", () => {
|
|
assert.equal(ghoul.POWERS.die.weight, ghoul.POWERS.life.weight);
|
|
assert.equal(ghoul.POWERS.die.drop, true);
|
|
assert.equal(ghoul.POWERS.die.ms, undefined, "not a timed power-up");
|
|
for (const room of ghoul.ROOMS) {
|
|
const spec = ghoul.roomFor(room.id);
|
|
assert.ok(![...spec.items, ...spec.sky].some(([kind]) => kind === "die"), `${room.id} places none`);
|
|
}
|
|
const round = hall();
|
|
let dropped = 0;
|
|
for (let k = 0; k < 400; k++) {
|
|
const r = k / 400;
|
|
assert.notEqual(pickPower(() => r, round), "die", "never picked for a placed one");
|
|
assert.notEqual(pickPower(() => r, round, "life"), "die");
|
|
if (pickPower(() => r, round, "", true) === "die") dropped++;
|
|
}
|
|
assert.ok(dropped > 0, "but dropped now and then");
|
|
for (let seed = 1; seed <= 40; seed++) assert.ok(!ghoul.newRound(seed).loot.includes("die"));
|
|
// A kill whose roll lands on the die's slice drops it.
|
|
const dark = hall();
|
|
dark.dark = true;
|
|
const m = zombie(dark, 120);
|
|
const values = [0, 0.99];
|
|
ghoul.kill(dark, m, "shot", () => values.shift() ?? 0);
|
|
assert.equal(dark.drops.length, 1, "a kill drops a power-up on a low roll");
|
|
});
|
|
|
|
test("Ghoul Rush: picking up Lucky dice stacks them to MAX_HELD_DICE (13), then pays points like a 1UP at its cap, and the dice show in a pill", () => {
|
|
const round = hall();
|
|
const drop = { id: 1, kind: "die", x: round.you.x, y: round.you.y + 1, vx: 0, vy: 0, life: 9000, rest: true };
|
|
round.drops.push(drop);
|
|
ghoul.advance(round, 4, steady);
|
|
assert.equal(round.dice, 1);
|
|
assert.equal(round.drops.length, 0);
|
|
assert.equal(events(round, "power")[0].kind, "die");
|
|
assert.equal(ghoul.MAX_HELD_DICE, 13);
|
|
for (let k = 0; k < 20; k++) ghoul.applyPower(round, "die");
|
|
assert.equal(round.dice, ghoul.MAX_HELD_DICE, "stacks to the cap");
|
|
const score = round.score;
|
|
ghoul.applyPower(round, "die");
|
|
assert.equal(round.dice, ghoul.MAX_HELD_DICE, "no more past it");
|
|
assert.equal(round.score, score + ghoul.POWER_POINTS, "points instead");
|
|
const canvas = { getContext: () => null };
|
|
const game = ghoul.default.create({ canvas });
|
|
game.start();
|
|
game.round.dice = 0;
|
|
assert.ok(!game.hud.effects.some((e) => /DICE/.test(e.text)), "no pill without dice");
|
|
game.round.dice = 3;
|
|
const pill = game.hud.effects.find((e) => /DICE/.test(e.text));
|
|
assert.equal(pill.text, "DICE x3");
|
|
assert.equal(pill.color, ghoul.POWERS.die.color);
|
|
});
|
|
|
|
test("Ghoul Rush: dice carry over to the next room and the next stage, and a new round starts with three", () => {
|
|
const round = hall(4);
|
|
round.hasKey = true;
|
|
through(round);
|
|
assert.equal(round.phase, "pick");
|
|
assert.equal(round.dice, 4);
|
|
round.offer = ["manor"];
|
|
round.phaseMs = 0;
|
|
ghoul.pickStage(round, 0);
|
|
assert.equal(round.dice, 4, "into the stage");
|
|
through(round);
|
|
assert.equal(round.dice, 4, "into its next room");
|
|
assert.equal(ghoul.newRound(9).dice, ghoul.START_DICE);
|
|
});
|
|
|
|
test("Ghoul Rush: a fresh run holds 3 Lucky dice, a lost life with one in hand starts the roll, and the dice carry into the hall and the first stage pick", () => {
|
|
assert.equal(ghoul.START_DICE, 3);
|
|
const round = ghoul.newRound(5);
|
|
assert.equal(round.dice, 3, "a run starts with three");
|
|
assert.equal(round.spec.id, "hall");
|
|
for (const st of round.spawns) st.over = true;
|
|
round.monsters.length = 0;
|
|
round.hordeMs = Infinity;
|
|
stand(round, 100);
|
|
lose(round, "zombie");
|
|
assert.equal(round.phase, "roll", "a lost life with a die in hand rolls");
|
|
assert.equal(round.dice, 2, "the roll spends one");
|
|
const next = ghoul.newRound(5);
|
|
next.hasKey = true;
|
|
through(next);
|
|
assert.equal(next.phase, "pick");
|
|
assert.equal(next.dice, 3, "into the first stage pick");
|
|
next.offer = ["manor"];
|
|
next.phaseMs = 0;
|
|
ghoul.pickStage(next, 0);
|
|
assert.equal(next.dice, 3, "into the stage");
|
|
});
|
|
|
|
test("Ghoul Rush: a death with dice holds and rolls just one; a six saves Planny where he stood with a heart and the Garlic shield, the room not reset, and the other dice are kept", () => {
|
|
const round = hall(3);
|
|
const far = zombie(round, round.camX + ghoul.FIELD_W + 40);
|
|
far.hp = 3;
|
|
const x = round.you.x;
|
|
assert.equal(lose(round, "zombie"), true);
|
|
assert.equal(round.phase, "roll");
|
|
assert.equal(round.lives, 3, "no life lost yet");
|
|
assert.equal(round.dice, 2, "the die is in hand");
|
|
assert.equal(events(round, "diceStart").length, 1);
|
|
assert.equal(events(round, "diceRoll").length, 0, "the die is still flying in from the HUD");
|
|
assert.equal(events(round, "lose").length, 0, "not lost");
|
|
const random = rolls(SIX);
|
|
// The lead-in: the die flies in, then the rattle starts.
|
|
ghoul.advance(round, ghoul.LEAD_MS + 8, random);
|
|
assert.equal(events(round, "diceRoll").length, 1);
|
|
assert.equal(events(round, "diceFace").length, 0);
|
|
// Half way through: tumbling, no face yet.
|
|
ghoul.advance(round, (ghoul.TUMBLE_MS - ghoul.LEAD_MS) / 2, random);
|
|
assert.equal(round.phase, "roll");
|
|
assert.equal(events(round, "diceFace").length, 0);
|
|
// It lands, and holds its beat.
|
|
ghoul.advance(round, (ghoul.TUMBLE_MS - ghoul.LEAD_MS) / 2, random);
|
|
assert.deepEqual(events(round, "diceFace").map((e) => e.face), [6]);
|
|
assert.equal(round.phase, "roll");
|
|
ghoul.advance(round, ghoul.ROLL_MS - ghoul.TUMBLE_MS + 8, random);
|
|
assert.equal(events(round, "diceRoll").length, 1, "no second die");
|
|
assert.equal(events(round, "diceSaved").length, 1);
|
|
assert.equal(events(round, "diceFail").length, 0);
|
|
assert.equal(round.phase, "play", "back in play at once");
|
|
assert.equal(round.dice, 2, "the others are kept");
|
|
assert.equal(round.lives, 4, "a heart on top");
|
|
assert.equal(round.you.x, x);
|
|
assert.equal(round.you.garlic, true);
|
|
assert.ok(round.you.safeMs > 0 && round.you.safeMs <= ghoul.SAFE_MS);
|
|
assert.equal(round.you.out, 0);
|
|
assert.equal(round.roll, null);
|
|
assert.equal(events(round, "lose").length, 0);
|
|
assert.equal(events(round, "respawn").length, 0);
|
|
assert.equal(round.roomLost, false);
|
|
assert.ok(round.monsters.includes(far) && !far.dead, "a monster out of view is left where it stands");
|
|
assert.equal(far.hp, 3);
|
|
});
|
|
|
|
test("Ghoul Rush: the same random rolls the same face, and each slice of the die lands on its face", () => {
|
|
const face = (value) => {
|
|
const round = hall(5);
|
|
lose(round, "bone");
|
|
ghoul.advance(round, ghoul.ROLL_MS, rolls(value));
|
|
return events(round, "diceFace").map((e) => e.face);
|
|
};
|
|
assert.deepEqual(face(0.4), face(0.4));
|
|
assert.deepEqual([ONE, 0.2, 0.4, 0.6, 0.8, SIX].flatMap(face), [1, 2, 3, 4, 5, 6]);
|
|
});
|
|
|
|
test("Ghoul Rush: a 5 saves him with a heart and no shield, a 4 just saves him, and a heart has no cap", () => {
|
|
const five = hall(1);
|
|
lose(five, "zombie");
|
|
ghoul.advance(five, ghoul.ROLL_MS + 8, rolls(FIVE));
|
|
assert.equal(five.phase, "play");
|
|
assert.equal(five.lives, 4);
|
|
assert.equal(five.you.garlic, false);
|
|
const four = hall(1);
|
|
lose(four, "zombie");
|
|
ghoul.advance(four, ghoul.ROLL_MS + 8, rolls(FOUR));
|
|
assert.equal(four.phase, "play");
|
|
assert.equal(four.lives, 3);
|
|
assert.equal(four.you.garlic, false);
|
|
assert.ok(four.you.safeMs > 0, "still safe a moment");
|
|
const held = hall(1);
|
|
held.you.garlic = true;
|
|
lose(held, "pit");
|
|
ghoul.advance(held, ghoul.ROLL_MS + 8, rolls(FOUR));
|
|
assert.equal(held.you.garlic, true, "a shield he already held stays");
|
|
const some = hall(1);
|
|
some.lives = 9;
|
|
lose(some, "zombie");
|
|
ghoul.advance(some, ghoul.ROLL_MS + 8, rolls(FIVE));
|
|
assert.equal(some.lives, 10, "a heart under the cap");
|
|
const full = hall(1);
|
|
full.lives = ghoul.MAX_LIVES;
|
|
const score = full.score;
|
|
lose(full, "zombie");
|
|
ghoul.advance(full, ghoul.ROLL_MS + 8, rolls(FIVE));
|
|
assert.equal(full.lives, ghoul.MAX_LIVES, "never past MAX_LIVES (13)");
|
|
assert.equal(full.score, score + ghoul.POWER_POINTS, "points instead");
|
|
});
|
|
|
|
test("Ghoul Rush: a 3 costs the life and he comes back with Rapid fire and a Garlic shield, a 2 with Bottle Rockets and a Garlic shield", () => {
|
|
for (const [value, check] of [
|
|
[THREE, (round) => assert.equal(round.effects.rapid, ghoul.POWERS.rapid.ms)],
|
|
[TWO, (round) => assert.deepEqual(round.arms.map((a) => [a.kind, a.n]), [["rocket", ghoul.POWERS.rocket.sticks]])],
|
|
]) {
|
|
const round = hall(2);
|
|
lose(round, "zombie");
|
|
ghoul.advance(round, ghoul.ROLL_MS + 8, rolls(value));
|
|
assert.equal(round.phase, "crash", "the life is lost");
|
|
assert.equal(round.lives, 2);
|
|
assert.equal(round.dice, 1, "and no second die is rolled");
|
|
assert.equal(round.you.garlic, false, "not until he is back");
|
|
assert.equal(events(round, "diceGift").length, 0);
|
|
ghoul.advance(round, ghoul.CRASH_MS + 8, steady);
|
|
assert.equal(round.phase, "ready");
|
|
assert.equal(round.you.garlic, true);
|
|
check(round);
|
|
assert.equal(events(round, "diceGift").length, 1);
|
|
assert.equal(round.diceGift, 0, "spent");
|
|
// The next loss, with no die, leaves him nothing (long enough alive to earn no quick-fall shield).
|
|
round.you.aliveMs = 1e9;
|
|
round.dice = 0;
|
|
round.phase = "play";
|
|
round.you.garlic = false;
|
|
round.you.safeMs = 0;
|
|
lose(round, "zombie");
|
|
ghoul.advance(round, ghoul.CRASH_MS + 8, steady);
|
|
assert.equal(round.you.garlic, false, "the gift comes once");
|
|
assert.equal(events(round, "diceGift").length, 1);
|
|
check(round);
|
|
}
|
|
});
|
|
|
|
test("Ghoul Rush: a 1 costs the life and leaves nothing, with its laugh and its words", () => {
|
|
const round = hall(2);
|
|
lose(round, "zombie");
|
|
ghoul.advance(round, ghoul.ROLL_MS - 8, rolls(ONE));
|
|
assert.equal(round.phase, "roll", "the beat has not finished");
|
|
ghoul.advance(round, 16, steady);
|
|
assert.deepEqual(events(round, "diceFace").map((e) => e.face), [1]);
|
|
assert.equal(events(round, "diceFail").length, 1);
|
|
assert.equal(events(round, "diceSaved").length, 0);
|
|
assert.equal(round.dice, 1);
|
|
assert.equal(round.lives, 2);
|
|
assert.equal(round.phase, "crash");
|
|
assert.equal(events(round, "lose").length, 1);
|
|
ghoul.advance(round, ghoul.CRASH_MS + 8, steady);
|
|
assert.equal(round.phase, "ready", "and the room starts over");
|
|
assert.equal(events(round, "diceGift").length, 0);
|
|
assert.equal(round.arms.length, 0);
|
|
assert.equal(round.effects.rapid || 0, 0);
|
|
assert.equal(ghoul.DICE_FACES[1].line, "Better Luck Next Time");
|
|
});
|
|
|
|
test("Ghoul Rush: on the last heart a 5 or 6 saves him in place, a 2, 3 or 4 pays one heart and he respawns as usual, a 1 loses the run", () => {
|
|
const saved = hall(1);
|
|
saved.lives = 1;
|
|
lose(saved, "zombie");
|
|
ghoul.advance(saved, ghoul.ROLL_MS + 8, rolls(FIVE));
|
|
assert.equal(saved.lives, 2, "saved in place, with the 5's heart");
|
|
assert.equal(saved.over, false);
|
|
assert.equal(saved.phase, "play");
|
|
for (const face of [TWO, THREE, FOUR]) {
|
|
const mercy = hall(1);
|
|
mercy.lives = 1;
|
|
lose(mercy, "zombie");
|
|
ghoul.advance(mercy, ghoul.ROLL_MS + 8, rolls(face));
|
|
assert.equal(events(mercy, "diceHeart").length, 1, "a heart is paid");
|
|
assert.equal(mercy.phase, "crash", "the loss goes ahead");
|
|
ghoul.advance(mercy, ghoul.CRASH_MS + 40, steady);
|
|
assert.notEqual(mercy.phase, "crash", "past the crash");
|
|
assert.equal(mercy.lives, 1, "one heart left");
|
|
assert.equal(mercy.over, false);
|
|
assert.ok(["ready", "play"].includes(mercy.phase), `respawned as usual (${mercy.phase})`);
|
|
assert.equal(mercy.diceGift, 0, "no gift on top");
|
|
}
|
|
// Not on the last heart: a 3 is a gift, a 4 a save, as ever.
|
|
const plenty = hall(1);
|
|
plenty.lives = 2;
|
|
lose(plenty, "zombie");
|
|
ghoul.advance(plenty, ghoul.ROLL_MS + 8, rolls(FOUR));
|
|
assert.equal(plenty.lives, 2);
|
|
assert.equal(events(plenty, "diceHeart").length, 0);
|
|
const lost = hall(1);
|
|
lost.lives = 1;
|
|
lose(lost, "zombie");
|
|
ghoul.advance(lost, ghoul.ROLL_MS + ghoul.CRASH_MS + 40, rolls(ONE));
|
|
assert.equal(lost.lives, 0);
|
|
assert.equal(lost.over, true);
|
|
});
|
|
|
|
test("Ghoul Rush: endless lives never roll the dice", () => {
|
|
const round = hall(3);
|
|
round.infinite = true;
|
|
lose(round, "zombie");
|
|
assert.equal(round.phase, "crash");
|
|
assert.equal(round.dice, 3, "kept");
|
|
assert.equal(round.lives, 3);
|
|
assert.equal(events(round, "diceStart").length, 0);
|
|
});
|
|
|
|
test("Ghoul Rush: the clock running out can be saved too, with some time back", () => {
|
|
const round = hall(1);
|
|
round.timeMs = 5;
|
|
ghoul.advance(round, 8, steady);
|
|
assert.equal(round.phase, "ask", "the clock running out asks too");
|
|
accept(round);
|
|
assert.equal(round.phase, "roll");
|
|
ghoul.advance(round, ghoul.ROLL_MS + 8, rolls(SIX));
|
|
assert.equal(round.phase, "play");
|
|
assert.ok(round.timeMs > ghoul.SAVED_TIME_MS - 100 && round.timeMs <= ghoul.SAVED_TIME_MS);
|
|
assert.equal(round.lives, 4, "and a six's heart");
|
|
});
|
|
|
|
test("Ghoul Rush: a pit fall rolls too, and a save puts Planny back on the last solid ground he stood on, clear of the edge", () => {
|
|
const pitRoom = ghoul.ROOMS.find((r) => ghoul.roomFor(r.id).ground.some((p, i, all) => i + 1 < all.length && p[1] < all[i + 1][0]));
|
|
assert.ok(pitRoom, "some room has a pit");
|
|
const stage = ghoul.STAGES.find((st) => st.rooms.includes(pitRoom.id));
|
|
const round = inRoom(ghoul.newRound(5), stage.id, pitRoom.id);
|
|
round.lives = 3;
|
|
round.dice = 1;
|
|
const g = round.spec.ground;
|
|
const at = g.findIndex((p, i) => i + 1 < g.length && p[1] < g[i + 1][0]);
|
|
const edge = g[at][1] - 0.2;
|
|
const y = g[at][2];
|
|
stand(round, edge);
|
|
round.input.right = true;
|
|
ghoul.advance(round, 4, steady);
|
|
assert.equal(round.you.restX, round.you.x);
|
|
// Off the edge and down.
|
|
Object.assign(round.you, { x: g[at][1] + 2, y: ghoul.PIT_Y - 1, state: "air", vy: -20 });
|
|
round.input.right = false;
|
|
round.you.safeMs = 1e9;
|
|
ghoul.advance(round, 4, steady);
|
|
assert.equal(round.phase, "ask", "a pit asks too");
|
|
accept(round);
|
|
assert.equal(round.phase, "roll");
|
|
assert.equal(events(round, "diceStart")[0].cause, "pit");
|
|
assert.equal(round.lives, 3);
|
|
ghoul.advance(round, ghoul.ROLL_MS + 8, rolls(FOUR));
|
|
assert.equal(round.phase, "play");
|
|
const you = round.you;
|
|
assert.equal(you.y, y);
|
|
assert.equal(you.state, "run");
|
|
assert.ok(you.x < g[at][1] - 1.9, "back from the edge");
|
|
assert.ok(ghoul.groundAt(round.spec, you.x - 2) === y && ghoul.groundAt(round.spec, you.x + 2) === y, "with ground to both sides");
|
|
assert.equal(you.garlic, false, "a 4 gives no shield");
|
|
assert.equal(round.lives, 3);
|
|
// A low roll and the fall costs the life.
|
|
const lost = inRoom(ghoul.newRound(5), stage.id, pitRoom.id);
|
|
lost.dice = 1;
|
|
Object.assign(lost.you, { y: ghoul.PIT_Y - 1, state: "air", vy: -20 });
|
|
lost.lives = 3;
|
|
lost.you.safeMs = 1e9;
|
|
ghoul.advance(lost, 4, steady);
|
|
accept(lost);
|
|
ghoul.advance(lost, ghoul.ROLL_MS + 8, rolls(0.2));
|
|
assert.equal(lost.lives, 2);
|
|
assert.equal(lost.phase, "crash");
|
|
});
|
|
|
|
test("Ghoul Rush: in an ordinary room a saved life blows apart every monster in view, for their points but with nothing dropped, and leaves the ones out of view", () => {
|
|
const round = hall(1);
|
|
round.you.x = 100;
|
|
const near = [zombie(round, 110), zombie(round, 130), zombie(round, round.camX + 5)];
|
|
const far = zombie(round, round.camX + ghoul.FIELD_W + 40);
|
|
const score = round.score;
|
|
lose(round, "zombie");
|
|
ghoul.advance(round, ghoul.ROLL_MS + 8, rolls(SIX));
|
|
assert.equal(round.phase, "play");
|
|
assert.ok(near.every((m) => m.dead), "all in view are dead");
|
|
assert.ok(!far.dead && round.monsters.includes(far), "the one out of view lives");
|
|
assert.deepEqual(round.monsters, [far], "the dead are cleared away");
|
|
assert.equal(events(round, "diceBlast").length, 3);
|
|
assert.equal(events(round, "diceSaved")[0].blasted, 3);
|
|
assert.equal(events(round, "kill").length, 3);
|
|
assert.ok(round.score > score, "their points count");
|
|
assert.equal(round.drops.length, 0, "and they leave nothing");
|
|
assert.equal(round.you.garlic, true, "the shield stays too");
|
|
// Any saving face blows them apart, not only a six.
|
|
const four = hall(1);
|
|
const by = zombie(four, 110);
|
|
lose(four, "zombie");
|
|
ghoul.advance(four, ghoul.ROLL_MS + 8, rolls(FOUR));
|
|
assert.ok(by.dead);
|
|
});
|
|
|
|
test("Ghoul Rush: in a boss's room a saved life blows nothing apart, and the boss is untouched", () => {
|
|
const round = inRoom(ghoul.newRound(5), "wing", "crypt");
|
|
round.you.safeMs = 0;
|
|
round.boss.state = "fight";
|
|
round.boss.t = -1e9;
|
|
const hp = round.boss.hp;
|
|
const m = ghoul.spawnMonster(round, "zombie", round.you.x + 6, ghoul.groundAt(round.spec, round.you.x + 6), { rise: 0, awake: true });
|
|
round.dice = 1;
|
|
round.events.length = 0;
|
|
lose(round, "bones");
|
|
ghoul.advance(round, ghoul.ROLL_MS + 8, rolls(SIX));
|
|
assert.equal(round.phase, "play");
|
|
assert.ok(!m.dead && round.monsters.includes(m), "the monster stands");
|
|
assert.equal(round.boss.hp, hp);
|
|
assert.equal(round.boss.state, "fight");
|
|
assert.equal(events(round, "diceBlast").length, 0);
|
|
assert.equal(events(round, "diceSaved")[0].blasted, 0);
|
|
assert.equal(round.you.garlic, true);
|
|
assert.ok(round.you.safeMs > 0, "the safe moment covers him");
|
|
});
|
|
|
|
test("Ghoul Rush: every step of the roll has a look and a sound, and the revive's jingle plays once", () => {
|
|
const round = hall(3);
|
|
zombie(round, 110);
|
|
lose(round, "zombie");
|
|
ghoul.advance(round, ghoul.ROLL_MS + 8, rolls(SIX));
|
|
const played = [];
|
|
const fx = {};
|
|
const kit = {
|
|
tone: (name) => played.push(name),
|
|
burst() {},
|
|
float() {},
|
|
ring() {},
|
|
banner() {},
|
|
shake() {},
|
|
flash() {},
|
|
glow() {},
|
|
splat() {},
|
|
floorAt: () => 6,
|
|
markFurthest() {},
|
|
roomBanner() {},
|
|
fx,
|
|
monsters: ghoul.MONSTERS,
|
|
powers: ghoul.POWERS,
|
|
bosses: ghoul.BOSSES,
|
|
g: { READY_MS: ghoul.READY_MS, BOSS_INTRO_MS: ghoul.BOSS_INTRO_MS, CLEAR_MS: ghoul.CLEAR_MS },
|
|
};
|
|
for (const e of round.events) react(e, kit);
|
|
assert.equal(played.filter((n) => n === "ghoulLuckySave").length, 1);
|
|
for (const type of ["diceStart", "diceRoll", "diceFace", "diceSaved", "diceBlast", "diceFail", "diceGift"]) {
|
|
const sounds = [];
|
|
const face = type === "diceSaved" ? 5 : 3;
|
|
react({ type, face, x: 10, y: 6, n: 1 }, { ...kit, tone: (n) => sounds.push(n) });
|
|
if (type !== "diceBlast") assert.ok(sounds.length, `${type} has a sound`);
|
|
}
|
|
// A 1 laughs, with the mechanical laugh, and the toll stays out of its way.
|
|
const laugh = [];
|
|
react({ type: "diceFace", face: 1, x: 10, y: 6 }, { ...kit, tone: (n) => laugh.push(n) });
|
|
assert.deepEqual(laugh, ["ghoulDiceLaugh"]);
|
|
const after = [];
|
|
react({ type: "diceFail", face: 1, x: 10, y: 6 }, { ...kit, tone: (n) => after.push(n) });
|
|
assert.deepEqual(after, []);
|
|
assert.ok(toneNames().includes("ghoulDiceLaugh"), "the laugh is a tone");
|
|
assert.ok(fx.lucky && fx.lucky.life > 0, "the word starts to sweep");
|
|
});
|