2026-11-03 20:32:49 -08:00
// Web console tests, Ghoul Rush's ending: four pages that obey the story's rules (2 to 4 short lines, no digits, no em dash, YOU on each, the gag's FINAL NOTICE); the House's last room opens it instead of the win; a press turns pages only after the lockout and finishes the typing first; holding fire skips it, a tap never does; the last page wins the run once, with n = round.winN; the window's keys, a click, a pause, its track and its sounds; every scene draws on a fake canvas at many moments; every event it raises has a react; every tone it names exists.
// Run with: node --test scripts/test-web-console-activities-ghoul-ending.mjs
2026-11-05 20:26:49 -08:00
import "./seed-random.mjs" ;
2026-11-03 20:32:49 -08:00
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 ghoulSfx from "../src/web-console/public/activities/ghoul-rush/sfx/ghoul-sfx.js" ;
import { react } from "../src/web-console/public/activities/ghoul-rush/draw/ghoul-draw.js" ;
import { PAGES as STORY_PAGES } from "../src/web-console/public/activities/ghoul-rush/story/ghoul-story.js" ;
import {
CLICK_OFF_MS ,
ENDING_HINT ,
ENDING_LOCK_MS ,
ENDING_TRACK ,
FLAG_MS ,
LAST_HINT ,
LIGHTS_OUT ,
MAX_LINE ,
PAGES ,
RELOCK_MS ,
SKIP_HINT ,
SKIP_HOLD_MS ,
SLIDE_MS ,
STAMP_MS ,
UNFOLD_MS ,
beginEnding ,
pressEnding ,
releaseEnding ,
revealEnd ,
skipEnding ,
stepEnding ,
takeEnding ,
} from "../src/web-console/public/activities/ghoul-rush/story/ghoul-ending.js" ;
import { SCENE_H , TEXT_SIZE , endingArt , roadFlat , windowLit } from "../src/web-console/public/activities/ghoul-rush/story/ghoul-ending-draw.js" ;
import { compileTrack } from "../src/web-console/public/music.js" ;
import { toneNames } from "../src/web-console/public/tones.js" ;
const steady = () => 0.5 ;
const DASH = String . fromCharCode ( 0x2014 );
const events = ( round , type ) => round . events . filter (( e ) => e . type === type );
const isTone = ( name ) => toneNames (). includes ( name ) || Object . hasOwn ( ghoulSfx . tones , name );
function fakeCtx ( texts ) {
return new Proxy ({}, {
get : ( t , name ) => ( name in t ? t [ name ] : name === "fillText" ? ( s ) => texts . push ( String ( s )) : () => {}),
set : ( t , name , value ) => (( t [ name ] = value ), true ),
});
}
function through ( round ) {
round . phase = "clear" ;
round . phaseMs = 1 ;
ghoul . advance ( round , 4 , steady );
}
// A round walked through the hall and every stage to the House, then through each of the finale's rooms until the ending opens.
function toEnding ( seed = 4 ) {
const round = ghoul . newRound ( seed );
round . dice = 0 ;
through ( round );
round . cleared = ghoul . STAGES . slice ( 0 , ghoul . RUN_STAGES ). map (( st ) => st . id );
round . offer = null ;
through ( round );
assert . equal ( round . stage , ghoul . FINALE . id , "the House" );
for ( let k = 0 ; k < 20 && round . phase !== "ending" ; k ++ ) through ( round );
assert . equal ( round . phase , "ending" , "the House's last room opens the ending" );
return round ;
}
// A window game in the ending, from the stage select's last entry (the House), and its sounds.
function openGame () {
const texts = [];
const sounds = [];
const tracks = [];
const ctx = fakeCtx ( texts );
const g = ghoul . default . create ({ canvas : { width : 0 , height : 0 , getContext : () => ctx }, tone : ( name ) => sounds . push ( name ), music : ( name ) => tracks . push ( name ) });
g . resize ( 900 , 900 );
g . stageSelect ();
for ( let i = 0 ; i < ghoul . SELECTABLE . length ; i ++ ) g . key ( "down" );
g . key ( "action" );
assert . equal ( g . round . stage , ghoul . FINALE . id );
for ( let k = 0 ; k < 20 && g . round . phase !== "ending" ; k ++ ) through ( g . round );
assert . equal ( g . round . phase , "ending" );
g . tick ( 16 );
return { g , texts , sounds , tracks };
}
const tick = ( g , ms ) => {
for ( let t = 0 ; t < ms ; t += 16 ) g . tick ( 16 );
};
const lock = ( g ) => tick ( g , ENDING_LOCK_MS + 20 );
// To the point the page can turn: its typing done and its scene played out.
const playedOut = ( pg ) => Math . max ( revealEnd ( pg ), pg . wait );
const typedOut = ( g ) => tick ( g , playedOut ( PAGES [ g . round . ending . page ]) - g . round . ending . ms + 40 );
test ( "Ghoul Rush ending: four pages, 2 to 4 short lines each that fit the field, no digits, no em dash, never the hero's name, YOU on every page" , () => {
assert . equal ( PAGES . length , 4 );
assert . deepEqual ( PAGES . map (( p ) => p . chapter ), [ "LIGHTS OUT" , "THE ROAD" , "MORNING" , "FINAL NOTICE" ]);
assert . equal ( new Set ( PAGES . map (( p ) => p . id )). size , PAGES . length , "unique ids" );
for ( const p of PAGES ) {
assert . ok ( p . chapter && p . scene && p . pal . sky && p . pal . ground && p . pal . a && p . pal . glow , ` ${ p . id } has a heading, a scene and colors` );
assert . ok ( p . lines . length >= 2 && p . lines . length <= 4 , ` ${ p . id } has 2 to 4 lines` );
const text = [ p . chapter , ... p . lines ]. join ( "\n" );
assert . ok ( ! text . includes ( DASH ), ` ${ p . id } has no em dash` );
assert . ok ( ! /\d/ . test ( text ), ` ${ p . id } has no digit` );
assert . ok ( ! /planny|the player|the hero|\bhero\b/i . test ( text ), ` ${ p . id } never names the hero` );
assert . ok ( /\bYOU\b/ . test ( p . lines . join ( " " )), ` ${ p . id } speaks to YOU` );
for ( const line of p . lines ) {
assert . ok ( line . length <= MAX_LINE , ` ${ p . id } : " ${ line } " is ${ line . length } characters` );
assert . ok ( line . length * TEXT_SIZE * 0.62 <= ghoul . FIELD_W - 1 , ` ${ p . id } : " ${ line } " fits the field` );
}
for ( const [ at , name , vol , rate ] of p . cues ) {
assert . ok ( at >= 0 && at < 9000 && vol > 0 && vol <= 1 && rate > 0 , ` ${ p . id } : a cue is timed and audible` );
assert . ok ( isTone ( name ), ` ${ p . id } : ${ name } is a tone` );
}
assert . ok ( p . cues . every (( c , i ) => i === 0 || c [ 0 ] >= p . cues [ i - 1 ][ 0 ]), ` ${ p . id } : its cues are in order` );
}
const lines = PAGES . flatMap (( p ) => p . lines );
assert . equal ( new Set ( lines ). size , lines . length , "no line used twice" );
const story = new Set ( STORY_PAGES . flatMap (( p ) => p . lines ));
assert . ok ( lines . every (( l ) => ! story . has ( l )), "no line copied from the intro story" );
const all = lines . join ( "\n" );
assert . ok ( all . includes ( "FINAL NOTICE" ) && /unpaid bills/ . test ( all ), "the mailbox gag lands" );
assert . ok ( /unfolds/ . test ( all ) && /cottage/ . test ( all ), "the road and the cottage it was once" );
assert . equal ( ENDING_TRACK , "ghoulMarrowEnding" );
});
test ( "Ghoul Rush ending: the scene timings agree with the cues (a falling tone per window, the click, the flag, the slide, the stamp)" , () => {
const lights = PAGES [ 0 ]. cues . filter (([, n ]) => n === "ghoulEndingWindow" || n === "ghoulEndingLast" );
assert . deepEqual ( lights . map (([ ms ]) => ms ), LIGHTS_OUT . map (([, ms ]) => ms ), "a tone as each window goes out" );
assert . equal ( lights . at ( - 1 )[ 1 ], "ghoulEndingLast" , "the last window has its own tone" );
const rates = lights . slice ( 0 , - 1 ). map (( c ) => c [ 3 ]);
assert . ok ( rates . every (( r , i ) => i === 0 || r < rates [ i - 1 ]), "each window's tone a little lower" );
assert . equal ( new Set ( LIGHTS_OUT . map (([ i ]) => i )). size , 10 , "every one of the house's ten windows goes out" );
assert . ok ( LIGHTS_OUT . at ( - 1 )[ 1 ] - LIGHTS_OUT . at ( - 2 )[ 1 ] >= 1000 , "a long breath before the last" );
for ( const [ i , ms ] of LIGHTS_OUT ) {
assert . equal ( windowLit ( i , ms - 1 ), 1 );
assert . equal ( windowLit ( i , ms + 2000 ), 0 );
}
assert . equal ( roadFlat ( 0 , 0 ), 0 , "the road starts folded" );
assert . equal ( roadFlat ( 0 , 20000 ), 1 , "and ends flat" );
assert . ok ( roadFlat ( 10 , UNFOLD_MS + 600 ) > roadFlat ( 0 , UNFOLD_MS + 600 ), "it unfolds from the far end toward YOU" );
const cue = ( pg , name ) => PAGES [ pg ]. cues . find (([, n ]) => n === name ) ? .[ 0 ];
assert . equal ( cue ( 1 , "ghoulEndingClickOff" ), CLICK_OFF_MS );
assert . equal ( cue ( 1 , "ghoulEndingFold" ), UNFOLD_MS );
assert . equal ( cue ( 3 , "ghoulEndingFlag" ), FLAG_MS );
assert . equal ( cue ( 3 , "ghoulEndingPaper" ), SLIDE_MS );
assert . equal ( cue ( 3 , "ghoulEndingStamp" ), STAMP_MS );
});
test ( "Ghoul Rush ending: the House's end opens it instead of the win, and nothing else moves while it is up" , () => {
const round = toEnding ();
assert . equal ( round . won , false , "not won yet" );
assert . equal ( round . over , false );
assert . equal ( round . winN , ghoul . RUN_STAGES + 1 );
assert . equal ( events ( round , "won" ). length , 0 );
assert . deepEqual ( events ( round , "endingPage" ). map (( e ) => e . page ), [ 0 ]);
assert . equal ( round . ending . page , 0 );
round . input . right = true ;
const x = round . you . x ;
const clock = round . clock ;
ghoul . advance ( round , 2000 , steady );
assert . equal ( round . you . x , x , "YOU stay put" );
assert . equal ( round . clock , clock , "the room's clock holds" );
assert . equal ( round . phase , "ending" );
assert . ok ( round . ending . ms >= 2000 );
assert . equal ( beginEnding ({ ... round , events : [], input : {} }), true , "beginEnding says there is an ending" );
});
test ( "Ghoul Rush ending: a press turns a page only after the lockout, typing finishes first, and the last page wins the run once with n = winN" , () => {
const round = toEnding ();
round . events . length = 0 ;
assert . equal ( takeEnding ( round ), false , "not at once" );
ghoul . advance ( round , ENDING_LOCK_MS - 40 , steady );
assert . equal ( takeEnding ( round ), false , "not before the lockout" );
ghoul . advance ( round , 60 , steady );
assert . ok ( round . ending . ms < revealEnd ( PAGES [ 0 ]));
assert . equal ( takeEnding ( round ), true );
assert . equal ( round . ending . page , 0 , "the first press finishes the typing" );
assert . equal ( round . ending . full , true );
assert . equal ( takeEnding ( round ), false , "a press right on top of it does not count" );
ghoul . advance ( round , RELOCK_MS + 20 , steady );
assert . equal ( takeEnding ( round ), false , "the page waits for its scene to play out (the last window)" );
assert . equal ( round . ending . page , 0 );
ghoul . advance ( round , PAGES [ 0 ]. wait - round . ending . ms + 10 , steady );
assert . ok ( round . ending . ms >= LIGHTS_OUT . at ( - 1 )[ 1 ], "every window is out by then" );
assert . equal ( takeEnding ( round ), true );
assert . equal ( round . ending . page , 1 , "now the page turns" );
assert . equal ( round . ending . ms , 0 );
assert . equal ( takeEnding ( round ), false , "each page has its own lockout" );
for ( let at = 1 ; at < PAGES . length ; at ++ ) {
assert . equal ( round . ending . page , at );
assert . equal ( round . won , false , `not won on page ${ at + 1 } ` );
ghoul . advance ( round , playedOut ( PAGES [ at ]) + 20 , steady );
assert . equal ( takeEnding ( round ), true );
}
assert . deepEqual ( events ( round , "endingPage" ). map (( e ) => e . page ), [ 1 , 2 , 3 ]);
assert . equal ( round . won , true , "the last page's press wins" );
assert . equal ( round . over , true );
assert . equal ( round . ending , null );
assert . notEqual ( round . phase , "ending" );
assert . deepEqual ( events ( round , "won" ), [{ type : "won" , stages : round . cleared . length , n : ghoul . RUN_STAGES + 1 }]);
assert . equal ( takeEnding ( round ), false , "nothing to take after" );
assert . equal ( skipEnding ( round ), false , "nothing to skip after" );
ghoul . advance ( round , 2000 , steady );
assert . equal ( events ( round , "won" ). length , 1 , "the won event fires once" );
});
test ( "Ghoul Rush ending: holding fire for a second skips it all on any page, a tap or a short hold does not, and a skip always works" , () => {
const r = toEnding ();
assert . equal ( pressEnding ( r , true ), false , "a repeat is nothing" );
assert . equal ( r . ending . hold , - 1 );
assert . equal ( pressEnding ( r , false ), true );
assert . equal ( r . ending . hold , 0 , "a fresh press starts the clock" );
stepEnding ( r , SKIP_HOLD_MS - 50 );
assert . equal ( r . phase , "ending" );
releaseEnding ( r );
assert . equal ( r . ending . hold , - 1 , "let go stops the clock" );
stepEnding ( r , 3000 );
assert . equal ( r . phase , "ending" );
pressEnding ( r , false );
stepEnding ( r , SKIP_HOLD_MS + 10 );
assert . equal ( r . won , true , "the hold skipped it all" );
assert . equal ( r . over , true );
assert . equal ( events ( r , "won" ). length , 1 );
// A skip from any page.
for ( let at = 0 ; at < PAGES . length ; at ++ ) {
const s = toEnding ( at + 7 );
s . ending . page = at ;
assert . equal ( skipEnding ( s ), true );
assert . equal ( s . won , true );
assert . equal ( events ( s , "won" )[ 0 ]. n , s . winN );
}
assert . equal ( skipEnding ( ghoul . newRound ( 1 )), false , "no ending, nothing to skip" );
});
test ( "Ghoul Rush ending: the window's keys, any move and fire alike, turn pages; repeats and early presses never do; a click does; a pause holds it" , () => {
for ( const name of [ "left" , "right" , "up" , "down" , "action" ]) {
const { g } = openGame ();
g . key ( name );
assert . equal ( g . round . ending . full , false , ` ${ name } : early press ignored` );
g . release ( name );
lock ( g );
g . key ( name , true );
assert . equal ( g . round . ending . full , false , ` ${ name } : a repeat is ignored` );
g . key ( name );
assert . equal ( g . round . ending . full , true , ` ${ name } : a fresh press finishes the typing first` );
g . release ( name );
typedOut ( g );
g . key ( name );
assert . equal ( g . round . ending . page , 1 , ` ${ name } : the next press turns it` );
g . release ( name );
assert . equal ( g . round . input . fire || g . round . input . left || g . round . input . right || g . round . input . up || g . round . input . down , false , ` ${ name } : nothing is kept held` );
}
const { g } = openGame ();
lock ( g );
g . pointer ( "down" , 10 , 10 );
assert . equal ( g . round . ending . full , true , "a click finishes the typing" );
typedOut ( g );
g . pointer ( "down" , 10 , 10 );
assert . equal ( g . round . ending . page , 1 , "and the next click turns the page" );
g . pause ();
const held = g . round . ending . ms ;
tick ( g , 2000 );
assert . equal ( g . round . ending . ms , held , "a pause holds the page's clock" );
g . key ( "action" );
assert . equal ( g . round . ending . hold , - 1 , "no key counts while paused" );
g . resume ();
tick ( g , 100 );
assert . ok ( g . round . ending . ms > held );
});
test ( "Ghoul Rush ending: through every page on a real clock to the end screen, with its track, its tones, page turns and the escape" , () => {
const { g , texts , sounds , tracks } = openGame ();
tick ( g , 1300 );
assert . ok ( tracks . length && tracks . every (( t ) => t === ENDING_TRACK ), "only the ending's track plays under it" );
assert . ok ( sounds . includes ( "ghoulEndingHush" ) && sounds . includes ( "ghoulEndingWindow" ), "the first page's tones play" );
let guard = 0 ;
while ( g . state === "running" && guard ++ < 20 ) {
typedOut ( g );
tick ( g , RELOCK_MS + 40 );
g . key ( "right" );
g . release ( "right" );
tick ( g , 16 );
}
assert . equal ( g . state , "over" );
assert . equal ( g . round . won , true );
assert . ok ( sounds . includes ( "ghoulStoryPage" ), "a page turn rustles" );
for ( const n of [ "ghoulEndingFold" , "ghoulEndingClickOff" , "ghoulEndingBird" , "ghoulEndingFlag" , "ghoulEndingStamp" ]) assert . ok ( sounds . includes ( n ), ` ${ n } played` );
texts . length = 0 ;
g . resize ( 900 , 900 );
assert . ok ( texts . some (( t ) => t . startsWith ( "You escaped! Marrow starves" )), "the end screen follows" );
// Held fire skips it in the window too.
const { g : h } = openGame ();
for ( let k = 0 ; k < 20 ; k ++ ) h . key ( "action" , true );
tick ( h , 2000 );
assert . equal ( h . round . phase , "ending" , "a held key from before never skips" );
h . key ( "action" );
h . key ( "action" , true );
tick ( h , SKIP_HOLD_MS + 100 );
assert . equal ( h . state , "over" );
assert . equal ( h . round . won , true );
});
test ( "Ghoul Rush ending: every scene draws on a fake canvas at many moments, with its heading, hints and lines, without throwing" , () => {
const { g , texts } = openGame ();
for ( let at = 0 ; at < PAGES . length ; at ++ ) {
for ( const ms of [ 0 , 1 , 120 , 600 , 900 , 1100 , 1500 , 2300 , 2900 , 3100 , 4000 , 4600 , 5200 , 6200 , 6500 , 8000 , 12000 , 40000 ]) {
for ( const full of [ false , true ]) {
for ( const hold of [ - 1 , 500 ]) {
g . round . ending = { page : at , ms , full , arm : 0 , hold , cue : 99 , shown : 0 , back : "clear" };
g . tick ( 1 );
}
}
}
g . round . ending = { page : at , ms : 100 , full : false , arm : 0 , hold : - 1 , cue : 99 , shown : 0 , back : "clear" };
texts . length = 0 ;
g . tick ( 1 );
assert . ok ( texts . includes ( SKIP_HINT . toUpperCase ()), `page ${ at + 1 } shows how to skip` );
assert . equal ( texts . includes ( ENDING_HINT ) || texts . includes ( LAST_HINT ), false , "no continue hint inside the lockout" );
if ( PAGES [ at ]. wait ) {
g . round . ending . ms = PAGES [ at ]. wait - 100 ;
g . round . ending . full = true ;
texts . length = 0 ;
g . tick ( 1 );
assert . equal ( texts . includes ( ENDING_HINT ) || texts . includes ( LAST_HINT ), false , `page ${ at + 1 } : no continue hint while its scene plays out` );
}
g . round . ending . ms = 60000 ;
g . round . ending . full = true ;
texts . length = 0 ;
g . tick ( 1 );
assert . ok ( texts . includes ( PAGES [ at ]. chapter ), `page ${ at + 1 } draws its heading` );
assert . ok ( texts . includes ( at === PAGES . length - 1 ? LAST_HINT : ENDING_HINT ), `page ${ at + 1 } shows the continue hint` );
for ( const line of PAGES [ at ]. lines ) assert . ok ( texts . includes ( line ), `page ${ at + 1 } : " ${ line } " is drawn in full` );
}
assert . ok ( texts . includes ( "FINAL NOTICE" ), "the stamp reads FINAL NOTICE" );
assert . ok ( SCENE_H > 20 && SCENE_H < 40 , "the scene keeps to the top of the field" );
// The art alone, with no ending: draws nothing and does not throw.
const art = endingArt ({ label () {}, GOLD : "#fc0" , BONE : "#eee" });
art . card ( fakeCtx ([]), { round : { ending : null } });
});
test ( "Ghoul Rush ending: every event it raises has a react, its own react answers only its own events, and every tone it owns is a real, prefixed sound" , () => {
const round = toEnding ();
const s = round . ending ;
for ( let at = 0 ; at < PAGES . length ; at ++ ) {
s . page = at ;
s . ms = 0 ;
s . cue = 0 ;
s . full = false ;
stepEnding ( round , 10000 );
s . arm = 0 ;
takeEnding ( round );
}
skipEnding ( round );
const kinds = new Set ( round . events . map (( e ) => e . type ));
for ( const kind of [ "endingPage" , "storyTone" , "won" ]) assert . ok ( kinds . has ( kind ), ` ${ kind } is raised` );
const played = [];
const marks = [];
const fx = { tone : ( n ) => played . push ( n ), burst () {}, float () {}, ring () {}, banner : () => ({}), shake () {}, flash () {}, glow () {}, splat () {}, fx : { clock : 0 , banners : [] }, markFurthest : ( n ) => marks . push ( n ), roomBanner () {}, monsters : {}, powers : {}, bosses : {}, g : ghoul };
for ( const e of round . events ) {
if ( ! [ "endingPage" , "storyTone" , "won" ]. includes ( e . type )) continue ;
react ( e , fx );
}
assert . ok ( played . includes ( "ghoulStoryPage" ), "a page turn plays its rustle" );
assert . ok ( played . includes ( "ghoulEndingWindow" ) && played . includes ( "ghoulEndingGag" ), "the timed tones play through the story's own event" );
assert . deepEqual ( marks , [ ghoul . RUN_STAGES + 1 ], "the win marks the House beaten" );
const art = endingArt ({ label () {}, GOLD : "#fc0" , BONE : "#eee" });
const k = { tone () {} };
assert . equal ( art . react ({ type : "endingPage" , page : 1 }, k ), true );
for ( const type of [ "won" , "storyTone" , "storyPage" , "kill" , "hit" , "room" ]) assert . equal ( art . react ({ type }, k ), false , ` ${ type } is not its own` );
const own = Object . keys ( ghoulSfx . tones ). filter (( n ) => n . startsWith ( "ghoulEnding" ));
assert . ok ( own . length >= 10 , "a handful of the ending's own tones" );
for ( const p of PAGES ) for ( const [, name ] of p . cues ) assert . ok ( isTone ( name ), ` ${ name } exists` );
const track = ghoulSfx . music [ ENDING_TRACK ];
assert . ok ( track , "the ending's track is in the game's music" );
const song = compileTrack ( track );
assert . ok ( song . length >= 64 , "it runs a few bars" );
// The user's pick (eighties horror end credits): a steady middle tempo, never a race.
assert . ok ( track . bpm >= 84 && track . bpm <= 120 , "a middle tempo" );
assert . equal ( track . rush || 0 , 0 , "it never races" );
});