2026-11-05 07:57:21 -08:00
// Web console tests, Flock Dash: the round, the leader, the path and the followers, strays joining, the stages and their hazards, snaps, lives, the portal, banners, the memo, power-ups, the combo, the score and the game contract.
// Run with: node --test scripts/test-web-console-activities-flock.mjs
//
// No browser and no server: the game draws only through the canvas it is
// handed, so a stub canvas stands in for the page, as in
// scripts/test-web-console-activities-rapids.mjs, whose helpers this file copies.
2026-11-05 20:26:49 -08:00
import "./seed-random.mjs" ;
2026-11-05 07:57:21 -08:00
import test from "node:test" ;
import assert from "node:assert/strict" ;
import * as flock from "../src/web-console/public/activities/flock.js" ;
import { hudLayout , SKIES , SUCCESS } from "../src/web-console/public/activities/flock-draw.js" ;
import { LIVES , livesText , PILL , PILL_CONTRAST , pillContrast , pillInk } from "../src/web-console/public/activities/pills.js" ;
import { toneNames , humNames } from "../src/web-console/public/tones.js" ;
const { advance , collect , newRound , placeFlock , recordPath , screenX , spawnStrays , steer , BAND_MAX , BAND_MIN , BASE_SPEED , CLIMB , EDGE , FIELD_H , FIELD_W , H , MIN_CELL , PICK_R , SPACING , START_LIVES , STRAY_AHEAD_MAX , STRAY_AHEAD_MIN , STRAY_BEHIND , STRAY_GAP_MAX , STRAY_GAP_MIN , STRAY_POINTS , W } = flock ;
const game = flock . default ;
// A 2D context whose every method is a no-op that counts itself.
function stubCanvas () {
const calls = { count : 0 , stops : 0 };
const gradient = { addColorStop : () => { calls . stops += 1 ; } };
const ctx = new Proxy ({ createLinearGradient : () => gradient }, {
get : ( target , name ) => ( name in target ? target [ name ] : () => { calls . count += 1 ; }),
set : ( target , name , value ) => { target [ name ] = value ; return true ; },
});
return { canvas : { width : 0 , height : 0 , style : {}, getContext : () => ctx }, calls };
}
// A round whose only strays and hazards are the ones a test places: none will
// spawn near.
const clearSky = ( seed = 1 ) => {
const round = newRound ( seed );
round . nextStray = 1e9 ;
round . hazards = [];
round . crates = [];
round . portal . x = Infinity ;
return round ;
};
test ( "newRound starts on stage 1 with three lives, an empty flock and no held input" , () => {
const round = newRound ( 7 );
assert . equal ( round . stage , 1 );
assert . equal ( round . lives , START_LIVES );
assert . equal ( START_LIVES , 3 );
assert . equal ( round . speed , BASE_SPEED );
assert . equal ( round . scroll , 0 );
assert . deepEqual ( round . flock , []);
assert . deepEqual ( round . path , []);
assert . deepEqual ( round . input , { up : false , down : false , left : false , right : false });
assert . equal ( round . infinite , false );
assert . equal ( round . over , false );
});
test ( "a seed always deals the same strays" , () => {
const a = newRound ( 42 );
const b = newRound ( 42 );
advance ( a , 2000 );
advance ( b , 2000 );
assert . deepEqual ( a . strays . map (( s ) => [ s . x , s . y ]), b . strays . map (( s ) => [ s . x , s . y ]));
});
test ( "held up moves the leader up and it stops at the edge; held down the same at the bottom" , () => {
const round = clearSky ();
const start = round . leader . y ;
round . input . up = true ;
advance ( round , 200 );
assert . ok ( round . leader . y < start , "it climbs" );
advance ( round , 5000 );
assert . equal ( round . leader . y , EDGE );
round . input . up = false ;
round . input . down = true ;
advance ( round , 5000 );
assert . equal ( round . leader . y , FIELD_H - EDGE );
});
test ( "left and right stay inside the band, and the world x follows the scroll" , () => {
const round = clearSky ();
round . input . right = true ;
advance ( round , 5000 );
assert . equal ( round . leader . sx , BAND_MAX );
assert . equal ( round . leader . x , round . scroll + BAND_MAX );
round . input . right = false ;
round . input . left = true ;
advance ( round , 5000 );
assert . equal ( round . leader . sx , BAND_MIN );
assert . equal ( screenX ( round , round . leader . x ), BAND_MIN );
});
test ( "steer eases the climb in: a first small slice is short of full speed" , () => {
const round = clearSky ();
round . input . up = true ;
steer ( round , 4 );
assert . ok ( round . leader . vy < 0 && round . leader . vy > - CLIMB , `vy ${ round . leader . vy } ` );
});
test ( "placeFlock puts every follower its spacing behind the leader along a curved path" , () => {
const round = clearSky ();
for ( let k = 1 ; k <= 8 ; k ++ ) round . flock . push ({ id : k });
// Fly a sine path, one that bends both ways.
for ( let ms = 0 ; ms < 6000 ; ms += 4 ) {
round . input . up = Math . sin ( ms / 400 ) > 0 ;
round . input . down = ! round . input . up ;
advance ( round , 4 );
}
const { path , flock : birds } = round ;
const end = path [ path . length - 1 ]. s ;
birds . forEach (( bird , i ) => {
const want = end - ( i + 1 ) * SPACING ;
let best = Infinity ;
let along = 0 ;
for ( let k = 1 ; k < path . length ; k ++ ) {
const [ a , b ] = [ path [ k - 1 ], path [ k ]];
const len = b . s - a . s ;
const t = Math . max ( 0 , Math . min ( 1 , (( bird . x - a . x ) * ( b . x - a . x ) + ( bird . y - a . y ) * ( b . y - a . y )) / ( len * len )));
const d = Math . hypot ( a . x + ( b . x - a . x ) * t - bird . x , a . y + ( b . y - a . y ) * t - bird . y );
if ( d < best ) [ best , along ] = [ d , a . s + len * t ];
}
assert . ok ( best < 1e-6 , `follower ${ i + 1 } sits on the path (off by ${ best } )` );
assert . ok ( Math . abs ( along - want ) < 1e-6 , `follower ${ i + 1 } is ${ ( end - along ). toFixed ( 3 ) } behind, wanted ${ ( end - want ). toFixed ( 3 ) } ` );
});
});
test ( "a follower whose place falls before the path's start sits on the first point" , () => {
const round = clearSky ();
round . flock . push ({ id : 1 });
round . leader . x = round . scroll + round . leader . sx ;
recordPath ( round );
placeFlock ( round );
assert . deepEqual ([ round . flock [ 0 ]. x , round . flock [ 0 ]. y ], [ round . path [ 0 ]. x , round . path [ 0 ]. y ]);
});
test ( "recordPath skips a point too close to the last, and trims what the flock cannot reach" , () => {
const round = clearSky ();
recordPath ( round );
recordPath ( round );
assert . equal ( round . path . length , 1 , "a leader that has not moved adds nothing" );
advance ( round , 30_000 );
const span = round . path [ round . path . length - 1 ]. s - round . path [ 0 ]. s ;
assert . ok ( span <= 2 * SPACING + 4 + 1 , `the path spans ${ span } with no flock` );
});
test ( "a stray inside the pick radius is collected: the flock grows by one and the score by its points" , () => {
const round = clearSky ();
const { leader } = round ;
const near = { id : 900 , x : leader . x + 5 , y : leader . y , bob : 0 };
const far = { id : 901 , x : leader . x + 5 , y : leader . y + PICK_R + 12 , bob : 0 };
round . strays . push ( near , far );
advance ( round , 300 );
assert . deepEqual ( round . flock . map (( b ) => b . id ), [ 900 ]);
assert . equal ( round . score , STRAY_POINTS );
assert . ok ( ! round . strays . includes ( near ));
assert . ok ( round . strays . includes ( far ), "one out of reach stays loose" );
assert . equal ( typeof round . flock [ 0 ]. x , "number" , "the new bird has its place at once" );
});
test ( "collect also takes a bird from the scattered list, and returns the flock's length" , () => {
const round = clearSky ();
const bird = { id : 5 , x : 0 , y : 0 , until : 1 };
round . scattered . push ( bird );
assert . equal ( collect ( round , bird ), 1 );
assert . deepEqual ( round . scattered , []);
});
test ( "spawnStrays places strays ahead of the right edge, inside the edges, at the stage's gap" , () => {
const round = newRound ( 3 );
spawnStrays ( round , round . random );
assert . ok ( round . strays . length > 1 , "more than one comes" );
const right = round . scroll + FIELD_W ;
round . strays . forEach (( s , i ) => {
assert . ok ( s . x >= right + STRAY_AHEAD_MIN && s . x <= right + STRAY_AHEAD_MAX , `x ${ s . x } ` );
assert . ok ( s . y >= EDGE && s . y <= FIELD_H - EDGE , `y ${ s . y } ` );
if ( i ) {
const gap = s . x - round . strays [ i - 1 ]. x ;
assert . ok ( gap >= STRAY_GAP_MIN && gap <= STRAY_GAP_MAX , `gap ${ gap } ` );
}
});
});
test ( "strays left behind are dropped, so a long flight keeps the list short" , () => {
const round = newRound ( 9 );
round . hazards = [];
advance ( round , 60_000 );
assert . ok ( round . strays . length < 16 , ` ${ round . strays . length } strays` );
assert . ok ( round . strays . every (( s ) => s . x - round . scroll >= - STRAY_BEHIND ));
});
test ( "contract: action starts, pause stops the tick moving anything, resume plays on" , () => {
const { canvas } = stubCanvas ();
const g = game . create ({ canvas });
assert . equal ( game . id , "flock" );
assert . equal ( game . title , "Flock Dash" );
assert . equal ( g . state , "ready" );
assert . equal ( g . key ( "up" ), true , "a used name answers true before a round too" );
assert . equal ( g . key ( "action" ), true );
assert . equal ( g . state , "running" );
g . tick ( 100 );
const scroll = g . round . scroll ;
assert . ok ( scroll > 0 );
g . pause ();
assert . equal ( g . state , "paused" );
g . tick ( 1000 );
assert . equal ( g . round . scroll , scroll , "a paused sky holds still" );
g . resume ();
assert . equal ( g . state , "running" );
g . tick ( 100 );
assert . ok ( g . round . scroll > scroll );
});
test ( "contract: held keys act until let go, a pause lets go of them, and an unknown key is not used" , () => {
const { canvas } = stubCanvas ();
const g = game . create ({ canvas });
g . start ();
assert . equal ( g . key ( "up" ), true );
assert . equal ( g . round . input . up , true );
g . release ( "up" );
assert . equal ( g . round . input . up , false );
g . key ( "down" );
g . pause ();
assert . equal ( g . round . input . down , false );
g . resume ();
assert . equal ( g . key ( "jump" ), false );
});
test ( "contract: resize refuses a tiny box and sets the canvas's size" , () => {
const { canvas } = stubCanvas ();
const g = game . create ({ canvas });
assert . equal ( g . resize ( W * MIN_CELL - 1 , H * MIN_CELL ), false );
assert . equal ( g . resize ( W * 8 , H * 8 ), true );
assert . equal ( canvas . style . width , ` ${ W * 8 } px` );
assert . equal ( canvas . style . height , ` ${ H * 8 } px` );
});
test ( "contract: cheat marks the round, and a new round starts without it" , () => {
const { canvas } = stubCanvas ();
const g = game . create ({ canvas });
g . start ();
g . cheat ( true );
assert . equal ( g . round . infinite , true );
g . start ();
assert . equal ( g . round . infinite , false );
});
test ( "drawing: the leader and every follower in the flock are drawn on a frame" , () => {
const drawn = { followers : 0 , leaders : 0 };
const ctx = new Proxy ({}, {
get : ( target , name ) => {
if ( name === "ellipse" ) return ( x , y , rx ) => { if ( rx === 1.4 ) drawn . followers += 1 ; };
if ( name === "rotate" ) return () => { drawn . leaders += 1 ; };
return name in target ? target [ name ] : () => {};
},
set : ( target , name , value ) => { target [ name ] = value ; return true ; },
});
const g = game . create ({ canvas : { width : 0 , height : 0 , style : {}, getContext : () => ctx } });
g . resize ( W * 8 , H * 8 );
g . start ();
g . round . nextStray = 1e9 ;
g . round . strays = [];
g . tick ( 100 );
g . round . flock . push ({ id : 1 }, { id : 2 }, { id : 3 });
g . tick ( 100 );
drawn . followers = 0 ;
drawn . leaders = 0 ;
g . tick ( 16 );
assert . equal ( drawn . leaders , 1 , "the leader" );
assert . equal ( drawn . followers , 3 , "one body for each of three followers" );
});
test ( "the pills read the stage, the lives, the score and the flock, in that order, and the lives pill shows endless lives" , () => {
const hud = { stage : "Stage 1" , score : 120 , flock : 7 , min : 6 };
const pills = hudLayout ( 2.4 , W , 3 , hud , flock . HUD_H );
assert . deepEqual ( pills . map (( p ) => p . text ), [ "Stage 1" , livesText ( 3 ), "Score 120" , "Flock 7 / 6" ]);
assert . equal ( pills [ 1 ]. color , LIVES );
assert . equal ( hudLayout ( 2.4 , W , Infinity , hud , flock . HUD_H )[ 1 ]. text , livesText ( Infinity ));
});
/* ------------------------------------------- hazards, snaps, lives and grace */
// A level flock of `n` birds on a clear sky, the leader at its starting height.
const levelFlock = ( n , seed = 1 ) => {
const round = clearSky ( seed );
// The path is trimmed to the flock's length, so the flock flies it from the start.
for ( let k = 1 ; k <= n ; k ++ ) round . flock . push ({ id : k });
advance ( round , 3000 );
return round ;
};
const balloonAt = ( x , y , r = 1 ) => ({ kind : "balloon" , x , y , w : r * 2 , h : r * 2 , r , vx : 0 , vy : 0 });
test ( "buildStage gives the same list twice for a seed and stage, and another for another seed" , () => {
for ( let n = 1 ; n <= flock . MAX_STAGE ; n ++ ) {
assert . deepEqual ( flock . buildStage ( 5 , n ), flock . buildStage ( 5 , n ), `stage ${ n } ` );
assert . notDeepEqual ( flock . buildStage ( 5 , n ). hazards , flock . buildStage ( 6 , n ). hazards , `stage ${ n } ` );
}
});
test ( "no stage leaves the flock without a clear gap at any distance" , () => {
for ( const seed of [ 1 , 2 , 3 , 42 , 777 ]) {
for ( let n = 1 ; n <= flock . MAX_STAGE ; n ++ ) {
const { hazards , length } = flock . buildStage ( seed , n );
for ( let x = 0 ; x < length ; x += 0.5 ) {
const gap = flock . clearGap ( hazards , x );
assert . ok ( gap >= flock . GAP_MIN , `seed ${ seed } stage ${ n } at ${ x } : a gap of ${ gap } ` );
}
}
}
});
test ( "a stage opens calm, holds a calm stretch at its halfway marker, and ends calm before the portal" , () => {
for ( const seed of [ 1 , 2 , 3 ]) {
for ( let n = 1 ; n <= flock . MAX_STAGE ; n ++ ) {
const { hazards , length } = flock . buildStage ( seed , n );
const mid = length / 2 ;
for ( const h of hazards ) {
const [ from , to ] = flock . spanOf ( h );
assert . ok ( from >= flock . SAFE_START , `stage ${ n } : ${ h . kind } from ${ from } is in the opening` );
assert . ok ( to <= length - flock . SAFE_END , `stage ${ n } : ${ h . kind } to ${ to } is too near the portal` );
assert . ok ( to <= mid || from >= mid + flock . SAFE_START , `stage ${ n } : ${ h . kind } from ${ from } to ${ to } is in the calm stretch` );
}
}
}
});
test ( "every hazard kind first appears at its from stage" , () => {
for ( const seed of [ 1 , 2 , 3 , 42 ]) {
for ( const [ kind , spec ] of Object . entries ( flock . HAZARDS )) {
for ( let n = 1 ; n <= flock . MAX_STAGE ; n ++ ) {
const found = flock . buildStage ( seed , n ). hazards . some (( h ) => h . kind === kind );
if ( n < spec . from ) assert . equal ( found , false , ` ${ kind } before stage ${ spec . from } , in stage ${ n } ` );
if ( n === spec . from ) assert . equal ( found , true , ` ${ kind } missing from stage ${ n } , seed ${ seed } ` );
}
}
}
});
test ( "the stage table rises: faster each stage, with a bigger flock wanted, and stageFor clamps" , () => {
for ( let n = 2 ; n <= flock . MAX_STAGE ; n ++ ) {
assert . ok ( flock . STAGES [ n ]. speed > flock . STAGES [ n - 1 ]. speed , `stage ${ n } speed` );
assert . ok ( flock . STAGES [ n ]. min > flock . STAGES [ n - 1 ]. min , `stage ${ n } min` );
}
assert . equal ( flock . STAGES [ 1 ]. speed , BASE_SPEED );
assert . equal ( flock . stageFor ( 0 ), flock . STAGES [ 1 ]);
assert . equal ( flock . stageFor ( 99 ), flock . STAGES [ flock . MAX_STAGE ]);
});
test ( "a balloon on follower 4 snaps the flock to three birds and scatters the rest" , () => {
const round = levelFlock ( 8 );
const fourth = round . flock [ 3 ];
round . hazards . push ( balloonAt ( fourth . x , fourth . y ));
advance ( round , 4 );
assert . deepEqual ( round . flock . map (( b ) => b . id ), [ 1 , 2 , 3 ]);
assert . deepEqual ( round . scattered . map (( b ) => b . id ), [ 4 , 5 , 6 , 7 , 8 ]);
assert . equal ( round . snaps , 1 );
assert . equal ( round . lives , START_LIVES , "a snap costs no life" );
assert . equal ( round . banner . text , "Line broken!" );
});
test ( "hazard hit shapes: a balloon's circle, a bunch's balloons, a kite's string and diamond" , () => {
const { BIRD_R , hazardHits } = flock ;
const balloon = balloonAt ( 50 , 20 , 3 );
assert . equal ( hazardHits ( balloon , 50 , 23.5 , BIRD_R ), true );
assert . equal ( hazardHits ( balloon , 50 , 25 , BIRD_R ), false );
const bunch = { kind : "cluster" , x : 50 , y : 20 , parts : [{ dx : 2 , dy : 0 , r : 2 }] };
assert . equal ( hazardHits ( bunch , 53 , 20 , BIRD_R ), true );
assert . equal ( hazardHits ( bunch , 47 , 20 , BIRD_R ), false );
const kite = { kind : "kite" , x : 50 , y : 30 , tipX : 50 , top : true };
assert . equal ( hazardHits ( kite , 50 , 10 , BIRD_R ), true , "the string, from the top edge" );
assert . equal ( hazardHits ( kite , 50 , 30 , BIRD_R ), true , "the diamond" );
assert . equal ( hazardHits ( kite , 50 , 40 , BIRD_R ), false , "below the kite" );
});
test ( "a balloon drifts and bounces off the edges" , () => {
const round = clearSky ();
const balloon = { ... balloonAt ( round . scroll + 40 , 3 , 2 ), vy : - 6 };
round . hazards . push ( balloon );
flock . moveHazards ( round , 1 );
assert . equal ( balloon . y , 2 , "stopped at the edge" );
assert . equal ( balloon . vy , 6 , "and heading back" );
});
test ( "a thunderhead warns, then strikes down the warned column, and only the strike hits" , () => {
const round = clearSky ();
const storm = flock . buildStage ( 1 , 5 ). hazards . find (( h ) => h . kind === "storm" );
const cloud = { ... storm , x : round . scroll + 50 , timer : 100 , phase : "idle" };
round . hazards . push ( cloud );
flock . moveHazards ( round , 0.2 );
assert . equal ( cloud . phase , "warn" );
const y = cloud . top ? cloud . y + 5 : cloud . y - 5 ;
assert . equal ( flock . hazardHits ( cloud , cloud . col , y , flock . BIRD_R ), false , "a warning never hits" );
flock . moveHazards ( round , flock . STORM_WARN_MS / 1000 );
assert . equal ( cloud . phase , "strike" );
assert . equal ( flock . hazardHits ( cloud , cloud . col , y , flock . BIRD_R ), true );
const far = cloud . top ? cloud . y + flock . STORM_REACH + 5 : cloud . y - flock . STORM_REACH - 5 ;
assert . equal ( flock . hazardHits ( cloud , cloud . col , far , flock . BIRD_R ), false , "the far part of the field stays clear" );
flock . moveHazards ( round , flock . STORM_STRIKE_MS / 1000 );
assert . equal ( cloud . phase , "idle" );
});
test ( "a thunderhead's column holds still on the board through its warning, so what flashes is where the bolt lands" , () => {
const round = clearSky ();
const storm = flock . buildStage ( 1 , 5 ). hazards . find (( h ) => h . kind === "storm" );
const cloud = { ... storm , x : round . scroll + 40 , col : 0 , timer : 8 , phase : "idle" };
round . hazards . push ( cloud );
advance ( round , 16 );
assert . equal ( cloud . phase , "warn" );
const warned = cloud . col - round . scroll ;
advance ( round , flock . STORM_WARN_MS );
assert . equal ( cloud . phase , "strike" );
assert . ok ( Math . abs ( cloud . col - round . scroll - warned ) < 0.5 , `the column moved from ${ warned } to ${ cloud . col - round . scroll } ` );
});
test ( "flown for real, every stage with thunderheads sends lightning through the leader's band" , () => {
for ( let n = flock . HAZARDS . storm . from ; n <= flock . MAX_STAGE ; n ++ ) {
const round = clearSky ( 7 );
round . stage = n ;
round . speed = flock . STAGES [ n ]. speed ;
round . leader . grace = 1e9 ;
round . hazards = flock . buildStage ( 7 , n ). hazards . filter (( h ) => h . kind === "storm" );
assert . ok ( round . hazards . length > 0 , `stage ${ n } has clouds` );
let strikes = 0 ;
for ( let t = 0 ; t < 40_000 ; t += 16 ) {
advance ( round , 16 );
const inBand = ( h ) => h . phase === "strike" && h . col - round . scroll >= BAND_MIN && h . col - round . scroll <= BAND_MAX ;
if ( round . hazards . some ( inBand )) strikes += 1 ;
}
assert . ok ( strikes > 0 , `stage ${ n } : no strike reached the band` );
}
});
test ( "a thunderhead's strike can take a life, and leaves height to dodge it" , () => {
const round = clearSky ();
const storm = flock . buildStage ( 1 , 5 ). hazards . find (( h ) => h . kind === "storm" );
const cloud = { ... storm , x : round . leader . x , col : round . leader . x , phase : "strike" , timer : 1000 };
const [ lo , hi ] = flock . strikeBand ( cloud );
round . leader . y = ( lo + hi ) / 2 ;
round . hazards . push ( cloud );
advance ( round , 16 );
assert . equal ( round . lives , START_LIVES - 1 );
assert . ok ( lo > EDGE + flock . GAP_MIN || hi < FIELD_H - EDGE - flock . GAP_MIN , "a clear height is left" );
});
test ( "a scattered bird can be gathered before SCATTER_MS and is gone after" , () => {
const round = levelFlock ( 2 );
flock . snapAt ( round , 1 );
assert . equal ( round . flock . length , 0 );
const [ caught , late ] = round . scattered ;
assert . equal ( late . until , round . now + flock . SCATTER_MS );
caught . x = round . leader . x ;
caught . y = round . leader . y ;
advance ( round , 4 );
assert . deepEqual ( round . flock . map (( b ) => b . id ), [ caught . id ], "gathered while there is time" );
advance ( round , flock . SCATTER_MS );
late . x = round . leader . x ;
late . y = round . leader . y ;
advance ( round , 4 );
assert . equal ( round . flock . length , 1 , "too late to gather" );
advance ( round , 3000 );
assert . deepEqual ( round . scattered , [], "flown off and dropped" );
});
test ( "scattered birds keep up with the sky, slipping back slowly enough to be reached" , () => {
const round = levelFlock ( 3 );
flock . snapAt ( round , 1 );
const bird = round . scattered [ 0 ];
const before = bird . x - round . scroll ;
advance ( round , 1000 );
const slip = before - ( bird . x - round . scroll );
assert . ok ( slip > 0 && slip < flock . NUDGE , `it slipped back ${ slip } units in a second` );
});
test ( "a gust warns, then shoves the leader and snaps the flock, and never costs a life" , () => {
const round = levelFlock ( 4 );
const { leader } = round ;
leader . sx = 30 ;
round . hazards . push ({ kind : "gust" , x : round . scroll + FIELD_W , y : leader . y , w : flock . GUST_W , h : 8 , vx : 0 , vy : 0 , live : false });
const gust = round . hazards [ 0 ];
advance ( round , flock . GUST_WARN_MS - 20 );
assert . equal ( gust . live , false , "still a warning" );
assert . equal ( gust . x , round . scroll + FIELD_W , "the warning sits at the right edge" );
assert . equal ( leader . sx , 30 );
assert . equal ( round . flock . length , 4 );
advance ( round , 2500 );
assert . equal ( gust . live , true );
assert . ok ( leader . sx < 30 , `shoved back to ${ leader . sx } ` );
assert . equal ( round . flock . length , 0 , "the live band snapped the line" );
assert . equal ( round . lives , START_LIVES , "no life lost" );
assert . equal ( leader . alive , true );
});
test ( "a whole flock inside a slipstream never snaps, and the leader in it speeds the sky" , () => {
const round = levelFlock ( 6 );
const { leader } = round ;
round . hazards . push ({ kind : "stream" , x : round . scroll - 50 , y : leader . y , w : 2000 , h : 12 , vx : 0 , vy : 0 });
const from = round . scroll ;
advance ( round , 2000 );
assert . ok ( Math . abs ( round . scroll - from - 2 * ( round . speed + flock . STREAM_BOOST )) < 0.01 , "the boost" );
assert . equal ( round . flock . length , 6 );
assert . equal ( round . snaps , 0 );
});
test ( "a whole flock outside a slipstream never snaps, nor does a line flying through one" , () => {
const round = levelFlock ( 6 );
const { leader } = round ;
round . hazards . push ({ kind : "stream" , x : round . scroll , y : leader . y + 15 , w : 2000 , h : 8 , vx : 0 , vy : 0 });
advance ( round , 1000 );
assert . equal ( round . snaps , 0 , "all outside" );
assert . ok ( Math . abs ( round . scroll - round . speed - 3000 / 1000 * round . speed ) < 0.01 , "no boost outside it" );
round . hazards = [{ kind : "stream" , x : leader . x + 10 , y : leader . y , w : 40 , h : 8 , vx : 0 , vy : 0 }];
advance ( round , 4000 );
assert . equal ( round . snaps , 0 , "flowing in and out in a smooth line" );
assert . equal ( round . flock . length , 6 );
});
test ( "a line straddling a slipstream's end never snaps, even holding still across it" , () => {
const round = levelFlock ( 6 );
round . speed = 0 ;
const { flock : birds , leader } = round ;
// The lane ends between followers 3 and 4.
const edge = ( birds [ 2 ]. x + birds [ 3 ]. x ) / 2 ;
round . hazards . push ({ kind : "stream" , x : edge - 100 , y : leader . y , w : 100 , h : 8 , vx : 0 , vy : 0 });
advance ( round , 1000 );
assert . equal ( round . flock . length , 6 );
assert . equal ( round . snaps , 0 );
});
test ( "a line slipping out over a slipstream's long edge snaps there at once" , () => {
const round = levelFlock ( 8 );
const { leader } = round ;
round . hazards . push ({ kind : "stream" , x : round . scroll - 60 , y : leader . y , w : 400 , h : 8 , vx : 0 , vy : 0 });
advance ( round , 500 );
assert . equal ( round . snaps , 0 , "riding inside" );
round . input . up = true ;
for ( let t = 0 ; t < 1000 && ! round . snaps ; t += 4 ) advance ( round , 4 );
assert . equal ( round . snaps , 1 , "climbing out the side" );
assert . ok ( round . scattered . length > 0 );
assert . ok ( round . flock . length < 8 );
assert . ok ( Math . abs ( round . leader . y - round . hazards [ 0 ]. y ) > round . hazards [ 0 ]. h / 2 , "the leader is outside the lane" );
});
test ( "a line diving into a slipstream's side snaps too, and a leader flying alone never does" , () => {
const round = levelFlock ( 8 );
const { leader } = round ;
round . hazards . push ({ kind : "stream" , x : round . scroll - 60 , y : leader . y + 8 , w : 400 , h : 8 , vx : 0 , vy : 0 });
round . input . down = true ;
for ( let t = 0 ; t < 1000 && ! round . snaps ; t += 4 ) advance ( round , 4 );
assert . equal ( round . snaps , 1 );
const alone = clearSky ();
alone . hazards . push ({ kind : "stream" , x : alone . scroll - 60 , y : alone . leader . y + 8 , w : 400 , h : 8 , vx : 0 , vy : 0 });
alone . input . down = true ;
advance ( alone , 1000 );
assert . equal ( alone . snaps , 0 );
});
test ( "hitLeader takes one life and the flock, stops the flight, then gives grace" , () => {
const round = levelFlock ( 4 );
const { leader } = round ;
assert . equal ( flock . hitLeader ( round ), true );
assert . equal ( round . lives , START_LIVES - 1 );
assert . equal ( round . lost , 1 );
assert . equal ( round . flock . length , 0 );
assert . equal ( round . scattered . length , 4 );
assert . equal ( leader . alive , false );
assert . equal ( flock . hitLeader ( round ), false , "no second hit during the crash" );
assert . equal ( round . lives , START_LIVES - 1 );
const stopped = round . scroll ;
advance ( round , flock . CRASH_MS - 20 );
assert . equal ( round . scroll , stopped , "the sky waits" );
advance ( round , 40 );
assert . equal ( leader . alive , true );
assert . equal ( leader . grace > 0 , true );
assert . equal ( flock . hitLeader ( round ), false , "nothing hits during grace" );
assert . equal ( round . lives , START_LIVES - 1 );
advance ( round , flock . GRACE_MS );
assert . equal ( leader . grace , 0 );
assert . equal ( flock . hitLeader ( round ), true , "grace runs out" );
});
test ( "birds lost in a crash are gone once the stretch restarts, even when the restart is close by" , () => {
const round = levelFlock ( 16 );
flock . hitLeader ( round );
assert . equal ( round . scattered . length , 16 );
advance ( round , flock . CRASH_MS );
assert . equal ( round . leader . alive , true );
assert . deepEqual ( round . scattered , []);
advance ( round , 500 );
assert . equal ( round . flock . length , 0 );
});
test ( "while endless, a hit takes no life, and at zero lives the round ends" , () => {
const endless = clearSky ();
endless . infinite = true ;
flock . hitLeader ( endless );
assert . equal ( endless . lives , START_LIVES );
assert . equal ( endless . over , false );
const round = clearSky ();
round . lives = 1 ;
flock . hitLeader ( round );
assert . equal ( round . lives , 0 );
assert . equal ( round . over , true );
assert . equal ( advance ( round , 100 ), "over" );
});
test ( "a hazard on the leader costs a life through the running game" , () => {
const round = clearSky ();
advance ( round , 200 );
round . hazards . push ( balloonAt ( round . leader . x + 1 , round . leader . y , 2 ));
advance ( round , 20 );
assert . equal ( round . lives , START_LIVES - 1 );
});
test ( "a replay restarts at the last calm point passed and meets the same layout" , () => {
const round = newRound ( 11 );
round . nextStray = 1e9 ;
const first = round . hazards . map (( h ) => [ h . kind , h . x , h . y ]);
round . scroll = 100 ;
flock . hitLeader ( round );
advance ( round , flock . CRASH_MS );
assert . ok ( round . scroll < 1 , `before halfway it goes back to the start, at ${ round . scroll } ` );
assert . deepEqual ( round . hazards . map (( h ) => [ h . kind , h . x , h . y ]), first , "the same sky again" );
const mid = round . length / 2 ;
round . scroll = mid + 50 ;
round . leader . grace = 0 ;
flock . hitLeader ( round );
advance ( round , flock . CRASH_MS );
assert . ok ( Math . abs ( round . scroll - mid ) < 1 , `past halfway it goes back to the marker, at ${ round . scroll } ` );
assert . ok ( round . hazards . every (( h ) => h . x > mid ), "nothing from before the marker" );
assert . ok ( round . hazards . length > 0 );
assert . deepEqual ( round . path , [], "a fresh path" );
});
/* -------------------------------------------- the portal, banners, the memo */
// A flock of `n` a moment short of the portal, inside its ring.
const atPortal = ( n ) => {
const round = levelFlock ( n );
round . portal . x = round . leader . x + 1 ;
round . portal . y = round . leader . y ;
round . score = 0 ;
// A snap on the record, so only the portal's own pay shows; the flawless tests clear it.
round . snaps = 1 ;
return round ;
};
// The same, on the last stage: the small ring, swaying.
const atFinalPortal = ( n ) => {
const round = atPortal ( n );
round . stage = flock . MAX_STAGE ;
round . portal . h = flock . PORTAL_H_FINAL ;
round . portal . min = 3 ;
return round ;
};
test ( "the portal with the minimum forms a V and pays flock x stage x V_POINTS, then the next stage begins" , () => {
const round = atPortal ( 6 );
round . portal . min = 6 ;
advance ( round , 200 );
assert . ok ( round . portal . passed );
assert . ok ( round . portal . v , "the V is playing" );
assert . equal ( round . score , 6 * 1 * flock . V_POINTS );
assert . match ( round . banner . text , /^V formation! \+120/ );
const drifting = { ... balloonAt ( round . leader . x + 30 , 8 , 1 ), vy : 5 };
round . hazards = [ balloonAt ( round . leader . x + 2 , round . leader . y , 1 ), drifting ];
advance ( round , 600 );
assert . equal ( drifting . y , 8 , "hazards hold still for a V" );
assert . equal ( round . lives , START_LIVES , "and hit nothing" );
const [ a , b ] = round . flock ;
const slots = [ - 1 , 1 ]. map (( side ) => [ round . leader . x - flock . V_GAP , round . leader . y + side * flock . V_GAP * 0.55 ]);
assert . ok ( Math . hypot ( a . x - slots [ 0 ][ 0 ], a . y - slots [ 0 ][ 1 ]) < 0.01 , "the first bird in its slot" );
assert . ok ( Math . hypot ( b . x - slots [ 1 ][ 0 ], b . y - slots [ 1 ][ 1 ]) < 0.01 , "the second on the other arm" );
advance ( round , flock . V_MS );
assert . equal ( round . stage , 2 );
assert . equal ( round . flock . length , 6 , "the flock is kept" );
assert . equal ( round . speed , flock . STAGES [ 2 ]. speed );
assert . equal ( round . portal . passed , false );
assert . equal ( round . portal . min , flock . STAGES [ 2 ]. min );
assert . equal ( round . banner . text , "Stage 2: Head-winds" );
});
test ( "the portal without the minimum pays nothing and still moves to the next stage, showing why, then the stage" , () => {
const round = atPortal ( 2 );
round . portal . min = 6 ;
round . snaps = 3 ;
advance ( round , 200 );
assert . equal ( round . stage , 2 );
assert . equal ( round . score , 0 );
assert . equal ( round . flock . length , 2 );
assert . equal ( round . snaps , 0 , "the stage's counts start again" );
assert . equal ( round . banner . text , "Need 6 birds for the V" );
advance ( round , 1200 );
assert . equal ( round . banner . text , "Stage 2: Head-winds" );
});
test ( "before the last stage, flying around the ring moves on with no V" , () => {
const round = atPortal ( 8 );
round . portal . min = 6 ;
round . portal . y = FIELD_H / 2 ;
round . portal . h = 4 ;
round . leader . y = EDGE ;
advance ( round , 200 );
assert . equal ( round . stage , 2 );
assert . equal ( round . score , 0 );
assert . equal ( round . lives , START_LIVES );
});
test ( "missing the final portal costs a life and replays the stretch, even during grace, and never while endless" , () => {
const round = atFinalPortal ( 2 );
round . leader . y = EDGE ;
round . leader . grace = 5000 ;
advance ( round , 200 );
assert . equal ( round . lives , START_LIVES - 1 );
assert . equal ( round . won , false );
assert . equal ( round . portal . passed , false );
assert . equal ( round . banner . text , "Missed the portal!" );
advance ( round , flock . CRASH_MS + 20 );
assert . equal ( round . leader . alive , true );
assert . ok ( round . scroll < 10 , `back to the start of the stretch, at ${ round . scroll } ` );
const endless = atFinalPortal ( 0 );
endless . infinite = true ;
endless . leader . y = EDGE ;
advance ( endless , 200 );
assert . equal ( endless . lives , START_LIVES );
assert . equal ( endless . won , false );
});
test ( "the last portal sways on a sine and the others hold still" , () => {
const round = atFinalPortal ( 0 );
round . portal . x = Infinity ;
const seen = [];
for ( let k = 0 ; k < 12 ; k ++ ) {
advance ( round , flock . FINAL_PERIOD_MS / 12 );
seen . push ( round . portal . y );
}
const reach = Math . max (... seen ) - Math . min (... seen );
assert . ok ( Math . abs ( reach - flock . FINAL_SWAY * 2 ) < 1 , `it sways ${ reach } ` );
const still = clearSky ();
const { y } = still . portal ;
advance ( still , 1000 );
assert . equal ( still . portal . y , y );
});
test ( "passing the final portal wins: at once with a short flock, after the V with the minimum" , () => {
const short = atFinalPortal ( 1 );
short . portal . y = FIELD_H / 2 ;
short . leader . y = FIELD_H / 2 ;
advance ( short , 100 );
assert . equal ( short . won , true );
assert . equal ( short . over , true );
assert . equal ( short . score , 0 );
assert . equal ( short . banner . text , "You made it!" );
const full = atFinalPortal ( 3 );
full . portal . y = FIELD_H / 2 ;
full . leader . y = FIELD_H / 2 ;
advance ( full , 200 );
assert . equal ( full . won , false , "the V plays first" );
assert . equal ( full . score , 3 * flock . MAX_STAGE * flock . V_POINTS );
advance ( full , flock . V_MS );
assert . equal ( full . won , true );
assert . equal ( full . over , true );
assert . equal ( full . stage , flock . MAX_STAGE , "no ninth stage" );
});
test ( "a banner is placed away from the leader, and underBanner sees what is in its strip" , () => {
const round = clearSky ();
const { bannerRow , underBanner , banner , BANNER_HALF } = flock ;
round . leader . y = 10 ;
const low = bannerRow ( round );
assert . ok ( low > FIELD_H / 2 , "the leader high, the banner low" );
round . leader . y = 44 ;
const high = bannerRow ( round );
assert . ok ( high < FIELD_H / 2 , "the leader low, the banner high" );
round . leader . y = FIELD_H - EDGE ;
const shown = banner ( round , "Hello" , "" , "#fff" );
shown . row = high ;
assert . equal ( underBanner ( round , shown ), false , "clear" );
round . leader . y = high + BANNER_HALF - 1 ;
assert . equal ( underBanner ( round , shown ), true , "the leader in the strip" );
round . leader . y = FIELD_H - EDGE ;
round . flock . push ({ id : 1 , x : round . scroll + 5 , y : high });
assert . equal ( underBanner ( round , shown ), true , "a follower in the strip" );
round . flock [ 0 ]. x = round . scroll - 5 ;
assert . equal ( underBanner ( round , shown ), false , "not a follower off the board" );
round . flock . length = 0 ;
round . hazards . push ( balloonAt ( round . scroll + 40 , high ));
assert . equal ( underBanner ( round , shown ), true , "a hazard in the strip" );
round . hazards [ 0 ]. x = round . scroll + FIELD_W + 30 ;
assert . equal ( underBanner ( round , shown ), false , "not one still off the board" );
round . hazards = [{ kind : "gust" , x : round . scroll + FIELD_W , y : high , w : flock . GUST_W , h : 8 , warnAt : 0 , liveAt : 1000 , vx : 0 , vy : 0 , live : false }];
assert . equal ( underBanner ( round , shown ), true , "a gust's warning in the strip" );
});
test ( "a banner fades while something is under it, comes back when clear, and ends in time" , () => {
const round = clearSky ();
round . leader . y = 10 ;
const shown = flock . banner ( round , "Hello" , "" , "#fff" , 4000 );
advance ( round , 16 );
assert . ok ( shown . row > FIELD_H / 2 , "placed on its first frame" );
const { row } = shown ;
round . input . down = true ;
advance ( round , 1200 );
round . input . down = false ;
assert . equal ( shown . row , row , "kept where it was placed" );
round . leader . y = row ;
for ( let k = 0 ; k < 20 ; k ++ ) advance ( round , 16 );
assert . ok ( shown . see < 0.2 , `see ${ shown . see } ` );
round . leader . y = 3 ;
for ( let k = 0 ; k < 40 ; k ++ ) advance ( round , 16 );
assert . ok ( shown . see > 0.9 , `see ${ shown . see } ` );
advance ( round , 4000 );
assert . equal ( round . banner , null );
});
test ( "contract: a round opens on its stage banner, and the pill reads the stage's title" , () => {
const { canvas } = stubCanvas ();
const g = game . create ({ canvas });
g . start ();
assert . equal ( g . round . banner . text , "Stage 1: Golden Hour" );
g . tick ( 16 );
assert . ok ( g . round . banner . row !== null );
});
test ( "drawing: a banner's text is drawn at its see-through alpha" , () => {
const seen = [];
const target = {
fillText ( text ) {
seen . push ([ text , target . globalAlpha ]);
},
};
const ctx = new Proxy ( target , {
get : ( t , name ) => ( name in t ? t [ name ] : () => {}),
set : ( t , name , value ) => {
t [ name ] = value ;
return true ;
},
});
const g = game . create ({ canvas : { width : 0 , height : 0 , style : {}, getContext : () => ctx } });
g . resize ( W * 8 , H * 8 );
g . start ();
g . tick ( 16 );
const { text } = g . round . banner ;
g . round . banner . see = flock . BANNER_SEE_THROUGH ;
seen . length = 0 ;
g . pause ();
const alpha = seen . find (([ t ]) => t === text );
assert . ok ( alpha , "the banner was drawn" );
assert . equal ( alpha [ 1 ], flock . BANNER_SEE_THROUGH );
});
test ( "contract: the memo keeps the furthest stage, on each new stage and at the end, and never goes back" , () => {
const { canvas } = stubCanvas ();
let saved = 0 ;
const memo = { get : () => saved , set : ( n ) => ( saved = n ) };
const g = game . create ({ canvas , memo });
g . start ();
g . tick ( 16 );
assert . equal ( saved , 0 , "starting writes nothing" );
g . round . portal . x = g . round . leader . x ;
g . tick ( 16 );
assert . equal ( g . round . stage , 2 );
assert . equal ( saved , 2 );
g . round . portal . x = g . round . leader . x ;
g . tick ( 16 );
assert . equal ( saved , 3 );
g . start ();
g . round . lives = 1 ;
flock . hitLeader ( g . round );
g . tick ( 16 );
assert . equal ( g . state , "over" );
assert . equal ( saved , 3 , "a shorter run keeps the furthest" );
saved = 0 ;
g . start ();
g . round . lives = 1 ;
flock . hitLeader ( g . round );
g . tick ( 16 );
assert . equal ( saved , 1 , "the end of a round saves it" );
});
test ( "contract: running out of lives ends the round, and action starts a fresh one" , () => {
const { canvas } = stubCanvas ();
const g = game . create ({ canvas });
g . start ();
g . round . lives = 1 ;
flock . hitLeader ( g . round );
g . tick ( 16 );
assert . equal ( g . state , "over" );
g . key ( "action" );
assert . equal ( g . state , "running" );
assert . equal ( g . round . lives , START_LIVES );
});
test ( "drawing: a frame with every hazard in every phase, the portal, loose birds and a banner draws without trouble" , () => {
const { canvas , calls } = stubCanvas ();
const g = game . create ({ canvas });
g . resize ( W * 8 , H * 8 );
g . start ();
const { round } = g ;
round . nextStray = 1e9 ;
const dealt = flock . buildStage ( 3 , flock . MAX_STAGE ). hazards ;
const kinds = Object . keys ( flock . HAZARDS );
round . hazards = kinds . map (( kind , i ) => ({ ... dealt . find (( h ) => h . kind === kind ), x : round . scroll + 40 + i * 6 }));
for ( const h of round . hazards ) {
if ( h . kind === "kite" ) h . tipX = h . x ;
if ( h . kind === "storm" ) Object . assign ( h , { phase : "warn" , col : h . x , timer : 9999 });
if ( h . kind === "gust" ) Object . assign ( h , { warnAt : 0 , liveAt : 1e9 });
}
round . portal . x = round . scroll + 80 ;
round . flock . push ({ id : 1 }, { id : 2 });
g . tick ( 16 );
flock . snapAt ( round , 2 );
const before = calls . count ;
g . tick ( 16 );
assert . ok ( calls . count > before );
const gust = round . hazards . find (( h ) => h . kind === "gust" );
Object . assign ( gust , { live : true , liveAt : 0 });
Object . assign ( round . hazards . find (( h ) => h . kind === "storm" ), { phase : "strike" });
round . infinite = true ;
g . tick ( 16 );
assert . equal ( g . state , "running" );
});
test ( "a bot on the clearest line through stage 1 at full speed loses no life" , () => {
const round = newRound ( 1 );
assert . deepEqual ( round . hazards . map (( h ) => h . x ), flock . buildStage ( 1 , 1 ). hazards . map (( h ) => h . x ), "the stage the plan names" );
const clearance = ( y ) => {
const { leader } = round ;
let least = Infinity ;
for ( const h of round . hazards ) {
if ( h . x < leader . x - 6 || h . x > leader . x + 30 ) continue ;
least = Math . min ( least , Math . abs ( y - h . y ) - h . r );
}
return least ;
};
let ms = 0 ;
const SAFE = 5 ;
while ( round . stage === 1 && ! round . over && ms < 120_000 ) {
const { leader } = round ;
let best = leader . y ;
// Holds its height until something comes near it, then takes the nearest
// height clear enough, which never means crossing what it is avoiding.
if ( clearance ( leader . y ) < SAFE ) {
let nearest = Infinity ;
for ( let y = EDGE ; y <= FIELD_H - EDGE ; y += 1 ) {
if ( clearance ( y ) >= SAFE && Math . abs ( y - leader . y ) < nearest ) {
nearest = Math . abs ( y - leader . y );
best = y ;
}
}
}
round . input . up = best < leader . y - 0.5 ;
round . input . down = best > leader . y + 0.5 ;
advance ( round , 16 );
ms += 16 ;
}
assert . equal ( round . lives , START_LIVES , `lives left after ${ ms } ms` );
assert . equal ( round . lost , 0 , "none lost on the way (the counts reset only at the portal)" );
assert . equal ( round . stage , 2 , "and through the portal" );
});
/* ------------------------------------------------------------- the power-ups */
const liveGust = ( round , y ) => ({ kind : "gust" , x : round . scroll - 40 , y , w : 120 , h : 12 , vx : 0 , vy : 0 , live : true , warnAt : 0 , liveAt : 0 });
test ( "the power table: three kinds, each with a color, and the timed ones with their time" , () => {
assert . deepEqual ( flock . POWER_KINDS , [ "tailwind" , "shield" , "magnet" ]);
for ( const kind of flock . POWER_KINDS ) assert . match ( flock . POWERS [ kind ]. color , /^#[0-9a-f]{6}$/ );
assert . equal ( flock . POWERS . tailwind . ms , 6000 );
assert . equal ( flock . POWERS . magnet . ms , 8000 );
assert . equal ( flock . POWERS . shield . ms , undefined );
assert . ok ( Object . isFrozen ( flock . POWERS . shield ));
});
test ( "a tailwind speeds the scroll and carries the line and the leader through a gust" , () => {
const plain = clearSky ();
advance ( plain , 1000 );
const round = levelFlock ( 4 );
const { leader } = round ;
leader . sx = 30 ;
const from = round . scroll ;
flock . applyPower ( round , "tailwind" );
round . hazards . push ( liveGust ( round , leader . y ));
advance ( round , 1000 );
assert . ok ( Math . abs ( round . scroll - from - BASE_SPEED * ( 1 + flock . TAILWIND_BOOST )) < 0.1 , "half as fast again" );
assert . ok ( Math . abs ( plain . scroll - BASE_SPEED ) < 0.1 );
assert . equal ( leader . sx , 30 , "no shove" );
assert . equal ( round . flock . length , 4 , "no snap" );
round . active . tailwind = 0 ;
advance ( round , 100 );
assert . ok ( leader . sx < 30 , "shoved again once it runs out" );
assert . equal ( round . flock . length , 0 , "and snapped" );
});
test ( "a shield soaks one leader hit with a moment's grace, and shields cap" , () => {
const round = clearSky ();
const { leader } = round ;
for ( let k = 0 ; k < 3 ; k ++ ) flock . applyPower ( round , "shield" );
assert . equal ( round . active . shields , flock . MAX_SHIELDS );
round . active . shields = 1 ;
round . flock . push ({ id : 1 }, { id : 2 });
assert . equal ( flock . hitLeader ( round ), false );
assert . equal ( round . active . shields , 0 );
assert . equal ( leader . grace , flock . SHIELD_GRACE );
assert . equal ( round . lives , START_LIVES , "no life" );
assert . equal ( round . flock . length , 2 , "no snap" );
assert . equal ( round . lost , 0 );
assert . equal ( leader . alive , true );
assert . equal ( flock . hitLeader ( round ), false , "grace holds" );
leader . grace = 0 ;
assert . equal ( flock . hitLeader ( round ), true , "the next hit counts" );
assert . equal ( round . lives , START_LIVES - 1 );
});
test ( "a shield soaks one snap and keeps the flock whole, and one hazard spends only one" , () => {
const round = levelFlock ( 5 );
round . active . shields = 2 ;
round . hazards . push ( balloonAt ( round . flock [ 2 ]. x + 2 , round . flock [ 2 ]. y , 1 ));
advance ( round , 300 );
assert . equal ( round . flock . length , 5 , "the flock is whole" );
assert . equal ( round . active . shields , 1 , "one shield for one balloon" );
assert . equal ( round . snaps , 0 , "a soaked snap is no snap" );
});
test ( "a shield soaks a slipstream's snap too" , () => {
const round = levelFlock ( 4 );
const { leader } = round ;
round . active . shields = 1 ;
// The lane's lower edge runs just above the level line; climbing crosses it.
round . hazards . push ({ kind : "stream" , x : round . scroll - 40 , y : leader . y - 6 , w : 400 , h : 10 , vx : 0 , vy : 0 });
round . input . up = true ;
advance ( round , 200 );
assert . equal ( round . active . shields , 0 , "spent on the line crossing the edge" );
assert . equal ( round . flock . length , 4 );
assert . equal ( round . snaps , 0 );
});
test ( "a magnet pulls a stray within reach and leaves one outside it, and a late scattered bird alone" , () => {
const round = clearSky ();
const { leader } = round ;
flock . applyPower ( round , "magnet" );
const near = { id : 1 , x : leader . x + 12 , y : leader . y + 10 , bob : 0 };
const far = { id : 2 , x : leader . x + 12 , y : leader . y + flock . MAGNET_REACH + 1 , bob : 0 };
const late = { id : 3 , x : leader . x + 5 , y : leader . y + 10 , vx : 0 , vy : 1 , until : - 1 };
round . strays . push ( near , far );
round . scattered . push ( late );
const y = { near : near . y , far : far . y , late : late . y };
advance ( round , 100 );
assert . ok ( near . y < y . near - 1 , "pulled toward the leader" );
assert . equal ( far . y , y . far , "out of reach" );
assert . ok ( late . y > y . late , "a bird out of time flies off, unpulled" );
round . active . magnet = 0 ;
const held = near . y ;
advance ( round , 20 );
assert . equal ( near . y , held , "no magnet, no pull" );
});
test ( "a thunderhead's warning column holds still on the board under a tailwind too" , () => {
const round = clearSky ();
flock . applyPower ( round , "tailwind" );
round . hazards . push ({ kind : "storm" , x : round . scroll + 50 , y : flock . STORM_H , w : flock . STORM_W , h : flock . STORM_H , vx : - 12 , vy : 0 , top : true , beat : 2000 , timer : 1 , phase : "idle" , col : round . scroll + 50 });
advance ( round , 8 );
const [ storm ] = round . hazards ;
assert . equal ( storm . phase , "warn" );
const at = storm . col - round . scroll ;
advance ( round , 500 );
assert . equal ( storm . phase , "warn" );
assert . ok ( Math . abs ( storm . col - round . scroll - at ) < 0.01 , "held at " + at );
});
test ( "the timers run out, and a crash ends them" , () => {
const round = clearSky ();
flock . applyPower ( round , "tailwind" );
flock . applyPower ( round , "magnet" );
advance ( round , flock . POWERS . tailwind . ms + 8 );
assert . equal ( round . active . tailwind , 0 );
assert . ok ( round . active . magnet > 0 , "the longer one still runs" );
advance ( round , flock . POWERS . magnet . ms );
assert . equal ( round . active . magnet , 0 );
const crashed = clearSky ();
flock . applyPower ( crashed , "tailwind" );
flock . applyPower ( crashed , "magnet" );
flock . hitLeader ( crashed );
assert . deepEqual ( crashed . active , { tailwind : 0 , magnet : 0 , shields : 0 });
});
test ( "crates are always in a clear height, come through every stage, and repeat by seed" , () => {
for ( let seed = 1 ; seed <= 25 ; seed ++ ) {
for ( let n = 1 ; n <= flock . MAX_STAGE ; n ++ ) {
const { hazards , crates , length } = flock . buildStage ( seed , n );
assert . ok ( crates . length >= 2 , `seed ${ seed } stage ${ n } : ${ crates . length } crates` );
assert . ok ( crates [ 0 ]. x >= flock . CRATE_EVERY [ 0 ]);
for ( const c of crates ) {
assert . ok ( flock . POWERS [ c . kind ]);
assert . ok ( c . x < length - flock . SAFE_END );
assert . ok ( c . y >= EDGE && c . y <= FIELD_H - EDGE );
for ( const h of hazards ) {
const [ from , to ] = flock . spanOf ( h );
if ( c . x + flock . CRATE_R < from || c . x - flock . CRATE_R > to ) continue ;
if ( h . kind === "balloon" ) assert . ok ( Math . abs ( c . y - h . y ) >= h . r + flock . CRATE_R , "off a balloon" );
if ( h . kind === "cluster" ) assert . ok ( Math . abs ( c . y - h . home ) >= h . h / 2 + flock . CLUSTER_SWAY + flock . CRATE_R , "off a bunch" );
if ( h . kind === "kite" ) assert . ok ( h . top ? c . y >= h . y + flock . KITE_R + flock . CRATE_R : c . y <= h . y - flock . KITE_R - flock . CRATE_R , "off a kite" );
}
}
}
}
assert . deepEqual ( flock . buildStage ( 4 , 3 ), flock . buildStage ( 4 , 3 ));
});
test ( "flying into a crate opens it with its banner, and a replay puts back the crates ahead" , () => {
const round = newRound ( 2 );
round . hazards = [];
round . nextStray = 1e9 ;
const [ first , ... rest ] = round . crates ;
round . crates = [{ ... first , x : round . leader . x + 2 , y : round . leader . y }, ... rest ];
const { kind } = first ;
advance ( round , 16 );
assert . equal ( round . crates . length , rest . length );
assert . equal ( round . banner . text , flock . POWERS [ kind ]. name );
assert . equal ( round . banner . sub , flock . POWERS [ kind ]. blurb );
assert . ok ( kind === "shield" ? round . active . shields === 1 : round . active [ kind ] > 0 );
round . active . shields = 0 ;
flock . hitLeader ( round );
advance ( round , flock . CRASH_MS + 16 );
assert . equal ( round . crates . length , rest . length + 1 , "the whole stretch's crates are back" );
});
/* ---------------------------------------------------------- combo and score */
test ( "the combo rises within COMBO_MS, multiplies the points, caps, and resets after" , () => {
const round = clearSky ();
const bird = ( id ) => {
const b = { id , x : 0 , y : 0 , bob : 0 };
round . strays . push ( b );
return b ;
};
const pays = [];
for ( let k = 1 ; k <= flock . MAX_COMBO + 1 ; k ++ ) {
const before = round . score ;
flock . collect ( round , bird ( k ));
pays . push ( round . score - before );
assert . equal ( round . combo , Math . min ( k , flock . MAX_COMBO ));
round . now += flock . COMBO_MS ;
}
assert . deepEqual ( pays , [ 1 , 2 , 3 , 4 , 5 , 5 ]. map (( m ) => m * STRAY_POINTS ));
round . now += 1 ;
const before = round . score ;
flock . collect ( round , bird ( 50 ));
assert . equal ( round . combo , 1 , "too late starts again" );
assert . equal ( round . score - before , STRAY_POINTS );
});
test ( "the combo lapses on its own, so its pill goes away" , () => {
const round = clearSky ();
round . combo = 3 ;
round . comboAt = round . now ;
advance ( round , flock . COMBO_MS - 8 );
assert . equal ( round . combo , 3 );
advance ( round , 16 );
assert . equal ( round . combo , 1 );
});
test ( "a scattered bird won back pays half and keeps the combo" , () => {
const round = clearSky ();
round . combo = 3 ;
round . comboAt = 5 ;
const bird = { id : 1 , x : 0 , y : 0 , until : 1e9 };
round . scattered . push ( bird );
flock . collect ( round , bird );
assert . equal ( round . score , STRAY_POINTS / 2 );
assert . equal ( round . combo , 3 );
assert . equal ( round . comboAt , 5 );
});
test ( "distance pays per DIST_STEP, double under a tailwind" , () => {
const round = clearSky ();
advance ( round , 1100 );
assert . equal ( round . score , Math . floor (( BASE_SPEED * 1.1 ) / flock . DIST_STEP ) * flock . DIST_POINTS );
const fast = clearSky ();
flock . applyPower ( fast , "tailwind" );
advance ( fast , 1100 );
const flown = BASE_SPEED * 1.1 * ( 1 + flock . TAILWIND_BOOST );
assert . equal ( fast . score , Math . floor ( flown / flock . DIST_STEP ) * flock . DIST_POINTS * 2 );
});
test ( "a flawless stage pays by its number after the V, and the stage's banner comes last" , () => {
const round = atPortal ( 6 );
round . portal . min = 6 ;
round . snaps = 0 ;
advance ( round , 200 );
assert . equal ( round . score , 6 * flock . V_POINTS + flock . FLAWLESS_POINTS );
assert . match ( round . banner . text , /^V formation!/ );
advance ( round , flock . V_MS );
assert . equal ( round . stage , 2 );
assert . equal ( round . banner . text , "Flawless!" );
advance ( round , 1400 );
assert . equal ( round . banner . text , "Stage 2: Head-winds" );
});
test ( "a short flock's flawless stage pays too; a snap, a life lost or a missed ring does not" , () => {
const short = atPortal ( 2 );
short . portal . min = 6 ;
short . snaps = 0 ;
advance ( short , 200 );
assert . equal ( short . score , flock . FLAWLESS_POINTS );
assert . equal ( short . banner . text , "Need 6 birds for the V" );
advance ( short , 1200 );
assert . equal ( short . banner . text , "Flawless!" );
const snapped = atPortal ( 2 );
snapped . portal . min = 6 ;
advance ( snapped , 200 );
assert . equal ( snapped . score , 0 );
const hurt = atPortal ( 2 );
hurt . portal . min = 6 ;
hurt . snaps = 0 ;
hurt . lost = 1 ;
advance ( hurt , 200 );
assert . equal ( hurt . score , 0 );
const around = atPortal ( 2 );
around . snaps = 0 ;
around . portal . y = around . leader . y + 40 ;
advance ( around , 200 );
assert . equal ( around . score , 0 );
});
// A game whose canvas records what is drawn on it, and how.
function recordingGame ( options = {}) {
const seen = { texts : [], arcs : [], boxes : 0 , windLines : 0 };
const ctx = new Proxy ({}, {
get : ( target , name ) => {
if ( name === "fillText" ) return ( text ) => seen . texts . push ( text );
if ( name === "arc" ) return ( x , y , r ) => seen . arcs . push ( r );
if ( name === "strokeRect" ) return () => { seen . boxes += 1 ; };
if ( name === "moveTo" ) return () => { if ( target . strokeStyle === flock . POWERS . tailwind . color ) seen . windLines += 1 ; };
return name in target ? target [ name ] : () => {};
},
set : ( target , name , value ) => { target [ name ] = value ; return true ; },
});
const g = game . create ({ canvas : { width : 0 , height : 0 , style : {}, getContext : () => ctx }, ... options });
g . resize ( W * 8 , H * 8 );
g . start ();
return { g , seen };
}
// Flies a game's round through the last portal on the next tick.
function winNext ( round ) {
round . hazards = [];
round . crates = [];
round . stage = flock . MAX_STAGE ;
round . portal . x = round . leader . x ;
round . portal . y = round . leader . y ;
round . portal . h = flock . PORTAL_H_FINAL ;
round . portal . min = 3 ;
round . portal . t = 0 ;
}
test ( "a flawless last stage pays, and the end screen says so" , () => {
const { g , seen } = recordingGame ();
winNext ( g . round );
seen . texts . length = 0 ;
g . tick ( 4 );
assert . equal ( g . state , "over" );
assert . ok ( g . score >= flock . FLAWLESS_POINTS * flock . MAX_STAGE );
assert . ok ( seen . texts . includes ( `You made it! Flawless + ${ flock . FLAWLESS_POINTS * flock . MAX_STAGE } ` ), seen . texts . join ( " | " ));
});
test ( "a win with a snap on the record names no bonus" , () => {
const { g , seen } = recordingGame ();
winNext ( g . round );
g . round . snaps = 1 ;
seen . texts . length = 0 ;
g . tick ( 4 );
assert . ok ( seen . texts . includes ( "You made it!" ), seen . texts . join ( " | " ));
assert . ok ( ! seen . texts . some (( t ) => / Flawless / . test ( t )));
});
test ( "contract: onScore fires once at the end, and a new best is announced once" , () => {
const { canvas } = stubCanvas ();
const scores = [];
const g = game . create ({ canvas , onScore : ( s ) => scores . push ( s ), best : () => 40 });
g . start ();
const { round } = g ;
round . hazards = [];
round . crates = [];
round . banner = null ;
round . score = 40 ;
g . tick ( 1 );
assert . equal ( round . banner , null , "level with the best is not past it" );
round . score = 41 ;
g . tick ( 1 );
assert . equal ( round . banner . text , "New best!" );
round . banner = null ;
round . score = 90 ;
g . tick ( 1 );
assert . equal ( round . banner , null , "only once" );
assert . deepEqual ( scores , []);
round . lives = 1 ;
flock . hitLeader ( round );
g . tick ( 16 );
g . tick ( 16 );
assert . equal ( g . state , "over" );
assert . deepEqual ( scores , [ g . score ]);
});
test ( "contract: a new best waits for a clear banner, and a crash cannot lose it" , () => {
const { canvas } = stubCanvas ();
const g = game . create ({ canvas , best : () => 40 });
g . start ();
const { round } = g ;
round . hazards = [];
round . crates = [];
round . score = 41 ;
const showing = round . banner . text ;
g . tick ( 1 );
assert . equal ( round . banner . text , showing , "the stage's title stays up" );
flock . hitLeader ( round );
g . tick ( flock . CRASH_MS + 500 );
g . tick ( 1 );
assert . equal ( round . banner . text , "New best!" );
});
test ( "contract: a first round with no best announces nothing, and a best that throws reads as none" , () => {
const { canvas } = stubCanvas ();
const g = game . create ({ canvas , best : () => { throw new Error ( "no" ); } });
g . start ();
g . round . banner = null ;
g . round . score = 500 ;
g . round . hazards = [];
g . tick ( 1 );
assert . equal ( g . round . banner , null );
});
test ( "teaser: the next hazard, then a win, then the jet stream, then the next stage" , () => {
const round = newRound ( 1 );
assert . equal ( flock . teaser ( round , 1 ), "Head-winds wait at stage 2..." );
round . stage = 5 ;
assert . equal ( flock . teaser ( round , 5 ), "Kite strings wait at stage 6..." );
round . stage = 2 ;
assert . equal ( flock . teaser ( round , 5 ), "Kite strings wait at stage 6..." , "what the furthest run has met is met" );
round . stage = 8 ;
round . won = true ;
assert . equal ( flock . teaser ( round , 8 ), "Can you bring a bigger flock?" );
round . won = false ;
assert . equal ( flock . teaser ( round , 8 ), "The jet stream is waiting. One more go?" );
round . stage = 6 ;
assert . equal ( flock . teaser ( round , 6 ), "Can you reach stage 7?" );
});
test ( "the strip adds the combo above 1 and the running power-ups after the flock" , () => {
const hud = { stage : "Stage 1" , score : 1 , flock : 2 , min : 6 , combo : 1 , powers : [] };
assert . deepEqual ( hudLayout ( 2.4 , W , 3 , hud , flock . HUD_H ). map (( p ) => p . text ), [ "Stage 1" , livesText ( 3 ), "Score 1" , "Flock 2 / 6" ]);
const round = clearSky ();
flock . applyPower ( round , "tailwind" );
flock . applyPower ( round , "shield" );
flock . applyPower ( round , "shield" );
flock . applyPower ( round , "magnet" );
const powers = flock . powerPills ( round );
assert . deepEqual ( powers . map (( p ) => p . text ), [ "Tailwind 6s" , "Shield x2" , "Magnet 8s" ]);
const pills = hudLayout ( 2.4 , W , 3 , { ... hud , stage : "Stage 8: The Jet Stream" , score : 12345 , combo : 3 , powers }, flock . HUD_H );
assert . deepEqual ( pills . map (( p ) => p . text ). slice ( 4 ), [ "x3" , "Tailwind 6s" , "Shield x2" , "Magnet 8s" ]);
assert . ok ( pills . every (( p ) => p . y + p . h <= flock . HUD_H ), "all of it fits the strip" );
});
test ( "drawing: crates, the magnet ring, tailwind streaks and the end screen draw, and the end names the run" , () => {
const { g , seen } = recordingGame ();
const { round } = g ;
round . hazards = [];
round . nextStray = 1e9 ;
round . crates = flock . POWER_KINDS . map (( kind , i ) => ({ kind , x : round . scroll + 40 + i * 8 , y : 40 }));
g . tick ( 16 );
assert . equal ( seen . boxes >= 3 , true , "a box per crate" );
assert . ok ( ! seen . arcs . includes ( flock . MAGNET_REACH ), "no ring without a magnet" );
assert . equal ( seen . windLines , 0 , "no streaks without a tailwind" );
flock . applyPower ( round , "tailwind" );
flock . applyPower ( round , "magnet" );
round . flock . push ({ id : 1 });
g . tick ( 16 );
assert . ok ( seen . arcs . includes ( flock . MAGNET_REACH ), "the magnet's ring" );
assert . ok ( seen . windLines >= 5 , "the tailwind's streaks" );
const { g : ended , seen : { texts } } = recordingGame ({ best : () => 5 });
ended . round . score = 12 ;
ended . round . lives = 1 ;
flock . hitLeader ( ended . round );
texts . length = 0 ;
ended . tick ( 16 );
assert . equal ( ended . state , "over" );
assert . ok ( texts . includes ( "Out of lives" ));
assert . ok ( texts . includes ( String ( ended . score )), "the score" );
assert . ok ( texts . includes ( `A new best! ${ ended . score } ` ), "the best" );
assert . ok ( texts . includes ( "Head-winds wait at stage 2..." ), "the teaser" );
});
test ( "the strip counts the flock against the portal's minimum, in the success color once met, and every pill reads" , () => {
const hud = { stage : "Stage 8: The Jet Stream" , score : 12345 , flock : 12 , min : 18 , combo : 3 , powers : [{ text : "Tailwind 6s" , color : flock . POWERS . tailwind . color , fill : 0.5 }, { text : "Shield x2" , color : flock . POWERS . shield . color , fill : 1 }, { text : "Magnet 8s" , color : flock . POWERS . magnet . color , fill : 0.5 }] };
const short = hudLayout ( 2.4 , W , 3 , hud , flock . HUD_H );
assert . equal ( short [ 3 ]. text , "Flock 12 / 18" );
assert . notEqual ( short [ 3 ]. color , SUCCESS );
const met = hudLayout ( 2.4 , W , 3 , { ... hud , flock : 18 }, flock . HUD_H );
assert . equal ( met [ 3 ]. color , SUCCESS );
assert . ok ( met . every (( p ) => p . y === met [ 0 ]. y ), "one row" );
assert . ok ( met . every (( p ) => p . y + p . h <= flock . HUD_H ), "inside the strip" );
for ( const p of [... short , ... met ]) {
if ( p . color === LIVES ) continue ;
assert . ok ( pillContrast ( pillInk ( p . color , p . fill < 1 ), PILL ) >= PILL_CONTRAST , `" ${ p . text } " reads on its pill` );
}
});
test ( "music: a deal has every track once and never opens on the last song" , () => {
for ( const last of flock . MUSIC_TRACKS ) {
for ( let k = 0 ; k < 40 ; k ++ ) {
const deck = flock . dealMusic ( Math . random , last );
assert . deepEqual ([... deck ]. sort (), [... flock . MUSIC_TRACKS ]. sort ());
assert . notEqual ( deck [ 0 ], last );
}
}
});
test ( "music: a run plays each song in full from its top, deals again after the last, and never opens on the song just played" , () => {
const asked = [];
let answer = true ;
const { canvas } = stubCanvas ();
const g = game . create ({ canvas , music : ( name , level , options ) => { asked . push ([ name , options ]); return answer ; } });
g . resize ( W * 8 , H * 8 );
g . start ();
g . round . hazards = [];
g . round . portal . x = Infinity ;
g . tick ( 4 );
const first = asked . at ( - 1 )[ 0 ];
assert . deepEqual ( asked . at ( - 1 )[ 1 ], { restart : true }, "from the top" );
g . tick ( 4 );
assert . equal ( asked . at ( - 1 )[ 0 ], first );
assert . equal ( asked . at ( - 1 )[ 1 ], undefined , "then just kept going" );
answer = "ended" ;
asked . length = 0 ;
for ( let k = 0 ; k <= flock . MUSIC_TRACKS . length ; k ++ ) g . tick ( 4 );
const opened = [ first , ... asked . filter (([, options ]) => options ? . restart ). map (([ name ]) => name )];
const count = flock . MUSIC_TRACKS . length ;
assert . equal ( new Set ( opened . slice ( 0 , count )). size , count , "all five, once each" );
assert . notEqual ( opened [ count ], opened [ count - 1 ], "the new deal opens on another song" );
});
test ( "the skies: a palette for every stage, deepening to stars only at the last" , () => {
for ( let n = 1 ; n <= flock . MAX_STAGE ; n ++ ) {
const sky = SKIES [ n ];
assert . ok ( sky , `stage ${ n } ` );
for ( const key of [ "top" , "mid" , "horizon" , "cloud" , "sun" ]) assert . match ( sky [ key ], /^#[0-9a-f]{6}$/ , `stage ${ n } ${ key } ` );
assert . equal ( typeof sky . sunY , "number" );
if ( n > 1 ) assert . ok ( sky . sunY > SKIES [ n - 1 ]. sunY , "the sun keeps sinking" );
assert . equal ( sky . stars > 0 , n === flock . MAX_STAGE );
}
});
test ( "drawing: a full frame on every stage, the V, the end screen and the win" , () => {
for ( let n = 1 ; n <= flock . MAX_STAGE ; n ++ ) {
const { canvas , calls } = stubCanvas ();
const g = game . create ({ canvas });
g . resize ( W * 8 , H * 8 );
g . start ();
const { round } = g ;
round . stage = n ;
round . nextStray = 1e9 ;
round . flock . push ({ id : 1 }, { id : 2 }, { id : 3 });
round . portal . x = round . leader . x + 10 ;
round . leader . grace = 500 ;
g . tick ( 16 );
assert . equal ( g . state , "running" , `stage ${ n } ` );
assert . ok ( calls . count > 0 );
assert . ok ( calls . stops >= 3 , "the sky's own gradient" );
round . portal . v = { t : 500 };
g . tick ( 16 );
assert . ok ( round . flock . every (( b ) => typeof b . x === "number" ));
}
const { g , seen } = recordingGame ();
winNext ( g . round );
g . tick ( 4 );
assert . equal ( g . round . won , true );
assert . equal ( g . state , "over" );
assert . ok ( seen . texts . includes ( "You made it!" ) || seen . texts . some (( t ) => String ( t ). startsWith ( "You made it!" )));
});
test ( "sounds: every event plays a sound that exists, warnings once each, and a sound never changes the round" , () => {
const played = [];
const hums = [];
const { canvas } = stubCanvas ();
const g = game . create ({ canvas , tone : ( name , level , pitch , louder ) => played . push ({ name , pitch , louder }), hum : ( id , name ) => hums . push ([ id , name ]) });
g . resize ( W * 8 , H * 8 );
g . start ();
const { round } = g ;
Object . assign ( round , { hazards : [], crates : [], nextStray : 1e9 });
round . portal . x = Infinity ;
g . tick ( 4 );
assert . ok ( played . some (( p ) => p . name === "flockStage" ), "the stage's sound opens the run" );
assert . deepEqual ( hums . at ( - 1 ), [ "flock:wind" , "flockWind" ]);
const names = () => played . map (( p ) => p . name );
const expectSound = ( name , act ) => {
played . length = 0 ;
act ();
g . tick ( 4 );
assert . ok ( names (). includes ( name ), ` ${ name } in ${ names (). join ( ", " ) } ` );
};
const near = ( bird = {}) => ({ id : 900 + played . length , x : round . leader . x , y : round . leader . y , bob : 0 , ... bird });
expectSound ( "flockChirp" , () => round . strays . push ( near ()));
expectSound ( "flockPower" , () => round . crates . push ({ kind : "magnet" , x : round . leader . x , y : round . leader . y }));
round . active . magnet = 0 ;
// Two gusts arriving together warn once.
played . length = 0 ;
const gust = ( y ) => ({ kind : "gust" , x : round . scroll + FIELD_W - 1 , y , w : 16 , h : 6 , vx : 0 , vy : 0 , live : false });
round . hazards = [ gust ( 5 ), gust ( 50 )];
g . tick ( 4 );
assert . equal ( names (). filter (( n ) => n === "flockGust" ). length , 1 , "one warning" );
round . hazards = [];
// A storm's warning and its strike.
played . length = 0 ;
const storm = { kind : "storm" , x : round . scroll + 80 , y : 5 , w : 12 , h : 5 , vx : - 12 , vy : 0 , top : true , beat : 2000 , timer : 1 , phase : "idle" , col : round . scroll + 80 };
round . hazards = [ storm ];
g . tick ( 8 );
assert . ok ( names (). includes ( "flockThunder" ));
storm . timer = 1 ;
played . length = 0 ;
g . tick ( 8 );
assert . ok ( names (). includes ( "flockStrike" ));
round . hazards = [];
// A snap, then a bird won back, then a shield on a hit, then a hit.
round . flock . push ({ id : 1 }, { id : 2 });
g . tick ( 500 );
expectSound ( "flockSnap" , () => round . hazards . push ({ kind : "balloon" , x : round . flock [ 1 ]. x , y : round . flock [ 1 ]. y , w : 2 , h : 2 , r : 1 , vx : 0 , vy : 0 }));
round . hazards = [];
round . leader . grace = 0 ;
expectSound ( "flockRejoin" , () => {
const b = round . scattered [ 0 ];
b . x = round . leader . x ;
b . y = round . leader . y ;
});
round . scattered = [];
round . flock . length = 0 ;
round . leader . grace = 0 ;
const onLeader = () => round . hazards . push ({ kind : "balloon" , x : round . leader . x , y : round . leader . y , w : 2 , h : 2 , r : 1 , vx : 0 , vy : 0 });
flock . applyPower ( round , "shield" );
expectSound ( "flockShield" , onLeader );
round . hazards = [];
round . leader . grace = 0 ;
expectSound ( "flockHit" , onLeader );
round . hazards = [];
// The portal, the V, the flawless bonus and the win.
const { g : won } = recordingGame ({ tone : ( name ) => played . push ({ name }) });
played . length = 0 ;
won . round . flock . push ({ id : 1 }, { id : 2 }, { id : 3 });
winNext ( won . round );
won . tick ( 4 );
for ( const name of [ "flockPortal" , "flockV" , "flockFlawless" ]) assert . ok ( names (). includes ( name ), ` ${ name } in ${ names (). join ( ", " ) } ` );
won . tick ( flock . V_MS + 8 );
assert . ok ( names (). includes ( "flockWin" ));
// A game over, and a new best.
const { g : lost } = recordingGame ({ tone : ( name ) => played . push ({ name }), best : () => 1 });
played . length = 0 ;
lost . round . score = 50 ;
lost . round . banner = null ;
lost . tick ( 4 );
assert . ok ( names (). includes ( "flockBest" ));
lost . round . lives = 1 ;
flock . hitLeader ( lost . round );
lost . tick ( 4 );
assert . ok ( names (). includes ( "flockOver" ));
for ( const name of new Set ( names ())) assert . ok ( toneNames (). includes ( name ), ` ${ name } is a tone` );
assert . ok ( humNames (). includes ( "flockWind" ));
assert . ok ( humNames (). includes ( "flockStream" ));
});
test ( "a sound never changes the round: one sky flown with the sounds heard and without comes out the same" , () => {
const fly = ( options ) => {
const realRandom = Math . random ;
Math . random = () => 0.5 ;
try {
const { canvas } = stubCanvas ();
const g = game . create ({ canvas , ... options });
g . resize ( W * 8 , H * 8 );
g . start ();
g . cheat ( true );
for ( let k = 0 ; k < 1500 ; k ++ ) {
const name = k % 80 < 40 ? "up" : "down" ;
g . key ( name );
g . release ( name === "up" ? "down" : "up" );
g . tick ( 16 );
}
return JSON . stringify ( g . round );
} finally {
Math . random = realRandom ;
}
};
const heard = [];
const loud = fly ({ tone : ( name ) => heard . push ( name ), hum : ( id ) => heard . push ( id ), music : ( name ) => { heard . push ( name ); return true ; } });
const quiet = fly ({});
assert . ok ( new Set ( heard ). size >= 4 , `sounds did play: ${ [... new Set ( heard )]. join ( ", " ) } ` );
assert . equal ( loud , quiet );
});
test ( "the wind hums with speed, and the slipstream rushes only while the leader rides it" , () => {
const hums = [];
const { canvas } = stubCanvas ();
const g = game . create ({ canvas , hum : ( id , name , level , pitch ) => hums . push ({ id , pitch }) });
g . resize ( W * 8 , H * 8 );
g . start ();
const { round } = g ;
Object . assign ( round , { hazards : [], crates : [], nextStray : 1e9 });
round . portal . x = Infinity ;
g . tick ( 16 );
const slow = hums . filter (( h ) => h . id === "flock:wind" ). at ( - 1 ). pitch ;
assert . ok ( ! hums . some (( h ) => h . id === "flock:stream" ));
round . speed = flock . STAGES [ flock . MAX_STAGE ]. speed ;
g . tick ( 16 );
assert . ok ( hums . filter (( h ) => h . id === "flock:wind" ). at ( - 1 ). pitch > slow , "faster, higher" );
round . hazards = [{ kind : "stream" , x : round . leader . x - 5 , y : round . leader . y , w : 40 , h : 12 , vx : 0 , vy : 0 }];
g . tick ( 16 );
assert . ok ( hums . some (( h ) => h . id === "flock:stream" ));
});
test ( "a long winding flock of 80 stays within a frame's budget" , () => {
const round = clearSky ( 5 );
for ( let k = 0 ; k < 80 ; k ++ ) round . flock . push ({ id : k + 1 });
// Fly a long weave so the path is full.
for ( let k = 0 ; k < 400 ; k ++ ) {
round . input . up = k % 40 < 20 ;
round . input . down = ! round . input . up ;
advance ( round , 16 );
}
assert . equal ( round . flock . length , 80 );
const runs = 200 ;
const started = performance . now ();
for ( let k = 0 ; k < runs ; k ++ ) {
placeFlock ( round );
advance ( round , flock . SLICE_MS );
}
const each = ( performance . now () - started ) / runs ;
assert . ok ( each < 2 , ` ${ each . toFixed ( 3 ) } ms a run` );
});