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