Add Bounce Road music, extras and arcade tests

AI Assisted
This commit is contained in:
jparkerweb committed 2026-11-13 23:28:42 -08:00
1 parent a0300d4ac2
commit 5679101487
23 files changed
+6004 -624

No files matched your search

+4 -11
View File
@@ -1,12 +1,12 @@
# Architecture: Activities (the games)
> Part of [AGENTS.md](../AGENTS.md) and the [Architecture index](./AGENTS-architecture.md): project guidance for AI coding agents.
One row per file of every game but Ghoul Rush (which has its own files: [core](./AGENTS-architecture-ghoul-core.md), [stages](./AGENTS-architecture-ghoul-stages.md), [rides](./AGENTS-architecture-ghoul-rides.md)), then the rules every game follows.
One row per file of every game but Ghoul Rush (which has its own files: [core](./AGENTS-architecture-ghoul-core.md), [stages](./AGENTS-architecture-ghoul-stages.md), [rides](./AGENTS-architecture-ghoul-rides.md)) and Bounce Road ([its own file](./AGENTS-architecture-bounce.md)), then the rules every game follows.
| File | Role |
|---|---|
| `public/activities.js` | the list of activities (`ACTIVITIES`: each game's id, title, picker row line `blurb` and module path) an optional `courses` list (Mini golf's six course ids, which open a course dashboard), `bestKey(id, course?)`, the flat looks.json key for its best score (`activityBestSnake`, one per golf course `activityBestGolfPirate` to `activityBestGolfFrost`, `activityBestTrails`, `activityBestBugs`, `activityBestDrive`, `activityBestStack`, `activityBestBumper`, `activityBestRapids`, `activityBestFuse`, `activityBestHop`, `activityBestBounce`, `activityBestGhoul`, `activityBestFlock`); lists Snake, Mini golf, Light Trails, Bug Hunt, Sunset Drive, Stack Deploy, Bumper Ring, Rapids Run, Hot Potato, Crossing Rush, Bounce Road, Ghoul Rush and Flock Dash, `bestKeys(entry)`, every best key a game keeps, `playedKey(id)` (`activityPlayedSnake`, the epoch ms a game was last picked, 0 for never) and `orderGames(list, looks, order)` (the picker's `{ played, unplayed }`), and documents the game contract including the course parts (`courses` and `preview()` on the export, `setCourse()` and `course` on the game), the optional `pointer(type, x, y)`, `release(name)` (a game key let go) and `lowerIsBetter`; data only, imported by the page and by Node |
| `public/activities/snake.js` | Snake: its rules as plain exported functions and the game contract (`create({ canvas, tone, onScore })` returning `start`, `pause`, `resume`, `key`, `tick`, `resize`, `score`, `state`); it never runs a timer or listens for keys, so the Activities window drives it; it also holds the music's rules: `MUSIC_TRACKS`, `dealMusic(random, last)` (a round's shuffle of the ten tracks, never opening on the last round's opener), `trackFor(deck, level)` and `heat(round)` (the snake's speed as 0.3 to 1, so the lead and drums are in from the first step) |
| `public/activities/snake.js` | Snake: lives (`START_LIVES` 3, `MAX_LIVES` 9, `lifeMark(n)`, `awardLives`, `GRACE_MS` of free passage after a crash puts the snake back mid-board via `respawn`; `cheat(on)` sets `round.infinite`) and the bosses (`BOSSES` by the level that opens with one: 4 Grumpy Golem, 6 Comet Queen, 8 Thunder Toad; `round.boss`, whose orbs are the food, `hitBoss`, `ageBoss`); its rules as plain exported functions and the game contract (`create({ canvas, tone, onScore })` returning `start`, `pause`, `resume`, `key`, `tick`, `resize`, `score`, `state`); it never runs a timer or listens for keys, so the Activities window drives it; it also holds the music's rules: `MUSIC_TRACKS`, `dealMusic(random, last)` (a round's shuffle of the ten tracks, never opening on the last round's opener), `trackFor(deck, level)` and `heat(round)` (the snake's speed as 0.3 to 1, so the lead and drums are in from the first step) |
| `public/activities/trails.js` | Light Trails: its rules as plain exported functions (`newRound`, `newHeat`, `turn`, `boost`, `advance` in 8 ms slices (where your crash is held for `GRACE_MS`, a turn in that time riding out of it; rivals get no grace), `choose` and `room` for the rivals' flood-fill steering, `applyPower` (a Mystery becoming another pad), `pickPower` (by each pad's `from` arena, a Heart only under `MAX_LIVES`), `fireLaser`, `hyperjump`, `awardLives` (a life every `LIFE_SCORE` points, the mark moving on at the cap), `spawnItem`, `closeRing`), the `ARENAS` (rivals, sharpness and what each adds), the `POWERS` pads (Boost, Phase, Eraser, Slow-mo, Coin, Heart, Shield held across heats until a crash in your grace pops it, Laser with `LASER_SHOTS`, Score x2 through one `gain()` every score goes through, Wide Trail with its side cells in `rider.wide`, Coin Rain whose `rain` coins never hold back a pad, Hyperjump, Mystery) and the game contract; `START_LIVES` is 5; memo is the furthest arena reached; a read-only `round` getter for the tests only; it also holds the music's rules: `MUSIC_TRACKS` (its five songs) and `dealMusic(random, last)` (a shuffle of them, never opening on `last`); a run plays the deal one song after another, each in full from the top (asking with `{ restart: true }` until the music takes it), moves on when `music()` answers `"ended"`, deals again after the last, and a new run deals afresh, never opening on the song the last run was playing; its tones and hums play `SFX_LOUDER` times as loud through tones.js's `louder`, all but the engine drones (`DRONES`), kept low under the songs |
| `public/activities/bugs.js` | Bug Hunt: its rules as plain exported functions (`newRound`, `spawnWave`, `slotPos`, `advance` in 8 ms slices over `round.input`, which `key()` and `release()` set, `hurtBug`, `hurtBoss`, `hitShip`, `applyPower`, `ghostly`, `tentacleTip`, `bossRadius`), the `BUGS` by first wave, the `BOSSES` every `BOSS_EVERY` waves, the `POWERS`, the `SECTORS` scenery and the game contract with `release()`; memo is the tally of `DISCOVERIES` as bits; a read-only `round` getter for the tests only |
| `public/activities/drive.js` | Sunset Drive: its rules as plain exported functions (`newRound`, `buildStage`, which appends a stage of road and returns its `forkAt`, `gateAt` and `fork`, `segAt`, `advance` in 8 ms slices over `round.input`, which `key()` and `release()` set, `boost`, `usePower` (the oldest queued power-up, which space fires ahead of `boost`), `hopHeight`, `checkTime`), the `POWERS` in `POWER_ORDER`, the `REGIONS` (roads with their bonus, bends, hills, traffic, colors and props) in `REGION_ORDER`, the projection and drawing (sky, road far to near, props, traffic, Planny's car) and the game contract with `release()`; the next road is built only when the fork is chosen, and `FORK_LEN` must stay at least `DRAW` so it is built before it comes into view; memo is the roads found as bits; a read-only `round` getter for the tests only |
@@ -21,13 +21,6 @@ One row per file of every game but Ghoul Rush (which has its own files: [core](.
| `public/activities/fuse-draw.js` | Hot Potato's drawing: `drawScene(ctx, view)` from one view object `fuse.js` refills each frame, in arena units: the strip above the arena in the page's colors with the pills (laid out by `hudLayout`, which starts a second row rather than run into the fuse and centers its rows in the strip), each venue's floor in its fixed palette (`themeFor`, `venueColor`), ice, running belts, the Rooftop's open edge, the things to run round, pickups, the runners (Planny on his feet with his star eye and stick arms, flailing while he holds a bomb, and still Planny when charred; arms and feet on the floor in `limbInk(level)`, the ink that stands out from that venue's tiles; rivals with a mark per personality; a white ring with a dark edge at the feet of a runner safe from a tag-back; the charred waddle to the nearest wall and the fall from the roof), the bomb over its holder (a red ball with a `<<<` band, growing and glowing as it burns, flashing white while it cannot be passed, its fuse a shortening curl with a spark, the last seconds in big numbers (under the holder's feet when there is no room above, `countY`), a hop across on a pass), blast clouds, the Blackout's dark worked out once a frame in cells, the red edge pulse in a fuse's last second, banners and the start and end strip with the big final score, and `readColors(canvas)`; decides nothing |
| `public/activities/hop.js` | Crossing Rush: its rules as plain exported functions over a round on a strip `COLS` (11) cells wide of 30 to 40 lanes, `VIEW_ROWS` (14) on the board at once (`newRound`, `newHeat(round, zone)`, which builds the heat's lanes from the round's seed, kept when a heat runs again, `buildLanes(zone, seed)` (groups of road, highway, ice, river, turtle, rapids or rail lanes with a grass row between each two, the zone's new thing first; the same seed builds the same lanes), `advance` in 8 ms slices (lanes flow, riders drift with their log, rivals choose, everyone is checked where they stand before any hop moves on, then hops and flights; hoppers home in the same slice finish by the moment each landed, a dead heat to you), `hop(round, hopper, dir)` (one cell, two with a Spring; a hopper counts in the cell it leaves for the first half and the one it lands on for the second; an icy lane slides it a cell more), `laneAt`, `occupied(round, row, col, atMs)` (a car or a train on it, or in a river no float or the edge, `atMs` ahead through `shiftAt`, which follows a lane's flips, surges and a Horn exactly), `sendBack` (to the last grass row, `safeBelow`, crediting a shove within `SHOVE_CREDIT_MS`), `shove(round, from, to)` (a cell the way `from` faces, only on a hopper `inReach` and never on one past the half of its hop home, once every `SHOVE_MS`), `plan(round, hopper, random, power)` (a look ahead of `LOOKAHEAD` to `LOOKAHEAD_SHARP` hops over the lanes as they will move, each hop followed by the hopper's wait where it lands; never a hop where it would be hit or fall in at full sharpness; a sloppy rival now and then hops on regardless), `applyPower`, `zoneFor` and `rivalPower` (each built once per zone), `rivalColors(you)`, `standings`), the `ZONES`, `RIVALS` and `POWERS`, and the game contract with `release()` (`key(name, repeat)` hops once a press: never on a repeat, never again until the arrow is let go, never with the press that plays on, and with one hop queued behind the one in the air; a pause drops what is held and the queue); rivals wait `REACT_MS` down to a sharp rival's after each landing, a Bruiser shoves anyone beside it into a lane, a Tagalong follows a row behind you and shoves near the top, and a rival that lets a shove go weighs the next one only after `SHOVE_LOOK_MS`; memo is the furthest zone reached, which can pass 9; a read-only `round` getter for the tests only. Tuned by a scratch sim |
| `public/activities/hop-draw.js` | Crossing Rush's drawing: `drawScene(ctx, view)` from one view object `hop.js` refills each frame, in board units: the strip above the field in the page's colors with the pills (laid out by `hudLayout`, which starts a second row rather than run into your place and centers its rows in the strip), the lanes in fixed colors (`LANES`, `lookOf`; pavement, grass with tufts, bushes and rocks, the checkered finish, roads with dashes and surge chevrons, icy roads, rivers with ripples and Rapids arrows, tracks with a signal that flashes while a train is coming), cars, vans, trucks, logs, turtles that sink and dive, the train, pickups, the hoppers (Planny on his stick feet with his star eye in every state: stretching mid-hop, spinning as he flies back, cheering, slumped when beaten; rival critters with a Hopper's ears, a Daredevil's goggles, a Bruiser's brow and a Tagalong's beak; arms and feet, and each rival's body edge, in `limbInk(look)`, the ink that stands out from that lane), a Shield's ring and a Spring's coil, staggered stars, arrows at the edge for hoppers out of view, the Night Market's dark (soft lights cut from a layer the size of the field with one gradient made with the layer, or in steps with no second canvas), the race bar in the page's colors, banners, and the start and end strip with the big final score; every word kept on the field by `labelSpot`, and `readColors(canvas)`, `zoneColor`; decides nothing |
| `public/activities/bounce.js` | Bounce Road: the cars, the hazards against them, the scoring and the round, as plain exported functions over a round on a road scrolling up a 72 unit wide field, 90 units of it on the board (it re-exports every rule of `bounce-road.js` and `bounce-rivals.js`, so the suite imports one module): `newRound(seed, random)`, `advance` in 4 ms slices over `round.input`, which `key()` and `release()` set (a jump press first, then your `move`, the rivals' `think` and `move`, the pads (a boost strip pushes you to `NITRO_TOP` for `BOOST_MS` even off the throttle, and the brake cuts it; a ramp launches any car crossing its lip quick enough `RAMP_AIR` the usual jump; a slick eases the steering at `SLICK_EASE` and makes a knock last for `SLICK_MS`), the bumps (`collide`: boxes pushed apart along the shallower overlap, side on a knock split by mass and harder for the car that did not steer in, end on speed passed forward, into a `HEAVY` truck's back at `CRASH_CLOSE` a crash; with Mega wheels a touch flattens; a close shave, `NEAR_GAP` or less between the boxes at speed and no touch, scores once), the barriers (a cone or a tire knocked flying slows you to `CONE_SLOW`; a block, pot or bucket nose first is a crash, from the side a push out), the hazards placed by the round's clock (a train hits a car on its track, a ball knocks a car by `BALL_KICK`, a sprinkler's jet pushes at `SPRAY_PUSH`, a drop falls `DROP_FALL_MS` after you come within `DROP_TRIGGER`, aimed at your line, and lies there after, a gust pushes at `WIND_PUSH`), then the ground (water or a hole under your middle a life, a flowerbed nose first a crash, a rival off the road out and yours within `CREDIT_MS`)), `jump`, `land` (on a car: flattened for its `points` times the chain up to `MAX_CHAIN`, a truck's roof `HAUL_POINTS`, the Monster a stomp, `STOMP_POINTS`, and on its last of `BOSS_HP` `BOSS_POINTS` times the lap and a life; on the road the chain ends, and the holes, trains, balls and barriers flown over and a ramp's big air score), `stunt` (a stunt's points times `comboOf(streak)`: every `COMBO_STEP` stunts within `STREAK_MS` of each other one more, up to `MAX_COMBO`), `lose` (a Bubble throws you clear instead), `applyPower`, `underBanner(round, y, cam)` (a rival, a coming train, a ball or a thing still falling in the strip) and `BANNER_Y`, `rivalColors(you)`), the `POWERS` (Spring, Bubble, Nitro, Mega wheels) and the game contract with `release()` (`key(name, repeat)`: held arrows drive and steer, space jumps once a press, never on a repeat or with the press that plays on, and a press up to `JUMP_BUFFER_MS` before a landing jumps on it; a pause lets go of every key and drops a press). A stage line scores `STAGE_POINTS` times the stage, `TIME_POINTS` a second under its par and, flawless, `FLAWLESS_POINTS` and a life back up to `MAX_LIVES`. Memo is the furthest stage reached, which can pass 10. A read-only `round` getter is for the tests only. Tuned by scratch bots: a careful bot clears all ten stages with no rivals on every seed tried (23 to 42 s a stage), and a bot with 150 ms reactions and 80 ms jump timing error reaches a median of stage 5 with the rivals out, stage 10 without |
| `public/activities/bounce-draw.js` | Bounce Road's drawing: `drawScene(ctx, view)` from one view object `bounce.js` refills each frame, in field units: the strip above the field in the page's colors with the pills (laid out by `hudLayout`: stage, lives, Spring, Bubble, Nitro and Mega with their timers, the chain and the combo with its timer; a pill that would run off the board starts a second row), the road a chunk of `CHUNK_ROWS` rows at a time, drawn off screen once per road and scale, a few kept and copied each frame (rows from `bounce-scenery.js`), the layers over it (`bounce-scenery.js`), the landing rings (yours in your highlight, a rival's in red, the Monster's its own size), the cars through `bounce-cars.js` (every shadow first, upright, then every body with its tumble: Planny in your highlight with his box in the page's panel color and his star eye, arms to the wheel, up in the air or cheering, down at the end; each rival kind in its own style and color, the Cop's siren while it chases, the Monster's dents and a star per life left above it, headlights at Night Lights), sparks, rings, the dark of Night Lights, the chain's big number, the stage bar beside the field, banners, and the start and end strip with the big final score and a dot per stage reached; every word kept on the field by `labelSpot`, and `readColors(canvas)`, `limbInk`, `inkOn`; decides nothing |
| `public/activities/bounce-cars.js` | Bounce Road's cars, drawing only and no imports: `drawCarBody(ctx, style, opts)` draws one top-down toy car about the origin, nose up, filling `w` by `h` field units exactly (tires on the box's corners), in one of `CAR_STYLES` (`STYLE_NAMES`: Planny's convertible with his star eye and arms to the wheel, hatch, sedan, coupe, muscle, pickup, van, box truck, police, racer, taxi, jeep, monster) with flat-fill shading worked out from `color` and `accent` (`shade`, `rgbOf`), and options for roll (`tilt`), a jump (`air`: it draws the shadow and the lift itself), a pancake (`squash`), night beams, a siren bar, damage, a boost flame and brake lights, all moving parts on `opts.clock`; `drawCarShadow` and `shadow: false` for a shadows-first pass in screen space; `carLength(style, w)` for a style's natural length and `carReach(style, opts)` (with `MARGINS`) for what reaches outside the box |
| `public/activities/bounce-scenery.js` | Bounce Road's scenery, drawing only: each stage's look in fixed colors (`LOOKS`: patio slabs, lawn stripes, kitchen tiles, garden, sand, a toy room's rug, a pond with lily pads, roof shingles, the night lawn with lamps and the Monster's dirt; `lookOf`, `stageColor`, `contrast`, `better`), `drawRow` (one row of the road in three passes over a chunk: the yard, the road's surface, the details: edges slanting from row to row, rivers, plank bridges with jagged broken ends, cracks, flowerbeds, rails across a crossing, cracked road over a pit, checkered stage lines, verge decor), and the layers drawn fresh each frame from the round's clock: `drawTimed` (a drawbridge lifting with its red lights, a swaying bridge where it is now, crumbled road gone to the pit), `drawPads` (running boost chevrons, ramps, slicks), `drawBlocks` (cones, toy blocks, pots, buckets, acorns and tires, knocked ones tumbling off), `drawStars`, `drawSigns` (a mark per hazard), `drawItems`, `drawHazardsLow` (crossing lights, the train, a rolling ball, a falling thing's growing shadow, a sprinkler's head), `drawHazardsHigh` (the jet, gust streaks, the thing still falling), `drawNight` and `drawFireflies`; decides nothing |
| `public/activities/bounce-road.js` | Bounce Road's road, rules only: the jump math every hole is sized by (`airMs(v)`, `reach(v)`, `LONGEST_JUMP`, `JUMP_FAIR`, `TOP_SPEED`, `MAX_SPEED`), `stageFor(n)` (built once a stage: the ten of `bounce-roads.js`, then laps from `LAP_FROM`, quicker, keener, busier, the Monster at every Monster Mash) and `stageName`, `newRoad(seed)` and `buildStage(road, n, random)` (a stage's rows from its own seed, by the stage's piece weights: straights, cracks, rivers on bridges with one or two broken spans or a drawbridge, splits round flowerbeds, ramps before a crack with stars beyond, cone or block chicanes, crumbling road, train crossings, swaying bridges, boost strips, slicks, balls, sprinklers, drops and gusts; every hole after a `RUNUP` with a sign and no longer than `MAX_HOLE`, the bridge between two breaks long enough to land `LONGEST_JUMP` on), `ensureRoad`, `groundAt(road, x, d, t)` (a row's edges eased from the row before's; a drawbridge water while lifted, a swaying bridge shifted, crumbled road a hole), `rowGone`, `spanAt`, `holesIn`, `firstAt`, `plainRow`, `safeSpot` (no hole, water, timed part or rails for `RESPAWN_RUN` ahead), and where each timed thing is at a moment: `swayOff`, `drawLift`, `crumbleAt` (falling away `CRUMBLE_DELAY` after you reach it, at `CRUMBLE_SPEED`, under a fair speed), `trainAt` (on, and lit `TRAIN_WARN_MS` before), `ballX`, `sprayAt`, `gustAt`; plus `seeded`, `GROUND`, `MARK`, `SPAN` |
| `public/activities/bounce-rivals.js` | Bounce Road's rivals, rules only: `RIVALS` (the Zigzag, Brick, Frog, Nudge, Hauler, Sneak, Bruiser, Racer, Cop and Monster: box, mass, speed, points, how readily each dodges, how often each comes, its car style and whether it comes from behind), `makeCar`, `think(round, car, ms, random)` (each kind's choice of speed and line: the Zigzag's weave, into your path when you follow; the Brick holding your lane and brake-checking from in front, then resting `BRAKE_REST_MS` or more; the Frog's hops toward you; the Nudge's chase and up to 1 + 2 times the stage's `sharp` swipes; the Hauler drifting to block; the Sneak dropping up to `SNEAK_DROPS` cones while you follow; the Bruiser slamming you within `BRUISER_RANGE`; the Racer passing then fleeing; the Cop sitting on your roomier side and leaning in to push you to the near edge for `COP_MS`, never on a bridge or by the water (`nearWater`), nor the Bruiser; the Monster keeping `BOSS_AHEAD` in front, hopping every `BOSS_HOP_MS` to come down where you will be and dropping tires; every rival rubber-banded to stay near you, swerving from under your landing as sharply as its stage allows, keeping to the narrowest road just ahead and the band a swaying bridge always covers, holding a slower car's speed, and hopping any hole, drawbridge, barrier or coming train, or flying off a ramp), `spawnRival`, `pickKind` (one of each special kind at a time), `HEAVY`, `RIVAL_MIN_SPEED` |
| `public/activities/bounce-roads.js` | Bounce Road's ten stages as data (no imports): `FIELD_W`, `FIELD_H`, `ROW`, `MAX_HOLE`, `LAP_FROM`, and per stage its length, par time, road widths, piece weights (straights, holes, rivers, splits, ramps, chicanes, crumbling road, trains, swaying bridges, boost strips, slicks, balls, sprinklers, drops, gusts), crack and broken span lengths, bridge widths and shares of broken, double and drawbridge spans, flowerbed sizes, barrier and drop kinds, the rivals' count, kinds, pace and sharpness, power-ups, stars, and whether the Monster comes |
| `public/activities/pills.js` | The pills every game but Mini golf draws along its top (no imports): `drawPill(ctx, x, y, w, h, text, color, fill, textY)` on one opaque dark backing, `PILL`, the same in light and dark and over any scene, a timer's share still left tinted at `PILL_TINT`, and the text in `pillInk(color, tinted)`: the pill's own color when it reads at `PILL_CONTRAST` (4.5:1) on the backing (and on the tint while a timer runs), else the least step toward white that does, so warnings stay red; lives are the one solid pill: a pill in the `LIVES` color is drawn on `LIVES_BACK` in white (`LIVES_INK`), its text from `livesText(n)` (a heart per life up to five, `♥ xN` past that, `♡` at none); `pillTint` and `pillContrast` for the unit suite |
| `public/activities/golf.js` | Mini golf: six eighteen-hole courses, one round at a time; its rules and physics as plain exported functions (`newRound(courseId)`, `holesOf`, `coursePar`, `strike`, `advance` on a fixed 4 ms sub-step, `nextHole`, `total`, `toPar`, `predictPath` for the spyglass, `moverAt`, `gateShut`, plus ice that barely slows the ball and wells that pull it in or push it away), the `POWERUPS` held for the next putt (`round.held`, then `round.active` for that putt), the arcade swing (`startSwing`, `setPower`, `meterAt`, `meterZone`, `swingShot`: a ping-pong power meter, slow at the bottom and fast at the top, with a MAX band that boosts and an overswing band that shanks; a shot clock in `advance()` that starts the meter after `SHOT_CLOCK_MS` and dribbles the ball after `METER_TRIPS` trips; all on the round's own clock), the pop-up gags, and the game contract with `pointer()` (the aim follows the pointer, a press swings, a press held on a roll fast-forwards), `release()` (held arrows turn the aim, held space fast-forwards) and `lowerIsBetter`, `courses` (the dashboard's cards), `preview(canvas, id, w, h)` (a course's card art) and `setCourse(id)`; deterministic (no `Math.random()`), a read-only `round` getter for the unit suite only |
| `public/activities/golf-draw.js` | Mini golf's drawing: `drawCourse(ctx, view)` from a plain view `golf.js` builds, each hole in its theme's fixed palette (`pirate`, `cave` with its darkness and glows, or a newer course's look from `golf-looks.js`, asked first for its grounds, water, tunnels, gates and wells), ice, the scorecard and banners in the course's voice, a bare view for the dashboard's card art, `knownGround`/`knownLiquid` for the unit suite, and `readColors(canvas)`, which reads the `--golf-*` properties `styles/activities.css` mixes from the tokens for the ball, pills and scorecard; decides nothing |
@@ -47,7 +40,7 @@ One row per file of every game but Ghoul Rush (which has its own files: [core](.
| `public/activities/golf-look-frost.js` | How Frosty Peaks is drawn: its palette, ground, water, props and scenery; drawing only, moving with the round's clock |
| `public/activities/golf-paint.js` | Mini golf's shared canvas helpers (`polygon`, `circle`, `ellipse`, `radial`, `fill`, `stroke`, `line`, `label`, `turned`, `t`, `scatter`, `bounds`), no imports, so the drawing files and the looks share them without import loops |
| `public/tones.js` | the activities' sound engine, all synthesized in the browser. Three parts: a shared kit of rich one-shot sounds (`RICH`: `layers` of parts played together, each a wave or a noise (`noise`, `pink`, `brown`) with its own `delay`, `gain`, `attack`, a sweeping `filter` and `vibrato`: `explode`, `smash`, `skid`, `whoosh`, `splashBig`, `fanfare`, `gameOver` and some fifty more, up to 1.2 s, at most `MAX_VOICES` parts sounding at once), held **hums** (`hum(id, name, level, pitch)`, called every frame a game wants it: oscillators and noise through one filter that follows the pitch, pulsed for an engine's strokes; a hum not asked for within `HUM_HOLD_MS` fades by itself, so a paused or closed game goes quiet without saying so, `hushTones()` quiets every one and the Activities window calls it whenever it stops ticking; at most `MAX_HUMS`; shared ones `car`, `toycar`, `electric`, `outboard`, `river`, `wind`, `cycle`, `fuse`, `haunt`, `squeal`, `meter`, `swarm`, `train`, `crowd`), and each game's own extras in `public/activities/<id>-sfx.js` (`{ tones, hums }`, plain objects, names prefixed with the game id, merged and frozen here; a name may be defined once across all of them, which `scripts/test-web-console-tones.mjs` checks along with every spec's shape and every name a game's source asks for). Everything plays through one compressor. The older single blips (`BLIPS`): `tone(name, level, pitch)` with an optional loudness from 0 to 1 and an optional pitch that scales every frequency, kept between 0.25 and 4, and an optional fourth `louder` (a game lifting its sounds as a whole, up to `LOUDER_MAX`, also the fifth argument of `hum()`), `unlockTones()`; Snake's blips plus golf's `putt`, `wall`, `bump`, `cup`, `ace` (a three-note rise), `splash`, `power` (a power-up, three notes), `tunnel`, `boom` (a cannon putt), `sizzle` (lava) and `fall` (the pit), the countdown's `count` and `go`, Stack Deploy's `thunk`, `slice` and `perfect`, which it pitches up a scale step for each perfect in a row, and Bumper Ring's `ram`, pitched and leveled by how hard the hit, and `rev`, a rival winding up a dash, and Hot Potato's `tick`, the fuse, which it ticks quicker and pitches higher as the fuse burns down, and `pop`, a pass, and Crossing Rush's `hop`, which it pitches up a step for each quick hop forward in a row, `boing`, a send-back, `bell`, a train coming, and `horn`, and Bounce Road's `engine`, a soft low triangle hum it plays every few frames while you pick up speed (quiet once you cruise or coast), pitched up with your speed, `spring`, a jump, pitched with your speed, and `squash`, a rival flattened, pitched up a step for each in a chain, and `beat`, a low thump while your wheels run on the verge (it borrows the other games' blips for its hazards and rivals), and Rapids Run's `pew` (a shot, a short soft triangle played quietly about seven times a second while fire is held), `charge` (a buoy taken), `lowcell` (the low battery's two-note beep, quicker the lower it runs), `dambreak` (a dam bursting) and `skim` (a bank skimmed at speed, pitched up the more you have skimmed), and Ghoul Rush's `ghoulBlast` (the blaster's bolt, a short soft triangle repeated while fire is held), `zombiePop` (a kill, pitched up a step for each in the chain), `ghoulStomp`, `ghoulBoo`, `ghoulRoar` and `zombieGroan` (now kept for the other games and the tests: Ghoul Rush's monsters speak with their own voices from `ghoul-sfx.js`), `ghoulCandy` (pitched up for candy in quick succession), `batSwoop` (a bat's kill), `doorUnlock` (the key), `doorThrough` (the door to the next room) and `creakBoard` (a crawler coming up, a chandelier or a crumbling board about to go), all soft triangles and sines), silent while Play sounds is off; separate from `sound.js`'s cue queue |
| `public/music.js` | the games' chiptune music: a small sequencer over `tones.js`'s context and compressor (`audioOut()`). A game calls `music(name, intensity)` from its `tick`; the track fades out within `MUSIC_HOLD_MS` once it stops being asked for, picks up again on the bar it left, asking for a different track crossfades the two over `CROSSFADE_S` (the old one keeps playing as it fades, so a new level is not a cut), and `hushMusic()` stops it at once. Tracks are note data under `music` in each game's `activities/<id>-sfx.js` (`{ bpm, rush, bar, voices, patterns, order }`, `bar` the steps in a bar when it is not 16, so the track resumes on a bar start and each pattern is whole bars: pulse, triangle and noise-drum voices, each joining once the intensity reaches its `from`; a step a token, `A4`, `-` to hold, `.` a rest, `A3^037` an arpeggio, drums `k s h o`), read by `compileTrack()` and booked `LOOKAHEAD_S` ahead on the audio clock. It also plays recorded **songs**: mp3s a game names under `songs` in its sfx file (a name to a served path, merged by `tones.js` as `SONG_TABLES`, listed by `songNames()`), asked for the same way, one `<audio>` element each made on first use, at `SONG_PEAK` times the volume, faded over `SONG_FADE_MS`; a song plays once, never looped, `music()` returning `"playing"` or `"ended"` (which the window's wrapper passes back to the game), `{ restart: true }` taking it back to the top with `load()` (no seeking, since the server sends no byte ranges), and a song no longer asked for fades and pauses where it was. The window plays it only while Play sounds, Play game sounds and Play game music (`looks.gameMusic`, off by default) are all on |
| `public/music.js` | the games' chiptune music: a small sequencer over `tones.js`'s context and compressor (`audioOut()`). A game calls `music(name, intensity)` from its `tick`; the track fades out within `MUSIC_HOLD_MS` once it stops being asked for, picks up again on the bar it left, asking for a different track crossfades the two over `CROSSFADE_S` (the old one keeps playing as it fades, so a new level is not a cut), and `hushMusic()` stops it at once. A track loops while asked for, and `music()` returns `"playing"`, then `"ended"` once it has run through to its last bar (Bounce Road's cue to ask for the next of its twenty), with `{ restart: true }` starting it from its top. Tracks are note data under `music` in each game's `activities/<id>-sfx.js` (`{ bpm, rush, bar, voices, patterns, order }`, `bar` the steps in a bar when it is not 16, so the track resumes on a bar start and each pattern is whole bars: pulse, triangle and noise-drum voices, each joining once the intensity reaches its `from`; a step a token, `A4`, `-` to hold, `.` a rest, `A3^037` an arpeggio, drums `k s h o`), read by `compileTrack()` and booked `LOOKAHEAD_S` ahead on the audio clock. It also plays recorded **songs**: mp3s a game names under `songs` in its sfx file (a name to a served path, merged by `tones.js` as `SONG_TABLES`, listed by `songNames()`), asked for the same way, one `<audio>` element each made on first use, at `SONG_PEAK` times the volume, faded over `SONG_FADE_MS`; a song plays once, never looped, `music()` returning `"playing"` or `"ended"` (which the window's wrapper passes back to the game), `{ restart: true }` taking it back to the top with `load()` (no seeking, since the server sends no byte ranges), and a song no longer asked for fades and pauses where it was. The window plays it only while Play sounds, Play game sounds and Play game music (`looks.gameMusic`, off by default) are all on |
| `public/activities/<game>-sfx.js` | each game's own sound effects (`bounce`, `bugs`, `bumper`, `drive`, `flock`, `fuse`, `golf`, `hop`, `rapids`, `snake`, `stack`, `trails`): `tones` (one-shots played with `tone(name, level, pitch)`) and `hums` (held sounds kept going with `hum(id, name, level, pitch)`), merged into `tones.js` beside the shared kit; definitions only |
| `public/activities/snake-music.js` | Snake's ten music tracks as data (no imports): `SNAKE_MUSIC`, `{ bpm, rush, voices, patterns, order }` each, named `snake<Place>` and listed in `MUSIC_TRACKS` in `snake.js`. A round deals them in a fresh order, one to each level, so a run hears a different track at every level and none twice. They were picked on the pages in `prototypes/music/snake` (rhythm-first folk and world tunes led by something plucked or reedy, mostly dark or modal), and their bars are not all sixteen steps: 6/8 is 12, 7/8 is 14, ten beats is 20, twelve beats is 24, each pattern a whole number of its bars; merged by `snake-sfx.js` |
| `public/activities/light-trails/1.mp3` to `5.mp3` | Light Trails' five background songs, named `trailsSong1` to `trailsSong5` under `songs` in `trails-sfx.js` and listed in `SERVABLE`; re-encoded for size with ffmpeg (80 kbps stereo MP3 at 44.1 kHz, loudness-normalized to -16 LUFS with `loudnorm`, metadata stripped), about 7.6 MB together, and copied into every skill with the rest of the console. The server leaves them out of its start-up cache warm |
@@ -58,7 +51,7 @@ One row per file of every game but Ghoul Rush (which has its own files: [core](.
**Building an Activities game:** the rules every game follows, so a new one plays like the rest.
- **Lives are prominent.** A game with lives draws them as the lives pill: `livesText(round.lives)` in the `LIVES` color from `pills.js`, placed right after the level/stage pill, which `drawPill()` draws solid pink with a heart per life. Never a plain `♥ N` on the dark backing: that was hard to read at a glance. The unit suite checks every game with lives for it.
- **Every game adds looks.json keys, and `cleanLooks()` keeps at most 120.** A new game adds a best (one per course for a game with courses), a memo, a played time (`activityPlayed<Id>`) and, with music, a music volume; the picker adds `activityOrder`. About 76 keys are in use, so raise the cap (or fold keys) before the games that would pass 120.
- **Every game adds looks.json keys, and `cleanLooks()` keeps at most 120.** A new game adds a best (one per course for a game with courses), a memo, a played time (`activityPlayed<Id>`) and, with music, a music volume; the picker adds `activityOrder`. About 77 keys are in use, so raise the cap (or fold keys) before the games that would pass 120.
- **Every game with lives takes the endless-lives code.** Typing up, down, up, down, left, right, left, right, B, A, space on the board gives endless lives until the round starts over or the person leaves the game (`CHEAT_CODE` in `screens/activities.js`, which calls the game's `cheat(true)` and `cheat(false)` on leaving for the picker or closing). A game with lives answers `cheat(on)` by setting `round.infinite`, never takes a life while it is set (`if (!round.infinite) round.lives -= 1`), lets `start()` make a new round without it, and shows `livesText(Infinity)` ("♥ x∞") in its lives pill. `scripts/test-web-console-activities.mjs` checks every listed game whose round has `lives`.
- **Banners never get in the way.** A banner over the board (`"Hit!"`, a new level, a power-up) is placed on the frame it first shows, on the part of the board away from the player, and fades to `BANNER_SEE_THROUGH` (0.12) over `BANNER_FADE_MS` while the player, or anything the player must react to (a diving bug, a bomb, a rival, a hazard, the road over a hill), is in its strip; Snake's `bannerRow()` and `underBanner()` are the model. Give the banner object a `see` field, multiply the draw's alpha by it, and export the strip check (`underBanner`) for the unit suite.
- **The window owns pausing.** A game never resumes itself; `screens/activities.js` decides when a key or click plays on, including the hold on a question or finish (see the row above), so a game needs nothing of its own for it. Full screen is the window's too (`setFull()`: the button, `F`, and a turn or finish putting it back; `fitFull()` sizes the game to the whole screen (black bars where its shape leaves room) and docks the overlaid panel in a bar that holds it, `data-dock="side"` or `"below"`, or floats it, `"float"`, shrunk to the score while a round plays and the pointer is still; and tells the desktop app `activities-full`); a game only sees a bigger `resize()`, so a new game needs nothing for it, as long as its `resize()` sets the canvas's CSS size.
@@ -0,0 +1,21 @@
# Architecture: Bounce Road
> Part of [AGENTS.md](../AGENTS.md) and the [Architecture index](./AGENTS-architecture.md): project guidance for AI coding agents.
Bounce Road's files under `src/web-console/public/activities/`. The other games and the rules every game follows are in [Activities](./AGENTS-architecture-activities.md).
How it fits together: a **stage** is a theme (its look and what it lays on the road) in a slot (how hard: length, holes, rivals), so a run can deal the themes in a new order and stay fair. Every third stage is a boss stage in that boss's arena; fifteen stages make a lap. Rules never draw and drawing never decides: `bounce.js` refills one view object a frame and `bounce-draw.js` draws from it.
| File | Role |
|---|---|
| `public/activities/bounce.js` | the cars, the hazards against them, the gadgets, the scoring and the round, as plain exported functions over a round on a road scrolling up a 72 unit wide field, 90 units of it on the board (it re-exports every rule of `bounce-road.js` and `bounce-rivals.js`, so a suite imports one module). `newRound(seed, random, shuffle)` (the game passes `shuffle` true; the suites leave it off for the classic stage order), `advance` in 4 ms slices over `round.input` (a jump press first, then a `fire`, your `move`, the rivals' `think` and `move`, the pads, the bumps, the barriers, the hazards, `threats`, the ground, progress and traffic). **Driving:** `move`, `jump`, `land` (a landing on a rival flattens it for its points times the chain up to `MAX_CHAIN`; a truck's or the Supply truck's roof is `HAUL_POINTS` and a trampoline; a Spike's roof is a life; a boss takes a hit, `hurtBoss`), `collide` (side knocks split by mass, end on speed passed forward, a heavy back at `CRASH_CLOSE` a crash, a Slasher's blades out a crash, Mega wheels or a Fever flatten on touch), `stunt` (points times `comboOf(streak)`, doubled in a Fever, and it fills the Fever), `lose` (a Bubble saves instead), `underBanner`. **Power-ups** (`POWERS`): Spring, Bubble, Star magnet and a heart work as taken (`applyPower`); the ones with `uses` are gadgets (`GADGETS`: Nitro, Mega wheels, Rockets, Oil slick, Ground pound, Zapper), held one at a time in `you.held` until `usePower`. **The double tap:** `key("action")` jumps at once on the first press and sets `input.fire` on a second within `DOUBLE_TAP_MS` while a gadget is held (never on a repeat, never across a pause), so a jump never waits. **Weapons and the rivals' fire** (`threats`): `round.shots` (rockets: the first rival, boss or barrier in the way), `round.bolts` (a Blaster's: a knock and a slide, never a life), `round.bombs` (a Bomber's, blowing `BOMB_FUSE_MS` on), `round.lobs` (what a boss threw, landing `LOB_MS` on: a barrel lies there as a block, a bomb blows), `round.spills` (oil: yours spins a rival, a boss's takes your grip), the pull of a Magnet rival and the Robo-Vac. **Fever:** `round.fever` fills by `FEVER_GAIN` a stunt; full, `startFever` burns `FEVER_MS` of double points; a life lost halves the meter. **Lives and ranks:** a life every `LIFE_SCORE` points, for a flawless stage and for a boss; a stage line scores `STAGE_POINTS` times the stage, `TIME_POINTS` a second under par and `FLAWLESS_POINTS`, and ranks the stage S to C into `round.ranks`. **The boss hold:** while a boss is alive and the next stage is not yet built, `progress` calls `extendStage` instead of `ensureRoad`, so a boss stage lasts until its boss is beaten (on a road built far ahead, as the suites do, the boss gets away at the line instead). **Road things it settles:** boost strips, ramps, slicks, conveyors (`BELT_PUSH`), spring pads, cones and blocks, bumpers (`BUMPER_POINTS`, a kick, never a life), trains, balls, rollers, sprinklers, drops, gusts, lasers and stompers; an icy or wet stage (`spec.ice`) has less grip everywhere. **The game contract** with `release()`, `cheat(on)`, the events each frame turns into sounds, sparks, floats and banners (`handle`), a power-up's name flashed near the top of the field for `TOAST_MS` (`fx.toast`), the pills (`hudOf`: stage, lives, effects with their timers, the gadget held as `TAP x2: NAME`, the Fever meter, a boss's hp), and the music: `MUSIC_TRACKS` (the twenty chip tracks, a radio in random order), `dealMusic(random, last)` and `MUSIC_HEAT` (the intensity the game asks for: 0.5 on the road, 0.8 while a boss lives, 1 in a Fever), each track played through (`music()` says `"ended"`), a new deal after the last. Memo is the furthest stage reached. A read-only `round` getter is for the tests only. Tuned by scratch bots: a careful bot clears all fifteen classic stages with no rivals on every seed tried, 17 to 35 s a stage |
| `public/activities/bounce-roads.js` | the stages as data and plain arithmetic (no imports): `FIELD_W`, `FIELD_H`, `ROW`, `MAX_HOLE`, `WORLD` (every third stage a boss), `CYCLE` (fifteen stages a lap), `MAX_RIVALS`; `THEMES` (fourteen plain themes and five boss arenas: each one's road widths, piece weights, bridges, flowerbeds, barrier and drop kinds, what its ball, roller and stomper are drawn as, `ice`, `dark`, `boss`, and a `tier` for where in a run it belongs), `REGULAR`, `BOSS_ORDER`, `ARENAS`, `TWISTS` (Rush hour, Gold rush, Lights out, Downpour, Supply drop, Turbo lane) with `TWIST_SHARE`, `KIND_FROM` (the slot each rival kind first comes in), `slotFor(n)` (a stage's difficulty from its place: length, par, pace, sharpness, rivals, kinds, crack and gap lengths), `stageSpec(n, id, twist)` (slot, then theme, then what the twist changes), `classicTheme(n)` and `STAGES` (the first lap of an unshuffled run). The place to tune the difficulty |
| `public/activities/bounce-road.js` | the road, rules only: the jump math every hole is sized by (`airMs(v)`, `reach(v)`, `LONGEST_JUMP`, `JUMP_FAIR`, `TOP_SPEED`, `MAX_SPEED`); the run's plan, `planAt(road, n)` and `stageFor(n, road)` (with no road, or one made with no shuffle, the classic order; a shuffled road deals each lap from its seed: Chalk Lane first, ten of the plain themes roughly gentle to hard, the bosses in a new order with the Cat last on the first lap, a twist on some plain stages; built once a road) and `stageName`; `newRoad(seed, shuffle)` and `buildStage(road, n, random)` (a stage's rows from its own seed by its piece weights: straights, cracks, rivers on bridges, splits, ramps, chicanes, crumbling road, trains, swaying bridges, boost strips, slicks, balls, sprinklers, drops, gusts, conveyors, spring pads, bumpers, lasers, stompers and rollers; every hole after a `RUNUP` with a sign and no longer than `MAX_HOLE`; a boss stage opens with rockets on the road); `POWER_ROLL` and `rollPower(n, roll)` (which power-up, by stage); `extendStage(road, n, to)` (more of the last stage built, its line moving to the new end: the boss hold); the stunt pieces every theme lays (`WILD` in `bounce-roads.js`): `kicker` (a big ramp, `KICKER_AIR` the usual jump, over a chicane), `wall` (blocks right across the road), `trampoline` (three rows of spring pads) and `turbo` (a `TURBO_W` wide lane of boost strips); `ensureRoad`, `groundAt(road, x, d, t)`, `rowGone`, `spanAt`, `holesIn`, `firstAt`, `plainRow`, `safeSpot`; and where each timed thing is at a moment: `swayOff`, `drawLift`, `crumbleAt`, `trainAt`, `ballX` (a ball's and a roller's middle), `sprayAt`, `gustAt`, `laserAt` (on, and blinking `LASER_WARN_MS` before), `stomperAt` (down, the slice it lands in, and its shadow growing `STOMP_WARN_MS` before); plus `seeded`, `GROUND`, `MARK`, `SPAN` |
| `public/activities/bounce-rivals.js` | the rivals, rules only: `RIVALS` (box, mass, speed, points, dodge, weight, car style, and the flags `behind`, `spiky`, `friend`, `boss` with `hp` and a `hint`), `BOSS_KINDS`, `isBoss`, `makeCar`, `think(round, car, ms, random)`, `spawnRival`, `pickKind` (weighted among the stage's kinds, a kind new to the stage more often, one of each special kind at a time), `lob` (a thing thrown at where you are heading). The plain kinds: the Zigzag weaves, the Brick holds your lane and brake-checks, the Frog hops at you, the Sneak drops cones, the Nudge and the Cop chase and shove (never by the water), the Hauler blocks, the Bruiser slams, the Racer passes and flees. The ones with a trick: the Blaster lines up ahead, glows for `AIM_MS` and fires a bolt back down the road; the Slasher pulls alongside, glints for `BLADE_WARN_MS`, then its blades are out for `BLADE_MS`; the Spike sits in your lane, a crash to land on; the Bomber drops bombs while you follow; the Phantom is out of reach for `PHASE_OFF_MS` of every cycle; the Splitter bursts into two Minis; the Magnet hugs an edge and holds your speed; the Supply truck (a friend) keeps ahead for a while, then drives off. The bosses: the Big Rig (`tanker`: lobs barrels, leaks oil), the Robo-Vac (`vac`: sweeps, warns `VAC_WARN_MS`, charges back at you, then drives back up the road through anything), the Whirlybird (`chopper`: `lift` 1 and `high` while it bombs out of reach, then down on the road for `CHOPPER_LOW_MS`), the Monster (hops to come down where you will be, drops tires) and the Cat (`cat`: slams like the Monster, then sweeps across the road for `CAT_SWIPE_MS`). A zapped or oil-spun rival coasts blind (no steering, tricks or hops). Every other rival is rubber-banded to stay near you, swerves from under your landing as sharply as its stage allows, keeps to the narrowest road just ahead, and hops any hole, barrier, coming train, laser or roller |
| `public/activities/bounce-draw.js` | Bounce Road's drawing: `drawScene(ctx, view)` from one view object `bounce.js` refills each frame, in field units: the strip above the field in the page's colors with the pills (laid out by `hudLayout`: stage, lives, Spring, Bubble, Nitro and Mega with their timers, the chain and the combo with its timer; a pill that would run off the board starts a second row), the road a chunk of `CHUNK_ROWS` rows at a time, drawn off screen once per road and scale, a few kept and copied each frame (rows from `bounce-scenery.js`), the layers over it (`bounce-scenery.js`), the landing rings (yours in your highlight, a rival's in red, the Monster's its own size), the cars through `bounce-cars.js` (every shadow first, upright, then every body with its tumble: Planny in your highlight with his box in the page's panel color and his star eye, arms to the wheel, up in the air or cheering, down at the end; each rival kind in its own style and color, the Cop's siren while it chases, the Monster's dents and a star per life left above it, headlights at Night Lights), sparks, rings, the dark of Night Lights, the chain's big number, the stage bar beside the field, banners, and the start and end strip with the big final score and a dot per stage reached; every word kept on the field by `labelSpot`, and `readColors(canvas)`, `limbInk`, `inkOn`; decides nothing; since the arcade layer: a boss routed to its own drawer, the Whirlybird lifted over its shadow, a Phantom faded, your landing ring red and crossed over a Spike, the Fever meter along the strip, a boss's health bar across the top of the field, the title and over screens, a CRT scanline pass, and the dark whenever a stage's `dark` is set (Night Lights or a Lights out twist), with lasers, rockets, bolts and blasts drawn over it; it re-exports `CUSTOM_STYLES` |
| `public/activities/bounce-extras.js` | the arcade layer's drawing, no rules: `CUSTOM_STYLES` (`vac`, `chopper`, `paw`: the three bosses that are not car styles) with `drawBossBody` and `drawBossShadow`; `drawCarExtras` (a Blaster's turret, a Slasher's blades, a Spike's spikes, a Bomber's rack, a Phantom's shimmer, a Magnet's horseshoe, the Supply truck's crate, zap sparks, an oil spin, a boss dazed); `drawPulls` (a Magnet's and the Robo-Vac's pull), `drawYouUnder` and `drawYouOver` (the Fever's rings, the Star magnet's ring, the gadget held); `drawSpills`, `drawThreatsLow` (bombs, a lob's shadow) and `drawThreatsHigh` (rockets, bolts, lobs in flight, pixel fireballs from `fx.booms`); `drawFever`, `drawBossBar`, `drawTitle` (the logo, PRESS SPACE, GAME OVER, the last fifteen rank badges) and `drawScanlines`. Words are drawn through a `label` handed in by `bounce-draw.js`, which it may not import |
| `public/activities/bounce-cars.js` | Bounce Road's cars, drawing only and no imports: `drawCarBody(ctx, style, opts)` draws one top-down toy car about the origin, nose up, filling `w` by `h` field units exactly (tires on the box's corners), in one of `CAR_STYLES` (`STYLE_NAMES`: Planny's convertible with his star eye and arms to the wheel, hatch, sedan, coupe, muscle, pickup, van, box truck, police, racer, taxi, jeep, monster) with flat-fill shading worked out from `color` and `accent` (`shade`, `rgbOf`), and options for roll (`tilt`), a jump (`air`: it draws the shadow and the lift itself), a pancake (`squash`), night beams, a siren bar, damage, a boost flame and brake lights, all moving parts on `opts.clock`; `drawCarShadow` and `shadow: false` for a shadows-first pass in screen space; `carLength(style, w)` for a style's natural length and `carReach(style, opts)` (with `MARGINS`) for what reaches outside the box; plus the newer styles as data rows: armor, buggy, bubble, bus, mini, tow, supply and tanker |
| `public/activities/bounce-scenery.js` | Bounce Road's scenery, drawing only: each stage's look in fixed colors (`LOOKS`: patio slabs, lawn stripes, kitchen tiles, garden, sand, a toy room's rug, a pond with lily pads, roof shingles, the night lawn with lamps and the Monster's dirt; `lookOf`, `stageColor`, `contrast`, `better`), `drawRow` (one row of the road in three passes over a chunk: the yard, the road's surface, the details: edges slanting from row to row, rivers, plank bridges with jagged broken ends, cracks, flowerbeds, rails across a crossing, cracked road over a pit, checkered stage lines, verge decor), and the layers drawn fresh each frame from the round's clock: `drawTimed` (a drawbridge lifting with its red lights, a swaying bridge where it is now, crumbled road gone to the pit), `drawPads` (running boost chevrons, ramps, slicks), `drawBlocks` (cones, toy blocks, pots, buckets, acorns and tires, knocked ones tumbling off), `drawStars`, `drawSigns` (a mark per hazard), `drawItems`, `drawHazardsLow` (crossing lights, the train, a rolling ball, a falling thing's growing shadow, a sprinkler's head), `drawHazardsHigh` (the jet, gust streaks, the thing still falling), `drawNight` and `drawFireflies`; decides nothing; plus the nine newer looks (bath, pinball, desk, ice, lava, garage, hall, attic, couch) with their patterns, lava drawn fresh each frame (`drawLava`), an icy sheen and rain (`drawSheen`, `drawRain`), conveyors, spring pads, bumpers, barrels, the balls by kind, rollers, lasers (`drawBeams`), stompers, the newer signs, and every power-up's mark (`itemMark`, `drawPickup`: a gadget is a square crate, the rest round) |
| `public/activities/bounce-sfx.js` | its own sounds, merged into `tones.js`: `music` (the twenty tracks of `bounce-music.js`, its only import), `tones` (landings, the Monster, the siren, the crossing, a bumper, a rocket, oil, the ground pound, the Fever, a Slasher's blades, the Cat, the Robo-Vac's charge, a gadget loaded) and `hums` (your motor, the Monster, the Whirlybird's rotor, the Robo-Vac, crumbling road, a sprinkler); definitions only |
| `public/activities/bounce-music.js` | its music, all synthesized (no mp3): `SCORES`, twenty short scores (`{ title, key, scale, bpm, kit, bass, arp, drums, A: { chords, lead }, B: { chords, lead } }`: `key` the tonic as a MIDI note for the bass, `chords` a scale degree a bar, `lead` eight bars of sixteen characters, `1` to `7` the scale's degrees, `a` to `g` an octave up, `A` to `G` an octave down, `-` a hold, `.` a rest), and `BOUNCE_MUSIC`, `bounceSong1` to `bounceSong20`, each score turned by `build()` into a `music.js` track when the file loads: a bass, a lead and an arpeggio on one of five chip kits (`KITS`), drums, an echo of the lead (`from` 0.7, a boss) and a harmony under it (`from` 0.9, a Fever), in the order intro, tune, tune with its arpeggio, second tune twice, break, both tunes again (56 bars, 73 to 88 seconds at 146 to 178 bpm, `rush` 14). The bar patterns are `BASS`, `ARP` and `DRUMS`. No imports |
**Tests.** `scripts/test-web-console-activities-bounce.mjs` (driving, the road and its fairness, the stage plan, the older rivals, the bots), `scripts/test-web-console-activities-bounce-arcade.mjs` (gadgets, the Fever, ranks, the newer hazards and rivals, the bosses, the double tap, the music), `scripts/test-web-console-activities-bounce-game.mjs` (the game contract, pills, tones, drawing) and `scripts/test-web-console-activities-bounce-cars.mjs` (the car art). Changing only Bounce Road: run those four.