Spaces:
Running
Running
| // Dewhop core: deterministic simulation (no DOM). A dewdrop sits on a leaf; the next leaf above sways from side to | |
| // side on its vine. One tap makes the drop hop straight up; it lands if the swaying leaf is under it when the hop | |
| // ends (dead centre = a perfect). Miss once and the drop falls: the run is over. Wait too long and the sun dries the | |
| // drop off its leaf. Leaves get narrower and faster; later ones gust (speed up and slow down) or drift. | |
| // Same leaves for everyone each UTC day (seed = date). Fixed 60 Hz ticks. (c) 2026 CyberMax. All rights reserved. | |
| export const HZ = 60; | |
| export const HOP = 16; // ticks a hop takes (the leaf keeps swaying meanwhile: lead your tap) | |
| export const DRY = 5 * HZ; // ticks a drop can wait on one leaf before the sun dries it | |
| export const SETTLE = 14; // ticks after a landing before the next tap counts (the landing splash) | |
| export const X0 = 0.5; // the drop's column (fraction of the width); every leaf sways across it | |
| export function rng(seed) { | |
| let h = 0x811c9dc5; | |
| for (let i = 0; i < seed.length; i++) { h ^= seed.charCodeAt(i); h = Math.imul(h, 0x01000193); } | |
| let a = h >>> 0; | |
| return () => { | |
| a = (a + 0x6d2b79f5) >>> 0; | |
| let t = a; | |
| t = Math.imul(t ^ (t >>> 15), t | 1); | |
| t ^= t + Math.imul(t ^ (t >>> 7), t | 61); | |
| return ((t ^ (t >>> 14)) >>> 0) / 4294967296; | |
| }; | |
| } | |
| /** Leaf i of a seed: half-width w (fraction of the width), sway amplitude a, angular speed s (rad/s), phase ph, | |
| * gust g (the sway speeds up and slows down), side (the vine hangs from the left or the right), hue shift. */ | |
| export function leaf(seed, i) { | |
| const r = rng(`dewhop:${seed}:${i}`); | |
| return { | |
| w: Math.max(0.055, 0.135 - i * 0.0042 - r() * 0.015), | |
| a: Math.min(0.36, 0.2 + i * 0.008 + r() * 0.1), | |
| s: Math.min(3.0, 1.35 + i * 0.06 + r() * 0.35), | |
| ph: r() * Math.PI * 2, | |
| g: i < 5 ? 0 : Math.min(0.55, 0.15 + r() * 0.4), | |
| side: r() < 0.5 ? -1 : 1, | |
| tint: Math.floor(r() * 40) - 20, | |
| }; | |
| } | |
| /** The leaf centre (fraction of the width) after t ticks on it. Never stands still, always crosses the drop's column. */ | |
| export function leafX(l, t) { | |
| const x = t / HZ; | |
| const ang = l.ph + l.s * (x + l.g * Math.sin(x * 2.3) / 2.3); | |
| return X0 + l.a * Math.sin(ang); | |
| } | |
| /** Judge a landing: 'perfect' (middle third of the leaf), 'good' (on the leaf) or 'miss'. */ | |
| export function judge(l, t) { | |
| const d = Math.abs(leafX(l, t) - X0); | |
| return d <= l.w / 3 ? 'perfect' : d <= l.w ? 'good' : 'miss'; | |
| } | |
| /** A run: step(tap) once per tick; returns 'perfect' | 'good' | 'miss' | 'dry' | ''. */ | |
| export function makeSim(seed) { | |
| return { | |
| seed, i: 0, t: 0, wait: 0, hop: 0, cur: leaf(seed, 0), marks: [], score: 0, perfect: 0, streak: 0, best: 0, dead: false, last: '', dried: false, | |
| step(tap) { | |
| if (this.dead) return ''; | |
| this.t++; | |
| if (this.wait > 0) { this.wait--; return ''; } | |
| if (this.hop > 0) { | |
| if (--this.hop > 0) return ''; | |
| const res = judge(this.cur, this.t); | |
| this.marks.push(res); this.last = res; | |
| if (res === 'miss') { this.dead = true; return res; } | |
| this.score++; | |
| if (res === 'perfect') { this.perfect++; this.streak++; this.best = Math.max(this.best, this.streak); } else this.streak = 0; | |
| this.i++; this.cur = leaf(this.seed, this.i); this.t = 0; this.wait = SETTLE; | |
| return res; | |
| } | |
| if (tap) { this.hop = HOP; return ''; } | |
| if (this.t > DRY) { this.marks.push('miss'); this.last = 'dry'; this.dried = true; this.dead = true; return 'dry'; } | |
| return ''; | |
| }, | |
| }; | |
| } | |
| /** Emoji rows for the share text: 🟩 perfect, 🟨 good, 🟥 the miss that ended the run (rows of 10). */ | |
| export function grid(marks) { | |
| const e = marks.map((m) => (m === 'perfect' ? '🟩' : m === 'good' ? '🟨' : '🟥')); | |
| const rows = []; | |
| for (let i = 0; i < e.length; i += 10) rows.push(e.slice(i, i + 10).join('')); | |
| return rows.join('\n'); | |
| } | |
| /** Ticks from now (on leaf l at tick t) until a tap would land dead centre: the bot and the fairness tests use it. */ | |
| export function bestTap(l, t, horizon = 4 * HZ) { | |
| let best = null; | |
| for (let k = 0; k < horizon; k++) { | |
| const d = Math.abs(leafX(l, t + k + 1 + HOP) - X0); // the tap tick, then HOP ticks of hop | |
| if (best === null || d < best.d - 1e-9) best = { k, d }; | |
| if (d < l.w / 6) return { k, d }; | |
| } | |
| return best; | |
| } | |