2026-11-02 12:00:13 -08:00
// 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 { test } from "node:test" ;
import assert from "node:assert/strict" ;
2026-11-03 15:18:09 -08:00
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" ;
2026-11-02 12:00:13 -08:00
import { toneNames } from "../src/web-console/public/tones.js" ;
const steady = () => 0.5 ;
2026-11-03 15:18:09 -08:00
// 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 ;
};
2026-11-02 12:00:13 -08:00
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 nine, 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" );
for ( let k = 0 ; k < 8 ; k ++ ) ghoul . applyPower ( round , "die" );
2026-11-03 15:18:09 -08:00
assert . equal ( round . dice , 9 );
2026-11-02 12:00:13 -08:00
const score = round . score ;
ghoul . applyPower ( round , "die" );
2026-11-03 15:18:09 -08:00
assert . equal ( round . dice , 10 , "no cap" );
assert . equal ( round . score , score , "no points instead" );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 15:18:09 -08:00
lose ( round , "zombie" );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
assert . equal ( lose ( round , "zombie" ), true );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 04:08:02 -08:00
assert . equal ( events ( round , "diceRoll" ). length , 0 , "the die is still flying in from the HUD" );
2026-11-02 12:00:13 -08:00
assert . equal ( events ( round , "lose" ). length , 0 , "not lost" );
const random = rolls ( SIX );
2026-11-03 04:08:02 -08:00
// 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 );
2026-11-02 12:00:13 -08:00
// Half way through: tumbling, no face yet.
2026-11-03 04:08:02 -08:00
ghoul . advance ( round , ( ghoul . TUMBLE_MS - ghoul . LEAD_MS ) / 2 , random );
2026-11-02 12:00:13 -08:00
assert . equal ( round . phase , "roll" );
assert . equal ( events ( round , "diceFace" ). length , 0 );
// It lands, and holds its beat.
2026-11-03 04:08:02 -08:00
ghoul . advance ( round , ( ghoul . TUMBLE_MS - ghoul . LEAD_MS ) / 2 , random );
2026-11-02 12:00:13 -08:00
assert . deepEqual ( events ( round , "diceFace" ). map (( e ) => e . face ), [ 6 ]);
assert . equal ( round . phase , "roll" );
2026-11-03 04:08:02 -08:00
ghoul . advance ( round , ghoul . ROLL_MS - ghoul . TUMBLE_MS + 8 , random );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 15:18:09 -08:00
lose ( round , "bone" );
2026-11-02 12:00:13 -08:00
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 ]);
});
2026-11-03 15:18:09 -08:00
test ( "Ghoul Rush: a 5 saves him with a heart and no shield, a 4 just saves him, and a heart has no cap" , () => {
2026-11-02 12:00:13 -08:00
const five = hall ( 1 );
2026-11-03 15:18:09 -08:00
lose ( five , "zombie" );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 15:18:09 -08:00
lose ( four , "zombie" );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
lose ( held , "pit" );
2026-11-02 12:00:13 -08:00
ghoul . advance ( held , ghoul . ROLL_MS + 8 , rolls ( FOUR ));
assert . equal ( held . you . garlic , true , "a shield he already held stays" );
const full = hall ( 1 );
full . lives = 9 ;
const score = full . score ;
2026-11-03 15:18:09 -08:00
lose ( full , "zombie" );
2026-11-02 12:00:13 -08:00
ghoul . advance ( full , ghoul . ROLL_MS + 8 , rolls ( FIVE ));
2026-11-03 15:18:09 -08:00
assert . equal ( full . lives , 10 , "no cap" );
assert . equal ( full . score , score , "no points instead" );
2026-11-02 12:00:13 -08:00
});
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 );
2026-11-03 15:18:09 -08:00
lose ( round , "zombie" );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
lose ( round , "zombie" );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 15:18:09 -08:00
lose ( round , "zombie" );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
lose ( saved , "zombie" );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
lose ( mercy , "zombie" );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
lose ( plenty , "zombie" );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
lose ( lost , "zombie" );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
lose ( round , "zombie" );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 15:18:09 -08:00
assert . equal ( round . phase , "ask" , "the clock running out asks too" );
accept ( round );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 15:18:09 -08:00
assert . equal ( round . phase , "ask" , "a pit asks too" );
accept ( round );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 15:18:09 -08:00
accept ( lost );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
lose ( round , "zombie" );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 15:18:09 -08:00
lose ( four , "zombie" );
2026-11-02 12:00:13 -08:00
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 ;
2026-11-03 15:18:09 -08:00
lose ( round , "bones" );
2026-11-02 12:00:13 -08:00
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 );
2026-11-03 15:18:09 -08:00
lose ( round , "zombie" );
2026-11-02 12:00:13 -08:00
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" );
});