BlueGit

projects-timfalken-com meteors

Files

meteors / src / reward.js

reward.js

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