Public: anyone can read this; the crew can change it.

Migrated from github.com/amirmushichge/pixel-plays

Add Bird Watch: the playable page and its place in the catalogue, on the rules in `bird-watch/watch.js` #229

Merged opened this

Check · Review · Land · Live done — Landed and live in production.

Merged

vesper/pixel-plays:vesper/181-add-bird-watch-the-playable-page-and-its → main 6 commits fork 2 threads · 2 unresolved

  • Merged. vesper/181-add-bird-watch-the-playable-page-and-its was merged into main as fa2d5a9.

Review

Sign in to review this change.
9 files changed +542 −2
README.md +3 −2

Diff not shown — a line 2,056 characters wide (limit 2,000). +3 −2

View file
bird-watch/index.html added +434
@@ -0,0 +1,434 @@
1 <!doctype html>
2 <html lang="en">
3 <head>
4 <meta charset="utf-8">
5 <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
6 <title>Bird Watch</title>
7 <!-- og:begin -->
8 <meta name="description" content="Remember where each bird perched">
9 <link rel="canonical" href="https://pixel-plays--forge-trevato-apps.open-platform.sh/bird-watch/">
10 <meta property="og:type" content="website">
11 <meta property="og:site_name" content="Pixel Plays">
12 <meta property="og:title" content="Bird Watch">
13 <meta property="og:description" content="Remember where each bird perched">
14 <meta property="og:url" content="https://pixel-plays--forge-trevato-apps.open-platform.sh/bird-watch/">
15 <meta property="og:image" content="https://pixel-plays--forge-trevato-apps.open-platform.sh/og/bird-watch.png">
16 <meta property="og:image:type" content="image/png">
17 <meta property="og:image:width" content="1200">
18 <meta property="og:image:height" content="630">
19 <meta property="og:image:alt" content="Bird Watch: the opening scene of the game">
20 <meta name="twitter:card" content="summary_large_image">
21 <!-- og:end -->
22 <style>
23 :root { --ink: #1c1b19; --muted: #6b675f; --paper: #fff; --accent: #6b8f3a; }
24 * { box-sizing: border-box; }
25 html, body { -webkit-user-select: none; user-select: none; -webkit-touch-callout: none; -webkit-tap-highlight-color: transparent; }
26 html, body { height: 100%; margin: 0; background: var(--paper); color: var(--ink); }
27 body { font: 13px/1.35 ui-monospace, "Cascadia Mono", Consolas, Menlo, monospace; overflow: hidden; }
28 #stage { position: fixed; inset: 0; display: grid; place-items: center; }
29 canvas { display: block; image-rendering: pixelated; touch-action: none; cursor: pointer; outline: none; }
30 .hud { position: fixed; left: max(16px, env(safe-area-inset-left)); right: max(16px, env(safe-area-inset-right)); display: flex; justify-content: space-between; align-items: flex-end; gap: 16px; pointer-events: none; }
31 #scores { position: fixed; top: max(14px, env(safe-area-inset-top)); left: max(16px, env(safe-area-inset-left)); display: grid; gap: 2px; pointer-events: none; }
32 #bottom { bottom: max(20px, env(safe-area-inset-bottom)); }
33 .row { display: flex; align-items: center; gap: 8px; color: var(--accent); }
34 .row b { font-size: 16px; font-weight: 600; min-width: 1ch; font-variant-numeric: tabular-nums; }
35 .row span { color: var(--muted); }
36 #status { color: var(--muted); min-height: 1.35em; }
37 button { pointer-events: auto; font: inherit; color: var(--muted); background: none; border: 0; padding: 13px 10px; margin: -13px -10px; min-height: 44px; cursor: pointer; }
38 button:hover, button:focus-visible { color: var(--ink); }
39 button:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
40 noscript p { position: fixed; inset: 40% 16px auto; margin: 0; text-align: center; color: var(--muted); }
41 </style>
42 </head>
43 <body>
44 <div id="stage"><canvas id="c" tabindex="0" aria-label="A garden with an oak, a fence, a shed roof and a bird feeder. Birds land on the perches for a moment and fly off; then the game names a bird. Tap the perch where it sat, or move with the arrow keys and press Space to choose. Five rounds, three pairs of binoculars; each species has its own shape."></canvas></div>
45 <noscript><p>Bird Watch needs JavaScript to play.</p></noscript>
46 <div id="scores">
47 <div class="row"><b id="round">1</b><span>round of 5</span></div>
48 <div class="row"><b id="right">0</b><span>answers right</span></div>
49 <div class="row"><b id="glasses">3</b><span>binoculars left</span></div>
50 </div>
51 <div class="hud" id="bottom">
52 <div id="status" role="status" aria-live="polite"></div>
53 <button id="mute" type="button" aria-pressed="false">sound on</button>
54 </div>
55 <script src="../shell.js"></script>
56 <script>
57 PixelPlays.mount({
58 id: 'bird-watch',
59 rules: [
60 'Watch the birds land on the perches, then fly off.',
61 'The game names a bird: tap the perch where it sat, or use arrows and Space.',
62 'A wrong perch costs a pair of binoculars; you have 3.',
63 'Clear 4 of the 5 rounds to win.',
64 ],
65 });
66 </script>
67 <script>window.PP_SCENE = { originY: 14, shadowX: 1.3, shadowY: -.12 };</script>
68 <script src="../engine.js"></script>
69 <script src="watch.js"></script>
70 <script>
71 'use strict';
72
73 /* ---------- the garden ---------- */
74 const OAK = { x: -6.5, y: -3, scale: 1.4 };
75 const SHED = { x0: 1.2, x1: 9.4, y0: -7.4, y1: -3, wall: 2.9, ridge: 4.7, ridgeX: 5.3 };
76 const FEEDER = { x: -3, y: 1.6 };
77 const FENCE_Y = 4.6, POST_H = 1.7, PLINTH = { x: -8.2, y: 6.2, h: .9 };
78 const LAWN = [[58, 108, 62], [66, 118, 66]], PATIO = [196, 184, 160];
79 const WOOD = [150, 112, 76], WOOD_DARK = [96, 70, 50], STONE = [190, 186, 176], ROOF = [160, 78, 62], WALL = [214, 200, 170];
80 const INK_PIX = rgb(28, 27, 25), RING_PIX = rgb(255, 255, 255), CURSOR_PIX = rgb(255, 214, 10), GOOD_PIX = rgb(60, 160, 80), BAD_PIX = rgb(200, 60, 50);
81
82 // where each perch is: the spot a bird's feet stand on
83 const SPOT = {
84 'oak-low': [OAK.x + 2.8, OAK.y + 1.6, 4.7],
85 'oak-high': [OAK.x - 1.4, OAK.y + .8, 6],
86 'oak-tip': [OAK.x + 1.2, OAK.y - .2, 6.9],
87 'fence-1': [-2, FENCE_Y, POST_H],
88 'fence-2': [2, FENCE_Y, POST_H],
89 'fence-3': [6, FENCE_Y, POST_H],
90 'roof-left': [SHED.x0 + .8, (SHED.y0 + SHED.y1) / 2, SHED.wall + (SHED.ridge - SHED.wall) * .8 / (SHED.ridgeX - SHED.x0) + .1],
91 'roof-ridge': [SHED.ridgeX, (SHED.y0 + SHED.y1) / 2, SHED.ridge + .1],
92 'roof-right': [SHED.x1 - .8, (SHED.y0 + SHED.y1) / 2, SHED.wall + (SHED.ridge - SHED.wall) * .8 / (SHED.x1 - SHED.ridgeX) + .1],
93 feeder: [FEEDER.x, FEEDER.y, 2.3],
94 };
95 const PERCH_NAME = {
96 'oak-low': 'low oak branch', 'oak-high': 'high oak branch', 'oak-tip': 'top of the oak', 'fence-1': 'first fence post',
97 'fence-2': 'middle fence post', 'fence-3': 'last fence post', 'roof-left': 'left of the shed roof', 'roof-ridge': 'shed roof ridge',
98 'roof-right': 'right of the shed roof', feeder: 'bird feeder',
99 };
100
101 function groundColor(x, y, ix, iy) {
102 const edge = Math.pow(Math.abs(x) / 10.4, 6) + Math.pow(Math.abs(y + .4) / 8.4, 6);
103 const rough = Math.pow(edge, 1 / 6) + (noise(x * 1.3, y * 1.3) - .5) * .06;
104 if (rough > 1) return 0;
105 if (rough > .95 && hash(ix, iy) < (rough - .95) / .05) return 0;
106 const t = .96 + (hash(ix, iy) - .5) * .08;
107 const patio = y > FENCE_Y + 1.4 && x > -5.5 && x < 6;
108 const c = patio ? PATIO : LAWN[Math.floor((x + y) / 2.5) & 1];
109 return rgb(c[0] * t, c[1] * t, c[2] * t);
110 }
111 const solid = (a, b, r0, r1, c) => capsule(a, b, r0, r1, () => c, 'rough');
112 const shade = (x, y, z, r) => castShadow(x, y, z, r, 1, 0);
113 function bakeShed() {
114 const { x0, x1, y0, y1, wall, ridge, ridgeX } = SHED;
115 box(x0 + .2, y0 + .2, 0, x1 - .2, y1 - .2, wall, WALL, 3);
116 for (let y = y0; y <= y1 + .01; y += .22) {
117 solid([x0, y, wall], [ridgeX, y, ridge], .17, .17, ROOF);
118 solid([ridgeX, y, ridge], [x1, y, wall], .17, .17, ROOF);
119 }
120 for (let x = x0; x <= x1; x += .7) { shade(x, y0, wall, .3); shade(x, y1, wall, .3); }
121 for (let y = y0; y <= y1; y += .7) shade(ridgeX, y, ridge, .3);
122 }
123 function bakeFence() {
124 for (const x of [-4, -2, 0, 2, 4, 6, 8]) {
125 solid([x, FENCE_Y, 0], [x, FENCE_Y, POST_H], .14, .12, WOOD);
126 shade(x, FENCE_Y, POST_H, .22);
127 }
128 for (const z of [.55, 1.15]) {
129 solid([-4, FENCE_Y, z], [8, FENCE_Y, z], .06, .06, WOOD_DARK);
130 for (let x = -4; x <= 8; x += .8) shade(x, FENCE_Y, z, .14);
131 }
132 }
133 function bakeFeeder() {
134 const { x, y } = FEEDER;
135 solid([x, y, 0], [x, y, 2.1], .1, .08, WOOD_DARK);
136 box(x - .6, y - .6, 2.1, x + .6, y + .6, 2.25, WOOD, 5);
137 for (const [dx, dy] of [[-.6, -.6], [.6, -.6], [-.6, .6], [.6, .6]]) solid([x + dx, y + dy, 2.2], [x + dx, y + dy, 2.7], .03, .03, WOOD_DARK);
138 for (let z = 0; z <= 2.2; z += .4) shade(x, y, z, .16);
139 shade(x + .5, y, 2.2, .3); shade(x - .5, y, 2.2, .3);
140 }
141 function bakePlinth() {
142 box(PLINTH.x - .9, PLINTH.y - .9, 0, PLINTH.x + .9, PLINTH.y + .9, PLINTH.h, STONE, 8);
143 for (const [dx, dy] of [[-.7, -.7], [.7, -.7], [-.7, .7], [.7, .7], [0, 0]]) shade(PLINTH.x + dx, PLINTH.y + dy, PLINTH.h, .3);
144 }
145 function bake() {
146 ground.fill(0); shadowMask.fill(0); staticShadow.fill(0); kinds.fill(0);
147 tufts.length = 0; leaves.length = 0;
148 zb.fill(-1e9);
149 pix.fill(rgb(255, 255, 255));
150 for (let iy = 0; iy < H; iy++) for (let ix = 0; ix < W; ix++) {
151 const g = unproject(ix + .5, iy + .5), i = iy * W + ix, c = groundColor(g.x, g.y, ix, iy);
152 if (!c) continue;
153 pix[i] = c; ground[i] = 1;
154 zb[i] = (g.x + g.y) / R2 * COS;
155 }
156 groundZ.set(zb);
157 growTree(OAK.x, OAK.y, OAK.scale, 260, 21);
158 for (let z = 0; z <= 3.4; z += .4) shade(OAK.x, OAK.y, z, .4);
159 bakeShed(); bakeFence(); bakeFeeder(); bakePlinth();
160 bakeOcclusion();
161 staticShadow.set(shadowMask);
162 applyShadows(groundZ);
163 bakedPix.set(pix);
164 bakedZ.set(zb);
165 }
166
167 /* ---------- the birds: each species has its own silhouette as well as its colours ---------- */
168 // r body radius, len body length, tall lifts the body upright, head radius, tail length and its rise (+ cocked up, - hanging),
169 // fork splits the tail, crest and ears stand above the head, beak is [length, radius]
170 const LOOK = {
171 robin: { body: [150, 108, 76], belly: [226, 98, 52], beak: [60, 50, 40], r: .36, len: .5, tall: 0, head: .25, tail: .6, rise: -.25, beak_: [.18, .05] },
172 wren: { body: [138, 94, 58], belly: [196, 164, 124], beak: [70, 56, 44], r: .25, len: .3, tall: 0, head: .19, tail: .5, rise: 1.1, beak_: [.3, .035] },
173 finch: { body: [218, 86, 112], belly: [240, 200, 190], beak: [236, 220, 190], r: .3, len: .45, tall: 0, head: .25, tail: .65, rise: -.3, fork: true, beak_: [.15, .1] },
174 jay: { body: [66, 110, 196], belly: [206, 210, 222], beak: [30, 30, 36], r: .42, len: .75, tall: 0, head: .3, tail: 1, rise: -.1, crest: .6, beak_: [.3, .07] },
175 sparrow: { body: [140, 100, 66], belly: [214, 196, 164], beak: [90, 70, 56], r: .46, len: .25, tall: 0, head: .3, tail: .28, rise: -.1, beak_: [.12, .07] },
176 owl: { body: [176, 146, 98], belly: [236, 224, 196], beak: [220, 170, 60], r: .5, len: 0, tall: .6, head: .44, tail: 0, rise: 0, ears: .35, owl: true, beak_: [.1, .06] },
177 magpie: { body: [32, 36, 52], belly: [244, 244, 240], beak: [20, 20, 24], r: .33, len: .7, tall: 0, head: .24, tail: 1.8, rise: -.05, beak_: [.26, .06] },
178 starling: { body: [58, 76, 70], belly: [96, 104, 120], beak: [240, 200, 40], r: .24, len: .9, tall: 0, head: .19, tail: .38, rise: -.2, beak_: [.55, .04] },
179 };
180 const BIRD_SCALE = 2;
181 const EYE = [250, 250, 250], PUPIL = [28, 27, 25];
182
183 // feet at (x, y, z), looking along (fx, fy); `flap` raises two wings (0 folded, 1 spread)
184 function drawBird(species, x, y, z, fx, fy, sc, flap = 0) {
185 const L = LOOK[species];
186 if (!L) return;
187 const pt = (a, h, side = 0) => [x + (fx * a - fy * side) * sc, y + (fy * a + fx * side) * sc, z + h * sc];
188 const bodyH = L.r * .9 + .05, headA = L.len / 2 + L.head * .6, headH = bodyH + L.tall + L.r * .45 + L.head * .75;
189 const add = (a, b, r0, r1, c) => dynamicAdd(a, b, r0 * sc, r1 * sc, () => c);
190 if (L.tail) {
191 const back = -L.len / 2 - L.r * .4;
192 for (const side of L.fork ? [-.09, .09] : [0]) add(pt(back, bodyH, side), pt(back - L.tail, bodyH + L.rise * L.tail * .6, side * 3), .1, .06, L.body);
193 }
194 add(pt(-L.len / 2, bodyH), pt(L.len / 2, bodyH + L.tall + (L.tall ? 0 : .08)), L.r, L.r * .92, L.body);
195 add(pt(-L.len * .2, bodyH - L.r * .5), pt(L.len / 2, bodyH + L.tall * .4 - L.r * .5), L.r * .78, L.r * .7, L.belly);
196 add(pt(headA, headH), pt(headA, headH), L.head, L.head, L.body);
197 add(pt(headA + L.head * .2, headH - L.head * .5), pt(headA + L.head * .2, headH - L.head * .5), L.head * .62, L.head * .62, L.belly);
198 add(pt(headA + L.head * .8, headH - .02), pt(headA + L.head * .8 + L.beak_[0], headH - .06), L.beak_[1] * 1.3, L.beak_[1] * .5, L.beak);
199 if (L.crest) add(pt(headA - L.head * .2, headH + L.head * .6), pt(headA - L.head * .9, headH + L.head * .6 + L.crest), .1, .05, L.body);
200 if (L.ears) for (const side of [-.26, .26]) add(pt(headA - .05, headH + L.head * .8, side), pt(headA - .1, headH + L.head * .8 + L.ears, side * 1.1), .1, .04, L.body);
201 for (const side of [-1, 1]) {
202 const e = pt(headA + L.head * .6, headH + L.head * .1, side * L.head * .78);
203 add(e, e, L.owl ? .14 : .06, L.owl ? .14 : .06, L.owl ? EYE : PUPIL);
204 if (species === 'owl') { const q = pt(headA + L.head * .7, headH + L.head * .1, side * L.head * .78); add(q, q, .07, .07, PUPIL); }
205 }
206 if (flap > 0) {
207 const lift = bodyH + L.tall * .5 + L.r * .4;
208 for (const side of [-1, 1]) add(pt(0, lift, side * L.r * .6), pt(-.2, lift + (flap - .5) * 1.5, side * (L.r + 1.1)), .16, .08, L.body);
209 }
210 }
211
212 /* ---------- state ---------- */
213 const nodes = {};
214 for (const k of ['round', 'right', 'glasses', 'status']) nodes[k] = document.getElementById(k);
215 const shown = {};
216 function setText(key, text) {
217 if (shown[key] === text) return;
218 shown[key] = text;
219 nodes[key].textContent = text;
220 }
221 const fresh = () => BirdWatch.round(BirdWatch.start(Math.floor(Math.random() * 4294967296))).state;
222
223 // timings, in seconds: the presentation only, the rules know nothing of them
224 const GAP = .5, FLY_IN = .4, HOLD = 1.3, FLY_OUT = .5, LEAVE_GAP = .08, REVEAL = 1.3;
225 let P = fresh();
226 // phase: 'show' (the flock lands and leaves), 'ask' (waiting for a perch), 'reveal' (the answer shown), 'over'
227 const G = { time: 0, age: 0, phase: 'show', noteUntil: 0, cursor: 'fence-2', keyed: false, last: null, event: '' };
228 const facing = perch => (BirdWatch.PERCHES.indexOf(perch) % 2 ? 1 : -1) * Math.SQRT1_2; // + faces screen-right
229 const showEnd = () => (P.birds.length - 1) * GAP + FLY_IN + HOLD + (P.birds.length - 1) * LEAVE_GAP + FLY_OUT + .3;
230
231 function renderHud() {
232 setText('round', String(Math.max(1, P.round)));
233 setText('right', String(P.right));
234 setText('glasses', String(P.binoculars));
235 }
236 function note(text) { setText('status', text); G.noteUntil = G.time + 1.8; }
237 const endLine = () => `${P.line} · tap or press a key to play again`;
238 // the canvas pixel of a perch, a little above the feet where the bird's body is
239 function perchPoint(perch) {
240 const [x, y, z] = SPOT[perch], p = project(x, y, z + .5);
241 return [p.sx, p.sy];
242 }
243
244 /* ---------- drawing ---------- */
245 function ellipse(sx, sy, rx, ry, color, n = 28) {
246 const pts = [];
247 for (let i = 0; i < n; i++) { const a = i / n * Math.PI * 2; pts.push([Math.round(sx + Math.cos(a) * rx), Math.round(sy + Math.sin(a) * ry)]); }
248 drawDots(pts, color);
249 }
250 function marker(perch, color, rx = 14, ry = 9) {
251 const [sx, sy] = perchPoint(perch);
252 ellipse(sx, sy, rx + 1, ry + 1, INK_PIX, 36);
253 ellipse(sx, sy, rx, ry, color);
254 }
255 // a bird of the flock at `age` seconds into the show (landing at its slot, leaving after the hold)
256 function drawFlockBird(bird, index) {
257 const land = index * GAP, leave = (P.birds.length - 1) * GAP + FLY_IN + HOLD + index * LEAVE_GAP;
258 const kin = (G.age - land) / FLY_IN, kout = (G.age - leave) / FLY_OUT;
259 if (kin <= 0 || kout >= 1) return;
260 placeBird(bird, Math.min(1, kin), Math.max(0, kout));
261 }
262 // `kin` 0..1 is the fly-in (1 = landed), `kout` 0..1 the fly-off
263 function placeBird(bird, kin, kout) {
264 const [x, y, z] = SPOT[bird.perch], f = facing(bird.perch), fx = f, fy = -f;
265 const a = 1 - (1 - kin) * (1 - kin), out = kout * kout;
266 const flying = kin < 1 || kout > 0;
267 const ox = -(1 - a) * 4.5 + out * 5, oy = (1 - a) * 4.5 - out * 5, oz = (1 - a) * 5.5 + out * 7;
268 const dir = kout > 0 ? 1 : -1;
269 drawBird(bird.species, x + ox, y + oy, z + oz, flying ? dir * Math.SQRT1_2 : fx, flying ? -dir * Math.SQRT1_2 : fy, BIRD_SCALE, flying ? .5 + .5 * Math.sin(G.time * 34) : 0);
270 }
271 function draw() {
272 pix.set(bakedPix);
273 zb.set(bakedZ);
274 pendingShadows.length = 0;
275 drawLeaves(STILL ? 0 : Math.floor(G.time * WIND_FPS) / WIND_FPS);
276 if (G.phase === 'show') P.birds.forEach(drawFlockBird);
277 if (G.phase === 'reveal' && G.last) placeBird(G.last, Math.min(1, G.age / FLY_IN), 0);
278 if (G.phase === 'ask' && P.asking) drawBird(P.asking.species, PLINTH.x, PLINTH.y, PLINTH.h, Math.SQRT1_2, -Math.SQRT1_2, 1.8);
279 if (G.phase === 'reveal' && G.last) drawBird(G.last.species, PLINTH.x, PLINTH.y, PLINTH.h, Math.SQRT1_2, -Math.SQRT1_2, 1.8);
280 flushShadows();
281 applyShadows(bakedZ);
282 shadeEdges();
283 if (G.phase === 'ask') {
284 for (const p of P.perches) marker(p, p === G.cursor && G.keyed ? CURSOR_PIX : RING_PIX, 11, 7);
285 if (G.keyed) marker(G.cursor, CURSOR_PIX, 14, 9);
286 }
287 if (G.phase === 'reveal') {
288 if (G.chosen && G.chosen !== G.last.perch) marker(G.chosen, BAD_PIX);
289 marker(G.last.perch, GOOD_PIX);
290 }
291 ctx.putImageData(image, 0, 0);
292 }
293
294 /* ---------- game ---------- */
295 function ask() {
296 const r = BirdWatch.ask(P);
297 P = r.state;
298 G.phase = 'ask'; G.age = 0; G.chosen = null;
299 setText('status', `Where did the ${r.species} sit? Tap a perch, or arrows and Space. Cursor on the ${PERCH_NAME[G.cursor]}`);
300 G.noteUntil = 0;
301 }
302 function nextRound() {
303 const r = BirdWatch.round(P);
304 P = r.state;
305 G.phase = 'show'; G.age = 0; G.last = null; G.chosen = null;
306 note(`Round ${P.round}: watch the ${P.birds.length} birds`);
307 }
308 function choose(perch) {
309 ensureAudio();
310 if (G.phase !== 'ask' || !P.asking) return;
311 const asked = P.asking, r = BirdWatch.answer(P, perch);
312 if (!r.ok) { note('pick one of the perches'); sound(120, .08, 'square'); return; }
313 P = r.state; G.last = asked; G.chosen = perch; G.event = r.event; G.phase = 'reveal'; G.age = 0; G.cursor = perch;
314 const where = PERCH_NAME[asked.perch];
315 setText('status', `${r.correct ? 'Yes' : 'No'}: the ${asked.species} sat on the ${where}`);
316 G.noteUntil = 0;
317 sound(r.correct ? 660 : 130, r.correct ? .12 : .3, r.correct ? 'sine' : 'sawtooth');
318 renderHud();
319 }
320 function restart() {
321 P = fresh(); G.phase = 'show'; G.age = 0; G.last = null; G.chosen = null; G.event = '';
322 note(`Round ${P.round}: watch the ${P.birds.length} birds`);
323 renderHud();
324 }
325 function update(dt) {
326 G.time += dt;
327 G.age += dt;
328 renderHud();
329 if (G.phase === 'show') {
330 if (G.age >= showEnd()) ask();
331 else if (G.time >= G.noteUntil) setText('status', `Round ${P.round}: watch the ${P.birds.length} birds`);
332 } else if (G.phase === 'reveal' && G.age >= REVEAL) {
333 if (G.event === 'over') { G.phase = 'over'; sound(P.line.startsWith('Sharp') ? 780 : 110, .5, 'sine'); }
334 else if (G.event === 'cleared') nextRound();
335 else ask();
336 }
337 if (G.phase === 'over') setText('status', endLine());
338 }
339 // birds landing: a short chirp of a pitch for each, only while the flock is shown
340 let chirped = -1;
341 function chirps() {
342 if (G.phase !== 'show') { chirped = -1; return; }
343 const n = Math.floor((G.age - FLY_IN * .8) / GAP);
344 if (n > chirped && n < P.birds.length) { chirped = n; sound(520 + BirdWatch.SPECIES.indexOf(P.birds[n].species) * 70, .09, 'triangle'); }
345 }
346
347 /* ---------- input ---------- */
348 const point = e => { const r = canvas.getBoundingClientRect(); return [(e.clientX - r.left) / r.width * W, (e.clientY - r.top) / r.height * H]; };
349 // the perch nearest a canvas point, or null when none is near enough
350 function nearest(px, py, reach = 24) {
351 let best = null, gap = reach;
352 for (const p of P.perches) {
353 const [sx, sy] = perchPoint(p), d = Math.hypot(px - sx, (py - sy) * 1.4);
354 if (d < gap) { gap = d; best = p; }
355 }
356 return best;
357 }
358 // the perch to move to from the cursor in a screen direction: near that way, and lined up with it
359 function neighbour(dx, dy) {
360 const [cx, cy] = perchPoint(G.cursor);
361 let best = null, cost = 1e9;
362 for (const p of P.perches) {
363 if (p === G.cursor) continue;
364 const [sx, sy] = perchPoint(p), along = (sx - cx) * dx + (sy - cy) * dy, across = Math.abs((sx - cx) * dy - (sy - cy) * dx);
365 if (along <= 2) continue;
366 const c = along + across * 2;
367 if (c < cost) { cost = c; best = p; }
368 }
369 return best;
370 }
371 const MOVES = { ArrowLeft: [-1, 0], ArrowRight: [1, 0], ArrowUp: [0, -1], ArrowDown: [0, 1] };
372 canvas.addEventListener('pointerdown', e => {
373 canvas.focus({ preventScroll: true });

Moving the cursor changes only a canvas ring. Call note(\${PERCH_NAME[to]}\) or setText('status', ...) here so the polite live region announces the perch. Without it, a screen-reader user cannot play with arrows and Space.

374 ensureAudio();
375 if (G.phase === 'over') { restart(); return; }
376 if (G.phase !== 'ask') return;
377 const [px, py] = point(e), perch = nearest(px, py);
378 G.keyed = false;
379 if (perch) choose(perch); else note('tap a perch');
380 });
381 canvas.addEventListener('keydown', e => {
382 const move = MOVES[e.key], pick = e.key === ' ' || e.key === 'Enter';
383 if (!move && !pick) return;
384 e.preventDefault();
385 if (G.phase === 'over') { if (!e.repeat) restart(); return; }
386 if (G.phase !== 'ask') return;
387 if (move) { G.keyed = true; const to = neighbour(...move); if (to) G.cursor = to; setText('status', `the ${PERCH_NAME[G.cursor]}`); return; }
388 if (!e.repeat) { G.keyed = true; choose(G.cursor); }
389 });
390
391 /* ---------- sound ---------- */
392 let audio = null, muted = false;
393 function ensureAudio() {
394 if (audio) { if (audio.state === 'suspended') audio.resume(); return; }
395 const AC = window.AudioContext || window.webkitAudioContext;
396 if (AC) audio = new AC();
397 }
398 function sound(freq, life, type, delay = 0) {
399 if (!audio || muted) return;
400 const now = audio.currentTime + delay, gain = audio.createGain(), osc = audio.createOscillator();
401 osc.type = type;
402 osc.frequency.setValueAtTime(freq, now);
403 gain.gain.setValueAtTime(.0001, now);
404 gain.gain.exponentialRampToValueAtTime(.07, now + .01);
405 gain.gain.exponentialRampToValueAtTime(.0005, now + life);
406 osc.connect(gain).connect(audio.destination);
407 osc.start(now); osc.stop(now + life + .02);
408 }
409 const muteButton = document.getElementById('mute');
410 muteButton.addEventListener('click', () => {
411 muted = !muted;
412 muteButton.textContent = muted ? 'sound off' : 'sound on';
413 muteButton.setAttribute('aria-pressed', String(muted));
414 });
415
416 /* ---------- fit and boot ---------- */
417 addEventListener('resize', fit);
418 fit();
419 bake();
420 note(`Round ${P.round}: watch the ${P.birds.length} birds`);
421 renderHud();
422 canvas.focus({ preventScroll: true });
423 let last = performance.now();
424 function frame(now) {
425 update(Math.min(.04, (now - last) / 1000));
426 chirps();
427 last = now;
428 draw();
429 requestAnimationFrame(frame);
430 }
431 requestAnimationFrame(frame);
432 </script>
433 </body>
434 </html>
bird-watch/page.test.mjs added +91
@@ -0,0 +1,91 @@
1 import { test, expect } from 'bun:test';
2 import { boot } from '../playtest.mjs';
3
4 // play until the first question is open
5 function asking(seed = 3) {
6 const g = boot('bird-watch', { seed });
7 for (let i = 0; i < 400 && g.read('G.phase') !== 'ask'; i++) g.run(.1);
8 expect(g.read('G.phase')).toBe('ask');
9 return g;
10 }
11
12 test('a tap a few pixels off a perch still picks that perch', () => {
13 const g = asking();
14 const [x, y] = g.read('perchPoint(P.asking.perch)');
15 g.tap(x + 6, y + 4);
16 expect(g.read('P.answered')).toBe(1);
17 expect(g.read('G.chosen')).toBe(g.read('G.last.perch'));
18 });
19
20 test('a tap far from every perch answers nothing and says to tap a perch', () => {
21 const g = asking();
22 g.tap(5, 275);
23 expect(g.read('P.answered')).toBe(0);
24 expect(g.read('G.phase')).toBe('ask');
25 expect(g.text()).toContain('tap a perch');
26 });
27
28 test('arrows move the cursor to another perch and space answers with it', () => {
29 const g = asking();
30 const from = g.read('G.cursor');
31 g.press('ArrowRight');
32 expect(g.read('G.cursor')).not.toBe(from);
33 g.press(' ');
34 expect(g.read('G.phase')).toBe('reveal');
35 });

Add tests for a wrong answer (binoculars drop, status names the right perch), for game over followed by restart, and for the arrow announcement.

36
37 test('the question opens and every arrow move says which perch the cursor is on', () => {
38 const g = asking();
39 const name = p => g.read(`PERCH_NAME[${JSON.stringify(p)}]`);
40 expect(g.el('status').textContent).toContain(`Cursor on the ${name(g.read('G.cursor'))}`);
41 const from = g.read('G.cursor');
42 g.press('ArrowRight');
43 const to = g.read('G.cursor');
44 expect(to).not.toBe(from);
45 expect(g.el('status').textContent).toBe(`the ${name(to)}`);
46 });
47
48 // answer the open question on purpose with a perch that is not the right one
49 function miss(g) {
50 const right = g.read('P.asking.perch');
51 const wrong = g.read('P.perches').find(p => p !== right);
52 g.tap(...g.read(`perchPoint(${JSON.stringify(wrong)})`));
53 }
54
55 test('a wrong perch costs a pair of binoculars and the status names the right perch', () => {
56 const g = asking();
57 const right = g.read('P.asking.perch');
58 expect(g.el('glasses').textContent).toBe('3');
59 miss(g);
60 expect(g.read('G.phase')).toBe('reveal');
61 expect(g.el('glasses').textContent).toBe('2');
62 expect(g.el('status').textContent).toStartWith('No:');
63 expect(g.el('status').textContent).toContain(g.read(`PERCH_NAME[${JSON.stringify(right)}]`));
64 });
65
66 test('three misses end the game and a tap restarts it at round 1 with 3 binoculars', () => {
67 const g = asking();
68 for (let i = 0; i < 3; i++) {
69 for (let j = 0; j < 800 && g.read('G.phase') !== 'ask'; j++) g.run(.1);
70 miss(g);
71 }
72 for (let j = 0; j < 100 && g.read('G.phase') !== 'over'; j++) g.run(.1);
73 expect(g.read('G.phase')).toBe('over');
74 expect(g.el('glasses').textContent).toBe('0');
75 g.tap(100, 100);
76 expect(g.read('G.phase')).toBe('show');
77 expect(g.el('glasses').textContent).toBe('3');
78 expect(g.el('round').textContent).toBe('1');
79 });
80
81 test('a key restarts a finished game too', () => {
82 const g = asking();
83 for (let i = 0; i < 3; i++) {
84 for (let j = 0; j < 800 && g.read('G.phase') !== 'ask'; j++) g.run(.1);
85 miss(g);
86 }
87 for (let j = 0; j < 100 && g.read('G.phase') !== 'over'; j++) g.run(.1);
88 g.press(' ');
89 expect(g.read('G.phase')).toBe('show');
90 expect(g.el('glasses').textContent).toBe('3');
91 });
index.html +1
@@ -119,6 +119,7 @@ footer a::after { content: none; }
119119 <li data-kind="Puzzle" data-input="Tap" style="--accent:#8a4b2f"><a href="shunting-yard/">Shunting Yard</a><span>Shunt the wagons through the sidings until the train leaves in order</span><span>Game forged by the crew</span><span class="tags">Puzzle · Tap</span></li>
120120 <li data-kind="Strategy" data-input="Tap" style="--accent:#b8475a"><a href="ferris-wheel/">Ferris Wheel</a><span>Seat the queue without tipping the wheel</span><span>Game forged by the crew</span><span class="tags">Strategy · Tap</span></li>
121121 <li data-kind="Puzzle" data-input="Keys" style="--accent:#3d6e4f"><a href="hedge-maze/">Hedge Maze</a><span>Find the way through the hedges to the fountain before the gardener rings the bell</span><span>Game forged by the crew</span><span class="tags">Puzzle · Keys</span></li>
122 <li data-kind="Memory" data-input="Tap" style="--accent:#6b8f3a"><a href="bird-watch/">Bird Watch</a><span>Remember where each bird perched</span><span>Game forged by the crew</span><span class="tags">Memory · Tap</span></li>
122123 <li data-kind="Strategy" data-input="Tap" style="--accent:#3d7f6e"><a href="bunting/">Bunting</a><span>Hang the flags for the fete so no two neighbours match</span><span>Game forged by the crew</span><span class="tags">Strategy · Tap</span></li>
123124 </ul>
124125 <footer>Concept by <a href="https://x.com/awwbhi2">abhi</a>. Game by <a href="https://x.com/AmirMushich">AmirMushich</a>. Visual reference for the style: shawn.'s <a href="https://x.com/zzzzshawn/status/2111546123546661289">Small plays</a>; no assets or subjects were copied.<br><a href="stats/">Most played</a></footer>
og/bird-watch.png added
Binary file not shown.
og/home.png
Binary file not shown.
rounds.mjs +5
@@ -184,6 +184,11 @@ export const ROUNDS = {
184184 const [from, to] = g.read('Yard.solve(P)[0]');
185185 g.press(String(from + 1)); g.press(String(to + 1));
186186 } },
187 // tap the perch where the named bird sat, round after round
188 'bird-watch': { over: /play again/, outcome: /Sharp eyes: \d+ rounds? cleared, \d+ answers? right/, beat: g => {
189 if (g.read('G.phase') === 'ask') g.tap(...g.read('perchPoint(P.asking.perch)'));
190 else g.run(.2);
191 } },
187192 // walk the one path to the fountain by the arrow keys, maze after maze; once five are solved, wait out the bell
188193 'hedge-maze': { over: /play again/, outcome: /\d+ mazes solved, best \d+\. You win!/, beat: g => {
189194 const s = g.read('P');
serve.test.mjs +7
@@ -570,6 +570,13 @@ test('Hedge Maze and its rules script are served without a track', async () => {
570570 expect((await fetch(base + '/hedge-maze/maze.js')).status).toBe(200);
571571 });
572572
573 test('Bird Watch and its rules script are served without a track', async () => {
574 const page = await fetch(base + '/bird-watch/');
575 expect(page.status).toBe(200);
576 expect(page.headers.get('content-type')).toBe('text/html; charset=utf-8');
577 expect((await fetch(base + '/bird-watch/watch.js')).status).toBe(200);
578 });
579
573580 test('Hot Air Balloon and its rules script are served without a track', async () => {
574581 const page = await fetch(base + '/hot-air-balloon/');
575582 expect(page.status).toBe(200);
shell.js +1
@@ -59,6 +59,7 @@ window.PixelPlays = (() => {
5959 { id: 'shunting-yard', title: 'Shunting Yard', blurb: 'Shunt the wagons through the sidings until the train leaves in order', kind: 'Puzzle', input: 'Tap', accent: '#8a4b2f', music: false, forged: true },
6060 { id: 'ferris-wheel', title: 'Ferris Wheel', blurb: 'Seat the queue without tipping the wheel', kind: 'Strategy', input: 'Tap', accent: '#b8475a', music: false, forged: true },
6161 { id: 'hedge-maze', title: 'Hedge Maze', blurb: 'Find the way through the hedges to the fountain before the gardener rings the bell', kind: 'Puzzle', input: 'Keys', accent: '#3d6e4f', music: false, forged: true },
62 { id: 'bird-watch', title: 'Bird Watch', blurb: 'Remember where each bird perched', kind: 'Memory', input: 'Tap', accent: '#6b8f3a', music: false, forged: true },
6263 { id: 'bunting', title: 'Bunting', blurb: 'Hang the flags for the fete so no two neighbours match', kind: 'Strategy', input: 'Tap', accent: '#3d7f6e', music: false, forged: true },
6364 ];
6465 const MUSIC_VOLUME = .4;

↑↓ navigate ↵ open ⌘↵ its app esc close

Keyboard shortcuts

Docs