2026-11-02 12:00:13 -08:00
// 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.
2026-11-05 20:26:49 -08:00
import "./seed-random.mjs" ;
2026-11-02 12:00:13 -08:00
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 * 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" ;
2026-11-02 12:00:13 -08:00
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" );
});