BlueGit

projects-timfalken-com meteors

Files

meteors / src / reward.js

reward.js

reward.js 12.9 KiB Download Raw
1/*
2 * End-of-round reward screen (t1173 / t1174).
3 *
4 * Logged-in only. Sequence: a centred "You won!" / "You lost..." for
5 * INTRO seconds, then it tweens to the top (RISE seconds). Once the
6 * server has confirmed the new profile total, blocks of the player's
7 * planet arc from the top of the screen into a counter at the bottom
8 * centre, one block per newly earned point. Each arrival adds 1.
9 *
10 * Spawn rate accelerates: rate(t) = RATE0 + ACCEL·t blocks/s, so the
11 * number spawned after t seconds is N(t) = RATE0·t + ACCEL·t²/2, and
12 * block i (0-based) leaves at T(i) = the t where N(t) = i.
13 * t1178: RATE0 = 15, ACCEL = 10 → 253 points ≈ 5.8 s, 800 ≈ 11.2 s, 2000 ≈ 18.6 s.
14 *
15 * The pure timing / sequencing part (Reward.spawnTime, Reward.createSequence)
16 * has no DOM and is unit-tested. Reward.play wires it to an overlay.
17 */
18(function (root)
19{
20'use strict';
21
22/** Blocks per second at t = 0 (t1177: 10, t1178: 15). */
23var RATE0 = 15;
24/** Rate increase in blocks/s per second (t1175: 3, t1177: 5, t1178: 10). */
25var ACCEL = 10;
26var INTRO = 1.0; // centred title before it rises
27var RISE = 0.6; // title tween to the top
28var FLIGHT = 0.7; // one block's arc duration
29var HOLD = 1.5; // final total shown before continuing
30var HOLD_ZERO = 1.5; // earned 0: show the number briefly
31var WAIT_MAX = 8; // give up waiting for the server after this
32
33/** Seconds after the start of counting when block i (0-based) leaves. */
34function spawnTime (i)
35{
36 if (!(i > 0))
37 { return 0; }
38 if (ACCEL === 0)
39 { return i / RATE0; }
40 return (-RATE0 + Math.sqrt(RATE0 * RATE0 + 2 * ACCEL * i)) / ACCEL;
41}
42
43/** Blocks spawned (left the top) by time t, capped at n. */
44function spawnedBy (t, n)
45{
46 if (!(t >= 0) || !(n > 0))
47 { return 0; }
48 // Block i has left when T(i) <= t, i.e. i <= N(t).
49 var k = Math.floor(RATE0 * t + ACCEL * t * t / 2 + 1e-9) + 1;
50 return Math.min(n, Math.max(0, k));
51}
52
53/** Blocks that have arrived in the counter by time t. */
54function arrivedBy (t, n, flight)
55{
56 flight = flight == null ? FLIGHT : flight;
57 return spawnedBy(t - flight, n);
58}
59
60/** Total seconds from the first spawn until the last block arrives. */
61function countDuration (n, flight)
62{
63 flight = flight == null ? FLIGHT : flight;
64 if (!(n > 0))
65 { return 0; }
66 return spawnTime(n - 1) + flight;
67}
68
69/**
70 * A pure, dt-driven sequence. Phases: intro → rise → wait → count →
71 * hold → done. `setResult({ before, after })` supplies the confirmed
72 * totals (earned = after − before, never negative); `setResult(null)`
73 * means the server did not confirm, so nothing is counted and the
74 * title is held briefly. tick(dt) returns
75 * { phase, counter, spawn: [indices], arrived, done }.
76 */
77function createSequence (opts)
78{
79 opts = opts || {};
80 var s = {
81 phase: 'intro',
82 t: 0, // time inside the current phase
83 countT: 0,
84 won: !!opts.won,
85 flight: opts.flight == null ? FLIGHT : opts.flight,
86 intro: opts.intro == null ? INTRO : opts.intro,
87 rise: opts.rise == null ? RISE : opts.rise,
88 hold: opts.hold == null ? HOLD : opts.hold,
89 holdZero: opts.holdZero == null ? HOLD_ZERO : opts.holdZero,
90 waitMax: opts.waitMax == null ? WAIT_MAX : opts.waitMax,
91 hasResult: false,
92 failed: false,
93 before: 0,
94 after: 0,
95 earned: 0,
96 spawned: 0,
97 arrived: 0,
98 counter: 0
99 };
100
101 s.setResult = function (res)
102 {
103 if (s.hasResult)
104 { return; }
105 s.hasResult = true;
106 if (!res || typeof res.after !== 'number' || !isFinite(res.after))
107 {
108 s.failed = true;
109 return;
110 }
111 var after = Math.max(0, Math.floor(res.after));
112 var before = typeof res.before === 'number' && isFinite(res.before)
113 ? Math.max(0, Math.floor(res.before)) : after;
114 if (before > after)
115 { before = after; }
116 s.before = before;
117 s.after = after;
118 s.earned = after - before;
119 s.counter = before;
120 };
121
122 s.finish = function ()
123 {
124 if (s.phase !== 'hold')
125 { return false; }
126 s.phase = 'done';
127 return true;
128 };
129
130 function enter (phase)
131 {
132 s.phase = phase;
133 s.t = 0;
134 }
135
136 s.tick = function (dt)
137 {
138 var out = { phase: s.phase, counter: s.counter, spawn: [], arrived: 0, done: false };
139 if (s.phase === 'done')
140 {
141 out.done = true;
142 return out;
143 }
144 dt = Math.max(0, Number(dt) || 0);
145 var left = dt;
146 // Allow several phase changes inside one large dt.
147 for (var guard = 0; guard < 8 && left >= 0; guard++)
148 {
149 if (s.phase === 'intro')
150 {
151 if (s.t + left < s.intro)
152 { s.t += left; left = -1; break; }
153 left -= (s.intro - s.t);
154 enter('rise');
155 }
156 else if (s.phase === 'rise')
157 {
158 if (s.t + left < s.rise)
159 { s.t += left; left = -1; break; }
160 left -= (s.rise - s.t);
161 enter('wait');
162 }
163 else if (s.phase === 'wait')
164 {
165 if (!s.hasResult)
166 {
167 s.t += left;
168 if (s.t >= s.waitMax)
169 {
170 s.hasResult = true;
171 s.failed = true;
172 enter('hold');
173 continue;
174 }
175 left = -1;
176 break;
177 }
178 if (s.failed || s.earned <= 0)
179 { enter('hold'); continue; }
180 enter('count');
181 s.countT = 0;
182 }
183 else if (s.phase === 'count')
184 {
185 s.countT += left;
186 left = -1;
187 var sp = spawnedBy(s.countT, s.earned);
188 for (var i = s.spawned; i < sp; i++)
189 { out.spawn.push(i); }
190 s.spawned = sp;
191 var ar = arrivedBy(s.countT, s.earned, s.flight);
192 out.arrived = ar - s.arrived;
193 s.arrived = ar;
194 s.counter = s.before + ar;
195 if (ar >= s.earned)
196 {
197 s.counter = s.after;
198 enter('hold');
199 }
200 break;
201 }
202 else if (s.phase === 'hold')
203 {
204 var need = (s.failed || s.earned <= 0) ? s.holdZero : s.hold;
205 if (s.t + left < need)
206 { s.t += left; left = -1; break; }
207 enter('done');
208 break;
209 }
210 else
211 { break; }
212 }
213 out.phase = s.phase;
214 out.counter = s.counter;
215 out.done = s.phase === 'done';
216 return out;
217 };
218
219 return s;
220}
221
222/* ---------------- DOM / canvas player (browser only) ---------------- */
223
224var active = null;
225
226function reducedMotion ()
227{
228 try
229 {
230 return !!(root.matchMedia && root.matchMedia('(prefers-reduced-motion: reduce)').matches);
231 }
232 catch (e) { return false; }
233}
234
235function tr (key, fallback)
236{
237 if (typeof I18n !== 'undefined' && I18n.t)
238 {
239 var v = I18n.t(key);
240 if (v && v !== key)
241 { return v; }
242 }
243 return fallback;
244}
245
246function planetImages (planet)
247{
248 var list = [];
249 var colors = (planet && planet.colors) || [];
250 for (var i = 0; i < colors.length; i++)
251 {
252 if (!colors[i] || !colors[i].image)
253 { continue; }
254 var img = new Image();
255 img.decoding = 'async';
256 img.src = colors[i].image;
257 list.push({ img: img, hex: colors[i].hex || '#ffffff' });
258 }
259 if (!list.length)
260 { list.push({ img: null, hex: '#ffffff' }); }
261 return list;
262}
263
264/**
265 * Show the reward overlay. opts: { won, planet, result: Promise<{before,
266 * after}|null>, onDone }. Returns a handle with .active and .cancel().
267 */
268function play (opts)
269{
270 opts = opts || {};
271 if (active)
272 { active.cancel(); }
273 var doc = root.document;
274 var overlay = doc.getElementById('reward');
275 var title = doc.getElementById('reward-title');
276 var counter = doc.getElementById('reward-total');
277 var label = doc.getElementById('reward-label');
278 var canvas = doc.getElementById('reward-canvas');
279 var hint = doc.getElementById('reward-hint');
280 if (!overlay || !title || !counter || !canvas)
281 {
282 if (opts.onDone)
283 { opts.onDone(); }
284 return null;
285 }
286 var still = reducedMotion();
287 var seq = createSequence({ won: opts.won, rise: still ? 0 : RISE });
288 var imgs = planetImages(opts.planet);
289 var flying = [];
290 var last = 0;
291 var raf = 0;
292 var pop = 0;
293 var ctx = canvas.getContext('2d');
294 var dpr = Math.min(2, root.devicePixelRatio || 1);
295 var W = 0;
296 var H = 0;
297
298 title.textContent = opts.won ? tr('reward.won', 'You won!') : tr('reward.lost', 'You lost...');
299 title.className = 'reward-title' + (opts.won ? ' won' : ' lost');
300 if (label)
301 { label.textContent = tr('reward.total', 'Total points'); }
302 counter.textContent = '';
303 counter.parentNode.hidden = true;
304 if (hint)
305 { hint.hidden = true; hint.textContent = tr('reward.continue', 'Tap to continue'); }
306 overlay.classList.toggle('reduced', still);
307 overlay.hidden = false;
308
309 function resize ()
310 {
311 W = root.innerWidth || 360;
312 H = root.innerHeight || 640;
313 canvas.width = Math.round(W * dpr);
314 canvas.height = Math.round(H * dpr);
315 canvas.style.width = W + 'px';
316 canvas.style.height = H + 'px';
317 if (ctx)
318 { ctx.setTransform(dpr, 0, 0, dpr, 0, 0); }
319 }
320 resize();
321 root.addEventListener('resize', resize);
322
323 function target ()
324 {
325 var r = counter.getBoundingClientRect();
326 if (r.width > 0)
327 { return { x: r.left + r.width / 2, y: r.top + r.height / 2 }; }
328 return { x: W / 2, y: H - 80 };
329 }
330
331 function spawn ()
332 {
333 var size = Math.max(28, Math.min(56, Math.round(Math.min(W, H) * 0.075)));
334 var sx = size + Math.random() * Math.max(1, W - 2 * size);
335 var sy = -size;
336 var tg = target();
337 // Random arc: control point pushed sideways and up.
338 var mx = (sx + tg.x) / 2 + (Math.random() - 0.5) * W * 0.9;
339 var my = Math.min(sy, tg.y) + (Math.random() * 0.5) * H;
340 flying.push({
341 t: 0,
342 sx: sx, sy: sy, cx: mx, cy: my,
343 pick: imgs[Math.floor(Math.random() * imgs.length)],
344 size: size,
345 rot: (Math.random() - 0.5) * 6
346 });
347 }
348
349 function draw (dt)
350 {
351 if (!ctx)
352 { return; }
353 ctx.clearRect(0, 0, W, H);
354 var tg = target();
355 for (var i = flying.length - 1; i >= 0; i--)
356 {
357 var f = flying[i];
358 f.t += dt / FLIGHT;
359 if (f.t >= 1)
360 {
361 flying.splice(i, 1);
362 continue;
363 }
364 var u = f.t;
365 // Ease in a little so blocks accelerate into the counter.
366 var e = u * u * (3 - 2 * u) * 0.35 + u * 0.65;
367 var a = 1 - e;
368 var x = a * a * f.sx + 2 * a * e * f.cx + e * e * tg.x;
369 var y = a * a * f.sy + 2 * a * e * f.cy + e * e * tg.y;
370 var s = f.size * (1 - 0.45 * e);
371 ctx.save();
372 ctx.translate(x, y);
373 ctx.rotate(f.rot * e);
374 if (f.pick.img && f.pick.img.complete && f.pick.img.naturalWidth)
375 { ctx.drawImage(f.pick.img, -s / 2, -s / 2, s, s); }
376 else
377 {
378 ctx.fillStyle = f.pick.hex;
379 ctx.fillRect(-s / 2, -s / 2, s, s);
380 }
381 ctx.restore();
382 }
383 }
384
385 function setCounter (v)
386 {
387 counter.textContent = String(v);
388 }
389
390 var handle = {
391 active: true,
392 seq: seq,
393 flyingCount: function () { return flying.length; },
394 cancel: function ()
395 { cleanup(false); }
396 };
397
398 function onTap (e)
399 {
400 if (seq.phase !== 'hold')
401 { return; }
402 if (e && e.type === 'keydown' && e.key !== ' ' && e.key !== 'Enter' && e.key !== 'Spacebar')
403 { return; }
404 if (e && e.preventDefault)
405 { e.preventDefault(); }
406 seq.finish();
407 }
408 overlay.addEventListener('pointerup', onTap);
409 doc.addEventListener('keydown', onTap);
410
411 function cleanup (callDone)
412 {
413 if (!handle.active)
414 { return; }
415 handle.active = false;
416 if (raf && root.cancelAnimationFrame)
417 { root.cancelAnimationFrame(raf); }
418 root.removeEventListener('resize', resize);
419 overlay.removeEventListener('pointerup', onTap);
420 doc.removeEventListener('keydown', onTap);
421 overlay.hidden = true;
422 overlay.classList.remove('risen');
423 if (ctx)
424 { ctx.clearRect(0, 0, W, H); }
425 if (active === handle)
426 { active = null; }
427 if (callDone && opts.onDone)
428 { opts.onDone(); }
429 }
430
431 Promise.resolve(opts.result).then(function (res)
432 { seq.setResult(res); }, function ()
433 { seq.setResult(null); });
434
435 function frame (now)
436 {
437 if (!handle.active)
438 { return; }
439 var dt = last ? Math.min(0.1, (now - last) / 1000) : 0;
440 last = now;
441 var prev = seq.phase;
442 var out = seq.tick(dt);
443 if (prev === 'intro' && out.phase !== 'intro')
444 { overlay.classList.add('risen'); }
445 if ((out.phase === 'count' || out.phase === 'hold' || out.phase === 'done')
446 && counter.parentNode.hidden && seq.hasResult && !seq.failed)
447 {
448 counter.parentNode.hidden = false;
449 setCounter(seq.before);
450 }
451 if (!still)
452 {
453 for (var i = 0; i < out.spawn.length; i++)
454 { spawn(); }
455 }
456 if (out.arrived > 0)
457 {
458 pop = 1;
459 setCounter(out.counter);
460 }
461 if (out.phase === 'hold' && !seq.failed)
462 { setCounter(seq.after); }
463 if (out.phase === 'hold' && hint && hint.hidden)
464 { hint.hidden = false; }
465 if (pop > 0)
466 {
467 pop = Math.max(0, pop - dt * 6);
468 counter.style.transform = 'scale(' + (1 + 0.18 * pop).toFixed(3) + ')';
469 }
470 draw(dt);
471 if (out.done)
472 {
473 cleanup(true);
474 return;
475 }
476 raf = root.requestAnimationFrame(frame);
477 }
478 raf = root.requestAnimationFrame(frame);
479 active = handle;
480 return handle;
481}
482
483var Reward = {
484 RATE0: RATE0,
485 ACCEL: ACCEL,
486 INTRO: INTRO,
487 RISE: RISE,
488 FLIGHT: FLIGHT,
489 HOLD: HOLD,
490 HOLD_ZERO: HOLD_ZERO,
491 WAIT_MAX: WAIT_MAX,
492 spawnTime: spawnTime,
493 spawnedBy: spawnedBy,
494 arrivedBy: arrivedBy,
495 countDuration: countDuration,
496 createSequence: createSequence,
497 play: play,
498 isActive: function () { return !!(active && active.active); },
499 /** Read-only snapshot for tests and debugging. */
500 debugState: function ()
501 {
502 if (!active)
503 { return null; }
504 var q = active.seq;
505 return {
506 phase: q.phase, counter: q.counter, before: q.before, after: q.after,
507 earned: q.earned, spawned: q.spawned, arrived: q.arrived,
508 failed: q.failed, won: q.won, flying: active.flyingCount()
509 };
510 }
511};
512
513if (typeof module !== 'undefined' && module.exports)
514{ module.exports = Reward; }
515root.Reward = Reward;
516})(typeof globalThis !== 'undefined' ? globalThis : this);