Add Activities with Snake and Mini golf to play through a wait, paused whenever it is your turn

AI Assisted
This commit is contained in:
jparkerweb committed 2026-10-27 18:20:31 -07:00
1 parent 720758a7ee
commit dbd31611b7
17 files changed
+8920 -7

No files matched your search

File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+9 -3
View File
@@ -644,16 +644,22 @@ test("the favicon is served as an SVG with a PNG fallback and the page points at
/* ---------------------------------------------------------------- help */ /* ---------------------------------------------------------------- help */
test("help: 18 tabs with unique ids", () => { test("help: 19 tabs with unique ids", () => {
assert.equal(HELP_TABS.length, 18); assert.equal(HELP_TABS.length, 19);
assert.equal(new Set(HELP_TABS.map((t) => t.id)).size, 18); assert.equal(new Set(HELP_TABS.map((t) => t.id)).size, 19);
assert.ok(Object.isFrozen(HELP_TABS) && HELP_TABS.every((t) => Object.isFrozen(t)), "the tab list is frozen"); assert.ok(Object.isFrozen(HELP_TABS) && HELP_TABS.every((t) => Object.isFrozen(t)), "the tab list is frozen");
const ids = HELP_TABS.map((t) => t.id); const ids = HELP_TABS.map((t) => t.id);
assert.equal(ids.indexOf("git"), ids.indexOf("build") + 1, "The git board comes right after Watching a build"); assert.equal(ids.indexOf("git"), ids.indexOf("build") + 1, "The git board comes right after Watching a build");
assert.equal(HELP_TABS[ids.indexOf("git")].label, "The git board"); assert.equal(HELP_TABS[ids.indexOf("git")].label, "The git board");
assert.equal(helpTabFor({ workflow: "git" }), "git"); assert.equal(helpTabFor({ workflow: "git" }), "git");
assert.equal(ids.indexOf("activities"), ids.indexOf("ask") + 1, "Activities comes right after Ask a quick question");
assert.equal(HELP_TABS[ids.indexOf("activities")].label, "Activities");
const tpl = helpTemplate(); const tpl = helpTemplate();
for (const id of ids) assert.match(tpl, new RegExp(`<section class="help-panel" data-tab="${id}">`), `${id} has a section`); for (const id of ids) assert.match(tpl, new RegExp(`<section class="help-panel" data-tab="${id}">`), `${id} has a section`);
// The die sits right of the megaphone, so the megaphone is no longer the far-right button.
assert.doesNotMatch(tpl, /far right/, "no line calls a top-bar button the far-right one");
const around = tpl.match(/<section class="help-panel" data-tab="around">([\s\S]*?)<\/section>/)[1];
assert.match(around, /<strong>die<\/strong>[\s\S]*?"Activities"/, "Finding your way around points the die at the Activities topic");
}); });
test("help: the template's icons and panels match HELP_TABS in order, headed by their labels", () => { test("help: the template's icons and panels match HELP_TABS in order, headed by their labels", () => {
+31
View File
@@ -0,0 +1,31 @@
// Plan2Code Web Console - the list of activities: the games the Activities window can open.
//
// The source of truth for which games exist. The window (screens/activities.js)
// knows only this list; each game is its own module under activities/, loaded
// with import() the first time it is opened, and answers the same calls:
// create({ canvas, tone, onScore }) returning start, pause, resume, key, tick
// and resize, plus score and state (scripts/test-web-console-activities.mjs
// checks every listed game against it). create() is also handed best(), the
// saved best, and memo, a number kept between sessions; a game may ignore
// both. Three parts are optional: pointer(type,
// x, y) for a game played by mouse, release(name) for a game that acts on a
// key held down (handed the same names as key() when the key is let go), and
// lowerIsBetter on the module's export for a game whose best is its lowest
// round. Adding a game is one file and
// one line here. No DOM access and no imports: the page and `node --test` both
// import this file.
const entry = (id, title) => Object.freeze({ id, title, module: `/activities/${id}.js` });
export const ACTIVITIES = Object.freeze([entry("snake", "Snake"), entry("golf", "Mini golf")]);
// The looks.json key that holds a game's best score: activityBestSnake for
// snake. Built the way soundKey() builds the per-sound switches, so every key
// stays flat (cleanLooks() drops nested objects).
export const bestKey = (id) => "activityBest" + id[0].toUpperCase() + id.slice(1);
// The looks.json key that holds a game's memo: one whole number the game may
// keep between sessions (Snake keeps its tally of surprises found as bits).
// Handed to create() as memo { get, set }; a game that has no use for it
// leaves it at 0.
export const memoKey = (id) => "activityMemo" + id[0].toUpperCase() + id.slice(1);
@@ -0,0 +1,825 @@
// Plan2Code Web Console - mini golf's scenery and props: the sharks, bats and torches round the course, the looks of what the ball hits, and the power-up icons.
//
// Drawing only, like golf-draw.js, which calls in here: no rules and no state.
// Every piece is drawn in course units around its own point, and anything
// that moves (a fin circling, a wing flapping, a flame) follows the round's
// clock, never Math.random(), so a paused frame stays still. The palette `p`
// is the hole's theme from golf-draw.js.
/* --------------------------------------------------------------- helpers */
export function polygon(ctx, points) {
ctx.beginPath();
points.forEach((q, i) => (i ? ctx.lineTo(q.x, q.y) : ctx.moveTo(q.x, q.y)));
ctx.closePath();
}
export function circle(ctx, x, y, r) {
ctx.beginPath();
ctx.arc(x, y, Math.max(0.01, r), 0, Math.PI * 2);
}
export function ellipse(ctx, x, y, rx, ry, rot = 0) {
ctx.beginPath();
if (typeof ctx.ellipse === "function") ctx.ellipse(x, y, Math.max(0.01, rx), Math.max(0.01, ry), rot, 0, Math.PI * 2);
else ctx.arc(x, y, Math.max(0.01, rx), 0, Math.PI * 2);
}
// A radial gradient, or null where the context makes none (a stub in Node):
// the caller then fills flat or skips the glow.
export function radial(ctx, x, y, r0, r1, stops) {
if (typeof ctx.createRadialGradient !== "function") return null;
let g = null;
try {
g = ctx.createRadialGradient(x, y, r0, x, y, r1);
} catch {
return null;
}
if (!g || typeof g.addColorStop !== "function") return null;
for (const [at, color] of stops) g.addColorStop(at, color);
return g;
}
const fill = (ctx, color) => {
ctx.fillStyle = color;
ctx.fill();
};
const stroke = (ctx, color, width) => {
ctx.strokeStyle = color;
ctx.lineWidth = width;
ctx.stroke();
};
function line(ctx, x1, y1, x2, y2, color, width) {
ctx.beginPath();
ctx.moveTo(x1, y1);
ctx.lineTo(x2, y2);
stroke(ctx, color, width);
}
function label(ctx, str, x, y, size, color, font) {
ctx.font = `700 ${size}px ${font || "sans-serif"}`;
ctx.textAlign = "center";
ctx.textBaseline = "middle";
ctx.fillStyle = color;
ctx.fillText(str, x, y);
}
// Turns the context to draw along an angle around a point, for the callback.
function turned(ctx, x, y, angle, draw) {
ctx.save();
ctx.translate(x, y);
ctx.rotate(angle);
draw();
ctx.restore();
}
const t = (clock) => clock / 1000;
/* ---------------------------------------------------------------- props */
// The looks of a bumper, by `look` or the theme's own.
export function drawBumperLook(ctx, p, b, clock) {
const look = b.look || (p.theme === "cave" ? "mushroom" : "barrel");
const { x, y, r } = b;
circle(ctx, x + 1.5, y + 2, r);
fill(ctx, p.shadow);
if (look === "barrel") {
circle(ctx, x, y, r);
fill(ctx, "#94602e");
circle(ctx, x, y, r * 0.72);
stroke(ctx, "#3a2a1c", 1.4);
circle(ctx, x, y, r * 0.38);
fill(ctx, "#6f4520");
circle(ctx, x, y, r);
stroke(ctx, "#3a2a1c", 1.6);
} else if (look === "cannonball") {
circle(ctx, x, y, r);
fill(ctx, "#25252c");
circle(ctx, x - r * 0.35, y - r * 0.35, r * 0.3);
fill(ctx, "#6d6d7a");
} else if (look === "chest") {
const s = r * 1.5;
ctx.fillStyle = "#7a4a1e";
ctx.fillRect(x - s / 2, y - s / 2, s, s);
ctx.fillStyle = "#d9a520";
ctx.fillRect(x - s / 2, y - 1.2, s, 2.4);
ctx.fillRect(x - 1.5, y - 2.5, 3, 5);
ctx.strokeStyle = "#3a2410";
ctx.lineWidth = 1;
ctx.strokeRect(x - s / 2, y - s / 2, s, s);
} else if (look === "coin") {
const shine = 0.5 + 0.5 * Math.sin(t(clock) * 3 + x);
circle(ctx, x, y, r);
fill(ctx, "#e8b923");
circle(ctx, x, y, r * 0.7);
stroke(ctx, "#a87a0c", 1.3);
label(ctx, "$", x, y + 0.5, r * 1.1, "#a87a0c");
circle(ctx, x - r * 0.4, y - r * 0.4, r * 0.18 + shine * 0.6);
fill(ctx, "#fff6c9");
} else if (look === "mushroom") {
const squish = 1 + Math.sin(t(clock) * 4 + y) * 0.04;
circle(ctx, x, y, r * squish);
fill(ctx, "#e0468a");
for (const [dx, dy, s] of [[-0.4, -0.3, 0.22], [0.35, -0.2, 0.18], [0, 0.4, 0.2], [0.45, 0.35, 0.13]]) {
circle(ctx, x + dx * r, y + dy * r, s * r);
fill(ctx, "#ffe3f1");
}
} else if (look === "rock") {
circle(ctx, x, y, r);
fill(ctx, "#5a5468");
circle(ctx, x - r * 0.15, y - r * 0.15, r * 0.62);
fill(ctx, "#77708a");
circle(ctx, x - r * 0.25, y - r * 0.25, r * 0.25);
fill(ctx, "#a49dba");
} else if (look === "crystal") {
const pts = [];
for (let i = 0; i < 6; i++) {
const a = (i / 6) * Math.PI * 2 + Math.PI / 6;
pts.push({ x: x + Math.cos(a) * r, y: y + Math.sin(a) * r });
}
polygon(ctx, pts);
fill(ctx, "#8a66ee");
polygon(ctx, [pts[0], pts[2], pts[4]]);
fill(ctx, "#b59cff");
circle(ctx, x - r * 0.25, y - r * 0.3, r * 0.2);
fill(ctx, "#f1ebff");
} else {
circle(ctx, x, y, r);
fill(ctx, "#9c3327");
}
}
// A mover at its place this moment.
export function drawMoverLook(ctx, p, m, clock) {
const { x, y, r } = m;
const look = m.look || "barrel";
ellipse(ctx, x + 1.5, y + 2.5, r, r * 0.9);
fill(ctx, p.shadow);
if (look === "barrel") {
// Rolls the way it travels: the hoops slide past.
const roll = (m.y * 0.4 + m.x * 0.4) % 6;
circle(ctx, x, y, r);
fill(ctx, "#a06a34");
ctx.save();
circle(ctx, x, y, r);
ctx.clip();
for (let k = -2; k <= 2; k++) line(ctx, x - r, y + k * 6 + roll - 3, x + r, y + k * 6 + roll - 3, "#3a2a1c", 1.5);
ctx.restore();
label(ctx, "TNT", x, y, r * 0.6, "#ffe9b0");
} else if (look === "crab") {
const wig = Math.sin(t(clock) * 14) * 1.5;
for (const side of [-1, 1]) {
for (let k = 0; k < 3; k++) line(ctx, x + side * r * 0.6, y - 2 + k * 2.5, x + side * (r + 3), y - 3 + k * 3 + wig * side, "#a8261b", 1.2);
circle(ctx, x + side * (r + 1), y - r * 0.9 + wig, r * 0.42);
fill(ctx, "#e1402d");
}
ellipse(ctx, x, y, r, r * 0.75);
fill(ctx, "#e1402d");
for (const side of [-1, 1]) {
circle(ctx, x + side * 2.2, y - r * 0.55, 1.6);
fill(ctx, "#ffffff");
circle(ctx, x + side * 2.2, y - r * 0.55, 0.8);
fill(ctx, "#111111");
}
} else if (look === "cart") {
const s = r * 1.6;
ctx.fillStyle = "#3d3a44";
ctx.fillRect(x - s / 2 - 2, y - s / 2 + 1, 3, s - 2);
ctx.fillRect(x + s / 2 - 1, y - s / 2 + 1, 3, s - 2);
ctx.fillStyle = "#6b6373";
ctx.fillRect(x - s / 2, y - s / 2, s, s);
ctx.strokeStyle = "#2a2730";
ctx.lineWidth = 1.2;
ctx.strokeRect(x - s / 2, y - s / 2, s, s);
for (const [dx, dy, c] of [[-3, -2, "#f2c84b"], [3, 1, "#7fe6ff"], [-1, 3, "#f2c84b"], [2, -4, "#ff7ad9"]]) {
circle(ctx, x + dx, y + dy, 2.2);
fill(ctx, c);
}
} else if (look === "fireball") {
const flick = 1 + Math.sin(t(clock) * 25) * 0.08;
const glow = radial(ctx, x, y, 0, r * 2.4, [[0, "rgba(255,220,120,0.9)"], [0.4, "rgba(255,120,30,0.6)"], [1, "rgba(255,60,0,0)"]]);
if (glow) {
circle(ctx, x, y, r * 2.4);
fill(ctx, glow);
}
circle(ctx, x, y, r * flick);
fill(ctx, "#ff7a1a");
circle(ctx, x - 1, y - 1, r * 0.55 * flick);
fill(ctx, "#ffe08a");
// A goofy face, because why not.
circle(ctx, x - 2.5, y - 1, 1);
fill(ctx, "#3a1200");
circle(ctx, x + 2.5, y - 1, 1);
fill(ctx, "#3a1200");
}
}
// A spinner's bar, with its look: a ship's wheel spoke, a kraken tentacle, a
// dragon's tail, or a plain plank.
export function drawSpinnerLook(ctx, p, s, clock) {
const look = s.look || "plank";
const angle = Math.atan2(s.y2 - s.y1, s.x2 - s.x1);
const arm = Math.hypot(s.x2 - s.x1, s.y2 - s.y1) / 2;
ctx.lineCap = "round";
line(ctx, s.x1 + 1.5, s.y1 + 2, s.x2 + 1.5, s.y2 + 2, p.shadow, 6);
if (look === "wheel") {
line(ctx, s.x1, s.y1, s.x2, s.y2, "#7a4a22", 4.5);
line(ctx, s.x1, s.y1, s.x2, s.y2, "#b07a43", 1.6);
for (const [ex, ey] of [[s.x1, s.y1], [s.x2, s.y2]]) {
circle(ctx, ex, ey, 3.2);
fill(ctx, "#6b3f1d");
}
circle(ctx, s.x, s.y, 13);
stroke(ctx, "#7a4a22", 3);
circle(ctx, s.x, s.y, 5);
fill(ctx, "#e0b030");
} else if (look === "tentacle" || look === "tail") {
const tentacle = look === "tentacle";
turned(ctx, s.x, s.y, angle, () => {
for (const dir of [-1, 1]) {
ctx.beginPath();
for (let i = 0; i <= 12; i++) {
const u = i / 12;
const w = Math.sin(u * 6 + t(clock) * 5) * 2.2 * u;
if (i === 0) ctx.moveTo(0, 0);
else ctx.lineTo(dir * u * arm, w);
}
stroke(ctx, tentacle ? "#8e3fa8" : "#b5262a", 5.5);
for (let i = 2; i < 11; i += 2) {
const u = i / 12;
circle(ctx, dir * u * arm, Math.sin(u * 6 + t(clock) * 5) * 2.2 * u + (tentacle ? 1.5 : -1.5), tentacle ? 1.2 : 1.6);
fill(ctx, tentacle ? "#f0b7ff" : "#f2c84b");
}
}
});
circle(ctx, s.x, s.y, 6);
fill(ctx, tentacle ? "#6c2a82" : "#7d1418");
} else {
line(ctx, s.x1, s.y1, s.x2, s.y2, p.spinner, 4);
circle(ctx, s.x, s.y, 5);
fill(ctx, p.hub);
}
}
// A power-up's icon, `r` across, centered on x, y.
export function drawPowerIcon(ctx, kind, x, y, r) {
if (kind === "doubloon") {
circle(ctx, x, y, r);
fill(ctx, "#f0c22c");
circle(ctx, x, y, r * 0.7);
stroke(ctx, "#a87a0c", r * 0.18);
label(ctx, "1", x, y + r * 0.05, r * 1.1, "#a87a0c");
} else if (kind === "cannon") {
circle(ctx, x - r * 0.15, y + r * 0.15, r * 0.8);
fill(ctx, "#25252c");
line(ctx, x + r * 0.35, y - r * 0.35, x + r * 0.75, y - r * 0.85, "#c8a26a", r * 0.18);
circle(ctx, x + r * 0.8, y - r * 0.9, r * 0.25);
fill(ctx, "#ffb020");
} else if (kind === "ghost") {
ctx.beginPath();
ctx.arc(x, y - r * 0.15, r * 0.75, Math.PI, 0);
ctx.lineTo(x + r * 0.75, y + r * 0.8);
for (let i = 0; i < 4; i++) ctx.lineTo(x + r * 0.75 - (i + 0.5) * r * 0.375, y + (i % 2 ? r * 0.8 : r * 0.5));
ctx.lineTo(x - r * 0.75, y + r * 0.8);
ctx.closePath();
fill(ctx, "#f4f7ff");
for (const dx of [-0.28, 0.28]) {
circle(ctx, x + dx * r, y - r * 0.2, r * 0.15);
fill(ctx, "#1c1c2a");
}
} else if (kind === "magnet") {
ctx.beginPath();
ctx.arc(x, y - r * 0.05, r * 0.6, Math.PI, 0, false);
stroke(ctx, "#d4342a", r * 0.45);
ctx.fillStyle = "#d9d9e3";
ctx.fillRect(x - r * 0.83, y, r * 0.45, r * 0.55);
ctx.fillRect(x + r * 0.38, y, r * 0.45, r * 0.55);
} else if (kind === "bouncy") {
ellipse(ctx, x, y + r * 0.25, r * 0.85, r * 0.55);
fill(ctx, "#ffd43b");
circle(ctx, x - r * 0.35, y - r * 0.35, r * 0.42);
fill(ctx, "#ffd43b");
polygon(ctx, [{ x: x - r * 0.75, y: y - r * 0.4 }, { x: x - r * 1.05, y: y - r * 0.25 }, { x: x - r * 0.72, y: y - r * 0.18 }]);
fill(ctx, "#ff8a1f");
circle(ctx, x - r * 0.42, y - r * 0.45, r * 0.1);
fill(ctx, "#111111");
} else if (kind === "bigcup") {
ctx.fillStyle = "#efdcae";
ctx.fillRect(x - r * 0.85, y - r * 0.7, r * 1.7, r * 1.4);
ctx.strokeStyle = "#a7834c";
ctx.lineWidth = r * 0.1;
ctx.strokeRect(x - r * 0.85, y - r * 0.7, r * 1.7, r * 1.4);
line(ctx, x - r * 0.35, y - r * 0.3, x + r * 0.35, y + r * 0.3, "#d4342a", r * 0.22);
line(ctx, x + r * 0.35, y - r * 0.3, x - r * 0.35, y + r * 0.3, "#d4342a", r * 0.22);
} else if (kind === "spyglass") {
ctx.lineCap = "round";
line(ctx, x - r * 0.75, y + r * 0.55, x + r * 0.55, y - r * 0.45, "#a8792b", r * 0.42);
line(ctx, x - r * 0.2, y + r * 0.12, x + r * 0.55, y - r * 0.45, "#d9a94a", r * 0.55);
circle(ctx, x + r * 0.62, y - r * 0.5, r * 0.3);
fill(ctx, "#bfe8ff");
}
}
/* --------------------------------------------------------------- scenery */
// Each kind of scenery: the layer it goes on ("low" under the walls, "high"
// over the ball, "glow" over a cave's darkness) and how it is drawn. `light`
// is the glow a cave casts around it, if any.
const DECOR = {
/* pirate */
shark: {
layer: "low",
draw(ctx, p, d, clock) {
const a = t(clock) * 0.9 * (d.s > 0.85 ? 1 : -1) + d.x;
const x = d.x + Math.cos(a) * 32 * d.s;
const y = d.y + Math.sin(a) * 9 * d.s;
const dir = Math.sign(-Math.sin(a) * (d.s > 0.85 ? 1 : -1)) || 1;
ctx.lineCap = "round";
line(ctx, x - dir * 4, y + 4, x - dir * 18, y + 5, "rgba(255,255,255,0.55)", 1.2);
polygon(ctx, [{ x: x - 5 * d.s, y: y + 4 }, { x: x + 5 * d.s, y: y + 4 }, { x: x - dir * 3 * d.s, y: y - 9 * d.s }]);
fill(ctx, "#5d6b78");
},
},
ship: {
layer: "low",
draw(ctx, p, d, clock) {
const bob = Math.sin(t(clock) * 1.6) * 1.5;
const y = d.y + bob;
polygon(ctx, [{ x: d.x - 22, y: y }, { x: d.x + 22, y: y }, { x: d.x + 15, y: y + 9 }, { x: d.x - 16, y: y + 9 }]);
fill(ctx, "#5c3416");
line(ctx, d.x, y, d.x, y - 30, "#3a2410", 1.6);
polygon(ctx, [{ x: d.x - 13, y: y - 26 }, { x: d.x + 13, y: y - 26 }, { x: d.x + 11, y: y - 6 }, { x: d.x - 11, y: y - 6 }]);
fill(ctx, "#f1ead6");
ctx.fillStyle = "#111111";
ctx.fillRect(d.x, y - 36, 9, 6);
circle(ctx, d.x + 4.5, y - 33, 1.5);
fill(ctx, "#ffffff");
},
},
bottle: {
layer: "low",
draw(ctx, p, d, clock) {
const a = Math.sin(t(clock) * 2 + d.x) * 0.5;
turned(ctx, d.x, d.y + Math.sin(t(clock) * 1.7) * 1.5, a, () => {
ellipse(ctx, 0, 0, 7, 3);
fill(ctx, "rgba(90,170,110,0.85)");
ctx.fillStyle = "#f4ead0";
ctx.fillRect(-3, -1.2, 5, 2.4);
ctx.fillStyle = "#8a5a2b";
ctx.fillRect(6, -1.3, 3, 2.6);
});
},
},
palm: {
layer: "low",
draw(ctx, p, d, clock) {
const s = d.s;
ellipse(ctx, d.x, d.y + 4 * s, 16 * s, 8 * s);
fill(ctx, "#ecd79c");
const sway = Math.sin(t(clock) * 1.3 + d.x) * 0.12;
line(ctx, d.x, d.y + 4 * s, d.x + 4 * s, d.y - 14 * s, "#8a5a2b", 2.5 * s);
for (let i = 0; i < 5; i++) {
const a = (i / 5) * Math.PI * 2 + sway;
ctx.beginPath();
ctx.moveTo(d.x + 4 * s, d.y - 14 * s);
ctx.quadraticCurveTo(d.x + 4 * s + Math.cos(a) * 9 * s, d.y - 18 * s + Math.sin(a) * 6 * s, d.x + 4 * s + Math.cos(a) * 15 * s, d.y - 12 * s + Math.sin(a) * 8 * s);
stroke(ctx, "#2f8f3c", 3 * s);
}
circle(ctx, d.x + 3 * s, d.y - 12 * s, 1.8 * s);
fill(ctx, "#6b4a2a");
},
},
wreck: {
layer: "low",
draw(ctx, p, d, clock) {
const tilt = -0.35 + Math.sin(t(clock) * 0.8) * 0.03;
turned(ctx, d.x, d.y, tilt, () => {
polygon(ctx, [{ x: -50, y: -6 }, { x: 40, y: -10 }, { x: 52, y: 4 }, { x: 30, y: 14 }, { x: -44, y: 12 }]);
fill(ctx, "#5c3416");
for (let x = -40; x < 40; x += 10) line(ctx, x, -6, x + 3, 12, "#3a2410", 1);
polygon(ctx, [{ x: -8, y: -8 }, { x: 6, y: -9 }, { x: 0, y: 6 }]);
fill(ctx, "#1b6d99");
line(ctx, 10, -8, 22, -46, "#3a2410", 2);
polygon(ctx, [{ x: 13, y: -40 }, { x: 34, y: -36 }, { x: 18, y: -24 }]);
fill(ctx, "rgba(241,234,214,0.8)");
});
},
},
crab: {
layer: "low",
draw(ctx, p, d, clock) {
drawMoverLook(ctx, p, { x: d.x + Math.sin(t(clock) * 1.5) * 10, y: d.y, r: 6 * d.s, look: "crab" }, clock);
},
},
parrot: {
layer: "high",
draw(ctx, p, d, clock) {
const bob = Math.abs(Math.sin(t(clock) * 3)) * -3;
const y = d.y + bob;
ellipse(ctx, d.x, y, 5, 8);
fill(ctx, "#e4312b");
ellipse(ctx, d.x + 3, y + 2, 3, 6, 0.3);
fill(ctx, "#2f7fd8");
circle(ctx, d.x, y - 8, 4);
fill(ctx, "#e4312b");
polygon(ctx, [{ x: d.x - 3, y: y - 8 }, { x: d.x - 7, y: y - 6 }, { x: d.x - 3, y: y - 5 }]);
fill(ctx, "#f2c84b");
circle(ctx, d.x - 1, y - 9, 1);
fill(ctx, "#111111");
polygon(ctx, [{ x: d.x - 2, y: y + 7 }, { x: d.x + 2, y: y + 7 }, { x: d.x + 1, y: y + 15 }]);
fill(ctx, "#2e9e48");
// Squawks now and then.
if (Math.floor(t(clock) / 2.5) % 3 === 0) label(ctx, "SQUAWK!", d.x, y - 18, 6, "#fff6c9");
},
},
island: {
layer: "low",
draw(ctx, p, d) {
ellipse(ctx, d.x, d.y, 18 * d.s, 9 * d.s);
fill(ctx, "#ecd79c");
line(ctx, d.x - 3, d.y - 3, d.x + 3, d.y + 3, "#d4342a", 1.6);
line(ctx, d.x + 3, d.y - 3, d.x - 3, d.y + 3, "#d4342a", 1.6);
},
},
cannon: {
layer: "low",
draw(ctx, p, d, clock) {
const dir = d.s < 0 ? -1 : 1;
ctx.fillStyle = "#6b3f1d";
ctx.fillRect(d.x - 8, d.y - 3, 16, 7);
turned(ctx, d.x, d.y, dir * Math.PI / 2, () => {
ctx.fillStyle = "#2b2b30";
ctx.fillRect(-4, -4, 18, 8);
circle(ctx, -4, 0, 5);
fill(ctx, "#2b2b30");
});
// A puff of smoke every few seconds.
const k = (t(clock) + d.x / 50) % 3;
if (k < 0.8) {
const r = 3 + k * 9;
circle(ctx, d.x, d.y + dir * (16 + k * 10), r);
fill(ctx, `rgba(230,230,230,${0.8 - k})`);
if (k < 0.15) label(ctx, "BOOM!", d.x, d.y + dir * 30, 7, "#ffb020");
}
},
},
anchor: {
layer: "low",
draw(ctx, p, d) {
ctx.lineCap = "round";
line(ctx, d.x, d.y - 10, d.x, d.y + 8, "#5b6470", 2.2);
line(ctx, d.x - 5, d.y - 6, d.x + 5, d.y - 6, "#5b6470", 2);
ctx.beginPath();
ctx.arc(d.x, d.y + 1, 7, 0.2, Math.PI - 0.2);
stroke(ctx, "#5b6470", 2.2);
circle(ctx, d.x, d.y - 12, 2.2);
stroke(ctx, "#5b6470", 1.5);
},
},
tentacle: {
layer: "low",
draw(ctx, p, d, clock) {
const s = d.s;
ctx.lineCap = "round";
ctx.beginPath();
for (let i = 0; i <= 10; i++) {
const u = i / 10;
const x = d.x + Math.sin(u * 4 + t(clock) * 2 + d.y) * 6 * s * u;
const y = d.y + 10 * s - u * 26 * s;
if (i === 0) ctx.moveTo(x, y);
else ctx.lineTo(x, y);
}
stroke(ctx, "#8e3fa8", 5 * s);
ellipse(ctx, d.x, d.y + 10 * s, 7 * s, 2.5 * s);
stroke(ctx, "rgba(255,255,255,0.5)", 1);
},
},
kraken: {
layer: "low",
draw(ctx, p, d, clock) {
ellipse(ctx, d.x, d.y + 6, 40, 16);
fill(ctx, "#6c2a82");
const blink = Math.floor(t(clock) * 10) % 40 === 0;
for (const dx of [-16, 16]) {
ellipse(ctx, d.x + dx, d.y - 2, 8, blink ? 1 : 7);
fill(ctx, "#fff6c9");
if (!blink) {
circle(ctx, d.x + dx + Math.sin(t(clock)) * 2, d.y - 1, 3);
fill(ctx, "#111111");
}
}
},
},
ghost: {
layer: "high",
draw(ctx, p, d, clock) {
const y = d.y + Math.sin(t(clock) * 1.8 + d.x) * 5;
const x = d.x + Math.sin(t(clock) * 0.7 + d.y) * 14;
ctx.globalAlpha = 0.6 + Math.sin(t(clock) * 2.3) * 0.2;
drawPowerIcon(ctx, "ghost", x, y, 12 * d.s);
if (Math.floor(t(clock) / 3) % 2 === 0) label(ctx, "Booo!", x + 16 * d.s, y - 12 * d.s, 6, "#f4f7ff");
ctx.globalAlpha = 1;
},
},
jolly: {
layer: "low",
draw(ctx, p, d, clock) {
const wave = Math.sin(t(clock) * 4) * 1.5;
line(ctx, d.x, d.y + 14, d.x, d.y - 14, "#3a2410", 1.5);
ctx.beginPath();
ctx.moveTo(d.x, d.y - 14);
ctx.quadraticCurveTo(d.x + 9, d.y - 16 + wave, d.x + 18, d.y - 14 + wave);
ctx.lineTo(d.x + 18, d.y - 2 + wave);
ctx.quadraticCurveTo(d.x + 9, d.y - 4 + wave, d.x, d.y - 2);
ctx.closePath();
fill(ctx, "#111111");
circle(ctx, d.x + 9, d.y - 9 + wave * 0.6, 2.5);
fill(ctx, "#f4f1ea");
},
},
skullrock: {
layer: "low",
draw(ctx, p, d, clock) {
ellipse(ctx, d.x, d.y + 40, 70, 20);
fill(ctx, "#ecd79c");
ellipse(ctx, d.x, d.y, 42, 38);
fill(ctx, "#8a8478");
ellipse(ctx, d.x, d.y - 4, 36, 30);
fill(ctx, "#a29c8f");
const glow = 0.5 + 0.5 * Math.sin(t(clock) * 2);
for (const dx of [-14, 14]) {
ellipse(ctx, d.x + dx, d.y - 6, 9, 10);
fill(ctx, "#1d1a17");
circle(ctx, d.x + dx, d.y - 5, 2 + glow);
fill(ctx, `rgba(255,80,40,${0.5 + glow * 0.5})`);
}
polygon(ctx, [{ x: d.x, y: d.y + 2 }, { x: d.x - 4, y: d.y + 10 }, { x: d.x + 4, y: d.y + 10 }]);
fill(ctx, "#1d1a17");
for (let i = -3; i <= 3; i++) {
ctx.fillStyle = "#f1ead6";
ctx.fillRect(d.x + i * 5 - 2, d.y + 16, 4, 6);
}
},
},
chest: {
layer: "low",
draw(ctx, p, d, clock) {
ctx.fillStyle = "#7a4a1e";
ctx.fillRect(d.x - 12, d.y - 4, 24, 14);
ctx.fillStyle = "#5c3416";
ctx.fillRect(d.x - 12, d.y - 14, 24, 8);
for (let i = 0; i < 6; i++) {
circle(ctx, d.x - 9 + i * 3.6, d.y - 4 - (i % 2) * 2, 2.4);
fill(ctx, "#f0c22c");
}
const sparkle = Math.floor(t(clock) * 4) % 6;
circle(ctx, d.x - 8 + sparkle * 3, d.y - 8, 1.2);
fill(ctx, "#ffffff");
},
},
/* cave */
bat: {
layer: "high",
draw(ctx, p, d, clock) {
const s = d.s;
const a = t(clock) * 1.1 + d.x;
const x = d.x + Math.sin(a) * 40 * s;
const y = d.y + Math.sin(a * 2) * 12 * s;
const flap = Math.sin(t(clock) * 18 + d.y) * 5 * s;
for (const dir of [-1, 1]) {
polygon(ctx, [{ x, y }, { x: x + dir * 6 * s, y: y - 4 * s - flap }, { x: x + dir * 13 * s, y: y - 1 * s - flap * 0.6 }, { x: x + dir * 9 * s, y: y + 2 * s }, { x: x + dir * 5 * s, y: y + 1 * s }]);
fill(ctx, "#0b0910");
}
circle(ctx, x, y, 3 * s);
fill(ctx, "#0b0910");
for (const dir of [-1, 1]) {
circle(ctx, x + dir * 1.2 * s, y - 0.6 * s, 0.7 * s);
fill(ctx, "#ff4d4d");
}
},
},
stalactite: {
layer: "high",
draw(ctx, p, d) {
const s = d.s;
for (const [dx, h, w] of [[-14, 18, 6], [0, 30, 8], [12, 14, 5], [24, 22, 6]]) {
polygon(ctx, [{ x: d.x + dx * s - w * s, y: d.y }, { x: d.x + dx * s + w * s, y: d.y }, { x: d.x + dx * s, y: d.y + h * s }]);
fill(ctx, "#3d3747");
polygon(ctx, [{ x: d.x + dx * s - w * s * 0.3, y: d.y }, { x: d.x + dx * s + w * s * 0.2, y: d.y }, { x: d.x + dx * s, y: d.y + h * s * 0.85 }]);
fill(ctx, "#5d566a");
}
},
},
crystal: {
layer: "glow",
light: { r: 34, color: "rgba(150,110,255,0.45)" },
draw(ctx, p, d, clock) {
const s = d.s;
const pulse = 0.8 + Math.sin(t(clock) * 2 + d.x) * 0.2;
for (const [dx, h, a, c] of [[-6, 16, -0.4, "#7b5cf0"], [0, 22, 0, "#a68cff"], [6, 14, 0.45, "#5fd3ff"]]) {
turned(ctx, d.x + dx * s, d.y, a, () => {
polygon(ctx, [{ x: -3 * s, y: 0 }, { x: 3 * s, y: 0 }, { x: 2 * s, y: -h * s }, { x: 0, y: -(h + 4) * s }, { x: -2 * s, y: -h * s }]);
ctx.globalAlpha = pulse;
fill(ctx, c);
ctx.globalAlpha = 1;
});
}
},
},
torch: {
layer: "glow",
light: { r: 60, color: "rgba(255,170,60,0.5)" },
draw(ctx, p, d, clock) {
ctx.lineCap = "round";
line(ctx, d.x, d.y + 10, d.x, d.y - 2, "#6b4a2a", 2.5);
const f = Math.sin(t(clock) * 21 + d.x) * 1.2 + Math.sin(t(clock) * 13) * 0.8;
polygon(ctx, [{ x: d.x - 4, y: d.y - 2 }, { x: d.x + 4, y: d.y - 2 }, { x: d.x + f * 0.6, y: d.y - 13 - f }]);
fill(ctx, "#ff8a1f");
polygon(ctx, [{ x: d.x - 2, y: d.y - 2 }, { x: d.x + 2, y: d.y - 2 }, { x: d.x + f * 0.3, y: d.y - 8 - f * 0.5 }]);
fill(ctx, "#ffe08a");
},
},
lantern: {
layer: "glow",
light: { r: 50, color: "rgba(255,210,110,0.45)" },
draw(ctx, p, d, clock) {
const swing = Math.sin(t(clock) * 1.5) * 4;
line(ctx, d.x, 0, d.x + swing, d.y + 4, "#3d3747", 1);
ctx.fillStyle = "#3d3747";
ctx.fillRect(d.x + swing - 4, d.y + 4, 8, 10);
ctx.fillStyle = "#ffd36b";
ctx.fillRect(d.x + swing - 2.5, d.y + 6, 5, 6);
},
},
eyes: {
layer: "glow",
draw(ctx, p, d, clock) {
// Two eyes in the dark that blink, and now and then look at you.
const k = Math.floor(t(clock) * 8 + d.x) % 30;
const open = k > 1 ? 1 : 0.15;
const look = Math.sin(t(clock) * 0.6 + d.y) * 1.5;
for (const dx of [-5, 5]) {
ellipse(ctx, d.x + dx * d.s, d.y, 3.2 * d.s, 2.2 * d.s * open);
fill(ctx, "#ffe14d");
if (open > 0.5) {
ellipse(ctx, d.x + dx * d.s + look, d.y, 0.9 * d.s, 2 * d.s);
fill(ctx, "#111111");
}
}
},
},
skeleton: {
layer: "low",
draw(ctx, p, d, clock) {
ctx.lineCap = "round";
line(ctx, d.x - 9, d.y + 6, d.x + 9, d.y - 2, "#d8d2c2", 2.2);
line(ctx, d.x - 9, d.y - 2, d.x + 9, d.y + 6, "#d8d2c2", 2.2);
circle(ctx, d.x, d.y - 8, 6);
fill(ctx, "#ece6d6");
// The jaw chatters.
const jaw = Math.abs(Math.sin(t(clock) * 6)) * 1.5;
ctx.fillStyle = "#ece6d6";
ctx.fillRect(d.x - 3.5, d.y - 3 + jaw, 7, 2.5);
for (const dx of [-2.2, 2.2]) {
circle(ctx, d.x + dx, d.y - 9, 1.6);
fill(ctx, "#1d1a17");
}
},
},
rails: {
layer: "low",
draw(ctx, p, d) {
for (let y = d.y - 105; y <= d.y + 105; y += 9) {
ctx.fillStyle = "#4a3a2a";
ctx.fillRect(d.x - 10, y, 20, 3);
}
line(ctx, d.x - 6, d.y - 108, d.x - 6, d.y + 108, "#8b8796", 1.6);
line(ctx, d.x + 6, d.y - 108, d.x + 6, d.y + 108, "#8b8796", 1.6);
},
},
gems: {
layer: "glow",
light: { r: 26, color: "rgba(255,120,220,0.35)" },
draw(ctx, p, d) {
const s = d.s;
for (const [dx, dy, c] of [[-6, 2, "#ff5bd6"], [4, 3, "#4de3ff"], [-1, -3, "#f2c84b"], [8, -2, "#5bff9a"], [-9, -4, "#f2c84b"]]) {
polygon(ctx, [{ x: d.x + dx * s, y: d.y + (dy - 3) * s }, { x: d.x + (dx + 3) * s, y: d.y + dy * s }, { x: d.x + dx * s, y: d.y + (dy + 3) * s }, { x: d.x + (dx - 3) * s, y: d.y + dy * s }]);
fill(ctx, c);
}
},
},
spider: {
layer: "high",
draw(ctx, p, d, clock) {
const y = d.y + Math.sin(t(clock) * 1.2) * 18;
line(ctx, d.x, 0, d.x, y, "rgba(220,220,230,0.6)", 0.6);
for (const dir of [-1, 1]) {
for (let k = 0; k < 4; k++) {
ctx.beginPath();
ctx.moveTo(d.x, y);
ctx.lineTo(d.x + dir * 5, y - 3 + k * 2);
ctx.lineTo(d.x + dir * 8, y + k * 2.4);
stroke(ctx, "#15121b", 1);
}
}
circle(ctx, d.x, y, 3.5);
fill(ctx, "#15121b");
for (const dir of [-1, 1]) {
circle(ctx, d.x + dir * 1.3, y - 1, 0.8);
fill(ctx, "#ff4d4d");
}
},
},
web: {
layer: "low",
draw(ctx, p, d) {
ctx.strokeStyle = "rgba(220,220,235,0.35)";
ctx.lineWidth = 0.6;
for (let i = 0; i < 8; i++) {
const a = (i / 8) * Math.PI * 2;
ctx.beginPath();
ctx.moveTo(d.x, d.y);
ctx.lineTo(d.x + Math.cos(a) * 26, d.y + Math.sin(a) * 26);
ctx.stroke();
}
for (const r of [8, 15, 22]) {
circle(ctx, d.x, d.y, r);
ctx.stroke();
}
},
},
glowworms: {
layer: "glow",
light: { r: 40, color: "rgba(110,255,200,0.3)" },
draw(ctx, p, d, clock) {
for (let i = 0; i < 9; i++) {
const x = d.x - 40 + i * 10 + Math.sin(t(clock) + i) * 3;
const y = d.y + Math.sin(t(clock) * 1.4 + i * 0.9) * 6;
circle(ctx, x, y, 1.4 + (Math.sin(t(clock) * 3 + i) + 1) * 0.5);
fill(ctx, "#8cffd9");
}
},
},
mushroom: {
layer: "glow",
light: { r: 30, color: "rgba(255,90,180,0.35)" },
draw(ctx, p, d) {
for (const [dx, dy, r] of [[-5, 3, 5], [4, -2, 6.5], [7, 6, 3.5]]) {
circle(ctx, d.x + dx, d.y + dy, r);
fill(ctx, "#e0468a");
circle(ctx, d.x + dx - r * 0.3, d.y + dy - r * 0.3, r * 0.25);
fill(ctx, "#ffe3f1");
}
},
},
dragon: {
layer: "glow",
light: { r: 70, color: "rgba(255,90,40,0.3)" },
draw(ctx, p, d, clock) {
// A sleeping dragon's head poking in from the right edge, snoring.
const cx = d.x - 6;
const breathe = Math.sin(t(clock) * 1.4) * 1.5;
ellipse(ctx, cx, d.y, 44 + breathe, 32);
fill(ctx, "#a3202a");
for (let i = 0; i < 4; i++) {
polygon(ctx, [{ x: cx - 26 + i * 12, y: d.y - 28 + i * 2 }, { x: cx - 20 + i * 12, y: d.y - 40 + i * 2 }, { x: cx - 14 + i * 12, y: d.y - 27 + i * 2 }]);
fill(ctx, "#f2c84b");
}
// The closed eye, a sleepy curve.
ctx.beginPath();
ctx.arc(cx - 14, d.y - 12, 6, 0.2, Math.PI - 0.2);
stroke(ctx, "#1d0608", 1.8);
for (const dy of [-2, 6]) {
circle(ctx, cx - 36 - breathe, d.y + dy, 2);
fill(ctx, "#1d0608");
}
const k = (t(clock) % 3) / 3;
label(ctx, "Z", cx - 46 - k * 14, d.y - 10 - k * 26, 7 + k * 5, `rgba(255,240,200,${1 - k})`);
label(ctx, "z", cx - 52 - k * 8, d.y - 2 - k * 14, 5 + k * 3, `rgba(255,240,200,${0.8 - k * 0.8})`);
},
},
};
export const DECOR_KINDS = Object.freeze(Object.keys(DECOR));
// Draws the hole's scenery that belongs on `layer`.
export function drawDecor(ctx, p, decor, clock, layer) {
for (const d of decor) {
const kind = DECOR[d.kind];
if (kind && kind.layer === layer) kind.draw(ctx, p, d, clock);
}
}
// The glows the scenery casts, for a cave's darkness: { x, y, r, color }.
export function decorLights(decor) {
const lights = [];
for (const d of decor) {
const kind = DECOR[d.kind];
if (kind && kind.light) lights.push({ x: d.x, y: d.y - 4, r: kind.light.r * (d.s || 1), color: kind.light.color });
if (d.kind === "eyes") lights.push({ x: d.x, y: d.y, r: 12, color: "rgba(255,225,80,0.25)" });
}
return lights;
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,444 @@
// Plan2Code Web Console - mini golf's course: the eighteen holes as data, in course units.
//
// Data only: no DOM and no imports, so the game (activities/golf.js) and the
// unit suite both read it as it is. Every hole is drawn on a fixed course of
// COURSE_W by COURSE_H units, scaled to the board like Snake's fixed grid, so
// a resize never moves a ball.
//
// The front nine is Pirate Cove: greens afloat in a shark sea, wooden rails,
// barrels and cannonballs. The back nine is the Caves of Doom: mossy stone in
// the dark, glowing pools, lava, a bottomless pit, mine carts and crushers.
//
// A hole is { name, par, theme, quip, ground, liquid, tee, cup, outline,
// walls, bumpers, sand, water, slopes, bridges, spinners, tunnels, movers,
// gates, powerups, decor }:
// theme "pirate" or "cave": the palette, the lighting and the gags
// quip a line shown as the hole starts
// ground how the green is drawn: "grass", "deck", "moss" or "stone"
// liquid what the water is: "sea", "pool", "lava" or "chasm" (the rule
// is the same, a stroke and back where the putt began)
// tee, cup points { x, y }
// outline the playing area as a polygon; its edges are the course edge,
// and they lead the walls list
// walls line segments { x1, y1, x2, y2 }
// bumpers circles { x, y, r, look? } that kick the ball back faster
// sand polygons that slow the ball several times over
// water polygons that cost a stroke, unless the ball is on a bridge
// slopes { points, push: { x, y } }: a polygon that pushes the ball each
// moment it is inside, in units per second per second (ramps,
// currents and updrafts too)
// bridges rectangles { x, y, w, h }: safe ground over water
// spinners { x, y, arm, speed, look? }: a windmill-style bar through its
// center, arm units each way, turning speed radians a second
// tunnels { a, b }: two mouths; entering one sends the ball out of the
// other with its speed kept
// movers { x, y, r, dx, dy, period, phase?, look? }: a bumper that swings
// dx, dy units each way from x, y, once every period ms
// gates { x1, y1, x2, y2, period, open, offset?, look? }: a wall that is
// there for the last (1 - open) of every period ms
// powerups { x, y, kind }: a pad the rolling ball picks up, for its next
// putt (the kinds are POWERUPS in golf.js)
// decor { kind, x, y, s? }: scenery that never touches the ball
// A polygon is a list of points { x, y }.
export const COURSE_W = 400;
export const COURSE_H = 300;
const pt = (x, y) => ({ x, y });
const rect = (x, y, w, h) => [pt(x, y), pt(x + w, y), pt(x + w, y + h), pt(x, y + h)];
const wall = (x1, y1, x2, y2) => ({ x1, y1, x2, y2 });
const bump = (x, y, r, look) => (look ? { x, y, r, look } : { x, y, r });
const pad = (x, y, kind) => ({ x, y, kind });
const deco = (kind, x, y, s = 1) => ({ kind, x, y, s });
// The outline's edges, closing back to its first point.
const edges = (outline) => outline.map((p, i) => {
const q = outline[(i + 1) % outline.length];
return wall(p.x, p.y, q.x, q.y);
});
function freezeDeep(value) {
if (value && typeof value === "object") {
Object.values(value).forEach(freezeDeep);
Object.freeze(value);
}
return value;
}
// Fills the empty lists and puts the outline's edges first among the walls.
function hole(def) {
const theme = def.theme || "pirate";
return {
name: def.name,
par: def.par,
theme,
quip: def.quip || "",
ground: def.ground || (theme === "cave" ? "moss" : "grass"),
liquid: def.liquid || (theme === "cave" ? "pool" : "sea"),
tee: def.tee,
cup: def.cup,
outline: def.outline,
walls: [...edges(def.outline), ...(def.walls || [])],
bumpers: def.bumpers || [],
sand: def.sand || [],
water: def.water || [],
slopes: def.slopes || [],
bridges: def.bridges || [],
spinners: def.spinners || [],
tunnels: def.tunnels || [],
movers: def.movers || [],
gates: def.gates || [],
powerups: def.powerups || [],
decor: def.decor || [],
};
}
const pirate = (def) => hole({ ...def, theme: "pirate" });
const cave = (def) => hole({ ...def, theme: "cave" });
export const HOLES = freezeDeep([
/* ------------------------------------------- front nine: Pirate Cove */
// 1: a straight plank over the sea, to learn the putt. The sharks wait.
pirate({
name: "Walk the Plank",
par: 2,
quip: "Arr! Straight down the plank, matey. The sharks be hungry.",
ground: "deck",
tee: pt(90, 150),
cup: pt(310, 150),
outline: rect(60, 110, 280, 80),
decor: [deco("shark", 200, 62, 1), deco("shark", 140, 244, 0.8), deco("ship", 345, 52), deco("bottle", 40, 250), deco("palm", 30, 70, 0.8)],
}),
// 2: an L that turns left; a barrel splits the lane, and a doubloon waits in
// the corner for whoever banks it there.
pirate({
name: "Shipwreck Cove",
par: 3,
quip: "Bank it off the corner. That doubloon makes yer next putt free!",
tee: pt(75, 228),
cup: pt(268, 75),
outline: [pt(40, 195), pt(232, 195), pt(232, 40), pt(305, 40), pt(305, 262), pt(40, 262)],
bumpers: [bump(268, 142, 10, "barrel")],
powerups: [pad(268, 228, "doubloon")],
decor: [deco("wreck", 125, 110), deco("crab", 70, 282), deco("parrot", 345, 70), deco("shark", 355, 200, 0.7), deco("palm", 20, 175, 0.9)],
}),
// 3: cannonballs across the straight line, a powder barrel rolling the
// lane, and cannons firing from the shore.
pirate({
name: "Cannon Alley",
par: 3,
quip: "Fire in the hole! Grab the cannonball for a mighty blast.",
tee: pt(70, 150),
cup: pt(330, 150),
outline: rect(40, 60, 320, 180),
bumpers: [
bump(160, 108, 12, "cannonball"),
bump(160, 192, 12, "cannonball"),
bump(222, 150, 14, "cannonball"),
bump(278, 98, 10, "cannonball"),
bump(278, 202, 10, "cannonball"),
],
movers: [{ x: 110, y: 150, r: 9, dx: 0, dy: 62, period: 2600, look: "barrel" }],
powerups: [pad(92, 80, "cannon")],
decor: [deco("cannon", 120, 42), deco("cannon", 280, 42), deco("cannon", 200, 262, -1), deco("anchor", 380, 270)],
}),
// 4: two staggered traps; the straight line crosses both, a weave misses
// them, and the treasure map waits beyond the second.
pirate({
name: "Treasure Beach",
par: 3,
quip: "X marks the spot! The map makes the next cup HUGE.",
tee: pt(70, 150),
cup: pt(330, 150),
outline: rect(40, 70, 320, 160),
sand: [
rect(135, 112, 60, 118),
rect(235, 70, 60, 118),
],
bumpers: [bump(215, 150, 9, "chest")],
powerups: [pad(165, 195, "doubloon"), pad(265, 210, "bigcup")],
decor: [deco("palm", 28, 52), deco("palm", 372, 252), deco("crab", 200, 254), deco("island", 350, 40), deco("bottle", 60, 262)],
}),
// 5: the lagoon runs wall to wall; the bridge is the only dry way over, and
// the kraken's tentacle sweeps the far bank. The ghost floats right across.
pirate({
name: "Kraken's Lagoon",
par: 4,
quip: "Release the kraken! Or grab the ghost ball and float over it.",
tee: pt(65, 80),
cup: pt(330, 80),
outline: rect(30, 40, 340, 220),
water: [rect(165, 40, 80, 220)],
bridges: [{ x: 165, y: 190, w: 80, h: 40 }],
spinners: [{ x: 305, y: 172, arm: 34, speed: -1.9, look: "tentacle" }],
powerups: [pad(90, 240, "ghost")],
decor: [deco("tentacle", 205, 95), deco("tentacle", 190, 150, 0.8), deco("kraken", 205, 280), deco("shark", 380, 140, 0.6)],
}),
// 6: a ghost ship's deck with an open hold amidships; around it by the
// rails, or a rubber duck's bounce off them.
pirate({
name: "Ghost Ship",
par: 3,
quip: "Ooooo, a haunted deck. Mind the hold, it goes straight to the sea.",
ground: "deck",
tee: pt(75, 150),
cup: pt(330, 150),
outline: [pt(40, 90), pt(280, 70), pt(370, 150), pt(280, 230), pt(40, 210)],
water: [rect(150, 118, 90, 64)],
powerups: [pad(105, 118, "bouncy"), pad(105, 182, "magnet")],
decor: [deco("ghost", 200, 40), deco("ghost", 300, 262, 0.7), deco("tentacle", 195, 160), deco("jolly", 60, 40)],
}),
// 7: a ship's wheel turns across the way to the cup; walls close the way
// around it.
pirate({
name: "The Ship's Wheel",
par: 3,
quip: "Hard to starboard! Time yer putt through the spinning wheel.",
tee: pt(70, 150),
cup: pt(330, 150),
outline: rect(40, 80, 320, 140),
walls: [
wall(240, 80, 240, 107),
wall(240, 193, 240, 220),
],
spinners: [{ x: 240, y: 150, arm: 40, speed: 1.6, look: "wheel" }],
powerups: [pad(130, 105, "bouncy")],
decor: [deco("parrot", 240, 60), deco("anchor", 30, 260), deco("shark", 200, 262, 0.9), deco("island", 360, 45)],
}),
// 8: a long U the slow way round, past a scuttling crab, or the skull's
// tunnel straight across.
pirate({
name: "Skull Island",
par: 3,
quip: "Into the skull's mouth and out its ear. Totally normal.",
tee: pt(75, 65),
cup: pt(325, 125),
outline: [pt(40, 40), pt(110, 40), pt(110, 195), pt(290, 195), pt(290, 40), pt(360, 40), pt(360, 262), pt(40, 262)],
tunnels: [
{ a: pt(75, 170), b: pt(325, 62) },
],
movers: [{ x: 200, y: 245, r: 8, dx: 60, dy: 0, period: 3000, look: "crab" }],
powerups: [pad(160, 214, "magnet")],
decor: [deco("skullrock", 200, 115), deco("shark", 200, 45, 0.7), deco("palm", 148, 175, 0.7), deco("palm", 255, 172, 0.8)],
}),
// 9: up the ramp, over the bridge, through the gold to the cup.
pirate({
name: "Captain's Plunder",
par: 4,
quip: "The captain's own treasure! Ramp, bridge, gold. Go!",
tee: pt(70, 240),
cup: pt(340, 60),
outline: rect(30, 30, 340, 240),
// The ramp climbs to the bridge: too soft a putt rolls back down it.
slopes: [
{ points: rect(95, 55, 55, 50), push: pt(-110, 0) },
],
water: [
rect(150, 30, 90, 240),
],
bridges: [
{ x: 150, y: 55, w: 90, h: 50 },
],
bumpers: [
bump(288, 118, 12, "coin"),
bump(336, 132, 10, "coin"),
bump(296, 200, 12, "coin"),
bump(270, 40, 8, "coin"),
],
movers: [{ x: 320, y: 250, r: 7, dx: 30, dy: 0, period: 2400, look: "crab" }],
powerups: [pad(60, 150, "spyglass"), pad(270, 160, "doubloon")],
decor: [deco("tentacle", 195, 180), deco("tentacle", 210, 240, 0.7), deco("chest", 385, 80), deco("jolly", 385, 250)],
}),
/* ---------------------------------------- back nine: Caves of Doom */
// 10: a winding passage into the dark past a glowing pool, a mushroom on
// the bend.
cave({
name: "Into the Dark",
par: 3,
quip: "Welcome to the Caves of Doom. Your ball is the only light. Gulp.",
tee: pt(60, 230),
cup: pt(340, 80),
outline: [pt(30, 200), pt(230, 200), pt(230, 40), pt(370, 40), pt(370, 120), pt(300, 120), pt(300, 260), pt(30, 260)],
water: [rect(115, 236, 75, 24)],
bumpers: [bump(265, 160, 9, "mushroom")],
powerups: [pad(265, 232, "spyglass")],
decor: [deco("bat", 110, 90), deco("bat", 160, 130, 0.8), deco("eyes", 90, 150), deco("torch", 30, 185), deco("stalactite", 330, 0), deco("crystal", 380, 200), deco("eyes", 345, 230, 0.7)],
}),
// 11: a forest of stalagmites, with gaps a ball can thread.
cave({
name: "Stalagmite Forest",
par: 3,
quip: "Pointy rocks everywhere. Bounce through like a pinball.",
ground: "stone",
tee: pt(70, 150),
cup: pt(335, 150),
outline: rect(40, 50, 320, 200),
bumpers: [
bump(120, 90, 9, "rock"), bump(120, 150, 9, "rock"), bump(120, 210, 9, "rock"),
bump(162, 120, 9, "rock"), bump(162, 180, 9, "rock"),
bump(204, 90, 9, "rock"), bump(204, 150, 9, "rock"), bump(204, 210, 9, "rock"),
bump(246, 120, 9, "rock"), bump(246, 180, 9, "rock"),
bump(288, 90, 9, "rock"), bump(288, 210, 9, "rock"),
],
powerups: [pad(225, 236, "bouncy")],
decor: [deco("bat", 100, 30), deco("bat", 300, 270, 0.8), deco("stalactite", 80, 0), deco("stalactite", 250, 0, 1.2), deco("crystal", 20, 270), deco("skeleton", 375, 40)],
}),
// 12: a lava lake wall to wall, two thin stone bridges, and a fireball
// bobbing up and down across both of them.
cave({
name: "Lava Lake",
par: 4,
quip: "The floor is lava. No, really. Fireball incoming!",
liquid: "lava",
ground: "stone",
tee: pt(65, 150),
cup: pt(335, 150),
outline: rect(30, 40, 340, 220),
water: [rect(130, 40, 140, 220)],
bridges: [
{ x: 130, y: 70, w: 140, h: 28 },
{ x: 130, y: 205, w: 140, h: 28 },
],
movers: [{ x: 200, y: 150, r: 8, dx: 0, dy: 95, period: 3600, look: "fireball" }],
powerups: [pad(85, 235, "ghost")],
decor: [deco("torch", 20, 100), deco("torch", 380, 100), deco("skeleton", 375, 270), deco("stalactite", 200, 0, 0.8)],
}),
// 13: three mine carts rattle up and down across the straight line.
cave({
name: "Mine Cart Madness",
par: 3,
quip: "Runaway mine carts! Time it... or blast through with the cannon.",
ground: "stone",
tee: pt(60, 150),
cup: pt(345, 150),
outline: rect(30, 40, 340, 220),
movers: [
{ x: 140, y: 150, r: 12, dx: 0, dy: 85, period: 2200, look: "cart" },
{ x: 220, y: 150, r: 12, dx: 0, dy: 85, period: 2800, phase: 0.3, look: "cart" },
{ x: 300, y: 150, r: 12, dx: 0, dy: 85, period: 2000, phase: 0.6, look: "cart" },
],
powerups: [pad(60, 70, "cannon")],
decor: [deco("rails", 140, 150), deco("rails", 220, 150), deco("rails", 300, 150), deco("lantern", 20, 40), deco("gems", 385, 270), deco("bat", 200, 20)],
}),
// 14: crystals everywhere and two slingshot walls: pure pinball.
cave({
name: "Crystal Pinball",
par: 3,
quip: "TILT! Crystals, bumpers and a big treasure-map cup.",
tee: pt(70, 230),
cup: pt(330, 70),
outline: rect(40, 40, 320, 220),
walls: [
wall(300, 252, 350, 215),
wall(48, 150, 85, 122),
],
bumpers: [
bump(130, 110, 11, "crystal"),
bump(200, 80, 11, "crystal"),
bump(200, 170, 13, "crystal"),
bump(270, 140, 11, "crystal"),
bump(140, 200, 10, "crystal"),
bump(330, 140, 9, "crystal"),
],
powerups: [pad(205, 238, "bigcup")],
decor: [deco("crystal", 22, 210, 1.2), deco("crystal", 380, 280), deco("crystal", 385, 120, 0.8), deco("bat", 200, 280, 0.7)],
}),
// 15: a bottomless pit wall to wall, one rope bridge over it, and an
// updraft blowing across the bridge.
cave({
name: "The Bottomless Pit",
par: 3,
quip: "Don't look down. Seriously. There's an updraft on the bridge.",
liquid: "chasm",
ground: "stone",
tee: pt(75, 150),
cup: pt(325, 150),
outline: rect(40, 50, 320, 200),
water: [rect(150, 50, 100, 200)],
bridges: [{ x: 150, y: 132, w: 100, h: 36 }],
slopes: [{ points: rect(150, 132, 100, 36), push: pt(0, 70) }],
powerups: [pad(100, 80, "magnet")],
decor: [deco("spider", 330, 70), deco("web", 360, 230), deco("skeleton", 60, 230), deco("torch", 30, 150), deco("torch", 370, 150)],
}),
// 16: a winding grotto; the glowworm current carries the ball up and over.
cave({
name: "Glowworm Grotto",
par: 3,
quip: "Ride the glowworm current. They're friendly. Probably.",
tee: pt(70, 90),
cup: pt(310, 200),
outline: rect(30, 60, 340, 180),
walls: [
wall(130, 60, 130, 180),
wall(250, 120, 250, 240),
],
slopes: [{ points: rect(140, 70, 100, 100), push: pt(0, -90) }],
bumpers: [bump(190, 215, 10, "mushroom"), bump(310, 90, 10, "mushroom")],
powerups: [pad(165, 195, "spyglass")],
decor: [deco("glowworms", 200, 30), deco("glowworms", 100, 270), deco("mushroom", 20, 250), deco("mushroom", 385, 50), deco("eyes", 300, 270)],
}),
// 17: a corridor of stone crushers slamming down in turn, lava in its
// corners.
cave({
name: "Crusher Corridor",
par: 4,
quip: "SMASH! SMASH! SMASH! Run the crushers... if you dare.",
ground: "stone",
liquid: "lava",
tee: pt(60, 150),
cup: pt(345, 150),
outline: rect(30, 90, 340, 120),
water: [rect(160, 90, 30, 24), rect(240, 186, 30, 24)],
gates: [
{ x1: 130, y1: 90, x2: 130, y2: 210, period: 2400, open: 0.55, offset: 0, look: "crusher" },
{ x1: 210, y1: 90, x2: 210, y2: 210, period: 2400, open: 0.55, offset: 0.33, look: "crusher" },
{ x1: 290, y1: 90, x2: 290, y2: 210, period: 2400, open: 0.55, offset: 0.66, look: "crusher" },
],
powerups: [pad(95, 195, "cannon"), pad(250, 105, "doubloon")],
decor: [deco("skeleton", 200, 245), deco("torch", 100, 70), deco("torch", 300, 70), deco("stalactite", 200, 0, 1.3), deco("bat", 60, 260, 0.8)],
}),
// 18: the dragon's hoard: a lava lake, a portal over it, the dragon's tail
// sweeping, gold everywhere, and the dragon himself asleep at the edge.
cave({
name: "The Dragon's Hoard",
par: 5,
quip: "SHHH! The dragon is sleeping. Grab the gold and sink it.",
liquid: "lava",
tee: pt(60, 240),
cup: pt(305, 75),
outline: rect(20, 45, 325, 230),
water: [rect(130, 45, 80, 160)],
tunnels: [{ a: pt(70, 80), b: pt(245, 70) }],
spinners: [{ x: 275, y: 160, arm: 34, speed: 2.2, look: "tail" }],
bumpers: [bump(300, 220, 9, "coin"), bump(235, 112, 9, "coin"), bump(95, 145, 9, "coin")],
powerups: [pad(170, 240, "bigcup"), pad(65, 180, "ghost")],
decor: [deco("dragon", 400, 160), deco("gems", 30, 290), deco("gems", 372, 270, 0.8), deco("torch", 10, 160), deco("stalactite", 200, 0)],
}),
]);
// Where the front nine ends: the scorecard after it heads into the caves.
export const FRONT_NINE = 9;
+954
View File
@@ -0,0 +1,954 @@
// Plan2Code Web Console - Mini golf, the second activity: eighteen holes seen from above, rules, physics and the game contract.
//
// The Activities window (screens/activities.js) drives everything, as it does
// for Snake: it ticks the game, hands it keys, key releases and pointer
// events, and pauses it. Play is arcade quick: the aim follows the pointer
// (or held arrows), one press starts the power meter and a second sets the
// power, and a shot clock starts the meter for a player who dawdles. The
// rules are plain functions over a round object (newRound, startSwing,
// setPower, strike, advance and helpers), exported so the unit suite can play
// exact shots without a canvas. Physics runs on a fixed sub-step and never reads the
// clock or Math.random(), so the same shot always rolls the same way. The
// course is data (golf-holes.js); the drawing lives in golf-draw.js and its
// scenery in golf-decor.js.
import { COURSE_W, COURSE_H, FRONT_NINE, HOLES } from "./golf-holes.js";
import { drawCourse, readColors } from "./golf-draw.js";
export { COURSE_W, COURSE_H, FRONT_NINE, HOLES };
// One physics step, in ms. tick() runs as many as the elapsed time holds and
// carries the rest to the next tick.
export const SUB_STEP_MS = 4;
// The most time one tick() plays, matching the window's own frame cap.
export const MAX_TICK_MS = 250;
export const BALL_R = 4;
export const CUP_R = 7;
export const TUNNEL_R = 9;
export const POWERUP_R = 9;
// The fastest a ball ever moves, in units a second. At SUB_STEP_MS it covers
// 2.4 units a step, under BALL_R, so no step can carry it through a wall. A
// cannon shot may go faster, still under BALL_R a step.
export const MAX_SPEED = 600;
export const CANNON_MAX = 900;
// A full-power putt's speed, in units a second. A MAX putt (MAX_BOOST) comes
// to 598, just under MAX_SPEED.
export const STRIKE_SPEED = 520;
// Rolling: a steady slowing plus a share of the speed, both multiplied in sand.
const FRICTION = 40;
const DRAG = 1.2;
export const SAND_FACTOR = 4;
// Under this speed, off any slope, the ball has stopped. High enough to cut
// the slow creep at the end of a roll.
const STOP_SPEED = 8;
// Over the cup under this speed, the ball drops; faster, it rolls over.
export const CAPTURE_SPEED = 130;
// The share of its speed into a wall the ball keeps coming off it.
const WALL_KEEP = 0.7;
// The speed a bumper adds on top of a full bounce.
const BUMPER_KICK = 60;
// A hit into a wall this fast or more gets the wall tone.
const FIRM_HIT = 60;
export const MAX_STROKES = 8;
// How long the scorecard waits between holes before moving on by itself.
export const CARD_MS = 1500;
// The power-ups: a pad the rolling ball runs over is held for the next putt,
// and that putt alone gets its help. One is held at a time; a new pad
// replaces the one held. A held power-up carries over to the next hole.
export const POWERUPS = Object.freeze({
doubloon: Object.freeze({ name: "Lucky Doubloon", blurb: "the next putt is free" }),
cannon: Object.freeze({ name: "Cannonball", blurb: "the next putt fires 1.6x as hard" }),
ghost: Object.freeze({ name: "Ghost Ball", blurb: "the next putt floats over water, sand and bumpers" }),
magnet: Object.freeze({ name: "Parrot Magnet", blurb: "the next putt homes in on the cup" }),
bouncy: Object.freeze({ name: "Rubber Duck", blurb: "the next putt bounces off walls at full speed" }),
bigcup: Object.freeze({ name: "Treasure Map", blurb: "the next putt aims at a HUGE cup" }),
spyglass: Object.freeze({ name: "Spyglass", blurb: "see where the next putt will roll" }),
});
export const CANNON_BOOST = 1.6;
export const BIG_CUP = 2.4;
// The magnet turns the ball toward the cup inside this reach, by up to this
// many radians a second, never adding speed, so a ball under it still stops.
export const MAGNET_R = 110;
const MAGNET_TURN = 7;
// The magnet and the big cup let a faster ball drop.
const HELPED_CAPTURE = 1.7;
// How far ahead the spyglass looks, in ms of rolling.
const PREDICT_MS = 3000;
// The swing. A press starts the power meter and a second sets the power. The
// needle runs from empty to past full and back once every METER_MS, slow at
// the bottom and fast at the top (METER_CURVE), so a soft putt is easy to
// catch and a full one is not. The MAX band, just under full, putts
// MAX_BOOST as hard. Past full is the overswing: OVER_POWER, pulled off line
// by up to OVER_PULL, the more the deeper into it.
export const METER_MS = 1750;
const METER_CURVE = 1.6;
export const MAX_BAND = 0.12;
export const MAX_BOOST = 1.15;
export const OVER_BAND = 0.1;
export const OVER_POWER = 0.7;
const OVER_PULL = (14 * Math.PI) / 180;
// The softest putt a press can set.
const MIN_POWER = 0.03;
// The shot clock: a ball this long at rest starts the meter by itself, and a
// meter left running METER_TRIPS trips dribbles the ball off at DRIBBLE_POWER.
export const SHOT_CLOCK_MS = 6000;
export const METER_TRIPS = 3;
const DRIBBLE_POWER = 0.06;
// Holding the action key or the pointer down while the ball rolls plays the
// roll this many times as fast.
export const FAST_FORWARD = 3;
// Keyboard aiming: a press nudges the aim by AIM_NUDGE, and held, it turns
// from TURN_SLOW up to TURN_FAST radians a second over TURN_RAMP_MS.
const AIM_NUDGE = Math.PI / 180;
const TURN_SLOW = (35 * Math.PI) / 180;
const TURN_FAST = (220 * Math.PI) / 180;
const TURN_RAMP_MS = 700;
// Below this many CSS pixels the course is too small to play.
export const MIN_W = 320;
export const MIN_H = 240;
// How many recent positions the rolling ball's trail keeps.
const TRAIL = 12;
// How long a popped-up word stays on the board, in ms of the round's clock.
const TOAST_MS = 1300;
/* --------------------------------------------------------------- geometry */
const dist = (ax, ay, bx, by) => Math.hypot(ax - bx, ay - by);
export function inPolygon(points, x, y) {
let inside = false;
for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
const a = points[i];
const b = points[j];
if ((a.y > y) !== (b.y > y) && x < ((b.x - a.x) * (y - a.y)) / (b.y - a.y) + a.x) inside = !inside;
}
return inside;
}
const inRect = (r, x, y) => x >= r.x && x <= r.x + r.w && y >= r.y && y <= r.y + r.h;
// The point on segment a-b closest to p.
function closest(x1, y1, x2, y2, px, py) {
const dx = x2 - x1;
const dy = y2 - y1;
const len = dx * dx + dy * dy;
const t = len ? Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / len)) : 0;
return { x: x1 + t * dx, y: y1 + t * dy };
}
// A spinner's bar as a segment at the round's clock.
export function spinnerEnds(s, clockMs) {
const a = s.speed * (clockMs / 1000);
const cx = Math.cos(a) * s.arm;
const cy = Math.sin(a) * s.arm;
return { x1: s.x - cx, y1: s.y - cy, x2: s.x + cx, y2: s.y + cy };
}
// A mover's center and velocity at the round's clock: a smooth swing either
// side of where it rests.
export function moverAt(m, clockMs) {
const turn = (2 * Math.PI) / m.period;
const a = turn * clockMs + 2 * Math.PI * (m.phase || 0);
const s = Math.sin(a);
const c = Math.cos(a) * turn * 1000;
return { x: m.x + m.dx * s, y: m.y + m.dy * s, vx: m.dx * c, vy: m.dy * c, r: m.r };
}
// How far through its period a gate is, 0 to 1, and whether it is shut.
export const gatePhase = (g, clockMs) => (((clockMs / g.period + (g.offset || 0)) % 1) + 1) % 1;
export const gateShut = (g, clockMs) => gatePhase(g, clockMs) >= g.open;
export const onSlope = (hole, x, y) => hole.slopes.some((s) => inPolygon(s.points, x, y));
export const inSand = (hole, x, y) => hole.sand.some((p) => inPolygon(p, x, y));
export const onBridge = (hole, x, y) => hole.bridges.some((r) => inRect(r, x, y));
export const inWater = (hole, x, y) => hole.water.some((p) => inPolygon(p, x, y)) && !onBridge(hole, x, y);
/* ------------------------------------------------------------------ rules */
const parTotal = (upTo) => HOLES.slice(0, upTo).reduce((n, h) => n + h.par, 0);
// The ball at rest, waiting for a putt: the shot clock starts again and the
// aim turns back toward the cup, so a straight putt needs no aiming at all.
function atRest(round) {
const hole = HOLES[round.hole];
round.phase = "aim";
round.restMs = 0;
round.aimAngle = Math.atan2(hole.cup.y - round.ball.y, hole.cup.x - round.ball.x);
}
function placeOnTee(round) {
const hole = HOLES[round.hole];
round.ball = { x: hole.tee.x, y: hole.tee.y, vx: 0, vy: 0, moving: false };
round.from = { x: hole.tee.x, y: hole.tee.y };
round.strokes = 0;
round.putts = 0;
round.tunnelLock = null;
round.trail = [];
round.active = null;
round.taken = [];
round.holeStart = round.clock;
atRest(round);
}
// Hole 1, the ball on its tee, nothing scored. `phase` is "aim" (the ball at
// rest, waiting for a putt), "swing" (the power meter running), "rolling",
// "card" (the scorecard between holes) or "done" (the round is over).
// `restMs` is how long the ball has waited (the shot clock), `swingMs` how
// long the meter has run, `swingAngle` the aim it locked, and `lastSwing`
// where the needle stopped last time. `held` is the power-up waiting for the
// next putt, `active` the one helping the putt in play, and `taken` the pads
// this hole has used up.
export function newRound() {
const round = {
hole: 0,
card: [],
clock: 0,
cardMs: 0,
sunk: null,
swingMs: 0,
swingAngle: 0,
lastSwing: null,
held: null,
};
placeOnTee(round);
return round;
}
// Every finished hole's strokes plus the hole in play.
export const total = (round) => round.card.reduce((n, s) => n + s, 0) + (round.phase === "card" || round.phase === "done" ? 0 : round.strokes);
// Against par for the holes played so far, the one in play counted once it is
// finished: negative is under par.
export const toPar = (round) => round.card.reduce((n, s) => n + s, 0) - parTotal(round.card.length);
// Putts from where the ball rests: power 0 to MAX_BOOST of STRIKE_SPEED, at
// an angle in radians (0 is along +x). A held power-up goes into this putt.
// Returns whether a putt was taken (a Lucky Doubloon putt is taken but not
// counted).
export function strike(round, angle, power) {
if ((round.phase !== "aim" && round.phase !== "swing") || round.ball.moving || !(power > 0)) return false;
round.active = round.held;
round.held = null;
const boost = round.active === "cannon" ? CANNON_BOOST : 1;
const speed = STRIKE_SPEED * Math.min(MAX_BOOST, power) * boost;
const ball = round.ball;
round.from = { x: ball.x, y: ball.y };
ball.vx = Math.cos(angle) * speed;
ball.vy = Math.sin(angle) * speed;
ball.moving = true;
round.putts += 1;
if (round.active !== "doubloon") round.strokes += 1;
round.phase = "rolling";
round.trail = [];
return true;
}
// The needle `ms` into a swing: from 0 (empty) up to 1 + OVER_BAND (the top
// of the overswing) and back, once every METER_MS.
export function meterAt(ms) {
const t = ((ms % METER_MS) + METER_MS) % METER_MS / METER_MS;
const u = t < 0.5 ? t * 2 : 2 - t * 2;
return (1 + OVER_BAND) * u ** METER_CURVE;
}
export const meterZone = (pos) => (pos > 1 ? "over" : pos >= 1 - MAX_BAND ? "max" : "normal");
// What a press at needle `pos` puts on a ball aimed at `angle`: { zone,
// angle, power }. An overswing pulls left and right on alternate putts (`n`),
// so the same swing always goes the same way.
export function swingShot(pos, angle, n) {
const zone = meterZone(pos);
if (zone === "max") return { zone, angle, power: MAX_BOOST };
if (zone === "over") {
const depth = Math.min(1, (pos - 1) / OVER_BAND);
return { zone, angle: angle + (n % 2 ? 1 : -1) * (0.4 + 0.6 * depth) * OVER_PULL, power: OVER_POWER };
}
return { zone, angle, power: Math.max(MIN_POWER, pos) };
}
// Starts the power meter on a ball at rest, the aim locked where it points.
export function startSwing(round) {
if (round.phase !== "aim" || round.ball.moving) return false;
round.phase = "swing";
round.swingMs = 0;
round.swingAngle = round.aimAngle;
return true;
}
// Sets the power where the needle is and putts. Returns the shot swingShot()
// made of it, or null when no meter was running.
export function setPower(round) {
if (round.phase !== "swing") return null;
const pos = meterAt(round.swingMs);
const shot = swingShot(pos, round.swingAngle, round.putts);
if (!strike(round, shot.angle, shot.power)) return null;
round.lastSwing = pos;
return shot;
}
// The scorecard for a finished hole, or the end of the round after the last.
// A water penalty on the last stroke can take the count past the cap, so the
// hole in play is capped too, not only its card entry. A hole always scores
// at least 1, however many doubloons went into it.
function finishHole(round, strokes, events) {
round.strokes = Math.max(1, Math.min(round.strokes, MAX_STROKES));
round.card.push(Math.max(1, Math.min(strokes, MAX_STROKES)));
round.ball.vx = 0;
round.ball.vy = 0;
round.ball.moving = false;
round.active = null;
round.cardMs = 0;
round.phase = round.hole === HOLES.length - 1 ? "done" : "card";
if (round.phase === "done") events.push("done");
}
// Leaves the scorecard for the next hole's tee.
export function nextHole(round) {
if (round.phase !== "card") return false;
round.hole += 1;
round.sunk = null;
placeOnTee(round);
return true;
}
// The ball off a fixed segment or a moving bar: pushed clear, and bounced
// with `keep` of its speed into the surface. `sx`, `sy` is how fast the
// surface itself moves at the contact (a spinner), 0 for a wall.
function bounceOffSegment(ball, seg, events, keep = WALL_KEEP, sx = 0, sy = 0) {
const p = closest(seg.x1, seg.y1, seg.x2, seg.y2, ball.x, ball.y);
let nx = ball.x - p.x;
let ny = ball.y - p.y;
let d = Math.hypot(nx, ny);
if (d >= BALL_R) return false;
if (d === 0) {
// Dead on the line: back out the way it came, or, at rest, square off it.
const v = Math.hypot(ball.vx, ball.vy);
const len = Math.hypot(seg.x2 - seg.x1, seg.y2 - seg.y1) || 1;
nx = v ? -ball.vx / v : -(seg.y2 - seg.y1) / len;
ny = v ? -ball.vy / v : (seg.x2 - seg.x1) / len;
d = 1;
} else {
nx /= d;
ny /= d;
}
ball.x = p.x + nx * BALL_R;
ball.y = p.y + ny * BALL_R;
const into = (ball.vx - sx) * nx + (ball.vy - sy) * ny;
if (into < 0) {
ball.vx -= (1 + keep) * into * nx;
ball.vy -= (1 + keep) * into * ny;
if (-into >= FIRM_HIT) events.push("wall");
}
return true;
}
// A ball off a round bumper, standing or moving at (bvx, bvy): a full bounce
// plus a kick.
function bounceOffRound(ball, b, events, bvx = 0, bvy = 0) {
let nx = ball.x - b.x;
let ny = ball.y - b.y;
const d = Math.hypot(nx, ny);
if (d >= b.r + BALL_R || d === 0) return false;
nx /= d;
ny /= d;
ball.x = b.x + nx * (b.r + BALL_R);
ball.y = b.y + ny * (b.r + BALL_R);
const into = (ball.vx - bvx) * nx + (ball.vy - bvy) * ny;
if (into < 0) {
ball.vx -= 2 * into * nx;
ball.vy -= 2 * into * ny;
}
ball.vx += nx * BUMPER_KICK;
ball.vy += ny * BUMPER_KICK;
events.push("bump");
return true;
}
// Sets a resting ball that something knocked off rolling.
function knocked(round) {
const ball = round.ball;
if (!ball.moving && Math.hypot(ball.vx, ball.vy) >= STOP_SPEED) {
ball.moving = true;
round.phase = "rolling";
}
}
// What moves by itself sweeps a resting ball too, so this runs on every step:
// spinners' bars, movers and shut gates. A ghost ball slips through movers.
function sweepers(round, hole, events) {
const ball = round.ball;
for (const s of hole.spinners) {
const seg = spinnerEnds(s, round.clock);
const p = closest(seg.x1, seg.y1, seg.x2, seg.y2, ball.x, ball.y);
// The bar's own speed where it touches: the turn rate times the distance
// from the center, at right angles to it.
const sx = -s.speed * (p.y - s.y);
const sy = s.speed * (p.x - s.x);
if (bounceOffSegment(ball, seg, events, WALL_KEEP, sx, sy)) knocked(round);
}
if (round.active !== "ghost") {
for (const m of hole.movers) {
const at = moverAt(m, round.clock);
if (bounceOffRound(ball, at, events, at.vx, at.vy)) knocked(round);
}
}
for (const g of hole.gates) {
if (gateShut(g, round.clock)) bounceOffSegment(ball, g, events, wallKeep(round));
}
}
const wallKeep = (round) => (round.active === "bouncy" ? 1 : WALL_KEEP);
function tunnels(round, hole, events) {
const ball = round.ball;
if (round.tunnelLock) {
// Out of the mouth it came from before it can go in again.
if (dist(ball.x, ball.y, round.tunnelLock.x, round.tunnelLock.y) < TUNNEL_R) return;
round.tunnelLock = null;
}
for (const t of hole.tunnels) {
for (const [from, to] of [[t.a, t.b], [t.b, t.a]]) {
if (dist(ball.x, ball.y, from.x, from.y) < TUNNEL_R) {
ball.x = to.x;
ball.y = to.y;
round.tunnelLock = to;
round.trail = [];
events.push("tunnel");
return;
}
}
}
}
// A pad the ball runs over is used up for the hole and held for the next putt.
function powerups(round, hole, events) {
const ball = round.ball;
hole.powerups.forEach((p, i) => {
if (round.taken.includes(i) || dist(ball.x, ball.y, p.x, p.y) >= POWERUP_R) return;
round.taken.push(i);
round.held = p.kind;
events.push("powerup");
});
}
// The magnet bends the ball's path toward the cup without speeding it up.
function magnet(round, hole, dt) {
const ball = round.ball;
const speed = Math.hypot(ball.vx, ball.vy);
const dx = hole.cup.x - ball.x;
const dy = hole.cup.y - ball.y;
const d = Math.hypot(dx, dy);
if (!speed || !d || d > MAGNET_R) return;
const pull = MAGNET_TURN * dt * (1 - d / MAGNET_R) * speed;
const vx = ball.vx + (dx / d) * pull;
const vy = ball.vy + (dy / d) * pull;
const v = Math.hypot(vx, vy) || 1;
ball.vx = (vx / v) * speed;
ball.vy = (vy / v) * speed;
}
// The hole is over at MAX_STROKES without the ball in the cup: picked up.
function pickUpAtCap(round, events) {
if (round.strokes < MAX_STROKES) return;
events.push("pickup");
finishHole(round, MAX_STROKES, events);
}
// How wide the cup is, and how slow a ball must be to drop, for this putt.
export const cupReach = (round) => CUP_R * (round.active === "bigcup" ? BIG_CUP : 1);
const captureSpeed = (round) => CAPTURE_SPEED * (round.active === "bigcup" || round.active === "magnet" ? HELPED_CAPTURE : 1);
// One physics step of `dtMs` (SUB_STEP_MS from tick()). Returns what happened,
// as event names: "clock" (the shot clock started the meter), "dribble" (the
// meter ran out), "wall", "bump", "tunnel", "powerup", "splash", "cup",
// "ace", "stop", "pickup", "done", "hole".
export function advance(round, dtMs) {
const events = [];
if (round.phase === "done") return events;
round.clock += dtMs;
if (round.phase === "card") {
round.cardMs += dtMs;
if (round.cardMs >= CARD_MS && nextHole(round)) events.push("hole");
return events;
}
const hole = HOLES[round.hole];
const ball = round.ball;
const dt = dtMs / 1000;
const ghost = round.active === "ghost";
sweepers(round, hole, events);
if (!ball.moving) {
if (round.phase === "aim") {
round.restMs += dtMs;
if (round.restMs >= SHOT_CLOCK_MS && startSwing(round)) events.push("clock");
} else if (round.phase === "swing") {
round.swingMs += dtMs;
if (round.swingMs >= METER_TRIPS * METER_MS) {
strike(round, round.swingAngle, DRIBBLE_POWER);
events.push("dribble");
return events;
}
}
// A ball left on a slope rolls off it by itself.
if (!onSlope(hole, ball.x, ball.y)) return events;
ball.moving = true;
round.phase = "rolling";
}
for (const s of hole.slopes) {
if (inPolygon(s.points, ball.x, ball.y)) {
ball.vx += s.push.x * dt;
ball.vy += s.push.y * dt;
}
}
let speed = Math.hypot(ball.vx, ball.vy);
const top = round.active === "cannon" ? CANNON_MAX : MAX_SPEED;
if (speed > 0) {
const slow = (FRICTION + DRAG * speed) * (!ghost && inSand(hole, ball.x, ball.y) ? SAND_FACTOR : 1) * dt;
const next = Math.min(top, Math.max(0, speed - slow));
ball.vx *= next / speed;
ball.vy *= next / speed;
speed = next;
}
if (round.active === "magnet") magnet(round, hole, dt);
ball.x += ball.vx * dt;
ball.y += ball.vy * dt;
for (const w of hole.walls) bounceOffSegment(ball, w, events, wallKeep(round));
if (!ghost) for (const b of hole.bumpers) bounceOffRound(ball, b, events);
sweepers(round, hole, events);
speed = Math.hypot(ball.vx, ball.vy);
if (speed > top) {
ball.vx *= top / speed;
ball.vy *= top / speed;
speed = top;
}
tunnels(round, hole, events);
powerups(round, hole, events);
round.trail.push({ x: ball.x, y: ball.y });
if (round.trail.length > TRAIL) round.trail.shift();
if (dist(ball.x, ball.y, hole.cup.x, hole.cup.y) < cupReach(round) && speed < captureSpeed(round)) {
events.push(round.putts === 1 ? "ace" : "cup");
round.sunk = { x: ball.x, y: ball.y };
ball.x = hole.cup.x;
ball.y = hole.cup.y;
finishHole(round, round.strokes, events);
return events;
}
const stopping = speed < STOP_SPEED && !onSlope(hole, ball.x, ball.y);
// A ghost ball floats over water, but not once it runs out of puff there.
if (inWater(hole, ball.x, ball.y) && (!ghost || stopping)) {
events.push("splash");
round.strokes += 1;
ball.x = round.from.x;
ball.y = round.from.y;
ball.vx = 0;
ball.vy = 0;
ball.moving = false;
atRest(round);
round.active = null;
round.tunnelLock = null;
round.trail = [];
pickUpAtCap(round, events);
return events;
}
if (stopping) {
ball.vx = 0;
ball.vy = 0;
ball.moving = false;
atRest(round);
round.active = null;
events.push("stop");
pickUpAtCap(round, events);
}
return events;
}
// Where a putt at `angle` and `power` would roll from the ball as it rests
// now, as points along its path (null where a tunnel jumps it), for the
// spyglass. Plays a copy of the round, so the round itself never changes.
export function predictPath(round, angle, power) {
const sim = structuredClone(round);
// The spyglass itself goes into the putt and does nothing to the roll.
if (sim.held === "spyglass") sim.held = null;
if (!strike(sim, angle, power)) return [];
const points = [{ x: sim.ball.x, y: sim.ball.y }];
for (let t = 0, n = 0; t < PREDICT_MS && sim.phase === "rolling"; t += SUB_STEP_MS, n++) {
const events = advance(sim, SUB_STEP_MS);
if (events.includes("splash")) break;
if (events.includes("tunnel")) points.push(null);
if (n % 5 === 0 || sim.phase !== "rolling") points.push({ x: sim.ball.x, y: sim.ball.y });
}
return points;
}
/* ------------------------------------------------------------------ gags */
// The words that pop up on the board, picked by a count so the same round
// always says the same things.
const SPLASH_WORDS = Object.freeze({
sea: ["SPLOOSH! Davy Jones says thanks", "Shark snack! Yum", "Man overboard!"],
pool: ["Bloop!", "Glub glub glub", "Something down there liked that"],
lava: ["SIZZLE! Extra crispy", "Toasty!", "Marshmallow, anyone?"],
chasm: ["Aaaaaaaaa...", "Bye bye, ball!", "Still falling..."],
});
const BUMP_WORDS = Object.freeze({
pirate: ["Bonk!", "Arr!", "Clunk!", "Yo ho!"],
cave: ["Boing!", "Clang!", "Ping!", "Bwomp!"],
});
const TUNNEL_WORDS = ["Whoosh!", "Wheee!", "Where'd it go?!"];
const MAX_WORDS = ["MAX POWER!", "CRUSHED IT!", "KA-BLAM!"];
const SHANK_WORDS = ["Overswing! Shanked it", "Whoa, too hard!", "Wild swing!"];
const DRIBBLE_WORDS = ["Too slow! Dribbled it", "Asleep at the tiller!", "Zzz... plop"];
const pick = (list, n) => list[n % list.length];
/* --------------------------------------------------------------- contract */
const TONE_FOR = Object.freeze({ wall: "wall", bump: "bump", cup: "cup", ace: "ace", tunnel: "tunnel", powerup: "power" });
const SPLASH_TONE = Object.freeze({ sea: "splash", pool: "splash", lava: "sizzle", chasm: "fall" });
function create({ canvas, tone = () => {}, onScore = () => {} }) {
const ctx = canvas.getContext("2d");
let colors = null;
let round = newRound();
let state = "ready";
let scale = 1;
let carry = 0;
// How long each arrow has been held, in ms (0 is up), and whether the roll
// is being fast-forwarded (the action key or the pointer held down).
const held = { left: 0, right: 0 };
let fast = false;
// Words popped up on the board, and how many of each kind so far.
let toasts = [];
let said = 0;
let lastBump = -Infinity;
// The ball is at rest on a hole and waiting for a putt.
const aiming = () => state === "running" && round.phase === "aim";
const say = (text, x, y, big = false) => {
toasts.push({ text, x, y, at: round.clock, big });
said += 1;
};
// A round on screen: running, or paused where it stood.
const live = () => state === "running" || state === "paused";
// The aim in play, or null: { angle, needle, zone }, with the needle and
// its zone only while the meter runs. Shown from the start of each hole, so
// the first press is never blind.
const currentAim = () => {
if (!live()) return null;
if (round.phase === "aim") return { angle: round.aimAngle, needle: null, zone: null };
if (round.phase !== "swing") return null;
const needle = meterAt(round.swingMs);
return { angle: round.swingAngle, needle, zone: meterZone(needle) };
};
// What the drawing needs of this moment, worked out here so golf-draw.js
// decides nothing.
const view = () => {
const hole = HOLES[round.hole];
const ball = round.ball;
const aimView = currentAim();
const card = round.phase === "card";
// The ball waits for a putt: aimed, or the meter running.
const waiting = round.phase === "aim" || round.phase === "swing";
toasts = toasts.filter((t) => round.clock - t.at < TOAST_MS);
// The spyglass follows the needle: the roll this press would make.
const spyShot = aimView && aimView.needle !== null && round.held === "spyglass" ? swingShot(aimView.needle, aimView.angle, round.putts) : null;
const spy = spyShot ? predictPath(round, spyShot.angle, spyShot.power) : null;
return {
course: { w: COURSE_W, h: COURSE_H },
hole,
holeNo: round.hole + 1,
clock: round.clock,
holeMs: round.clock - round.holeStart,
spinners: hole.spinners.map((s) => ({ ...spinnerEnds(s, round.clock), x: s.x, y: s.y, look: s.look })),
movers: hole.movers.map((m) => ({ ...moverAt(m, round.clock), look: m.look })),
gates: hole.gates.map((g) => ({ ...g, shut: gateShut(g, round.clock), phase: gatePhase(g, round.clock) })),
pads: hole.powerups.map((p, i) => ({ ...p, taken: round.taken.includes(i) })),
ball,
ballR: BALL_R,
cupR: CUP_R,
// The cup as this putt, or the one being aimed, will find it.
cupDraw: round.active === "bigcup" || (round.held === "bigcup" && waiting) ? CUP_R * BIG_CUP : CUP_R,
magnetR: round.active === "magnet" || (round.held === "magnet" && waiting) ? MAGNET_R : 0,
tunnelR: TUNNEL_R,
padR: POWERUP_R,
trail: round.phase === "rolling" ? round.trail : [],
aim: aimView,
// The power meter while it runs: the needle, the top of the overswing,
// where the MAX band starts, where the last swing stopped, and the
// trips left before the ball dribbles.
meter: aimView && aimView.needle !== null
? { needle: aimView.needle, zone: aimView.zone, top: 1 + OVER_BAND, maxFrom: 1 - MAX_BAND, last: round.lastSwing, tripsLeft: METER_TRIPS - Math.floor(round.swingMs / METER_MS) }
: null,
// The shot clock's share left, 1 to 0, while the ball waits.
shotClock: live() && round.phase === "aim" ? Math.max(0, 1 - round.restMs / SHOT_CLOCK_MS) : null,
fast: fast && round.phase === "rolling" ? FAST_FORWARD : 0,
spy,
held: round.held ? { kind: round.held, ...POWERUPS[round.held] } : null,
active: round.active,
toasts: toasts.map((t) => ({ ...t, age: (round.clock - t.at) / TOAST_MS })),
// A picked-up ball is simply gone; a sunk one shrinks into the cup.
sinking: card ? (round.sunk ? Math.min(1, round.cardMs / 350) : 1) : null,
phase: round.phase,
cardMs: round.cardMs,
card: HOLES.map((h, i) => ({ par: h.par, strokes: i < round.card.length ? round.card[i] : null })),
frontNine: FRONT_NINE,
// The card after the front nine heads into the caves.
turn: card && round.hole === FRONT_NINE - 1,
total: total(round),
parTotal: parTotal(HOLES.length),
toPar: toPar(round),
strokes: round.strokes,
pickedUp: card && !round.sunk,
ace: card && round.sunk !== null && round.card.at(-1) === 1,
state,
colors,
};
};
const paint = () => {
if (!ctx) return;
colors ||= readColors(canvas);
drawCourse(ctx, view());
};
const start = () => {
colors = null;
round = newRound();
carry = 0;
held.left = 0;
held.right = 0;
fast = false;
toasts = [];
said = 0;
lastBump = -Infinity;
state = "running";
paint();
};
const play = (events) => {
const hole = HOLES[round.hole];
const { x, y } = round.ball;
for (const e of events) {
if (e === "splash") {
tone(SPLASH_TONE[hole.liquid] || "splash");
say(`${pick(SPLASH_WORDS[hole.liquid] || SPLASH_WORDS.sea, said)} (+1)`, x, y);
continue;
}
if (e === "clock") {
tone("swing");
say("Shot clock! Swing!", x, y - 14, true);
}
if (e === "dribble") {
tone("shank");
say(pick(DRIBBLE_WORDS, said), x, y - 12);
}
if (TONE_FOR[e]) tone(TONE_FOR[e]);
if (e === "bump" && round.clock - lastBump > 450) {
lastBump = round.clock;
say(pick(BUMP_WORDS[hole.theme] || BUMP_WORDS.pirate, said), x, y - 8);
}
if (e === "tunnel") say(pick(TUNNEL_WORDS, said), x, y - 8);
if (e === "powerup" && round.held) say(`${POWERUPS[round.held].name}!`, x, y - 10, true);
// High, over the scorecard that is about to show.
if (e === "ace") say(hole.theme === "cave" ? "HOLE IN ONE! The cave echoes: one... one... one..." : "SHIVER ME TIMBERS! HOLE IN ONE!", COURSE_W / 2, 54, true);
}
// A fast-forward ends with the roll.
if (round.phase !== "rolling") fast = false;
if (events.includes("done") && state === "running") {
state = "over";
onScore(total(round));
}
};
// The first press starts the meter, the second sets the power and putts.
const swing = () => {
if (round.phase === "aim") {
if (!startSwing(round)) return false;
tone("swing");
paint();
return true;
}
const shot = setPower(round);
if (!shot) return false;
const { x, y } = round.ball;
tone(round.active === "cannon" ? "boom" : "putt", 0.4 + 0.6 * Math.min(1, shot.power));
if (shot.zone === "max") {
tone("max");
say(pick(MAX_WORDS, said), x, y - 12, true);
}
if (shot.zone === "over") {
tone("shank");
say(pick(SHANK_WORDS, said), x, y - 12);
}
if (round.active && POWERUPS[round.active]) say(round.active === "doubloon" ? "Free putt!" : `${POWERUPS[round.active].name} away!`, x, y - (shot.zone === "normal" ? 12 : 26));
paint();
return true;
};
const skipCard = () => {
if (state !== "running" || round.phase !== "card") return false;
nextHole(round);
paint();
return true;
};
// Held arrows turn the aim, slowly at first and faster the longer they are
// held.
const turn = (ms) => {
const dir = (held.right ? 1 : 0) - (held.left ? 1 : 0);
const ramp = Math.min(1, Math.max(held.left, held.right) / TURN_RAMP_MS);
if (held.left) held.left += ms;
if (held.right) held.right += ms;
if (!dir || round.phase !== "aim") return;
round.aimAngle += dir * (TURN_SLOW + (TURN_FAST - TURN_SLOW) * ramp * ramp) * (ms / 1000);
};
return {
get score() {
return total(round);
},
get state() {
return state;
},
// Not part of the contract: the round in play, so the unit suite can set
// up a shot on any hole. The window never reads it.
get round() {
return round;
},
start,
pause() {
if (state !== "running") return;
state = "paused";
// Nothing held carries over a pause: its release may never arrive.
held.left = 0;
held.right = 0;
fast = false;
paint();
},
resume() {
if (state === "paused") state = "running";
},
key(name) {
if (name === "action") {
if (state === "ready" || state === "over") start();
else if (state === "paused") state = "running";
else if (skipCard()) return true;
else if (round.phase === "rolling") fast = true;
else swing();
return true;
}
if (name !== "left" && name !== "right") return false;
if (!aiming()) return false;
// A press nudges at once; the window's key repeats change nothing, as
// the hold already turns the aim each tick.
if (!held[name]) {
held[name] = 1;
round.aimAngle += (name === "left" ? -1 : 1) * AIM_NUDGE;
paint();
}
return true;
},
release(name) {
if (name === "action") fast = false;
else if (name === "left" || name === "right") held[name] = 0;
else return false;
return true;
},
pointer(type, x, y) {
const cx = x / scale;
const cy = y / scale;
// The aim points from the ball at the pointer, wherever it is.
const aimAt = () => {
const { ball } = round;
if (!aiming() || Math.hypot(cx - ball.x, cy - ball.y) < 1) return false;
round.aimAngle = Math.atan2(cy - ball.y, cx - ball.x);
return true;
};
if (type === "up" || type === "cancel") {
fast = false;
return true;
}
if (type === "move") {
if (!aimAt()) return false;
paint();
return true;
}
if (type !== "down") return false;
if (state === "ready" || state === "over") {
start();
return true;
}
if (state !== "running") return false;
if (skipCard()) return true;
if (round.phase === "rolling") {
fast = true;
return true;
}
aimAt();
return swing();
},
tick(ms) {
if (state !== "running") return;
const step = Math.min(Math.max(0, ms), MAX_TICK_MS);
turn(step);
carry += step * (fast && round.phase === "rolling" ? FAST_FORWARD : 1);
while (carry >= SUB_STEP_MS && state === "running") {
carry -= SUB_STEP_MS;
play(advance(round, SUB_STEP_MS));
}
paint();
},
resize(w, h) {
if (!(w >= MIN_W && h >= MIN_H)) return false;
scale = Math.min(w / COURSE_W, h / COURSE_H);
colors = null;
const ratio = (typeof devicePixelRatio === "number" && devicePixelRatio > 0) ? devicePixelRatio : 1;
const cssW = COURSE_W * scale;
const cssH = COURSE_H * scale;
canvas.width = Math.round(cssW * ratio);
canvas.height = Math.round(cssH * ratio);
if (canvas.style) {
canvas.style.width = `${cssW}px`;
canvas.style.height = `${cssH}px`;
}
// Everything is drawn in course units.
if (ctx && typeof ctx.setTransform === "function") ctx.setTransform(ratio * scale, 0, 0, ratio * scale, 0, 0);
paint();
return true;
},
};
}
export default Object.freeze({ id: "golf", title: "Mini golf", lowerIsBetter: true, create });
File diff suppressed because it is too large. Load diff
+2 -1
View File
@@ -22,7 +22,7 @@ import {
adopt, banner, connect, fillSky, fitGrowBox, loadState, markSent, maybeWelcome, render, renderFooter, adopt, banner, connect, fillSky, fitGrowBox, loadState, markSent, maybeWelcome, render, renderFooter,
renderSidebar, renderWhere, save, startClock, startLooks, stagedPayload, syncWorkspaceScope, renderSidebar, renderWhere, save, startClock, startLooks, stagedPayload, syncWorkspaceScope,
wakeHoldsChime, wireAsk, wireCards, wireChrome, wireCleanup, wireDashboard, wireDocs, wireEnding, wakeHoldsChime, wireAsk, wireCards, wireChrome, wireCleanup, wireDashboard, wireDocs, wireEnding,
wireHelp, wireLooks, wireNotepad, wireWorkspace, wireActivities, wireHelp, wireLooks, wireNotepad, wireWorkspace,
} from "./screens/core.js"; } from "./screens/core.js";
import { sound } from "./sound.js"; import { sound } from "./sound.js";
@@ -50,6 +50,7 @@ wireCleanup();
wireDocs(); wireDocs();
wireAsk(); wireAsk();
wireNotepad(); wireNotepad();
wireActivities();
wireChrome(); wireChrome();
startClock(); startClock();
+1
View File
@@ -25,6 +25,7 @@ export const HELP_TABS = Object.freeze([
tab("git", "The git board", false), tab("git", "The git board", false),
tab("subagents", "Helpers (subagents)", false), tab("subagents", "Helpers (subagents)", false),
tab("ask", "Ask a quick question", false), tab("ask", "Ask a quick question", false),
tab("activities", "Activities", false),
tab("finishing", "Stopping and finishing", false), tab("finishing", "Stopping and finishing", false),
tab("prefs", "Keyboard and preferences", false), tab("prefs", "Keyboard and preferences", false),
tab("privacy", "Privacy and where things are saved", false), tab("privacy", "Privacy and where things are saved", false),
+27 -2
View File
@@ -9,6 +9,7 @@ import { normalizeRole, ROLE_NOT_SET } from "./starters.js";
import { bootData, hooks } from "./state.js"; import { bootData, hooks } from "./state.js";
import { el } from "./render.js"; import { el } from "./render.js";
import { tellApp } from "./app-bridge.js"; import { tellApp } from "./app-bridge.js";
import { ACTIVITIES, bestKey, memoKey } from "./activities.js";
const $ = (id) => document.getElementById(id); const $ = (id) => document.getElementById(id);
@@ -30,6 +31,13 @@ export const DEFAULT_LOOKS = {
...soundPrefs(null), ...soundPrefs(null),
width: DEFAULT_CARD_WIDTH, width: DEFAULT_CARD_WIDTH,
hideUnavailable: true, hideUnavailable: true,
// Activities: the top bar's die, the game last picked, and one best score
// per listed game (activityBestSnake), each a flat key for cleanLooks().
hideActivities: false,
lastActivity: "",
...Object.fromEntries(ACTIVITIES.map((a) => [bestKey(a.id), 0])),
// And one memo per game (activityMemoSnake): Snake's surprises found.
...Object.fromEntries(ACTIVITIES.map((a) => [memoKey(a.id), 0])),
}; };
export let looks = { ...DEFAULT_LOOKS }; export let looks = { ...DEFAULT_LOOKS };
@@ -46,6 +54,16 @@ export function adoptLooks(saved) {
Object.assign(looks, soundPrefs(looks)); Object.assign(looks, soundPrefs(looks));
if (typeof looks.hideUnavailable !== "boolean") looks.hideUnavailable = DEFAULT_LOOKS.hideUnavailable; if (typeof looks.hideUnavailable !== "boolean") looks.hideUnavailable = DEFAULT_LOOKS.hideUnavailable;
looks.width = cardWidth(looks.width); looks.width = cardWidth(looks.width);
if (typeof looks.hideActivities !== "boolean") looks.hideActivities = DEFAULT_LOOKS.hideActivities;
if (typeof looks.lastActivity !== "string") looks.lastActivity = DEFAULT_LOOKS.lastActivity;
// A best score is a whole number of points, never below none.
for (const a of ACTIVITIES) {
const key = bestKey(a.id);
const n = Number(looks[key]);
looks[key] = Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
const memo = Number(looks[memoKey(a.id)]);
looks[memoKey(a.id)] = Number.isFinite(memo) && memo > 0 ? Math.floor(memo) : 0;
}
if (saved && typeof saved === "object" && Object.hasOwn(saved, "role")) looks.role = normalizeRole(saved.role); if (saved && typeof saved === "object" && Object.hasOwn(saved, "role")) looks.role = normalizeRole(saved.role);
else delete looks.role; else delete looks.role;
} }
@@ -212,10 +230,17 @@ export function renderSwatches() {
box.disabled = !looks.sound; box.disabled = !looks.sound;
} }
$("looks-role").value = looks.role ?? ROLE_NOT_SET; $("looks-role").value = looks.role ?? ROLE_NOT_SET;
$("looks-activities").checked = !looks.hideActivities;
} }
// "Back to default": every look returns to its default, but the role is // "Back to default": every look returns to its default, but the role is
// marked as asked and the welcome stays seen. // marked as asked, the welcome stays seen, and the Activities' best scores
// and last pick stay (only Reset best scores clears those).
export function resetLooks() { export function resetLooks() {
looks = { ...DEFAULT_LOOKS, role: ROLE_NOT_SET, welcomeSeen: looks.welcomeSeen }; const kept = { lastActivity: looks.lastActivity };
for (const a of ACTIVITIES) {
kept[bestKey(a.id)] = looks[bestKey(a.id)];
kept[memoKey(a.id)] = looks[memoKey(a.id)];
}
looks = { ...DEFAULT_LOOKS, ...kept, role: ROLE_NOT_SET, welcomeSeen: looks.welcomeSeen };
} }
@@ -0,0 +1,714 @@
// Plan2Code Web Console - Activities: the top bar's die, its dialog, the frame timer, the keys and every pause rule.
//
// Small games for a long wait. The list of games is activities.js; each game
// is its own module under activities/, loaded with import() the first time it
// is opened, and answers the calls the list's header names. This file owns
// everything around a game: the dialog, the one frame timer, the keys and the
// pauses. A game never runs a timer of its own, so a paused game cannot move:
// pausing is this file not ticking plus the game's own paused state. Nothing
// here talks to the agent or the session; it only reads whose turn it is, so
// a question, a sign-off or a finish always pauses play and says so.
import { page, redraw } from "../state.js";
import { finish, myTurn } from "../selectors.js";
import { looks, saveLooks } from "../looks.js";
import { el, lightDismiss } from "../render.js";
import { ACTIVITIES, bestKey, memoKey } from "../activities.js";
import { tone, unlockTones } from "../tones.js";
const $ = (id) => document.getElementById(id);
const NOT_LOADED = "This activity could not be loaded. Close and open Activities to try again.";
const NEED_KEYBOARD = "Activities need a keyboard.";
const TOO_SMALL = "Make the window bigger to play.";
const TURN_BANNER = "Plan2Code needs you: a question is waiting.";
const FINISH_BANNER = "Plan2Code is finished.";
const RESET_LABEL = "Reset best scores";
const RESET_CONFIRM = "Reset? Click again";
// How long Reset waits for its second click before going back to its label.
const RESET_CONFIRM_MS = 4000;
// A frame that arrives after a long gap (a slow machine, a debugger) is
// counted as this much at most, so the snake never jumps several cells at once.
const MAX_FRAME_MS = 250;
// Every start and every play-on counts down 3, 2, 1 before the game moves,
// so a round never begins or picks up before the person is ready. The game
// is already running while the count shows; this file just does not tick it.
const COUNT_FROM = 3;
// The game keys: arrows and W/A/S/D steer, space is the game's action.
const KEYS = Object.freeze({
ArrowUp: "up",
ArrowDown: "down",
ArrowLeft: "left",
ArrowRight: "right",
w: "up",
s: "down",
a: "left",
d: "right",
" ": "action",
});
// The list the window shows, and where frames come from. Both are swapped
// only by the page tests (setActivityList, setTickSource).
let list = ACTIVITIES;
let tickSource = (fn) => requestAnimationFrame(fn);
// How long each number of the countdown shows, in ms. Swapped only by the
// page tests (setCountdownMs); 0 skips the countdown.
let countStepMs = 700;
// One game object per listed game for the page's life, so a closed and
// reopened window, or a skill change on the same page, resumes the same round.
const games = new Map();
// A load in flight per game id, so two quick opens share one import().
const loading = new Map();
let currentId = null;
// The games that keep their lowest round as the best (their export says
// lowerIsBetter), not their highest.
const lowerIsBetter = new Set();
// The frame timer. `gen` counts starts and stops, so a frame asked for before
// a stop does nothing when it arrives, whatever the tick source is.
let gen = 0;
let looping = false;
let lastFrame = null;
// The ms left of the countdown while one is showing, else 0. Game keys,
// clicks and presses on the board wait for it; P and Esc still pause.
let counting = 0;
// What renderActivities saw last time: the ids that were the person's to
// answer, and whether a finish was up. Null until the first render.
let seenTurn = null;
let seenFinish = false;
// Set when the person plays on after a turn or finish pause: the banner stays
// down until the next new question or finish.
let bannerDismissed = false;
// Reset's confirm: the timer that puts its label back, while one is waiting.
let resetTimer = null;
// Go to it closes the window onto a question, so the close must not hand
// focus back to the die.
let goingTo = false;
export function setTickSource(fn) {
tickSource = fn;
}
export function setCountdownMs(ms) {
countStepMs = ms;
}
export function setActivityList(next) {
list = next;
if (!list.some((e) => e.id === currentId)) currentId = null;
}
const game = () => (currentId ? games.get(currentId) || null : null);
/* ----------------------------------------------------------- the notes */
function showNote(text) {
const note = $("activities-note");
note.textContent = text;
note.hidden = !text;
}
const hasKeyboard = () => typeof matchMedia !== "function" || matchMedia("(any-pointer: fine)").matches;
/* ------------------------------------------------------------ drawing */
const best = (id) => looks[bestKey(id)] || 0;
// The header's " · Snake best: 12" for the game on screen, or "no best yet"
// before its first full round.
function paintTitle() {
const entry = list.find((e) => e.id === currentId);
const n = entry ? best(entry.id) : 0;
const text = entry ? (n ? ` · ${entry.title} best: ${n}` : ` · ${entry.title}: no best yet`) : "";
const span = $("activities-title-best");
if (span.textContent !== text) span.textContent = text;
}
// The round on screen, for the best-score effects: which game, the state it
// was last painted in, whether this round has passed the best (the sparks
// fire once a round), and whether its end set a new best.
const watched = { g: null, state: null, passed: false, record: false };
// A new round has begun when the game on screen changed, or went back to
// running from anything but a pause.
function watchRound(g) {
if (g !== watched.g || (g && g.state === "running" && watched.state !== "running" && watched.state !== "paused")) {
watched.passed = false;
watched.record = false;
}
watched.g = g;
watched.state = g ? g.state : null;
}
const SPARK_COLORS = Object.freeze(["#ff4fa3", "#f5b301", "#1fb6d9", "#57b54a", "#a466ff", "#ff8a1f"]);
const SPARKS = 22;
const SPARK_MS = 1100;
const calm = () => typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
// A fan of colored sparks up out of the score line's chips. They live on the
// dialog, not the line, since the line is rebuilt at every new score. Nothing
// under reduced motion; the colors alone mark the record there.
function sparks(line) {
const dialog = $("activities-modal");
if (!line || !dialog || calm()) return;
const chips = line.firstElementChild;
const x = line.offsetLeft + (chips ? chips.offsetLeft + chips.offsetWidth / 2 : 40);
const y = line.offsetTop + line.offsetHeight / 2;
for (let i = 0; i < SPARKS; i++) {
const a = Math.PI + (Math.PI * i) / (SPARKS - 1) + (Math.random() - 0.5) * 0.3;
const d = 50 + Math.random() * 70;
const s = el("span", "activities-spark");
s.setAttribute("aria-hidden", "true");
s.style.left = `${Math.round(x)}px`;
s.style.top = `${Math.round(y)}px`;
s.style.setProperty("--dx", `${Math.round(Math.cos(a) * d)}px`);
s.style.setProperty("--dy", `${Math.round(Math.sin(a) * d)}px`);
s.style.setProperty("--spin", `${Math.round((Math.random() - 0.5) * 720)}deg`);
s.style.setProperty("--c", SPARK_COLORS[i % SPARK_COLORS.length]);
dialog.append(s);
setTimeout(() => s.remove(), SPARK_MS);
}
}
// Plays the burst again from its start, even mid-burst.
function replay(node, cls) {
node.classList.remove(cls);
void node.offsetWidth;
node.classList.add(cls);
}
// The line under the board, once a round has started: a score chip, a meter
// filling toward the best (for a game where the highest wins and a best is
// saved), then a best chip. Reaching the best lights it; passing it turns the
// line into a rainbow and fires the sparks, once a round. The chips are only
// styling: the line still reads "Score: 3 · Best: 9". Set only when it
// changes, since every frame asks. A lowest-wins game with no best yet says
// so: "Best: 0" would read as a perfect round.
function paintScore() {
const g = game();
watchRound(g);
const line = $("activities-score");
const running = Boolean(g && g.state !== "ready");
const n = currentId ? best(currentId) : 0;
const lower = lowerIsBetter.has(currentId);
const score = running ? g.score : 0;
// A lowest-wins game only knows it beat its best when the round ends.
const chase = running && !lower && n > 0;
const mood = !running ? "" : chase && score > n ? "passed" : chase && score === n ? "tied" : watched.record ? "passed" : "";
const key = running ? `${score}|${n}|${lower}|${mood}` : "";
if (line.dataset.key === key) return;
line.dataset.key = key;
line.classList.toggle("tied", mood === "tied");
line.classList.toggle("passed", mood === "passed");
if (!running) return line.replaceChildren();
const chip = (cls, name, value) => {
const c = el("span", `activities-chip ${cls}`, `${name}: `);
c.append(el("b", null, value));
return c;
};
const parts = [chip("score", "Score", String(score))];
if (chase) {
const meter = el("span", "activities-meter");
meter.setAttribute("aria-hidden", "true");
meter.style.setProperty("--fill", String(Math.min(1, score / n)));
parts.push(meter);
}
parts.push(el("span", "activities-sep", " · "), chip("best", "Best", !n && lower ? "none yet" : String(n)));
line.replaceChildren(...parts);
if (mood === "passed" && !watched.passed) {
watched.passed = true;
replay(line, "burst");
sparks(line);
}
}
function paintOverlay() {
const g = game();
const overlay = $("activities-overlay");
// A game played by pointer also starts and plays on with a click.
const click = g && typeof g.pointer === "function";
let text = "";
if (g && g.state === "running" && counting > 0) text = String(Math.ceil(counting / countStepMs));
else if (g && g.state === "ready") text = click ? "Press space or click to start" : "Press space to start";
else if (g && g.state === "paused") text = click ? "Paused. Press space, P or click to play" : "Paused. Press space or P to play";
else if (g && g.state === "over") text = `Score: ${g.score}\nBest: ${best(currentId)}\n${click ? "Press space or click to play again" : "Press space to play again"}`;
if (overlay.textContent !== text) overlay.textContent = text;
overlay.classList.toggle("count", g !== null && g.state === "running" && counting > 0);
paintScore();
// Read after paintScore, which forgets the last round's record once a new one starts.
overlay.classList.toggle("record", Boolean(g && g.state === "over" && watched.record));
}
/* ------------------------------------------------------------ best scores */
// Called only when a round ends, so a half-played round is never saved. A
// save that does not land stays in the page and its local copy, and the next
// save carries it (looks.js sends every key it has not heard back about).
// A best of 0 means none yet, so a lowerIsBetter game's first round always
// counts.
// A round that beats a best already saved is a record: the end screen says so
// and, for a lowest-wins game (which could not tell mid-round), the sparks fire
// now. A first best is only a best.
function recordScore(id, score) {
const was = best(id);
if (!(lowerIsBetter.has(id) ? !was || score < was : score > was)) return;
looks[bestKey(id)] = score;
saveLooks();
paintTitle();
if (!was || id !== currentId) return;
watched.record = true;
if (lowerIsBetter.has(id)) {
tone("best");
watched.passed = true;
replay($("activities-score"), "burst");
sparks($("activities-score"));
}
}
function disarmReset() {
clearTimeout(resetTimer);
resetTimer = null;
$("activities-reset").textContent = RESET_LABEL;
}
// The first click asks, inside the window; a second within a few seconds
// writes 0 to every listed game's best (the server refuses null).
function resetBest() {
if (!resetTimer) {
$("activities-reset").textContent = RESET_CONFIRM;
resetTimer = setTimeout(disarmReset, RESET_CONFIRM_MS);
return;
}
disarmReset();
for (const entry of list) looks[bestKey(entry.id)] = 0;
saveLooks();
paintOverlay();
paintTitle();
}
// Sizes the game to the board. A board too small to play, or a page with no
// keyboard, shows its note in place of the board. A game that no longer fits
// stops moving, since nobody can see it.
function layout() {
const board = $("activities-board");
const g = game();
if (!hasKeyboard()) {
board.hidden = true;
return showNote(NEED_KEYBOARD);
}
if (!g) return;
board.hidden = false;
if (g.resize(board.clientWidth, board.clientHeight) === false) {
board.hidden = true;
pauseAll("hidden");
return showNote(TOO_SMALL);
}
showNote("");
}
/* -------------------------------------------------------- frame timer */
function stopLoop() {
gen++;
looping = false;
counting = 0;
}
// Runs only while the dialog is open and the game is running, and stops
// itself the moment either is no longer true.
function startLoop() {
const g = game();
if (looping || !g || g.state !== "running" || !$("activities-modal").open) return;
looping = true;
lastFrame = null;
counting = COUNT_FROM * countStepMs;
if (counting > 0) tone("count");
paintOverlay();
const mine = ++gen;
const frame = (now) => {
if (mine !== gen) return;
const t = typeof now === "number" ? now : performance.now();
if (!$("activities-modal").open || g !== game() || g.state !== "running") {
looping = false;
counting = 0;
return paintOverlay();
}
// The countdown's time is never handed to the game: its first tick comes
// a frame after the count ends.
if (counting > 0) {
const shown = Math.ceil(counting / countStepMs);
if (lastFrame !== null) counting -= Math.min(Math.max(0, t - lastFrame), MAX_FRAME_MS);
lastFrame = t;
if (counting <= 0) {
counting = 0;
tone("go");
} else if (Math.ceil(counting / countStepMs) !== shown) tone("count");
paintOverlay();
return tickSource(frame);
}
if (lastFrame !== null) g.tick(Math.min(Math.max(0, t - lastFrame), MAX_FRAME_MS));
lastFrame = t;
paintScore();
if (g.state !== "running") {
looping = false;
return paintOverlay();
}
tickSource(frame);
};
tickSource(frame);
}
// After anything the person does: the timer follows the game's state.
function follow() {
const g = game();
if (g && g.state === "running") startLoop();
else stopLoop();
paintOverlay();
}
// Runs what the person did to the game; when it took a paused game back to
// running, the banner goes away until the next new question or finish.
function play(g, act) {
const was = g.state;
act();
if (was === "paused" && g.state === "running") dismissBanner();
}
/* ------------------------------------------------------------- pauses */
// Every pause goes through here: "turn", "finish", "hidden", "blur" and
// "closed". None of them ever resumes or starts a round; only the person
// does: space, P or any other game key, a click on the overlay, or for a
// game that takes the pointer, a press on the board. A pause also drops a
// drag in progress.
function pauseAll(reason) {
const g = game();
if (g && g.state === "running") g.pause();
dragging = false;
if (g && typeof g.pointer === "function") g.pointer("cancel", 0, 0);
stopLoop();
paintOverlay();
}
/* ------------------------------------------------------------ loading */
async function loadGame(entry) {
if (games.has(entry.id)) return games.get(entry.id);
if (!loading.has(entry.id)) {
const made = (async () => {
const def = entry.game || (await import(entry.module)).default;
if (def.lowerIsBetter) lowerIsBetter.add(entry.id);
else lowerIsBetter.delete(entry.id);
const onScore = (score) => {
recordScore(entry.id, score);
paintOverlay();
};
// The game's memo is saved like a best score: privately, in looks.json.
const memo = {
get: () => looks[memoKey(entry.id)] || 0,
set: (n) => {
if (looks[memoKey(entry.id)] === n) return;
looks[memoKey(entry.id)] = n;
saveLooks();
},
};
const g = def.create({ canvas: $("activities-canvas"), tone, onScore, best: () => best(entry.id), memo });
games.set(entry.id, g);
return g;
})();
// A failed load is forgotten, so the next open tries again.
loading.set(entry.id, made);
made.finally(() => loading.delete(entry.id)).catch(() => {});
}
return loading.get(entry.id);
}
// Makes `id` the game on screen: the one before it is paused, then the new
// one is loaded, sized and drawn.
async function showGame(id) {
const entry = list.find((e) => e.id === id);
if (!entry) return;
if (currentId && currentId !== id) pauseAll("closed");
currentId = id;
drawPicker();
paintTitle();
try {
await loadGame(entry);
} catch {
if (currentId !== id) return;
$("activities-board").hidden = true;
return showNote(NOT_LOADED);
}
if (currentId !== id) return;
layout();
paintOverlay();
// Keys go to the game next, not to the picker button just pressed.
if (!$("activities-board").hidden) $("activities-board").focus({ preventScroll: true });
}
/* ------------------------------------------------------------- picker */
// Shown only once two or more games are listed; with one, the window opens
// straight into it.
function drawPicker() {
const picker = $("activities-picker");
if (list.length < 2) {
picker.hidden = true;
picker.replaceChildren();
return;
}
picker.hidden = false;
picker.replaceChildren(
...list.map((entry) => {
const b = el("button", "btn small ghost", entry.title);
b.type = "button";
b.dataset.activity = entry.id;
b.setAttribute("aria-pressed", String(entry.id === currentId));
b.addEventListener("click", () => pick(entry.id));
return b;
})
);
}
function pick(id) {
if (looks.lastActivity !== id) {
looks.lastActivity = id;
saveLooks();
}
showGame(id);
}
/* ------------------------------------------------------------ opening */
function startingId() {
if (currentId && list.some((e) => e.id === currentId)) return currentId;
if (list.length > 1 && list.some((e) => e.id === looks.lastActivity)) return looks.lastActivity;
return list.length ? list[0].id : null;
}
export async function openActivities() {
unlockTones();
const dlg = $("activities-modal");
showNote("");
if (!dlg.open) dlg.showModal();
renderBanner();
paintTitle();
$("activities-board").focus({ preventScroll: true });
const id = startingId();
if (id) await showGame(id);
}
function closeActivities() {
pauseAll("closed");
const dlg = $("activities-modal");
if (dlg.open) dlg.close();
}
/* --------------------------------------------------------------- keys */
function onKey(e) {
if (e.ctrlKey || e.metaKey || e.altKey) return;
const key = e.key.length === 1 ? e.key.toLowerCase() : e.key;
const onButton = document.activeElement instanceof HTMLButtonElement && e.currentTarget.contains(document.activeElement);
// A window button keeps its own space and Enter.
if (onButton && (key === " " || key === "Enter")) return;
if (key === "Escape") {
e.preventDefault();
e.stopPropagation();
return closeActivities();
}
const g = game();
const hidden = $("activities-board").hidden;
if (key === "p") {
e.preventDefault();
e.stopPropagation();
// A held P would flicker between the two; and a board nobody can see
// never plays.
if (e.repeat) return;
if (g && g.state === "running") pauseAll("key");
else if (g && g.state === "paused" && !hidden) play(g, () => g.resume());
return follow();
}
if (!Object.hasOwn(KEYS, key)) return;
e.preventDefault();
e.stopPropagation();
// A held space would restart a round the moment the last one ends; arrows
// may repeat.
if (e.repeat && KEYS[key] === "action") return;
if (!g || hidden || counting > 0) return follow();
if (g.state !== "paused") g.key(KEYS[key]);
// Any game key plays on from a pause, a held one excepted. A direction is
// passed on too, so one press resumes and steers; space only resumes, so it
// never also starts a new round.
else if (!e.repeat)
play(g, () => {
g.resume();
if (KEYS[key] !== "action") g.key(KEYS[key]);
});
follow();
}
// For a game with release(): a game key let go, so a game can act on a key
// held down (Mini golf's fast-forward and its turning aim). Always passed on,
// paused or not, so nothing is left held; a game's pause() drops whatever it
// holds anyway, since a release can be lost to a blur.
function onKeyUp(e) {
const key = e.key.length === 1 ? e.key.toLowerCase() : e.key;
if (!Object.hasOwn(KEYS, key)) return;
const g = game();
if (g && typeof g.release === "function") g.release(KEYS[key]);
}
/* ------------------------------------------------------------ pointer */
const POINTER = Object.freeze({ pointerdown: "down", pointermove: "move", pointerup: "up", pointercancel: "cancel" });
// True from a down passed on to the game until its up, cancel or a pause, so
// the release of a press that only played on, or of a drag a pause dropped,
// never reaches the game.
let dragging = false;
// For a game with pointer(): positions in CSS pixels from the canvas's
// top-left. A press on a paused board plays on and starts nothing else; on a
// ready or finished game it is passed on, so the game can start a round.
function onPointer(e) {
const g = game();
if (!g || typeof g.pointer !== "function" || $("activities-board").hidden) return;
const canvas = $("activities-canvas");
const type = POINTER[e.type];
// The countdown holds the board still: a press waits for it, and only the
// release of a press made before it gets through.
if (counting > 0 && type !== "up" && type !== "cancel") {
if (type === "down") e.preventDefault();
return;
}
if (type === "down") {
if (e.button !== 0) return;
e.preventDefault();
$("activities-board").focus({ preventScroll: true });
if (g.state === "paused") {
play(g, () => g.resume());
return follow();
}
// A drag that leaves the canvas still ends here with an up.
try {
canvas.setPointerCapture(e.pointerId);
} catch {}
dragging = true;
} else if (type === "up" || type === "cancel") {
if (!dragging) return;
dragging = false;
}
const r = canvas.getBoundingClientRect();
const used = g.pointer(type, e.clientX - r.left, e.clientY - r.top);
if (type !== "move" || used) follow();
}
/* ------------------------------------------------------- whose turn */
// The banner takes height from the board, so the game is laid out again
// whenever it comes or goes; otherwise the board would clip the canvas.
function renderBanner() {
const banner = $("activities-banner");
const text = bannerDismissed ? "" : myTurn().length ? TURN_BANNER : finish() ? FINISH_BANNER : "";
$("activities-banner-text").textContent = text;
if (banner.hidden === !text) return;
banner.hidden = !text;
if ($("activities-modal").open) layout();
}
// From the render pass: a question that was not the person's a render ago,
// or a finish that was not up, pauses play. A stopped session or a dropped
// connection is not a reason; only the person's turn is.
export function renderActivities() {
// The gear's Show Activities switch: off hides the die everywhere, and
// closes a window left open, paused.
$("btn-activities").hidden = looks.hideActivities;
if (looks.hideActivities && $("activities-modal").open) closeActivities();
const turn = new Set(myTurn().map((i) => i.id));
const done = Boolean(finish());
if (seenTurn) {
if ([...turn].some((id) => !seenTurn.has(id))) {
bannerDismissed = false;
pauseAll("turn");
}
if (done && !seenFinish) {
bannerDismissed = false;
pauseAll("finish");
}
}
seenTurn = turn;
seenFinish = done;
renderBanner();
}
function dismissBanner() {
if (bannerDismissed) return;
bannerDismissed = true;
renderBanner();
}
// Closes the window and, for a question, lands on the first one that is the
// person's, the way the page's own question list does.
function goToIt() {
const first = myTurn()[0];
goingTo = Boolean(first);
closeActivities();
if (!first) return;
page.selected = first.id;
page.view = "questions";
redraw();
const m = $("main");
m.focus();
m.scrollTop = 0;
}
/* -------------------------------------------------------------- wiring */
export function wireActivities() {
const dlg = $("activities-modal");
lightDismiss(dlg);
$("btn-activities").addEventListener("click", openActivities);
$("activities-close").addEventListener("click", closeActivities);
$("activities-reset").addEventListener("click", resetBest);
$("activities-goto").addEventListener("click", goToIt);
$("activities-overlay").addEventListener("click", () => {
const g = game();
if (!g || counting > 0) return;
play(g, () => g.key("action"));
follow();
$("activities-board").focus({ preventScroll: true });
});
dlg.addEventListener("keydown", onKey);
dlg.addEventListener("keyup", onKeyUp);
for (const type of Object.keys(POINTER)) $("activities-canvas").addEventListener(type, onPointer);
// Esc, and any other way the browser cancels the dialog, takes the same
// path as Close.
dlg.addEventListener("cancel", (e) => {
e.preventDefault();
closeActivities();
});
dlg.addEventListener("close", () => {
pauseAll("closed");
disarmReset();
if (!goingTo) $("btn-activities").focus();
goingTo = false;
});
document.addEventListener("visibilitychange", () => {
if (document.hidden) pauseAll("hidden");
});
window.addEventListener("blur", () => pauseAll("blur"));
window.addEventListener("resize", () => {
if (dlg.open) layout();
});
}
+7
View File
@@ -515,6 +515,13 @@ export function wireLooks() {
const preview = ["question", ...Object.keys(SOUND_EVENTS)].find(soundOn); const preview = ["question", ...Object.keys(SOUND_EVENTS)].find(soundOn);
if (preview) sound(preview); if (preview) sound(preview);
}); });
$("looks-activities").addEventListener("change", (e) => {
looks.hideActivities = !e.target.checked;
saveLooks();
// The die comes and goes with the next render, which also closes an open
// Activities window, paused.
redraw();
});
for (const box of document.querySelectorAll("input[data-sound]")) { for (const box of document.querySelectorAll("input[data-sound]")) {
box.addEventListener("change", () => { box.addEventListener("change", () => {
const event = box.dataset.sound; const event = box.dataset.sound;
@@ -0,0 +1,245 @@
/* Activities: the top bar's die, the dialog, the board, its overlay, the
your-turn banner and the notes. The game draws its own board on the canvas. */
/* The top bar's die, drawn and lit like the megaphone and the gear beside it. */
.icon-btn .dc-body { fill: none; stroke: var(--ink-3); stroke-width: 1.4; }
.icon-btn .dc-pip { fill: var(--ink-2); stroke: none; }
.icon-btn:hover .dc-body { stroke: var(--accent); }
.icon-btn:hover .dc-pip { fill: var(--accent); }
/* Show Activities off in User Preferences: .icon-btn's grid would beat the
attribute's own display. */
#btn-activities[hidden] { display: none; }
/* The dialog: Notebook-sized, with the board taking whatever height the
title, the banner, the picker, the note and the actions leave. */
.modal.activities {
width: min(1200px, 90vw);
height: min(900px, 85vh);
max-width: none;
max-height: none;
flex-direction: column;
}
.modal.activities[open] { display: flex; }
.modal.activities h2,
.modal.activities .modal-blurb,
.modal.activities .modal-actions { flex: none; }
.modal.activities .modal-blurb { margin-bottom: 12px; }
/* Plan2Code needs the person: an attention strip in the highlight color,
above the board, that never covers it. */
.activities-banner {
flex: none;
display: flex;
align-items: center;
gap: 12px;
margin-bottom: 12px;
padding: 8px 12px;
border: 1px solid var(--accent);
border-radius: 8px;
background: var(--accent-soft);
color: var(--ink);
}
.activities-banner[hidden] { display: none; }
.activities-banner-text { flex: 1 1 auto; font-weight: 600; }
.activities-banner .btn.primary { flex: none; background: var(--accent); border-color: var(--accent); color: var(--accent-ink); }
/* The picker: one button per game, shown only once two are listed. */
.activities-picker {
flex: none;
display: flex;
flex-wrap: wrap;
gap: 8px;
margin-bottom: 12px;
}
.activities-picker[hidden] { display: none; }
.activities-picker .btn[aria-pressed="true"] { background: var(--accent-soft); border-color: var(--accent-line); color: var(--ink); }
/* The board: fills the free space and centers the canvas, with the state
text laid over its middle. */
.activities-board {
position: relative;
flex: 1 1 auto;
min-height: 0;
display: flex;
align-items: center;
justify-content: center;
overflow: hidden;
border: 1px solid var(--rule-2);
background: var(--panel-2);
}
.activities-board:focus { outline: none; }
.activities-board:focus-visible { border-color: var(--accent-line); }
.activities-board[hidden] { display: none; }
.activities-board canvas { display: block; }
/* Mini golf's page colors (activities/golf-draw.js reads them off the
canvas) for its ball, aim, pills and scorecard, all mixed from the page's
tokens so they look right in light and dark and follow a picked highlight.
The course itself (a pirate sea, a dark cave) keeps its own fixed colors.
The canvas takes color-mix() as it is. */
.activities-board canvas {
--golf-shadow: color-mix(in srgb, black 24%, transparent);
--golf-pole: color-mix(in srgb, white 90%, var(--stage));
--golf-ball: color-mix(in srgb, white 96%, var(--stage));
--golf-aim: var(--golf-ball);
--golf-power: var(--accent);
--golf-card: var(--panel);
--golf-ink: var(--ink);
--golf-ink2: var(--ink-2);
--golf-under: var(--ok);
--golf-over: var(--warn);
--golf-burst: var(--stage);
}
.activities-overlay {
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
max-width: 80%;
padding: 10px 16px;
border-radius: 8px;
background: var(--panel);
color: var(--ink);
box-shadow: var(--shadow);
font-weight: 600;
text-align: center;
white-space: pre-line;
cursor: pointer;
}
/* The 3, 2, 1 before play: a big number, not a note, and nothing to click. */
.activities-overlay.count {
min-width: 2.4em;
font-size: 48px;
line-height: 1;
font-variant-numeric: tabular-nums;
cursor: default;
}
.activities-overlay:empty,
.activities-overlay[hidden] { display: none; }
/* The header's best for the game on screen: quieter than the title. */
.activities-title-best { font-weight: 400; color: var(--ink-2); font-variant-numeric: tabular-nums; }
/* The round's score beside the best, under the board, as colored chips with
a meter between them (screens/activities.js builds them). Its height is
fixed, empty or not, so the board does not jump the moment a round starts. */
.activities-score {
--score-gold: color-mix(in srgb, var(--stage) 80%, #f5b301);
flex: none;
height: 30px;
margin: 8px 0 0;
display: block;
line-height: 30px;
color: var(--ink-2);
font-variant-numeric: tabular-nums;
white-space: nowrap;
}
.activities-chip {
display: inline-block;
padding: 0 12px;
line-height: 26px;
border-radius: 999px;
border: 1px solid;
font-weight: 600;
vertical-align: middle;
}
.activities-chip b { font-weight: 800; font-size: 1.08em; }
.activities-chip.score {
border-color: var(--accent-line);
background: linear-gradient(135deg, var(--accent-soft), color-mix(in srgb, var(--accent) 22%, var(--panel)));
color: var(--ink);
}
.activities-chip.score b { color: var(--accent); }
.activities-chip.best {
border-color: color-mix(in srgb, var(--score-gold) 55%, transparent);
background: linear-gradient(135deg, color-mix(in srgb, var(--score-gold) 14%, var(--panel)), color-mix(in srgb, var(--score-gold) 28%, var(--panel)));
color: var(--ink);
}
.activities-chip.best b { color: var(--score-gold); }
/* The " · " between them stays in the text (a plain inline span, so its
spaces count) but takes no room; the best chip keeps its own gap. */
.activities-sep { font-size: 0; }
.activities-chip.best { margin-left: 8px; }
/* The meter: how far the score has come toward the best. */
.activities-meter {
display: inline-block;
width: 120px;
height: 8px;
margin: 0 2px 0 10px;
border-radius: 999px;
background: linear-gradient(90deg, var(--accent), var(--score-gold)) no-repeat var(--rule-2);
background-size: calc(var(--fill, 0) * 100%) 100%;
vertical-align: middle;
transition: background-size 200ms ease-out;
}
/* Reaching the best: the best chip glows. */
.activities-score.tied .activities-chip.best {
border-color: var(--score-gold);
box-shadow: 0 0 0 3px color-mix(in srgb, var(--score-gold) 30%, transparent);
}
/* Past it: a rainbow line and a NEW BEST tag (drawn by CSS, so the line still
reads as its plain text). */
.activities-score.passed .activities-chip,
.activities-score.passed .activities-meter {
background: linear-gradient(90deg, #ff4fa3, #f5b301, #57b54a, #1fb6d9, #a466ff, #ff4fa3);
background-size: 300% 100%;
border-color: transparent;
color: #ffffff;
}
.activities-score.passed .activities-chip b { color: #ffffff; }
.activities-score.passed .activities-chip { text-shadow: 0 1px 2px rgba(0, 0, 0, 0.45); }
.activities-score.passed .activities-chip.score::after {
content: "NEW BEST";
margin-left: 8px;
padding: 1px 6px;
border-radius: 999px;
background: rgba(0, 0, 0, 0.28);
font-size: 0.72em;
font-weight: 800;
letter-spacing: 0.06em;
}
/* The sparks fanning up out of the chips as the best is passed. */
.activities-spark {
position: absolute;
width: 8px;
height: 8px;
margin: -4px 0 0 -4px;
border-radius: 2px;
background: var(--c);
pointer-events: none;
opacity: 0;
z-index: 2;
}
/* The end of a round that set a new best: the overlay says so in rainbow. */
.activities-overlay.record { border: 2px solid transparent; background: linear-gradient(var(--panel), var(--panel)) padding-box, linear-gradient(90deg, #ff4fa3, #f5b301, #57b54a, #1fb6d9, #a466ff) border-box; }
.activities-overlay.record::before {
content: "New best!";
display: block;
margin-bottom: 4px;
font-size: 22px;
font-weight: 800;
background: linear-gradient(90deg, #ff4fa3, #f5b301, #1fb6d9, #a466ff);
-webkit-background-clip: text;
background-clip: text;
color: transparent;
}
@media (prefers-reduced-motion: no-preference) {
.activities-score.tied .activities-chip.best { animation: activities-glow 900ms ease-in-out infinite alternate; }
.activities-score.passed .activities-chip,
.activities-score.passed .activities-meter { animation: activities-rainbow 2.4s linear infinite; }
.activities-score.burst .activities-chip { animation: activities-rainbow 2.4s linear infinite, activities-pop 600ms cubic-bezier(0.3, 1.6, 0.5, 1); }
.activities-spark { animation: activities-spark 1s cubic-bezier(0.2, 0.7, 0.4, 1) forwards; }
.activities-overlay.record::before { animation: activities-pop 600ms cubic-bezier(0.3, 1.6, 0.5, 1); }
}
@keyframes activities-glow { to { box-shadow: 0 0 0 6px color-mix(in srgb, var(--score-gold) 12%, transparent), 0 0 16px color-mix(in srgb, var(--score-gold) 60%, transparent); } }
@keyframes activities-rainbow { to { background-position: 300% 0; } }
@keyframes activities-pop { 0% { transform: scale(0.8); } 60% { transform: scale(1.18); } 100% { transform: scale(1); } }
@keyframes activities-spark {
0% { opacity: 1; transform: translate(0, 0) rotate(0); }
70% { opacity: 1; }
100% { opacity: 0; transform: translate(var(--dx), calc(var(--dy) + 30px)) rotate(var(--spin)); }
}
/* The keyboard, bigger-window and load-failure notes: shown in place of play. */
.activities-note { flex: none; margin: 12px 0 0; color: var(--ink-2); }
.activities-note[hidden] { display: none; }
+122
View File
@@ -0,0 +1,122 @@
// Plan2Code Web Console - the tones: short synthesized blips for the activities, silent when Play sounds is off; defines only.
import { looks } from "./looks.js";
/* ------------------------------------------------------------- tones
Blips made in the browser, so there is no audio file to fetch. They are
not the main sounds in sound.js: the master Play sounds switch gates them,
and they have no switch of their own and no queue. A browser will not
make noise before the person has touched the page, so unlockTones() runs
from the click that opens Activities. A tone asked for before that stays
silent rather than throwing.
Every sound here is short (a quarter second at most) and quiet, so a cue
never outlasts the moment it belongs to. A tone either sweeps from one
pitch to another, or plays `notes` one after another in its time. */
const TONES = Object.freeze({
eat: Object.freeze({ type: "triangle", from: 660, to: 880, seconds: 0.12 }),
crash: Object.freeze({ type: "sawtooth", from: 220, to: 80, seconds: 0.2 }),
// The 3, 2, 1 before a round starts or plays on: a tick per number, then a
// higher one as play begins.
count: Object.freeze({ type: "sine", from: 440, to: 440, seconds: 0.08 }),
go: Object.freeze({ type: "sine", from: 880, to: 880, seconds: 0.14 }),
// Mini golf: the club on the ball, the ball off a wall or a bumper, into
// the cup, a hole in one (a little three-note rise), and into the water.
putt: Object.freeze({ type: "triangle", from: 520, to: 400, seconds: 0.06 }),
wall: Object.freeze({ type: "triangle", from: 300, to: 200, seconds: 0.07 }),
bump: Object.freeze({ type: "sine", from: 700, to: 1000, seconds: 0.09 }),
cup: Object.freeze({ type: "triangle", from: 520, to: 1040, seconds: 0.16 }),
ace: Object.freeze({ type: "triangle", notes: Object.freeze([523, 659, 784]), seconds: 0.24 }),
splash: Object.freeze({ type: "sine", from: 420, to: 120, seconds: 0.2 }),
// Mini golf's gags: a power-up grabbed (a sparkly rise), a tunnel's whoosh,
// a cannonball putt, the ball into lava, and the ball down the pit.
power: Object.freeze({ type: "square", notes: Object.freeze([784, 988, 1319]), seconds: 0.18 }),
tunnel: Object.freeze({ type: "sine", from: 200, to: 900, seconds: 0.16 }),
boom: Object.freeze({ type: "sawtooth", from: 160, to: 45, seconds: 0.22 }),
sizzle: Object.freeze({ type: "sawtooth", from: 900, to: 300, seconds: 0.2 }),
fall: Object.freeze({ type: "sine", from: 700, to: 60, seconds: 0.25 }),
// Mini golf's swing: the meter starting, a putt caught in the MAX band (a
// bright two-note hit), and an overswing's sour buzz.
swing: Object.freeze({ type: "square", from: 620, to: 660, seconds: 0.04 }),
max: Object.freeze({ type: "square", notes: Object.freeze([880, 1320]), seconds: 0.16 }),
shank: Object.freeze({ type: "sawtooth", from: 240, to: 110, seconds: 0.18 }),
// Snake's extras: a combo's quick chirp, a coin, a mystery box opening, a
// new level (a four-note climb), a shield taking a hit, a comet cutting
// the tail, and a new best mid-round. A grabbed power-up uses `power`, a
// smashed rock `boom` and a portal `tunnel`.
combo: Object.freeze({ type: "square", from: 880, to: 1320, seconds: 0.07 }),
coin: Object.freeze({ type: "square", notes: Object.freeze([988, 1319]), seconds: 0.1 }),
mystery: Object.freeze({ type: "triangle", notes: Object.freeze([392, 523, 466, 698]), seconds: 0.24 }),
levelup: Object.freeze({ type: "square", notes: Object.freeze([523, 659, 784, 1047]), seconds: 0.25 }),
shield: Object.freeze({ type: "sine", from: 1200, to: 500, seconds: 0.14 }),
zap: Object.freeze({ type: "sawtooth", from: 1400, to: 200, seconds: 0.15 }),
best: Object.freeze({ type: "triangle", notes: Object.freeze([784, 988, 1175, 1568]), seconds: 0.25 }),
});
// Peak gain, kept modest so a blip sits under the page rather than over it.
const PEAK = 0.08;
// A quick attack avoids a click at the start; the decay is exponential, which
// needs a non-zero floor, so the envelope stops at a tiny value, not zero.
const ATTACK = 0.01;
const FLOOR = 0.0001;
let ctx = null;
// Made on first use, not at load, so importing this file in Node is harmless.
// A missing AudioContext or a constructor that throws both give null.
function audioContext() {
if (ctx) return ctx;
if (typeof globalThis.AudioContext === "undefined") return null;
try {
ctx = new globalThis.AudioContext();
} catch {
ctx = null;
}
return ctx;
}
// Called from the click that opens Activities. A browser keeps a new context
// suspended until a gesture, and a rejected resume is not an error the page
// can act on, so every failure is swallowed.
export function unlockTones() {
try {
const c = audioContext();
if (c) Promise.resolve(c.resume()).catch(() => {});
} catch {}
}
// One oscillator from t0 for `seconds`, sweeping from one pitch to another.
function blip(c, type, from, to, t0, seconds, peak) {
const end = t0 + seconds;
const osc = c.createOscillator();
const gain = c.createGain();
osc.type = type;
osc.frequency.setValueAtTime(from, t0);
osc.frequency.exponentialRampToValueAtTime(to, end);
gain.gain.setValueAtTime(FLOOR, t0);
gain.gain.exponentialRampToValueAtTime(peak, t0 + ATTACK);
gain.gain.exponentialRampToValueAtTime(FLOOR, end);
osc.connect(gain);
gain.connect(c.destination);
osc.start(t0);
osc.stop(end);
}
// Plays one named blip, at `level` (0 to 1) of the usual loudness: a soft
// putt sounds soft. An unknown name, Play sounds off, or a context that is
// missing, suspended or closed all mean silence, not an error.
export function tone(name, level = 1) {
try {
const spec = Object.hasOwn(TONES, name) ? TONES[name] : null;
if (!spec || !looks.sound) return;
const c = audioContext();
if (!c || c.state !== "running") return;
const peak = Math.max(FLOOR * 10, PEAK * Math.min(1, Number(level) || 0));
const t0 = c.currentTime;
if (!spec.notes) return blip(c, spec.type, spec.from, spec.to, t0, spec.seconds, peak);
const each = spec.seconds / spec.notes.length;
spec.notes.forEach((f, i) => blip(c, spec.type, f, f, t0 + i * each, each, peak));
} catch {}
}
+9 -1
View File
@@ -71,6 +71,14 @@ export const SERVABLE = new Set([
"screens/workspace.js", "screens/workspace.js",
"screens/ask.js", "screens/ask.js",
"screens/notepad.js", "screens/notepad.js",
"screens/activities.js",
"activities.js",
"activities/snake.js",
"activities/golf.js",
"activities/golf-holes.js",
"activities/golf-draw.js",
"activities/golf-decor.js",
"tones.js",
"notepad-tabs.js", "notepad-tabs.js",
"net.js", "net.js",
"notepad.js", "notepad.js",
@@ -87,7 +95,7 @@ export const SERVABLE = new Set([
// Layers first, then one file per screen, then responsive and print last so // Layers first, then one file per screen, then responsive and print last so
// its overrides still come after everything they override. The files are not // its overrides still come after everything they override. The files are not
// on SERVABLE: they reach the page only through /app.css. // on SERVABLE: they reach the page only through /app.css.
export const CSS_ORDER = ["tokens.css", "shell.css", "planny.css", "pieces.css", "dashboard.css", "poses.css", "docs.css", "ask.css", "ending.css", "help.css", "looks.css", "notepad.css", "git.css", "responsive.css"]; export const CSS_ORDER = ["tokens.css", "shell.css", "planny.css", "pieces.css", "dashboard.css", "poses.css", "docs.css", "ask.css", "ending.css", "help.css", "looks.css", "notepad.css", "activities.css", "git.css", "responsive.css"];
// The files joined with one newline between them (each file's own last newline // The files joined with one newline between them (each file's own last newline
// is that one), as the server serves them before the accent rules. The test // is that one), as the server serves them before the accent rules. The test