// Web console tests, Rapids Run: the game contract, the river's shape, steering, speed, the guns, the battery and its buoys, crashes and the restart at the last dam, dams, combos, skims, power-ups, the river's foes and mini-bosses, the memo, the pills, the banners, and bots that show the river is always passable and that a careless run ends quickly. // Run with: node --test scripts/test-web-console-activities-rapids.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.mjs, whose helpers this file copies. import "./seed-random.mjs"; import test from "node:test"; import assert from "node:assert/strict"; import * as rapids from "../src/web-console/public/activities/rapids.js"; import { hudLayout, labelSpot, LOOKS, inkOn, contrast } from "../src/web-console/public/activities/rapids-draw.js"; import { ACCENTS } from "../src/web-console/public/palette.js"; import { LIVES_BACK, LIVES_INK, livesText } from "../src/web-console/public/activities/pills.js"; const { advance, applyPower, channelAt, channelsAt, ensureRiver, hurtBoss, isWater, lose, newRiver, newRound, onLand, placeAt, riverAt, screenY, stretchFor, stretchName, underBanner, AHEAD, BATTERY, BOSS_EVERY, BOSS_POINTS, BUOY_CHARGE, BUOY_POINTS, COMBO_MS, CRASH_MS, CRUISE, DAM_POINTS, DAM_W, DIST_STEP, DRAIN, EDGE, FAST, FIELD_H, FIELD_W, FIRE_MS, FLAWLESS_POINTS, FOES, GRACE_MS, H, LOW_BATTERY, MAX_COMBO, MAX_LIVES, MAX_SHIELDS, MIN_CELL, MIN_CHANNEL, POWERS, READY_MS, RESPAWN_AT, ROW, SHIP_L, SHIP_W, SKIM_MS, SKIM_POINTS, SLOPE, SLOW, START_LIVES, STRETCHES, W, BANNER_Y, } = rapids; const game = rapids.default; /* ------------------------------------------------------------- helpers */ // A 2D context whose every method is a no-op that counts itself. function stubCanvas() { const calls = { count: 0 }; const ctx = new Proxy({}, { 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, getContext: () => ctx }, calls }; } // A 2D context that records where each strip in a banner's shade is filled // (its top and height), and does nothing else. function bannerCanvas(shade) { const shades = []; const ctx = new Proxy({}, { get: (t, name) => (name === "fillRect" ? (x, y, w, h) => t.fillStyle === shade && shades.push([y, h]) : name in t ? t[name] : () => {}), set: (t, name, value) => { t[name] = value; return true; }, }); return { canvas: { width: 0, height: 0, getContext: () => ctx }, shades }; } // The page's tokens in light and dark, for readColors() through a stubbed // getComputedStyle. const THEME_TOKENS = Object.freeze({ light: Object.freeze({ "--panel": "#ffffff", "--panel-2": "#fbf9f6", "--rule": "#e4ddd1", "--accent": "#206cc3", "--ink": "#1d1a17" }), dark: Object.freeze({ "--panel": "#201d1a", "--panel-2": "#262220", "--rule": "#332e29", "--accent": "#619fe5", "--ink": "#f0ece5" }), }); // "#rrggbb" or "rgb(a)(...)" as [r, g, b, a], and the WCAG contrast of two. function rgbaOf(color) { const hex = /^#([0-9a-f]{6})$/i.exec(color); if (hex) return [0, 2, 4].map((k) => parseInt(hex[1].slice(k, k + 2), 16)).concat(1); const [r, g, b, a = 1] = /rgba?\(([^)]*)\)/.exec(color)[1].split(",").map(Number); return [r, g, b, a]; } const toHex = (rgb) => `#${rgb.slice(0, 3).map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`; const overColor = (top, alpha, base) => top.slice(0, 3).map((v, i) => v * alpha + base[i] * (1 - alpha)); function wcag(a, b) { const lum = (c) => { const [r, g, bl] = rgbaOf(c).slice(0, 3).map((v) => (v / 255 <= 0.03928 ? v / 255 / 12.92 : ((v / 255 + 0.055) / 1.055) ** 2.4)); return 0.2126 * r + 0.7152 * g + 0.0722 * bl; }; const [x, y] = [lum(a), lum(b)].sort((p, q) => q - p); return (x + 0.05) / (y + 0.05); } // A 2D context that keeps, for each pill it draws (a rounded fill, perhaps // a timer's rounded tint, then the text with no dark edge), the text's // color, the backing composited over `board` and each tint over that. function pillCanvas(board) { const drawn = []; let since = []; const target = { globalAlpha: 1, getTransform: () => ({ a: 2, b: 0, c: 0, d: 2, e: 0, f: 0 }), measureText: () => ({ width: 50 }) }; const ctx = new Proxy(target, { get: (t, name) => { if (name in t) return t[name]; if (name === "roundRect") return () => since.push({ k: "round" }); if (name === "fill") return () => since.push({ k: "fill", style: t.fillStyle, alpha: t.globalAlpha }); if (name === "fillText") return (text) => { drawn.push({ text: String(text), ink: t.fillStyle, since }); since = []; }; if (name === "strokeText" || name === "fillRect" || name === "stroke") return () => since.push({ k: name }); return () => {}; }, set: (t, name, value) => { t[name] = value; return true; }, }); const canvas = { width: 900, height: 900, getContext: () => ctx }; ctx.canvas = canvas; const pills = () => drawn.flatMap(({ text, ink, since: seq }) => { if (seq.some((e) => e.k === "strokeText") || seq.at(-1)?.k !== "fill") return []; const fills = seq.filter((e, i) => e.k === "fill" && seq[i - 1]?.k === "round"); const back = fills.find((e) => e.alpha === 1); if (!back) return []; const b = rgbaOf(back.style); const backing = toHex(overColor(b, b[3], rgbaOf(board))); const tints = fills.slice(fills.indexOf(back) + 1).map((e) => { const c = rgbaOf(e.style); return toHex(overColor(c, e.alpha * c[3], rgbaOf(backing))); }); return [{ text, ink, backing, tints }]; }); return { canvas, pills, reset: () => { drawn.length = 0; since = []; } }; } // Plays the game a few frames in light and dark under every highlight, runs // `setup(round)`, draws one more frame and checks every pill's text reads // at 4.5:1 on its backing and each tint, and that each of `expect` showed // (a "~" before one: drawn with a timer's tint). function checkPills({ setup = () => {}, expect = [] } = {}) { const saved = globalThis.getComputedStyle; try { for (const [theme, tokens] of Object.entries(THEME_TOKENS)) { for (const [id, accent] of Object.entries(ACCENTS)) { const values = { ...tokens, "--accent": accent[theme][0] }; globalThis.getComputedStyle = () => ({ getPropertyValue: (name) => values[name] || "" }); const { canvas, pills, reset } = pillCanvas(values["--panel"]); const g = game.create({ canvas }); g.resize(900, 900); g.key("action"); for (let k = 0; k < 5; k++) g.tick(16); setup(g.round); reset(); g.tick(16); const seen = pills(); assert.ok(seen.length > 0, `${theme}/${id}: pills drawn`); for (const p of seen) { for (const under of [p.backing, ...p.tints]) { const k = wcag(p.ink, under); assert.ok(k >= 4.5, `${theme}/${id}: "${p.text}" in ${p.ink} on ${under} reads ${k.toFixed(2)}:1`); } } for (const want of expect) { const tinted = want.startsWith("~"); const text = tinted ? want.slice(1) : want; assert.ok(seen.some((p) => p.text.includes(text) && (!tinted || p.tints.length)), `${theme}/${id}: "${text}" drawn${tinted ? " with its tint" : ""} (${seen.map((p) => p.text)})`); } } } } finally { if (saved === undefined) delete globalThis.getComputedStyle; else globalThis.getComputedStyle = saved; } } // A round with nothing on the river but the river: no foes, buoys, crates // or bolts, so a test sets out only what it means to. function quiet(seed = 7) { const round = newRound(seed); clear(round); return round; } function clear(round) { round.foes.length = 0; round.buoys.length = 0; round.crates.length = 0; round.bolts.length = 0; round.loaded = round.stretch + 1; return round; } // A foe set out by hand, shaped as the round's loader makes them. function foe(round, kind, x, d, extra = {}) { const f = { kind, n: round.stretch, x, d, vx: 0, hp: FOES[kind].hp, r: FOES[kind].r, t: 0, flash: 0, on: false, fireMs: 600, ...extra }; round.foes.push(f); return f; } const eventsOf = (round, type) => round.events.filter((e) => e.type === type); const center = (round, d = round.ship.d) => riverAt(round.river, d).c; // Runs `ms` in frames of 16, clearing the river ahead first if asked. function run(round, ms, each = () => {}) { for (let t = 0; t < ms && !round.over; t += 16) { each(round); advance(round, 16); } } // Starts a game the way the window's key does and checks its opening banner: // painted on the start's own frame, inside the field (0 to `field`), and in // the same place on the first tick. function openingBanner(g, shades, field) { shades.length = 0; g.key("action"); assert.equal(shades.length, 1, "the start paints its banner"); const [[top, h]] = shades; assert.ok(top >= 0 && top + h <= field, `inside the field, not at its top edge (${top})`); shades.length = 0; g.tick(16); assert.deepEqual(shades, [[top, h]], "in the same place once play begins"); } /* ---------------------------------------------------------------- bots */ // A careful bot: it keeps to the channel it is in over the next stretch of // river (its whole hull, the stern too), heads for the middle of the water // ahead, chases a buoy it can reach when the battery is under 90 and holds // its fire off it, dodges what it can, slows for a dam still standing and // fires the rest of the time. function carefulBot(round) { const { ship, river } = round; const inp = round.input; const look = 6 + ship.v * 0.45; let lo = -Infinity; let hi = Infinity; let cx = ship.x; for (let a = -3; a <= look; a += 1.5) { const ch = channelAt(river, cx, ship.d + a); lo = Math.max(lo, ch.lo); hi = Math.min(hi, ch.hi); if (hi - lo < 6) { lo = ch.lo; hi = ch.hi; cx = (lo + hi) / 2; } } const far = channelAt(river, cx, ship.d + look); let tx = (far.lo + far.hi) / 2; const want = round.battery < 90; if (want) { const reach = (b) => { const ch = channelAt(river, ship.x, b.d); return b.x > ch.lo + 1 && b.x < ch.hi - 1; }; const b = round.buoys.filter((o) => o.d > ship.d + 1 && o.d < ship.d + 60 && reach(o)).sort((a, c) => a.d - c.d)[0]; if (b) tx = b.x; } for (const f of round.foes) { const ahead = f.d - ship.d; if (f.kind === "whirl" || f.kind === "sentry") continue; if (ahead > -2 && ahead < 16 && Math.abs(f.x - ship.x) < f.r + 2.4) tx = f.x > (lo + hi) / 2 ? lo + 2.6 : hi - 2.6; } inp.fire = !(want && round.buoys.some((b) => b.d > ship.d && b.d < ship.d + 75 && Math.abs(b.x - ship.x) < 3.5)); if (hi - lo > 5.4) tx = Math.min(hi - 2.7, Math.max(lo + 2.7, tx)); inp.left = tx < ship.x - 0.3; inp.right = tx > ship.x + 0.3; inp.down = round.dam.hp > 0 && round.dam.d - ship.d < 75; inp.up = false; } /* ------------------------------------------------------------ contract */ test("Rapids Run answers the game contract: start, pause, resume, keys, releases, ticks, a too small board refused, a number score and a state", () => { assert.equal(game.id, "rapids"); assert.equal(game.title, "Rapids Run"); assert.equal(typeof game.create, "function"); assert.ok(Object.isFrozen(game)); assert.ok(!("lowerIsBetter" in game), "the highest score is the best"); const { canvas, calls } = stubCanvas(); const g = game.create({ canvas, tone: () => {}, onScore: () => {} }); assert.equal(g.state, "ready"); assert.equal(g.score, 0); g.pause(); assert.equal(g.state, "ready", "pause before start does nothing"); g.resume(); assert.equal(g.state, "ready", "resume before start does nothing"); g.tick(10_000); assert.equal(g.state, "ready", "a tick before start does nothing"); assert.equal(g.resize(1, 1), false, "a tiny board is refused"); assert.equal(g.resize(W * MIN_CELL - 1, 4000), false, "too narrow to play"); assert.equal(g.resize(4000, H * MIN_CELL - 1), false, "too short to play"); assert.equal(g.resize(W * MIN_CELL, H * MIN_CELL), true, "just big enough"); assert.equal(g.resize(2000, 2000), true); g.start(); assert.equal(g.state, "running"); g.key("left"); g.key("action"); g.pause(); assert.equal(g.state, "paused"); assert.deepEqual(Object.values(g.round.input), [false, false, false, false, false], "a pause lets go of every held key"); const before = { score: g.score, calls: calls.count, clock: g.round.clock }; g.tick(10_000); assert.deepEqual({ score: g.score, calls: calls.count, clock: g.round.clock }, before, "ticks while paused change nothing"); g.resume(); assert.equal(g.state, "running"); for (const name of ["up", "down", "left", "right"]) assert.equal(g.key(name), true, `${name} is used`); assert.equal(g.key("action"), true); assert.equal(g.key("jump"), false, "an unknown key is not used"); assert.equal(g.round.input.fire, true, "space held fires"); g.release("action"); g.release("left"); assert.equal(g.round.input.fire, false, "let go, it stops firing"); assert.equal(g.round.input.left, false); const drawn = calls.count; g.tick(200); assert.ok(calls.count > drawn, "a tick while running draws"); assert.equal(typeof g.score, "number"); }); test("Rapids Run: space or Enter starts a round from the start or end screen without firing (Enter has no release), a press while running fires, and a press while paused leaves resuming to the window", () => { const { canvas } = stubCanvas(); const g = game.create({ canvas }); g.resize(900, 900); g.key("action"); assert.equal(g.state, "running"); assert.equal(g.round.input.fire, false, "the start does not fire"); g.round.battery = 50; g.round.buoys.push({ x: g.round.ship.x, d: g.round.ship.d + 40, n: 1, t: 0 }); for (let k = 0; k < 30; k++) g.tick(16); assert.equal(g.round.stats.popped, 0, "so no buoy ahead is shot"); g.key("action"); assert.equal(g.round.input.fire, true, "a press while running fires"); g.release("action"); g.pause(); g.key("action"); assert.equal(g.state, "paused", "only the window plays on"); g.resume(); g.round.lives = 1; lose(g.round, "flat"); for (let k = 0; k < 100 && g.state === "running"; k++) g.tick(16); assert.equal(g.state, "over"); g.key("action"); assert.equal(g.state, "running", "a fresh round"); assert.equal(g.round.input.fire, false, "again without firing"); }); test("Rapids Run: the round's end calls onScore once with its score, shows it big, and space starts a fresh round", () => { const texts = []; let font = ""; const ctx = new Proxy({}, { get: (target, name) => (name === "fillText" ? (text) => texts.push([String(text), font]) : name in target ? target[name] : () => {}), set: (target, name, value) => { if (name === "font") font = value; target[name] = value; return true; }, }); const scores = []; const g = game.create({ canvas: { width: 0, height: 0, getContext: () => ctx }, onScore: (n) => scores.push(n) }); g.resize(900, 900); g.key("action"); g.tick(16); clear(g.round); g.round.lives = 1; g.round.score = 1234; g.round.ship.x = riverAt(g.round.river, g.round.ship.d).L + 0.2; for (let ms = 0; ms < CRASH_MS + 200 && g.state === "running"; ms += 16) g.tick(16); assert.equal(g.state, "over"); assert.deepEqual(scores, [g.score], "onScore once, with the score"); assert.ok(g.score >= 1234); texts.length = 0; g.resize(900, 900); assert.ok(texts.some(([t, f]) => t === String(g.score) && /\b7px/.test(f)), "the score, big"); assert.ok(texts.some(([t]) => t.startsWith("Reached Willow Run (dam 1)"))); g.tick(1000); assert.equal(scores.length, 1, "once"); g.key("action"); assert.equal(g.state, "running", "space starts again at once"); assert.equal(g.score, 0); assert.equal(g.round.lives, START_LIVES); }); /* -------------------------------------------------------------- river */ test("Rapids Run: the same seed builds the same river and plan, a different seed another", () => { const a = newRiver(42); const b = newRiver(42); const c = newRiver(43); for (const r of [a, b, c]) ensureRiver(r, 3000); assert.deepEqual(a.C.slice(0, 1200), b.C.slice(0, 1200)); assert.deepEqual(a.plans[2], b.plans[2]); assert.notDeepEqual(a.C.slice(0, 1200), c.C.slice(0, 1200)); }); test("Rapids Run: over the first ten stretches on many rivers, every row keeps a channel at least MIN_CHANNEL wide, the banks on the field, no bank slanting past SLOPE, and a dam DAM_W wide at each stretch's end", () => { for (let seed = 1; seed <= 25; seed++) { const river = newRiver(seed * 977); ensureRiver(river, 0); while (river.built < 10) rapids.buildStretch(river, river.built + 1); let prev = null; for (let i = 0; i < river.rows; i++) { const d = i * ROW; const r = riverAt(river, d); assert.ok(r.L >= EDGE - 1e-9 && r.R <= FIELD_W - EDGE + 1e-9, `seed ${seed} row ${i}: banks on the field (${r.L}, ${r.R})`); for (const ch of channelsAt(river, d)) assert.ok(ch.hi - ch.lo >= MIN_CHANNEL - 1e-9, `seed ${seed} row ${i}: a channel ${ch.hi - ch.lo} wide`); if (prev) { for (const k of ["L", "R"]) assert.ok(Math.abs(r[k] - prev[k]) <= SLOPE * ROW + 1e-9, `seed ${seed} row ${i}: ${k} slants ${Math.abs(r[k] - prev[k])}`); if (r.island && prev.island) for (const k of ["IL", "IR"]) assert.ok(Math.abs(r[k] - prev[k]) <= SLOPE * ROW + 1e-9, `seed ${seed} row ${i}: the island's ${k}`); } prev = r; } for (let n = 1; n <= 10; n++) { const dam = riverAt(river, river.damAt[n]); assert.ok(Math.abs(dam.w - DAM_W) < 1e-6 && !dam.island, `seed ${seed}: dam ${n} spans the river, ${DAM_W} wide`); assert.ok(river.damAt[n] > river.startAt[n] + 400, `seed ${seed}: stretch ${n} has room`); if (n > 1) assert.ok(river.startAt[n] > river.damAt[n - 1], "a stretch starts past the last dam"); assert.equal(river.bossAt[n] > 0, n % BOSS_EVERY === 0, "a basin before every BOSS_EVERYth dam"); } } }); test("Rapids Run: a stretch's plan puts foes, buoys and crates on open water (sentries on the bank), none where you start again and none just before the dam", () => { for (let seed = 1; seed <= 15; seed++) { const river = newRiver(seed * 31); ensureRiver(river, 0); while (river.built < 8) rapids.buildStretch(river, river.built + 1); for (let n = 1; n <= 8; n++) { const plan = river.plans[n]; assert.ok(plan.some((p) => p.kind === "buoy"), "buoys"); assert.ok(plan.some((p) => p.kind === "crate"), "a crate"); for (const p of plan) { assert.ok(p.d >= river.startAt[n] + 30, `seed ${seed} stretch ${n}: ${p.kind} clear of the restart`); assert.ok(p.d <= river.damAt[n] - 20, `seed ${seed} stretch ${n}: ${p.kind} clear of the dam`); if (p.kind === "gull") continue; if (p.kind === "sentry") assert.ok(!isWater(river, p.x, p.d) && p.x > 0 && p.x < FIELD_W, `${p.kind} on the bank`); else assert.ok(isWater(river, p.x, p.d), `seed ${seed} stretch ${n}: ${p.kind} at ${p.x} on the water`); if (p.kind !== "buoy" && p.kind !== "crate") assert.ok(FOES[p.kind].from <= n, `${p.kind} not before stretch ${FOES[p.kind].from}`); } } } }); test("Rapids Run: stretches are named, the eight then Night Water again and again, quicker each time, a boss every BOSS_EVERY", () => { assert.equal(STRETCHES.length, 8); assert.equal(stretchFor(1).name, "Willow Run"); assert.equal(stretchName(3), "Stone Gate (dam 3)"); assert.equal(stretchFor(9).name, "Night Water"); assert.equal(stretchFor(10).name, "Night Water 2"); assert.ok(stretchFor(4).boss && stretchFor(8).boss && !stretchFor(5).boss); for (let n = 1; n < 14; n++) assert.ok(stretchFor(n + 1).pace >= stretchFor(n).pace); for (let n = 1; n <= 14; n++) assert.ok(LOOKS[stretchFor(n).look], `stretch ${n} has a look`); }); /* -------------------------------------------------------------- moving */ test("Rapids Run: held arrows steer until let go, the skimmer stays on the field, and up, down or neither sets the speed", () => { const round = quiet(); const ship = round.ship; const x = ship.x; round.input.right = true; run(round, 300); assert.ok(ship.x > x + 4, "right steers right"); round.input.right = false; run(round, 400); assert.ok(Math.abs(ship.vx) < 0.5, "let go, it stops sliding"); const pace = stretchFor(1).pace; round.input.up = true; run(round, 1000); assert.ok(Math.abs(ship.v - FAST * pace) < 1e-6, "up held: full speed"); round.input.up = false; round.input.down = true; run(round, 1000); assert.ok(Math.abs(ship.v - SLOW * pace) < 1e-6, "down held: slow"); round.input.down = false; run(round, 1000); assert.ok(Math.abs(ship.v - CRUISE * pace) < 1e-6, "neither: cruising"); assert.ok(Math.abs(round.cam - (ship.d - rapids.BEHIND)) < 1e-9, "the view follows"); }); test("Rapids Run: the river runs DIST_POINTS a DIST_STEP, twice that at full speed", () => { const slow = quiet(); const fast = quiet(); fast.input.up = true; run(fast, 600); const d0 = { slow: slow.ship.d, fast: fast.ship.d }; const s0 = { slow: slow.score, fast: fast.score }; run(slow, 1000); run(fast, 1000); const rate = (r, k) => (r.score - s0[k]) / ((r.ship.d - d0[k]) / DIST_STEP); assert.ok(Math.abs(rate(slow, "slow") - 1) < 0.2, `cruising: about 1 a step (${rate(slow, "slow")})`); assert.ok(Math.abs(rate(fast, "fast") - 2) < 0.3, `full speed: about 2 a step (${rate(fast, "fast")})`); }); test("Rapids Run: held fire shoots every FIRE_MS, spread shot fans three, and a shot sinks a skiff", () => { const round = quiet(); round.input.fire = true; advance(round, 1000); const shots = eventsOf(round, "shoot").length; assert.ok(Math.abs(shots - 1000 / FIRE_MS) <= 1, `${shots} shots a second`); round.events.length = 0; round.shots.length = 0; applyPower(round, "spread"); advance(round, FIRE_MS); assert.equal(round.shots.length % 3, 0, "three at a time"); assert.ok(round.shots.some((s) => s.vx < 0) && round.shots.some((s) => s.vx > 0), "fanned out"); round.input.fire = false; round.shots.length = 0; const f = foe(round, "skiff", round.ship.x, round.ship.d + 20); round.input.fire = true; advance(round, 400); assert.ok(!round.foes.includes(f), "sunk"); assert.equal(eventsOf(round, "kill")[0].points, FOES.skiff.points); assert.equal(round.stats.kills, 1); }); /* ------------------------------------------------------------ battery */ test("Rapids Run: the battery drains DRAIN a second cruising, more at speed and less slowed; a buoy run over charges BUOY_CHARGE, never past full; a shot one is gone for BUOY_POINTS", () => { const cruise = quiet(); run(cruise, 1000); assert.ok(Math.abs(BATTERY - cruise.battery - DRAIN) < 0.1, `cruising drains ${BATTERY - cruise.battery}`); const fast = quiet(); fast.input.up = true; const slow = quiet(); slow.input.down = true; run(fast, 2000); run(slow, 2000); assert.ok(fast.battery < cruise.battery - DRAIN, "faster drains more"); assert.ok(slow.battery > BATTERY - 2 * DRAIN, "slowed drains less"); const round = quiet(); round.battery = 30; round.buoys.push({ x: round.ship.x, d: round.ship.d + 6, n: 1, t: 0 }); run(round, 400); assert.equal(round.buoys.length, 0); assert.ok(round.battery > 30 + BUOY_CHARGE - 2, `charged to ${round.battery}`); assert.equal(eventsOf(round, "charge").length, 1); round.battery = BATTERY - 5; round.buoys.push({ x: round.ship.x, d: round.ship.d + 6, n: 1, t: 0 }); run(round, 400); assert.ok(round.battery <= BATTERY, "never past full"); const shoot = quiet(); shoot.battery = 50; shoot.buoys.push({ x: shoot.ship.x, d: shoot.ship.d + 40, n: 1, t: 0 }); shoot.input.fire = true; const score = shoot.score; run(shoot, 500); assert.equal(shoot.buoys.length, 0, "shot to pieces"); assert.equal(eventsOf(shoot, "popbuoy")[0].points, BUOY_POINTS); assert.equal(eventsOf(shoot, "charge").length, 0, "and no charge from it"); assert.ok(shoot.score >= score + BUOY_POINTS); assert.ok(shoot.battery < 50); }); test("Rapids Run: a flat battery costs a life even with a shield, and the stretch starts again with a full one", () => { const round = quiet(); round.shield = 1; round.battery = 0.5; run(round, 400); const lost = eventsOf(round, "lose"); assert.equal(lost.length, 1); assert.equal(lost[0].cause, "flat"); assert.equal(round.lives, START_LIVES - 1); assert.equal(round.shield, 1, "the shield cannot help"); run(round, CRASH_MS + 50); assert.equal(round.phase, "ready"); assert.equal(round.battery, BATTERY); }); /* ------------------------------------------------------------ crashes */ test("Rapids Run: a bank or an island under the hull costs a life, the wreck shows CRASH_MS, then the skimmer waits READY_MS at the stretch's start, blinking for GRACE_MS", () => { const round = quiet(); const ship = round.ship; ship.x = riverAt(round.river, ship.d).R - 0.4; advance(round, 16); assert.equal(eventsOf(round, "lose")[0].cause, "bank"); assert.equal(round.phase, "crash"); assert.equal(ship.alive, false); const d = ship.d; advance(round, CRASH_MS - 100); assert.equal(ship.d, d, "the wreck holds still"); advance(round, 150); assert.equal(round.phase, "ready"); assert.equal(eventsOf(round, "respawn").length, 1); assert.equal(ship.d, round.river.startAt[1] + RESPAWN_AT); assert.ok(ship.invuln > GRACE_MS - 200); const at = ship.d; advance(round, READY_MS - 200); assert.equal(ship.d, at, "waiting still"); advance(round, 200); assert.equal(round.phase, "run"); assert.equal(eventsOf(round, "go").length, 1); // An island. const r2 = quiet(3); let isle = -1; for (let i = 0; i < r2.river.rows; i++) if (r2.river.IW[i] > 8) { isle = i; break; } if (isle < 0) { ensureRiver(r2.river, 4000); for (let i = 0; i < r2.river.rows; i++) if (r2.river.IW[i] > 8) { isle = i; break; } } assert.ok(isle > 0, "an island somewhere"); r2.ship.d = isle * ROW; r2.ship.x = r2.river.C[isle]; advance(r2, 16); assert.equal(eventsOf(r2, "lose")[0]?.cause, "bank", "an island is land too"); }); test("Rapids Run: running into a foe or a bolt costs a life; a shield takes one crash of any kind but a flat battery, and slides you off a bank", () => { const round = quiet(); foe(round, "mine", round.ship.x, round.ship.d + 3); advance(round, 100); assert.equal(eventsOf(round, "lose")[0].cause, "foe"); const r2 = quiet(); r2.bolts.push({ x: r2.ship.x, d: r2.ship.d + 3, vx: 0, vd: -20 }); advance(r2, 200); assert.equal(eventsOf(r2, "lose")[0].cause, "bolt"); const r3 = quiet(); applyPower(r3, "shield"); applyPower(r3, "shield"); applyPower(r3, "shield"); assert.equal(r3.shield, MAX_SHIELDS); const m = foe(r3, "skiff", r3.ship.x, r3.ship.d + 3); advance(r3, 100); assert.equal(eventsOf(r3, "lose").length, 0); assert.equal(eventsOf(r3, "shield").length, 1); assert.ok(!r3.foes.includes(m), "the skiff is rammed and sunk"); assert.equal(r3.shield, MAX_SHIELDS - 1); r3.ship.invuln = 0; r3.ship.x = riverAt(r3.river, r3.ship.d).L + 0.3; advance(r3, 16); assert.equal(eventsOf(r3, "lose").length, 0, "the last shield takes the bank"); assert.equal(r3.shield, 0); assert.ok(!onLand(r3.river, r3.ship.x, r3.ship.d), "and slides you off it"); assert.equal(r3.lives, START_LIVES); }); test("Rapids Run: while blinking after a crash nothing hits you, and lose() never takes two lives at once", () => { const round = quiet(); round.ship.invuln = 500; foe(round, "mine", round.ship.x, round.ship.d + 2); advance(round, 100); assert.equal(eventsOf(round, "lose").length, 0); round.ship.invuln = 0; assert.equal(lose(round, "foe"), true); assert.equal(lose(round, "foe"), false); assert.equal(round.lives, START_LIVES - 1); }); test("Rapids Run: losing the last life ends the round once the wreck has shown", () => { const round = quiet(); round.lives = 1; lose(round, "bank"); assert.equal(round.over, false); assert.equal(advance(round, CRASH_MS + 20), "over"); assert.equal(eventsOf(round, "over").length, 1); }); /* --------------------------------------------------------------- dams */ // Puts a quiet round just short of its dam, slowed and firing. function atDam(round, gap = 60) { const dam = round.dam; round.ship.d = dam.d - gap; round.ship.x = center(round); round.cam = round.ship.d - rapids.BEHIND; round.input.down = true; round.input.fire = true; } test("Rapids Run: a dam takes its stretch's damHp shots, scores DAM_POINTS times the stretch, and once past it the next stretch begins, with a bonus for no life lost", () => { const round = quiet(); atDam(round); const hp = stretchFor(1).damHp; assert.equal(round.dam.hp, hp); run(round, 4000, () => clear(round)); const hits = eventsOf(round, "damhit"); assert.equal(hits.length, hp - 1); const broke = eventsOf(round, "dambreak"); assert.equal(broke.length, 1); assert.equal(broke[0].points, DAM_POINTS * 1); assert.equal(round.stats.dams, 1); round.input.down = false; run(round, 3000, () => clear(round)); const next = eventsOf(round, "stretch"); assert.equal(next.length, 1); assert.equal(next[0].n, 2); assert.equal(next[0].bonus, FLAWLESS_POINTS); assert.equal(round.stretch, 2); assert.equal(round.dam.hp, stretchFor(2).damHp); assert.equal(round.dam.d, round.river.damAt[2]); }); test("Rapids Run: a dam still standing is a crash, and after one in stretch 2 you start again just past dam 1 with dam 2 whole", () => { const round = quiet(); placeAt(round, 2); clear(round); round.ship.d = round.dam.d - SHIP_L; round.ship.x = center(round, round.dam.d); round.dam.hp = 3; advance(round, 200); assert.equal(eventsOf(round, "lose")[0].cause, "dam"); advance(round, CRASH_MS + 50); assert.equal(round.stretch, 2); assert.equal(round.ship.d, round.river.startAt[2] + RESPAWN_AT); assert.ok(round.ship.d > round.river.damAt[1]); assert.equal(round.dam.hp, stretchFor(2).damHp, "the dam is whole again"); assert.equal(round.stretchHit, true, "and the life stays lost until the next dam"); }); test("Rapids Run: a stretch with a life lost earns no flawless bonus, even after the restart; a dam blasted then a crash before it stays open and is paid once", () => { const round = quiet(); round.ship.x = riverAt(round.river, round.ship.d).L + 0.2; advance(round, 16); assert.equal(eventsOf(round, "lose").length, 1); advance(round, CRASH_MS + READY_MS + 100); assert.equal(round.phase, "run"); clear(round); atDam(round); run(round, 6000, () => clear(round)); const next = eventsOf(round, "stretch"); assert.equal(next.length, 1); assert.equal(next[0].bonus, 0, "no flawless bonus"); assert.equal(round.stretchHit, false, "the next stretch starts clean"); const r2 = quiet(); atDam(r2); run(r2, 6000, (r) => { clear(r); if (r.dam.hp <= 0 && !eventsOf(r, "lose").length) lose(r, "foe"); }); assert.equal(eventsOf(r2, "dambreak").length, 1); assert.equal(eventsOf(r2, "lose").length, 1); const score = r2.score; advance(r2, CRASH_MS + READY_MS + 100); assert.equal(r2.dam.hp, 0, "the dam stays open after the restart"); run(r2, 40_000, (r) => { clear(r); r.battery = BATTERY; carefulBot(r); if (eventsOf(r, "stretch").length) r.over = true; }); assert.equal(eventsOf(r2, "dambreak").length, 1, "and is paid for once"); const passed = eventsOf(r2, "stretch"); assert.equal(passed.length, 1); assert.equal(passed[0].bonus, 0); assert.ok(r2.score >= score, "nothing taken back"); }); /* ------------------------------------------------------- combos, skims */ test("Rapids Run: kills within COMBO_MS step the combo up to MAX_COMBO, multiplying the points, and it lapses after", () => { const round = quiet(); const points = []; for (let k = 0; k < MAX_COMBO + 2; k++) { const f = foe(round, "skiff", 10, round.ship.d + 30); rapids.hurtFoe(round, f); points.push(round.events.at(-1).points); advance(round, 100); } assert.deepEqual(points, [1, 2, 3, 4, 5, 5, 5].map((m) => m * FOES.skiff.points)); assert.equal(round.bestCombo, MAX_COMBO); advance(round, COMBO_MS + 50); assert.equal(round.combo, 1); const f = foe(round, "mine", 10, round.ship.d + 30); assert.equal(rapids.hurtFoe(round, f), false, "a mine takes two"); assert.equal(rapids.hurtFoe(round, f), true); assert.equal(round.events.at(-1).points, FOES.mine.points); }); test("Rapids Run: skimming a bank closer than SKIM_GAP at cruising speed scores SKIM_POINTS each SKIM_MS; slowed down it scores nothing", () => { const skimming = quiet(); const hug = (r) => { const ch = channelAt(r.river, r.ship.x, r.ship.d); const ch2 = channelAt(r.river, r.ship.x, r.ship.d + SHIP_L / 2); r.ship.x = Math.max(ch.lo, ch2.lo) + SHIP_W / 2 + 0.5; r.ship.vx = 0; }; run(skimming, 1000, hug); const skims = eventsOf(skimming, "skim"); assert.ok(Math.abs(skims.length - 1000 / SKIM_MS) <= 1, `${skims.length} skims a second`); assert.equal(skims[0].points, SKIM_POINTS); const slow = quiet(); slow.input.down = true; run(slow, 600); slow.events.length = 0; run(slow, 1000, hug); assert.equal(eventsOf(slow, "skim").length, 0); }); /* ------------------------------------------------------------ powers */ test("Rapids Run: power-ups: a crate run over is taken; spread and magnet run out; the magnet pulls buoys in; surge fills the battery", () => { const round = quiet(); round.crates.push({ x: round.ship.x, d: round.ship.d + 6, n: 1, kind: "magnet" }); run(round, 400); assert.equal(round.crates.length, 0); assert.ok(rapids.active(round, "magnet")); round.battery = 40; const b = { x: round.ship.x + 12, d: round.ship.d + 14, n: 1, t: 0 }; round.buoys.push(b); run(round, 900); assert.equal(round.buoys.length, 0, "pulled in and taken"); assert.ok(round.battery > 60); run(round, POWERS.magnet.ms); assert.ok(!rapids.active(round, "magnet"), "it runs out"); round.battery = 10; applyPower(round, "surge"); assert.equal(round.battery, BATTERY); applyPower(round, "spread"); assert.equal(round.effects.spread, POWERS.spread.ms); assert.deepEqual(Object.keys(POWERS).sort(), ["magnet", "shield", "spread", "surge"]); }); /* -------------------------------------------------------------- foes */ test("Rapids Run: a skiff drifts and turns at the banks, a darter swerves into your lane, a mine sits still, and a whirlpool tugs you toward its eye and lets shots through", () => { const round = quiet(); const ch = channelAt(round.river, round.ship.x, round.ship.d + 30); const skiff = foe(round, "skiff", ch.hi - 2.5, round.ship.d + 40, { vx: 8 }); round.ship.d += 0; for (let k = 0; k < 40; k++) { advance(round, 16); round.ship.d = skiff.d - 40; } assert.ok(skiff.vx < 0, "turned at the bank"); const r2 = quiet(); r2.ship.x = center(r2) - 4; const dart = foe(r2, "darter", r2.ship.x + 6, r2.ship.d + 30, { vx: 2 }); advance(r2, 300); assert.ok(Math.abs(dart.x - r2.ship.x) < 6 - 1, "swerved toward you"); const r3 = quiet(); const mine = foe(r3, "mine", 10, r3.ship.d + 40); advance(r3, 300); assert.equal(mine.x, 10); const r4 = quiet(); r4.ship.x = center(r4) - 3; foe(r4, "whirl", center(r4), r4.ship.d + 1); const x0 = r4.ship.x; advance(r4, 100); assert.ok(r4.ship.x > x0 + 0.3, "tugged toward the eye"); r4.foes[0].d = r4.ship.d + 25; r4.foes[0].x = r4.ship.x; r4.input.fire = true; advance(r4, 300); assert.equal(r4.foes.length, 1, "a whirlpool cannot be shot"); assert.equal(eventsOf(r4, "kill").length, 0); }); test("Rapids Run: a gull drone takes off as you near and swoops across over land and all; a bank sentry fires at you while you are in its range", () => { const round = quiet(); const gull = foe(round, "gull", -3, round.ship.d + 80, { vx: 18 }); advance(round, 16); assert.equal(gull.on, false, "still waiting"); round.ship.d = gull.d - 50; advance(round, 16); assert.equal(gull.on, true); assert.equal(eventsOf(round, "gull").length, 1); const x = gull.x; const d = gull.d; advance(round, 500); assert.ok(gull.x > x + 8 && gull.d < d, "across and down at you"); const r2 = quiet(); const r = riverAt(r2.river, r2.ship.d + 40); foe(r2, "sentry", r.L - 3, r2.ship.d + 40); r2.input.down = true; advance(r2, 1000); assert.ok(eventsOf(r2, "bolt").length >= 1, "it fires"); assert.ok(r2.bolts.length >= 1); }); test("Rapids Run: foes turn up from their own stretch, and each stretch has more of them", () => { for (const [kind, from] of [["skiff", 1], ["mine", 1], ["gull", 2], ["sentry", 3], ["whirl", 5], ["darter", 6]]) assert.equal(FOES[kind].from, from); for (let n = 1; n < 10; n++) { if (stretchFor(n).boss || stretchFor(n + 1).boss) continue; assert.ok(stretchFor(n + 1).foes >= stretchFor(n).foes); } const river = newRiver(5); ensureRiver(river, 0); while (river.built < 7) rapids.buildStretch(river, river.built + 1); const kinds = new Set(river.plans.slice(1, 8).flatMap((p) => p.map((e) => e.kind))); for (const k of Object.keys(FOES)) assert.ok(kinds.has(k), `${k} turns up by stretch 7`); }); /* -------------------------------------------------------------- boss */ test("Rapids Run: at every BOSS_EVERYth dam a mini-boss holds the basin: the river stops, the battery holds, it fires, and sinking it scores, gives a life and opens the way", () => { const round = quiet(); placeAt(round, BOSS_EVERY); clear(round); round.ship.d = round.river.bossAt[BOSS_EVERY] - 2; round.ship.x = center(round); advance(round, 200); assert.equal(round.phase, "boss"); assert.equal(eventsOf(round, "bossin").length, 1); const boss = round.boss; assert.equal(boss.kind, "dredger"); const d = round.ship.d; const battery = round.battery; run(round, 3000, (r) => (r.ship.invuln = 1e9)); assert.equal(round.ship.d, d, "the river holds still"); assert.equal(round.battery, battery, "and the battery holds"); assert.ok(eventsOf(round, "bolt").some((e) => e.boss), "it fires"); round.lives = 2; assert.equal(hurtBoss(round, boss.hp), true); assert.equal(round.boss, null); assert.equal(round.phase, "run"); const down = eventsOf(round, "bossdown")[0]; assert.equal(down.points, BOSS_POINTS); assert.equal(round.lives, 3, "a life back"); assert.equal(round.crates.length, 1, "and a crate"); run(round, 2000); assert.ok(round.ship.d > d + 20, "the river runs again"); assert.equal(eventsOf(round, "bossin").length, 1, "and the boss never comes back"); const r2 = quiet(); placeAt(r2, BOSS_EVERY * 2); clear(r2); r2.ship.d = r2.river.bossAt[BOSS_EVERY * 2] - 1; r2.ship.x = center(r2); advance(r2, 100); assert.equal(r2.boss.kind, "ironclad", "the next boss is another"); r2.lives = MAX_LIVES; run(r2, 1500, (r) => (r.ship.invuln = 1e9)); hurtBoss(r2, r2.boss.hp); assert.equal(r2.lives, MAX_LIVES, "never past MAX_LIVES"); assert.equal(eventsOf(r2, "bossdown")[0].life, false); }); test("Rapids Run: a life lost once the boss's basin is reached starts again at the basin's mouth, not the whole stretch, and the boss comes back", () => { const round = quiet(); placeAt(round, BOSS_EVERY); clear(round); const bossAt = round.river.bossAt[BOSS_EVERY]; round.ship.d = bossAt - 1; round.ship.x = center(round); advance(round, 100); assert.equal(round.phase, "boss"); round.ship.invuln = 0; lose(round, "bolt"); advance(round, CRASH_MS + 50); assert.equal(round.phase, "ready"); assert.ok(round.ship.d < bossAt && round.ship.d > bossAt - 30, `at the basin's mouth (${round.ship.d}, the boss at ${bossAt})`); assert.ok(!onLand(round.river, round.ship.x, round.ship.d)); run(round, 3000, (r) => (r.ship.invuln = 1e9)); assert.equal(round.phase, "boss", "the boss again"); assert.ok(round.boss); }); /* ------------------------------------------------------------- banners */ test("Rapids Run: the banner's strip counts a foe, a bolt, the boss or a standing dam under it, and not a gull still waiting or a dam already open", () => { const round = quiet(); const dAt = (y) => round.cam + FIELD_H - y; assert.equal(underBanner(round), false, "nothing there"); const f = foe(round, "skiff", 20, dAt(BANNER_Y)); assert.equal(underBanner(round), true, "a skiff in the strip"); f.d = dAt(BANNER_Y + 20); assert.equal(underBanner(round), false, "well below it"); const g = foe(round, "gull", -3, dAt(BANNER_Y)); assert.equal(underBanner(round), false, "a gull not yet flying"); g.on = true; assert.equal(underBanner(round), true, "a gull swooping"); round.foes.length = 0; round.bolts.push({ x: 10, d: dAt(BANNER_Y + 2), vx: 0, vd: -10 }); assert.equal(underBanner(round), true, "a bolt"); round.bolts.length = 0; round.dam.d = dAt(BANNER_Y); assert.equal(underBanner(round), true, "a dam to shoot"); round.dam.hp = 0; assert.equal(underBanner(round), false, "an open dam"); assert.ok(BANNER_Y < FIELD_H - rapids.BEHIND - 15, "the strip sits well above the skimmer"); assert.equal(screenY(round, round.ship.d), FIELD_H - rapids.BEHIND); }); test("Rapids Run game: the opening banner sits in the field from the start's first frame, held through the 3, 2, 1, and does not jump on the first tick", () => { const { canvas, shades } = bannerCanvas("rgba(0, 0, 0, 0.32)"); const g = game.create({ canvas }); g.resize(900, 900); openingBanner(g, shades, FIELD_H); }); test("Rapids Run game: a banner fades to see-through while something you must react to is in its strip, and back once it is gone", () => { const alphas = []; const ctx = new Proxy({ globalAlpha: 1 }, { get: (t, name) => (name === "fillRect" ? () => t.fillStyle === "rgba(0, 0, 0, 0.32)" && alphas.push(t.globalAlpha) : name in t ? t[name] : () => {}), set: (t, name, value) => { t[name] = value; return true; }, }); const g = game.create({ canvas: { width: 0, height: 0, getContext: () => ctx } }); g.resize(900, 900); g.key("action"); g.tick(16); clear(g.round); const mine = foe(g.round, "mine", 6, 0); for (let k = 0; k < 40; k++) { mine.d = g.round.cam + FIELD_H - BANNER_Y; g.tick(16); } assert.ok(alphas.at(-1) <= 0.15, `see-through over the mine (${alphas.at(-1)})`); clear(g.round); for (let k = 0; k < 40; k++) g.tick(16); assert.ok(alphas.at(-1) > 0.9, `back once it is gone (${alphas.at(-1)})`); }); test("Rapids Run game: a banner that first shows during a boss fight sits lower, clear of the boss and still above the skimmer, and keeps the see-through rule", () => { const { canvas, shades } = bannerCanvas("rgba(0, 0, 0, 0.32)"); const g = game.create({ canvas }); g.resize(900, 900); g.key("action"); g.tick(16); const round = g.round; placeAt(round, BOSS_EVERY); clear(round); round.ship.d = round.river.bossAt[BOSS_EVERY] - 1; round.ship.x = center(round); // Past the opening banner, into the fight; the boss's own banner comes next. for (let k = 0; k < 150; k++) { round.ship.invuln = 1e9; shades.length = 0; g.tick(16); } assert.equal(round.phase, "boss"); assert.equal(shades.length, 1, "a banner showing"); const [[top, h]] = shades; const mid = top + h / 2; assert.ok(Math.abs(mid - rapids.BOSS_BANNER_Y) < 0.01, `placed low (${mid})`); assert.ok(Math.abs(screenY(round, round.boss.d) - mid) > rapids.BANNER_HALF + 2, "clear of the boss"); assert.ok(top + h < screenY(round, round.ship.d) - SHIP_L, "and above the skimmer"); round.bolts.length = 0; assert.equal(underBanner(round, mid), false, "nothing in its strip"); round.bolts.push({ x: 20, d: round.cam + FIELD_H - mid, vx: 0, vd: -10 }); assert.equal(underBanner(round, mid), true, "a bolt crossing it still counts"); }); test("Rapids Run game: the start and end screens' lines all fit the field at full size, and the start screen's strip is clear of the skimmer", () => { const lines = []; const shades = []; let font = ""; const ctx = new Proxy({}, { get: (t, name) => { if (name === "fillText") return (text, x, y, max) => lines.push({ text: String(text), size: Number(/([\d.]+)px/.exec(font)?.[1]), max, y }); if (name === "fillRect") return (x, y, w, h) => t.fillStyle === "rgba(0, 0, 0, 0.55)" && shades.push([y, h]); return name in t ? t[name] : () => {}; }, set: (t, name, value) => { if (name === "font") font = value; t[name] = value; return true; }, }); const memo = { get: () => 19, set() {} }; const g = game.create({ canvas: { width: 0, height: 0, getContext: () => ctx }, memo, best: () => 1 }); g.resize(900, 900); const fits = (what) => { const tally = lines.filter((l) => l.max === FIELD_W - 4); assert.ok(tally.length >= 3, `${what}: several lines (${tally.map((l) => l.text)})`); for (const l of tally) assert.ok(l.text.length * l.size * 0.62 <= l.max, `${what}: "${l.text}" fits without a squeeze`); }; fits("start"); const skimmer = FIELD_H - rapids.BEHIND - SHIP_L; assert.ok(shades.length && shades.every(([y, h]) => y + h < skimmer), `the start strip is clear of the skimmer (${shades})`); g.key("action"); g.tick(16); placeAt(g.round, 20); g.round.score = 99999; g.round.lives = 1; lose(g.round, "flat"); for (let k = 0; k < 100 && g.state === "running"; k++) g.tick(16); assert.equal(g.state, "over"); lines.length = 0; g.resize(900, 900); fits("end"); assert.ok(lines.some((l) => l.text === "Reached Night Water 12 (dam 20)")); assert.ok(lines.some((l) => l.text === "A new best!"), "the news on its own line"); }); test("Rapids Run: the end screen's boss hint names the next boss's dam from the one still standing", () => { const round = quiet(); placeAt(round, 7); assert.equal(rapids.teaser(round, 3), "A boss guards dam 8. One more go?"); placeAt(round, 8); assert.equal(rapids.teaser(round, 3), "A boss guards dam 8. One more go?", "dam 8 still standing"); round.dam.hp = 0; assert.equal(rapids.teaser(round, 3), "A boss guards dam 12. One more go?", "dam 8 open"); assert.equal(rapids.teaser(round, 14), "Can you beat dam 15?"); placeAt(round, 2); assert.equal(rapids.teaser(round, 0), "A new foe waits at stretch 3..."); }); /* --------------------------------------------------------------- pills */ test("Rapids Run: lives are drawn in the lives pill, solid, white, a heart per life, right after the stretch pill", () => { for (const lives of [3, 1, 5]) { const { canvas, pills, reset } = pillCanvas("#ffffff"); const g = game.create({ canvas }); g.resize(900, 900); g.key("action"); for (let k = 0; k < 5; k++) g.tick(16); g.round.lives = lives; reset(); g.tick(16); const all = pills(); const at = all.findIndex((p) => p.text.startsWith("♥")); assert.ok(at >= 0, `a lives pill (${all.map((p) => p.text)})`); const p = all[at]; assert.equal(p.text, livesText(lives)); assert.equal(p.backing, LIVES_BACK); assert.equal(p.ink, LIVES_INK); assert.ok(all[at - 1].text.startsWith("STRETCH"), "after the stretch pill"); } }); test("Rapids Run: every pill's text reads at 4.5:1 on its backing and its timer's tint, lives, a shield, spread, magnet and the combo included, in light and dark under every highlight", () => { checkPills({ setup: (r) => { r.shield = 1; r.effects.spread = POWERS.spread.ms / 2; r.effects.magnet = POWERS.magnet.ms / 2; r.combo = 3; r.comboMs = COMBO_MS / 2; }, expect: ["STRETCH 1", "♥", "SHIELD", "~SPREAD", "~MAGNET", "~x3 COMBO"], }); }); test("Rapids Run: the pills never overlap, leave the board or spill out of their strip, even on the smallest board with every pill wanted; every word stays on the field; Planny's arms stand out on the skimmer in every highlight", () => { const hud = { stretch: "STRETCH 12", color: "#57b54a", effects: [{ text: "SHIELD x2", color: "#1fb6d9", fill: 1 }, { text: "SPREAD", color: "#ff8a1f", fill: 0.5 }, { text: "MAGNET", color: "#a466ff", fill: 0.5 }], combo: 5, comboFill: 0.5 }; for (const u of [MIN_CELL, 4, 6, 10]) { const h = Math.max(12 / u, 2.4); const placed = hudLayout(h, W, MAX_LIVES, hud, rapids.HUD_H); assert.equal(placed.length, 6); for (const p of placed) { assert.ok(p.x >= 0 && p.x + p.w <= W, `u ${u}: ${p.text} on the board`); assert.ok(p.y >= 0 && p.y + p.h <= rapids.HUD_H, `u ${u}: ${p.text} in the strip (${p.y})`); } for (let i = 0; i < placed.length; i++) { for (let j = i + 1; j < placed.length; j++) { const a = placed[i]; const b = placed[j]; const apart = a.x + a.w <= b.x || b.x + b.w <= a.x || a.y + a.h <= b.y || b.y + b.h <= a.y; assert.ok(apart, `u ${u}: ${a.text} and ${b.text} apart`); } } } for (const [x, y] of [[0, 0], [FIELD_W, FIELD_H], [FIELD_W / 2, -5]]) { const at = labelSpot("Into the dam!", x, y, 2.8, FIELD_W, FIELD_H); assert.ok(at.x - at.max / 2 >= 0 && at.x + at.max / 2 <= FIELD_W && at.y > 0 && at.y < FIELD_H); } for (const theme of ["light", "dark"]) { for (const [id, accent] of Object.entries(ACCENTS)) { const fill = accent[theme][0]; assert.ok(contrast(inkOn(fill), fill) >= 3, `${theme}/${id}: arms on ${fill}`); } } }); /* ---------------------------------------------------- memo and tones */ test("Rapids Run game: the start screen names the furthest dam, and the memo only grows", () => { const texts = []; const ctx = new Proxy({}, { get: (target, name) => (name === "fillText" ? (text) => texts.push(String(text)) : name in target ? target[name] : () => {}), set: (target, name, value) => { target[name] = value; return true; }, }); let saved = 3; const sets = []; const memo = { get: () => saved, set: (n) => { sets.push(n); saved = n; } }; const g = game.create({ canvas: { width: 0, height: 0, getContext: () => ctx }, memo }); g.resize(900, 900); assert.ok(texts.some((t) => t.includes("Furthest: Stone Gate (dam 3)")), "the start screen names it"); assert.deepEqual(sets, [], "drawing writes nothing"); g.key("action"); g.tick(16); const breakDam = () => { clear(g.round); const dam = g.round.dam; dam.hp = 1; g.round.ship.d = dam.d - 30; g.round.ship.x = center(g.round); g.round.shots.push({ x: center(g.round, dam.d), d: dam.d - 2, vx: 0, vd: 60 }); g.tick(100); }; breakDam(); assert.equal(g.round.stats.dams, 1); assert.deepEqual(sets, [], "dam 1 is not further than dam 3"); placeAt(g.round, 5); breakDam(); assert.deepEqual(sets, [5], "dam 5 is"); placeAt(g.round, 2); breakDam(); assert.deepEqual(sets, [5], "and it never shrinks"); const fresh = game.create({ canvas: stubCanvas().canvas }); assert.equal(fresh.state, "ready", "no memo is fine"); }); test("Rapids Run game: every event has its sound: a soft pew, a charge, a kill, the dam's thunk and its break, the low battery's beep and the skim's whoosh, and passing the best plays the fanfare once", () => { const tones = []; const { canvas } = stubCanvas(); const g = game.create({ canvas, tone: (name, level = 1, pitch = 1) => tones.push({ name, level, pitch }), best: () => 50 }); g.resize(900, 900); g.key("action"); g.tick(16); clear(g.round); g.key("action"); g.tick(200); const pew = tones.find((t) => t.name === "pew"); assert.ok(pew && pew.level <= 0.25, "a quiet pew for every shot"); g.release("action"); g.round.battery = 30; g.round.buoys.push({ x: g.round.ship.x, d: g.round.ship.d + 4, n: 1, t: 0 }); g.tick(300); assert.ok(tones.some((t) => t.name === "charge")); rapids.hurtFoe(g.round, foe(g.round, "skiff", 10, g.round.ship.d + 30)); g.tick(16); assert.ok(tones.some((t) => t.name === "eat")); g.round.score = 60; g.tick(16); g.tick(16); assert.equal(tones.filter((t) => t.name === "best").length, 1, "the fanfare, once"); g.round.battery = LOW_BATTERY - 5; for (let k = 0; k < 30; k++) g.tick(16); assert.ok(tones.filter((t) => t.name === "lowcell").length >= 1, "the low battery beeps"); tones.length = 0; const dam = g.round.dam; g.round.ship.d = dam.d - 40; g.round.ship.x = center(g.round); g.round.battery = BATTERY; for (let k = 0; k < dam.max; k++) g.round.shots.push({ x: center(g.round, dam.d), d: dam.d - 2 - k * 0.01, vx: 0, vd: 60 }); g.tick(50); assert.ok(tones.some((t) => t.name === "thunk"), "each hit thunks"); assert.ok(tones.some((t) => t.name === "dambreak"), "and it breaks"); tones.length = 0; const skim = g.round; for (let k = 0; k < 40; k++) { clear(skim); const ch = channelAt(skim.river, skim.ship.x, skim.ship.d); const ch2 = channelAt(skim.river, skim.ship.x, skim.ship.d + SHIP_L / 2); skim.ship.x = Math.max(ch.lo, ch2.lo) + SHIP_W / 2 + 0.5; g.tick(16); } assert.ok(tones.some((t) => t.name === "skim"), "a skim whooshes"); for (const t of tones) assert.ok(t.level > 0 && t.level <= 1); }); test("Rapids Run game: a crash plays the crash, shakes and floats its cause, and the respawn's banner says the lives left", () => { const tones = []; const texts = []; const ctx = new Proxy({}, { get: (target, name) => (name === "fillText" ? (text) => texts.push(String(text)) : name in target ? target[name] : () => {}), set: (target, name, value) => { target[name] = value; return true; }, }); const g = game.create({ canvas: { width: 0, height: 0, getContext: () => ctx }, tone: (n) => tones.push(n) }); g.resize(900, 900); g.key("action"); g.tick(16); clear(g.round); g.round.ship.x = riverAt(g.round.river, g.round.ship.d).L + 0.2; texts.length = 0; g.tick(16); assert.ok(tones.includes("crash")); assert.ok(texts.includes("Ran aground!")); for (let ms = 0; ms < CRASH_MS + 50; ms += 16) g.tick(16); assert.ok(texts.includes("Ready?")); assert.ok(texts.includes("2 lives left")); }); test("Rapids Run game: the hums follow the action (the outboard pitched with the throttle, the river, a whirlpool, a boss's engines) and the big moments sound big", () => { const tones = []; const hums = []; const g = game.create({ canvas: stubCanvas().canvas, tone: (name, level = 1, pitch = 1) => tones.push({ name, level, pitch }), hum: (id, name, level = 1, pitch = 1) => hums.push({ id, name, level, pitch }) }); g.resize(900, 900); g.key("action"); assert.ok(tones.some((t) => t.name === "rapidsPullStart"), "the motor is pulled into life"); const motor = () => hums.filter((h) => h.id === "rapids:motor").at(-1); for (let k = 0; k < 10; k++) { clear(g.round); g.round.ship.x = center(g.round); g.tick(16); } assert.equal(motor().name, "outboard"); assert.ok(hums.some((h) => h.id === "rapids:river" && h.name === "river"), "the river runs under it"); const cruising = motor().pitch; g.key("up"); assert.ok(tones.some((t) => t.name === "rapidsRevUp"), "the throttle revs"); for (let k = 0; k < 60; k++) { clear(g.round); g.round.ship.x = center(g.round); g.tick(16); } assert.ok(motor().pitch > cruising, `faster is higher (${motor().pitch} > ${cruising})`); g.release("up"); clear(g.round); foe(g.round, "whirl", g.round.ship.x, g.round.ship.d + 12); g.round.ship.invuln = 1e6; g.tick(16); assert.ok(hums.some((h) => h.name === "rapidsWhirl" && h.level > 0), "a whirlpool swirls nearby"); clear(g.round); g.round.effects.spread = 600; for (let k = 0; k < 50; k++) g.tick(16); assert.ok(tones.some((t) => t.name === "powerDown"), "a timed power-up winds down when it runs out"); tones.length = 0; placeAt(g.round, BOSS_EVERY); clear(g.round); g.round.ship.d = g.round.river.bossAt[BOSS_EVERY]; g.round.ship.x = center(g.round); g.tick(16); assert.ok(tones.some((t) => t.name === "bossIntro"), "a boss steams in"); for (let k = 0; k < 80; k++) { g.round.ship.invuln = 1e6; g.tick(16); } assert.ok(hums.some((h) => h.id === "rapids:boss" && h.name === "rapidsBossEngine"), "its engines churn"); hurtBoss(g.round, Math.ceil(g.round.boss.max / 2)); g.tick(16); assert.ok(tones.some((t) => t.name === "rapidsBossRoar"), "it roars at its half"); hurtBoss(g.round, g.round.boss.hp); for (let k = 0; k < 40; k++) g.tick(16); assert.ok(tones.some((t) => t.name === "explode"), "it goes up"); assert.ok(tones.some((t) => t.name === "victory"), "and a victory plays after"); tones.length = 0; g.round.lives = 1; g.round.battery = 0.001; g.tick(16); assert.ok(tones.some((t) => t.name === "rapidsSputter"), "a flat battery sputters out"); for (let ms = 0; ms < CRASH_MS + 50 && g.state === "running"; ms += 16) g.tick(16); assert.equal(g.state, "over"); assert.ok(tones.some((t) => t.name === "gameOver"), "and the last life plays the game over"); for (const t of tones) assert.ok(t.level > 0 && t.level <= 1); for (const h of hums) assert.ok(h.level >= 0 && h.level <= 1 && h.pitch >= 0.25 && h.pitch <= 4, `${h.id} in range`); }); test("Rapids Run game: plays without a hum (or a tone) handed in", () => { const g = game.create({ canvas: stubCanvas().canvas }); g.resize(900, 900); g.key("action"); for (let k = 0; k < 20; k++) g.tick(16); assert.equal(g.state, "running"); }); /* ------------------------------------------------------------ drawing */ test("Rapids Run game: every stretch, the boss, a crash and the end draw with finite numbers only, and Planny's hull and star are in your highlight", () => { const bad = []; const fills = []; const target = { globalAlpha: 1, fillStyle: "", getTransform: () => ({ a: 2, b: 0, c: 0, d: 2, e: 0, f: 0 }) }; const ctx = new Proxy(target, { get: (t, name) => { if (name in t) return t[name]; if (name === "fill") return () => fills.push(t.fillStyle); return (...args) => { for (const a of args) if (typeof a === "number" && !Number.isFinite(a)) bad.push(`${String(name)}(${args.join(", ")})`); }; }, set: (t, name, value) => { t[name] = value; return true; }, }); const saved = globalThis.getComputedStyle; const values = { ...THEME_TOKENS.dark, "--accent": "#e75874" }; globalThis.getComputedStyle = () => ({ getPropertyValue: (name) => values[name] || "" }); try { const g = game.create({ canvas: { width: 0, height: 0, getContext: () => ctx } }); g.resize(900, 900); g.key("action"); g.tick(16); assert.ok(fills.filter((f) => f === "#e75874").length >= 2, "the hull and the star"); for (let n = 1; n <= 10; n++) { placeAt(g.round, n); for (let k = 0; k < 20; k++) g.tick(50); if (stretchFor(n).boss) { g.round.ship.d = g.round.river.bossAt[n] - 1; for (let k = 0; k < 40; k++) { g.round.ship.invuln = 1e9; g.tick(50); } assert.ok(g.round.boss, `stretch ${n}: a boss`); hurtBoss(g.round, g.round.boss.hp); g.tick(50); } } g.round.lives = 1; g.round.ship.invuln = 0; g.round.shield = 0; lose(g.round, "foe"); for (let k = 0; k < 40 && g.state === "running"; k++) g.tick(50); assert.equal(g.state, "over"); g.resize(900, 900); assert.deepEqual(bad, [], "no NaN or Infinity reaches the canvas"); } finally { if (saved === undefined) delete globalThis.getComputedStyle; else globalThis.getComputedStyle = saved; } }); /* --------------------------------------------------------------- bots */ test("Rapids Run: a careful bot plays the first seven stretches of many rivers, with the foes cleared away, and never runs aground, never meets a dam standing and is never trapped, each stretch taking 15 to 60 seconds", () => { for (let seed = 1; seed <= 6; seed++) { const round = newRound(seed); let t = 0; let since = 0; const lost = []; while (!round.over && round.stretch <= 7 && t < 600_000) { round.foes.length = 0; round.bolts.length = 0; if (round.boss) round.boss.hp = Math.min(round.boss.hp, 1); // Never trapped: the water the hull sits in is always wide enough. if (round.phase === "run") { const ch = channelAt(round.river, round.ship.x, round.ship.d); assert.ok(ch.hi - ch.lo >= MIN_CHANNEL - 1e-9, `seed ${seed}: room at ${round.ship.d}`); } carefulBot(round); advance(round, 16); t += 16; since += 16; for (const e of round.events.splice(0)) { if (e.type === "lose") lost.push(`${e.cause}@${round.stretch}`); if (e.type === "stretch") { assert.ok(since >= 15_000 && since <= 60_000, `seed ${seed}: stretch ${e.n - 1} took ${since} ms`); since = 0; } } } assert.ok(round.stretch > 7, `seed ${seed}: past dam 7 (at ${round.stretch}, lost ${lost})`); assert.ok(!lost.some((l) => l.startsWith("bank") || l.startsWith("dam")), `seed ${seed}: never aground or into a dam (${lost})`); } }); test("Rapids Run: the careful bot, with the foes left in, still blasts its first dam on most rivers", () => { let first = 0; for (let seed = 1; seed <= 6; seed++) { const round = newRound(seed); for (let t = 0; t < 600_000 && !round.over; t += 16) { carefulBot(round); advance(round, 16); } if (round.stats.dams >= 1) first += 1; } assert.ok(first >= 4, `${first} of 6 past the first dam`); }); test("Rapids Run: a sloppy bot (full speed, firing, steering at random) loses all three lives within 30 seconds, and one that never steers (so never grabs a buoy) within 100", () => { for (let seed = 1; seed <= 8; seed++) { const round = newRound(seed); const random = rapids.seeded(seed); let t = 0; for (; t < 30_000 && !round.over; t += 16) { round.input.up = true; round.input.fire = true; if (random() < 0.03) { const k = random(); round.input.left = k < 0.4; round.input.right = k > 0.6; } advance(round, 16); } assert.ok(round.over, `seed ${seed}: over within 30 s`); const still = newRound(seed); still.input.fire = true; let s = 0; for (; s < 100_000 && !still.over; s += 16) advance(still, 16); assert.ok(still.over, `seed ${seed}: never steering ends within 100 s`); } });