minimojs 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/minimo-ambient.js

@@ -0,0 +1,1445 @@
+import { DrawSprite, Sprite } from "./minimo.js";
+// Particles per million screen pixels at intensity 1.
+const RAIN_DENSITY = 480;
+const SNOW_DENSITY = 340;
+const DRIFT_IMAGE_DENSITY = 90;
+const DRIFT_DOT_DENSITY = 110;
+// Lightning never strikes closer together than this, and a strike flashes at
+// most twice, so flashes stay under WCAG 2.3.1's three per second.
+const MIN_STRIKE_GAP = 1.25;
+const SNOW_COLUMN = 4;
+const SNOW_SETTLE_SPEED = 1.1;
+const NUMERIC_FIELDS = [
+    "wind",
+    "gusts",
+    "rain",
+    "snow",
+    "fog",
+    "storm",
+    "darkness",
+    "tint",
+    "stars",
+];
+const WEATHER_FIELDS = ["wind", "gusts", "rain", "snow", "fog", "storm"];
+const PRESETS = {
+    clear: {},
+    drizzle: { rain: 0.25, wind: 0.1 },
+    rain: { rain: 0.6, wind: 0.2, gusts: 0.2 },
+    storm: { rain: 1, wind: 0.5, gusts: 0.6, storm: 0.6, fog: 0.2 },
+    snow: { snow: 0.5, wind: 0.1 },
+    blizzard: { snow: 1, wind: 0.8, gusts: 0.7, fog: 0.4 },
+    mist: { fog: 0.6, wind: 0.05 },
+    windy: { wind: 0.7, gusts: 0.8 },
+};
+/**
+ * A stream of leaves, petals, embers, bubbles, fireflies, or dust, created by
+ * {@link Ambient.addDrift}. It shares the ambient's wind and parallax.
+ */
+export class AmbientDrift {
+    /** @internal */
+    constructor(options) {
+        /** @internal */ this._particles = [];
+        /** @internal */ this._tween = null;
+        const motion = options.motion;
+        const dot = options.dot
+            ? { color: options.dot.color, radius: options.dot.radius ?? 2, glow: options.dot.glow ?? 0 }
+            : null;
+        const size = typeof options.size === "number" ? [options.size, options.size] : options.size ?? [16, 32];
+        this._options = {
+            motion,
+            images: options.images ?? [],
+            dot,
+            amount: clamp01(options.amount ?? 0.5),
+            size,
+            speed: options.speed ?? 1,
+            spin: options.spin ?? (motion === "fall" ? 1 : 0),
+            sway: options.sway ?? 1,
+            wind: options.wind ?? (motion === "fall" ? 1 : 0.5),
+            twinkle: clamp01(options.twinkle ?? 0),
+            lit: options.lit ?? (dot !== null && dot.glow > 0),
+            fade: options.fade ?? dot !== null,
+        };
+        this._amount = this._options.amount;
+    }
+    /** How the drift moves. */
+    get motion() {
+        return this._options.motion;
+    }
+    /** Density from `0` to `1`. Setting it stops a running {@link AmbientDrift.to}. */
+    get amount() {
+        return this._amount;
+    }
+    set amount(value) {
+        this._finishTween();
+        this._amount = clamp01(value);
+    }
+    /**
+     * Changes the density over `durationMs` milliseconds. The promise resolves
+     * when the amount arrives, or when a later change takes over.
+     */
+    to(amount, durationMs) {
+        this._finishTween();
+        const target = clamp01(amount);
+        if (!(durationMs > 0)) {
+            this._amount = target;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this._tween = { from: this._amount, to: target, elapsed: 0, duration: durationMs, resolve };
+        });
+    }
+    /** @internal */
+    _advance(dtMs) {
+        const tween = this._tween;
+        if (!tween)
+            return;
+        tween.elapsed += dtMs;
+        const k = Math.min(1, tween.elapsed / tween.duration);
+        this._amount = tween.from + (tween.to - tween.from) * smooth(k);
+        if (k >= 1)
+            this._finishTween();
+    }
+    /** @internal */
+    _finishTween() {
+        const tween = this._tween;
+        this._tween = null;
+        tween?.resolve();
+    }
+}
+/**
+ * Weather and atmosphere for a game: rain, snow, wind, fog, lightning,
+ * drifting leaves or fireflies, and the light of the hour.
+ *
+ * One shared state of intensities drives every effect, and every effect reads
+ * the same wind. All particles are painted into two canvas-sized surfaces, one
+ * behind the play field and one in front of it, so the module adds two sprites
+ * to the game whatever the weather.
+ *
+ * The ambient never moves a game sprite. The wind reaches the game only through
+ * {@link Ambient.windX}, which the game applies where it wants.
+ *
+ * Call {@link Ambient.update} once per frame. An ambient survives
+ * {@link Game.reset}: it puts its surfaces back on its next update and keeps
+ * its weather, so one ambient can serve every scene. Creating a new one in a
+ * scene's `onCreate` also works.
+ *
+ * @example
+ * ```ts
+ * const ambient = new Ambient(game, { surfaces: [ground], seed: 7 });
+ * ambient.preset("rain");
+ *
+ * // in onUpdate(dt)
+ * ambient.update(dt);
+ *
+ * // later: a storm rolls in over four seconds
+ * await ambient.to({ rain: 1, storm: 0.6, wind: 0.5 }, 4000);
+ * ```
+ */
+export class Ambient {
+    /**
+     * Creates an ambient and adds its two surfaces to the game.
+     *
+     * @param game - The game to draw into.
+     * @param options - Layers, surfaces, shelters, seed, colors, and initial state.
+     */
+    constructor(game, options = {}) {
+        /**
+         * Called on every lightning strike, for thunder, a camera shake, or a
+         * gameplay reaction.
+         */
+        this.onLightning = null;
+        /** @internal */ this._tweens = [];
+        /** @internal */ this._drifts = [];
+        /** @internal */ this._rain = [];
+        /** @internal */ this._snow = [];
+        /** @internal */ this._fog = [];
+        /** @internal */ this._stars = [];
+        /** @internal */ this._splashes = [];
+        /** @internal */ this._bolts = [];
+        /** @internal */ this._flashes = [];
+        /** @internal */ this._snowCover = new Map();
+        /** @internal */ this._dotTextures = new Map();
+        /** @internal */ this._fogTexture = null;
+        /** @internal */ this._lines = [];
+        /** @internal */ this._rects = [];
+        /** @internal */ this._time = 0;
+        /** @internal */ this._windX = 0;
+        /** @internal */ this._nextStrike = 0;
+        /** @internal */ this._destroyed = false;
+        /** @internal */
+        this._spawnRain = (particle, anywhere) => {
+            const W = this._game.width;
+            const H = this._game.height;
+            particle.x = this._random() * (W + 80) - 40;
+            particle.y = anywhere ? this._random() * H : -20 - this._random() * 120;
+            particle.vy = (950 + this._random() * 350) * (0.55 + 0.45 * particle.p);
+        };
+        /** @internal */
+        this._spawnSnow = (particle, anywhere) => {
+            const W = this._game.width;
+            const H = this._game.height;
+            particle.x = this._random() * (W + 80) - 40;
+            particle.y = anywhere ? this._random() * H : -10 - this._random() * 60;
+            particle.vy = (45 + this._random() * 55) * (0.5 + 0.5 * particle.p);
+            particle.size = 1.6 + this._random() * 2.2;
+            particle.spin = 0.6 + this._random() * 1.2;
+        };
+        this._game = game;
+        const seed = options.seed;
+        this._random = typeof seed === "number" && Number.isFinite(seed) ? seededRandom(seed) : Math.random;
+        this._frontShare = clamp01(options.front ?? 0.25);
+        this._windStrength = options.windStrength ?? 600;
+        this._maxSnowDepth = options.maxSnowDepth ?? 16;
+        this._fogColor = options.fogColor ?? "#dde5ee";
+        this._rainColor = options.rainColor ?? "#c8d6ea";
+        this._snowColor = options.snowColor ?? "#ffffff";
+        this.surfaces = options.surfaces ?? [];
+        this.shelters = options.shelters ?? [];
+        this.snowSettles = options.snowSettles ?? false;
+        this.reducedMotion = options.reducedMotion ?? prefersReducedMotion();
+        let maxParticles = options.maxParticles ?? 900;
+        const cores = typeof navigator !== "undefined" ? navigator.hardwareConcurrency ?? 8 : 8;
+        if (game.isMobileDevice() && cores <= 4)
+            maxParticles = Math.round(maxParticles * 0.6);
+        this._maxParticles = maxParticles;
+        this._state = {
+            wind: 0,
+            gusts: 0,
+            rain: 0,
+            snow: 0,
+            fog: 0,
+            storm: 0,
+            darkness: 0,
+            tint: 0,
+            stars: 0,
+            tintColor: "#1b2a55",
+        };
+        this._tint = parseHex(this._state.tintColor);
+        if (options.state)
+            this.set(options.state);
+        this._gustPhases = [0, 0, 0].map(() => this._random() * Math.PI * 2);
+        this._nextStrike = this._strikeDelay();
+        this._lastScrollX = game.scrollX;
+        this._lastScrollY = game.scrollY;
+        const W = game.width;
+        const H = game.height;
+        this._back = new DrawSprite(W, H, W / 2, H / 2);
+        this._front = new DrawSprite(W, H, W / 2, H / 2);
+        for (const surface of [this._back, this._front]) {
+            surface.ignoreScroll = true;
+            surface.isStatic = true;
+            surface.gravityScale = 0;
+        }
+        this._back.layer = options.backLayer ?? 5;
+        this._front.layer = options.frontLayer ?? 900;
+        this._back.redraw = (ctx) => this._paintBack(ctx);
+        this._front.redraw = (ctx) => this._paintFront(ctx);
+        game.add(this._back);
+        game.add(this._front);
+        this._createFog();
+        this._createStars();
+    }
+    /** The current state. Read-only: change it with {@link Ambient.set}, {@link Ambient.to}, or {@link Ambient.preset}. */
+    get state() {
+        return this._state;
+    }
+    /**
+     * The wind at this frame, gusts included, in pixels per second. Positive
+     * blows right. This is the only way the weather reaches the game's sprites:
+     *
+     * ```ts
+     * player.vx += ambient.windX * 0.3 * dt;
+     * ```
+     */
+    get windX() {
+        return this._windX;
+    }
+    /** `true` while any {@link Ambient.to} or {@link Ambient.preset} transition is running. */
+    get isTransitioning() {
+        return this._tweens.length > 0;
+    }
+    /** Changes state fields at once. Fields left out keep their value. */
+    set(change) {
+        this._takeOver(change);
+        for (const field of NUMERIC_FIELDS) {
+            const value = change[field];
+            if (typeof value === "number")
+                this._state[field] = clampField(field, value);
+        }
+        if (typeof change.tintColor === "string") {
+            this._tint = parseHex(change.tintColor);
+            this._state.tintColor = toHex(this._tint);
+        }
+    }
+    /**
+     * Changes state fields over `durationMs` milliseconds with an ease in and
+     * out. Fields left out keep their value and any transition they are in.
+     *
+     * A field that is already moving starts from wherever it is, so a new call
+     * can interrupt an old one without a jump. The promise resolves when every
+     * field arrives, or when later calls have taken all of them over.
+     */
+    to(change, durationMs) {
+        if (!(durationMs > 0)) {
+            this.set(change);
+            return Promise.resolve();
+        }
+        this._takeOver(change);
+        const numbers = new Map();
+        for (const field of NUMERIC_FIELDS) {
+            const value = change[field];
+            if (typeof value === "number")
+                numbers.set(field, { from: this._state[field], to: clampField(field, value) });
+        }
+        const color = typeof change.tintColor === "string" ? { from: { ...this._tint }, to: parseHex(change.tintColor) } : null;
+        if (numbers.size === 0 && !color)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            this._tweens.push({ numbers, color, elapsed: 0, duration: durationMs, resolve });
+        });
+    }
+    /**
+     * Moves to a named weather. The preset's fields are set, and the other
+     * weather fields (`wind`, `gusts`, `rain`, `snow`, `fog`, `storm`) go to `0`.
+     * Light fields are left alone, because weather and time of day are
+     * independent.
+     *
+     * @param name - The preset.
+     * @param durationMs - Transition length in milliseconds. `0`, the default, changes at once.
+     */
+    preset(name, durationMs = 0) {
+        const values = PRESETS[name];
+        if (!values)
+            throw new Error(`MinimoJS ambient: unknown preset '${String(name)}'.`);
+        const change = {};
+        for (const field of WEATHER_FIELDS)
+            change[field] = values[field] ?? 0;
+        return this.to(change, durationMs);
+    }
+    /**
+     * Adds a stream of drifting things: leaves, petals, embers, bubbles,
+     * fireflies, or dust. Images must already be loaded or created.
+     *
+     * @example
+     * ```ts
+     * const leaves = ambient.addDrift({ images: ["leaf-red", "leaf-gold"], motion: "fall", amount: 0.5 });
+     * const fireflies = ambient.addDrift({ dot: { color: "#fff6a0", glow: 8 }, motion: "hover", twinkle: 1 });
+     * ```
+     */
+    addDrift(options) {
+        const hasImages = Array.isArray(options.images) && options.images.length > 0;
+        if (hasImages === Boolean(options.dot)) {
+            throw new Error("MinimoJS ambient: a drift needs either images or a dot, and not both.");
+        }
+        for (const key of options.images ?? []) {
+            if (!this._game.hasImage(key)) {
+                throw new Error(`MinimoJS ambient: drift image '${key}' is not loaded. Load it in onPreload or create it with game.createTexture first.`);
+            }
+        }
+        const drift = new AmbientDrift(options);
+        this._drifts.push(drift);
+        return drift;
+    }
+    /** Removes a drift at once. Fade it out first with `drift.to(0, ms)` for a gentle exit. */
+    removeDrift(drift) {
+        const index = this._drifts.indexOf(drift);
+        if (index !== -1)
+            this._drifts.splice(index, 1);
+        drift._finishTween();
+    }
+    /** Removes all settled snow at once. */
+    clearSnow() {
+        this._snowCover.clear();
+    }
+    /**
+     * Depth of settled snow in pixels on a surface at world X, `0` where there
+     * is none. Useful for footprints, or for slowing a player in deep snow.
+     */
+    snowDepthAt(surface, worldX) {
+        const line = this._resolveLine(surface);
+        const cover = this._snowCover.get(surface);
+        if (!line || !cover)
+            return 0;
+        const column = Math.floor((worldX - line.left) / SNOW_COLUMN);
+        return column >= 0 && column < cover.depth.length ? cover.depth[column] : 0;
+    }
+    /**
+     * Advances the weather by `dt` seconds. Call it once per frame from the
+     * scene's `onUpdate`. Transition promises resolve from here.
+     */
+    update(dt) {
+        if (this._destroyed)
+            return;
+        const game = this._game;
+        const sprites = game.getSprites();
+        if (!sprites.includes(this._back))
+            game.add(this._back);
+        if (!sprites.includes(this._front))
+            game.add(this._front);
+        const dtMs = dt * 1000;
+        this._time += dt;
+        this._advanceTweens(dtMs);
+        for (const drift of this._drifts)
+            drift._advance(dtMs);
+        const W = game.width;
+        const H = game.height;
+        let dsx = game.scrollX - this._lastScrollX;
+        let dsy = game.scrollY - this._lastScrollY;
+        // A jump larger than the screen is a reset or a teleport, not camera motion.
+        if (Math.abs(dsx) > W)
+            dsx = 0;
+        if (Math.abs(dsy) > H)
+            dsy = 0;
+        this._lastScrollX = game.scrollX;
+        this._lastScrollY = game.scrollY;
+        this._resolveWorld();
+        this._updateWind();
+        this._updateRain(dt, dsx, dsy);
+        this._updateSnow(dt, dsx, dsy);
+        for (const drift of this._drifts)
+            this._updateDrift(drift, dt, dsx, dsy);
+        this._updateFog(dt, dsx, dsy);
+        this._updateStars(dsx, dsy);
+        this._updateSplashes(dt);
+        this._updateSnowCover(dt);
+        this._updateLightning(dt);
+        const s = this._state;
+        const light = s.darkness > 0.001 || s.tint > 0.001 || s.fog > 0.001;
+        const hasSnowCover = this._snowCover.size > 0;
+        this._back.visible =
+            this._rain.length > 0 || this._snow.length > 0 || this._drifts.length > 0 || s.fog > 0.001 || s.stars > 0.001 || this._bolts.length > 0;
+        this._front.visible =
+            this._back.visible || light || hasSnowCover || this._splashes.length > 0 || this._flashes.length > 0;
+    }
+    /** Removes both surfaces from the game and resolves every pending transition. The ambient does nothing afterwards. */
+    destroy() {
+        if (this._destroyed)
+            return;
+        this._destroyed = true;
+        this._game.destroySprite(this._back);
+        this._game.destroySprite(this._front);
+        for (const tween of this._tweens)
+            tween.resolve();
+        this._tweens = [];
+        for (const drift of this._drifts)
+            drift._finishTween();
+    }
+    // ---------------------------------------------------------------------------
+    // State and transitions
+    // ---------------------------------------------------------------------------
+    /** @internal */
+    _takeOver(change) {
+        for (const tween of this._tweens) {
+            for (const field of NUMERIC_FIELDS) {
+                if (typeof change[field] === "number")
+                    tween.numbers.delete(field);
+            }
+            if (typeof change.tintColor === "string")
+                tween.color = null;
+        }
+        this._tweens = this._tweens.filter((tween) => {
+            if (tween.numbers.size > 0 || tween.color)
+                return true;
+            tween.resolve();
+            return false;
+        });
+    }
+    /** @internal */
+    _advanceTweens(dtMs) {
+        if (this._tweens.length === 0)
+            return;
+        const done = [];
+        for (const tween of this._tweens) {
+            tween.elapsed += dtMs;
+            const k = Math.min(1, tween.elapsed / tween.duration);
+            const e = smooth(k);
+            for (const [field, range] of tween.numbers) {
+                this._state[field] = range.from + (range.to - range.from) * e;
+            }
+            if (tween.color) {
+                const { from, to } = tween.color;
+                this._tint = {
+                    r: from.r + (to.r - from.r) * e,
+                    g: from.g + (to.g - from.g) * e,
+                    b: from.b + (to.b - from.b) * e,
+                };
+                this._state.tintColor = toHex(this._tint);
+            }
+            if (k >= 1)
+                done.push(tween);
+        }
+        if (done.length === 0)
+            return;
+        this._tweens = this._tweens.filter((tween) => !done.includes(tween));
+        for (const tween of done)
+            tween.resolve();
+    }
+    // ---------------------------------------------------------------------------
+    // World: surfaces and shelters
+    // ---------------------------------------------------------------------------
+    /** @internal */
+    _resolveLine(surface) {
+        if (surface instanceof Sprite) {
+            const half = surface.bodyDisplayWidth / 2;
+            return {
+                key: surface,
+                left: surface.bodyCenterX - half,
+                right: surface.bodyCenterX + half,
+                y: surface.bodyCenterY - surface.bodyDisplayHeight / 2,
+            };
+        }
+        if (!surface || !Number.isFinite(surface.left) || !Number.isFinite(surface.right) || !Number.isFinite(surface.y)) {
+            return null;
+        }
+        return { key: surface, left: Math.min(surface.left, surface.right), right: Math.max(surface.left, surface.right), y: surface.y };
+    }
+    /** @internal */
+    _resolveWorld() {
+        this._lines = [];
+        for (const surface of this.surfaces) {
+            const line = this._resolveLine(surface);
+            if (line && line.right > line.left)
+                this._lines.push(line);
+        }
+        this._rects = [];
+        for (const shelter of this.shelters) {
+            if (shelter instanceof Sprite) {
+                const hw = shelter.bodyDisplayWidth / 2;
+                const hh = shelter.bodyDisplayHeight / 2;
+                this._rects.push({
+                    left: shelter.bodyCenterX - hw,
+                    top: shelter.bodyCenterY - hh,
+                    right: shelter.bodyCenterX + hw,
+                    bottom: shelter.bodyCenterY + hh,
+                });
+            }
+            else if (shelter) {
+                this._rects.push(shelter);
+            }
+        }
+        // Forget settled snow on surfaces that are no longer listed.
+        if (this._snowCover.size > 0) {
+            for (const key of this._snowCover.keys()) {
+                if (!this._lines.some((line) => line.key === key))
+                    this._snowCover.delete(key);
+            }
+        }
+    }
+    /** @internal */
+    _sheltered(wx, wy) {
+        for (const rect of this._rects) {
+            if (wx >= rect.left && wx <= rect.right && wy >= rect.top && wy <= rect.bottom)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Finds the surface a particle crossed this frame, moving from world Y
+     * `fromY` to `toY` at world X `wx`. Returns the world Y of the landing
+     * point, on top of any settled snow, or `null`.
+     * @internal
+     */
+    _landing(wx, fromY, toY) {
+        let best = null;
+        for (const line of this._lines) {
+            if (wx < line.left || wx > line.right)
+                continue;
+            const top = line.y - this._coverDepth(line, wx);
+            if (fromY <= top && toY >= top && (!best || top < best.y))
+                best = { y: top, line };
+        }
+        return best;
+    }
+    /** @internal */
+    _coverDepth(line, wx) {
+        const cover = this._snowCover.get(line.key);
+        if (!cover)
+            return 0;
+        const column = Math.floor((wx - line.left) / SNOW_COLUMN);
+        return column >= 0 && column < cover.depth.length ? cover.depth[column] : 0;
+    }
+    // ---------------------------------------------------------------------------
+    // Wind
+    // ---------------------------------------------------------------------------
+    /** @internal */
+    _updateWind() {
+        const t = this._time;
+        const [a, b, c] = this._gustPhases;
+        const g1 = Math.sin(t * 0.63 + a) * 0.55 + Math.sin(t * 1.71 + b) * 0.3 + Math.sin(t * 4.1 + c) * 0.15;
+        const g2 = Math.sin(t * 0.37 + b) * 0.6 + Math.sin(t * 2.3 + c) * 0.4;
+        const { wind, gusts } = this._state;
+        this._windX = this._windStrength * (wind * (1 + 0.85 * gusts * g1) + 0.25 * gusts * g2);
+    }
+    // ---------------------------------------------------------------------------
+    // Particles
+    // ---------------------------------------------------------------------------
+    /** @internal */
+    _budget() {
+        const area = (this._game.width * this._game.height) / 1000000;
+        const s = this._state;
+        let wanted = (s.rain * RAIN_DENSITY + s.snow * SNOW_DENSITY) * area;
+        for (const drift of this._drifts)
+            wanted += drift._amount * this._driftDensity(drift) * area;
+        const scale = wanted > this._maxParticles ? this._maxParticles / wanted : 1;
+        return this.reducedMotion ? scale * 0.5 : scale;
+    }
+    /** @internal */
+    _driftDensity(drift) {
+        return drift._options.dot ? DRIFT_DOT_DENSITY : DRIFT_IMAGE_DENSITY;
+    }
+    /** @internal */
+    _depth() {
+        const r = this._random();
+        return r < this._frontShare ? 1 + this._random() * 0.4 : 0.3 + this._random() * 0.7;
+    }
+    /** @internal */
+    _newParticle() {
+        return {
+            x: 0,
+            y: 0,
+            p: this._depth(),
+            vx: 0,
+            vy: 0,
+            size: 1,
+            phase: this._random() * Math.PI * 2,
+            spin: 0,
+            rotation: this._random() * 360,
+            image: 0,
+            fade: 0,
+            age: 0,
+            life: 0,
+            resting: 0,
+            wx: 0,
+            wy: 0,
+        };
+    }
+    /**
+     * Grows or shrinks a pool toward `target`: new particles fade in where they
+     * spawn, and particles beyond the target fade out, so intensity changes
+     * never pop.
+     * @internal
+     */
+    _fit(pool, target, dt, spawn) {
+        const count = Math.max(0, Math.round(target));
+        while (pool.length < count) {
+            const particle = this._newParticle();
+            spawn(particle, true);
+            pool.push(particle);
+        }
+        for (let i = 0; i < pool.length; i++) {
+            const particle = pool[i];
+            particle.fade = i < count ? Math.min(1, particle.fade + dt / 0.5) : particle.fade - dt / 0.6;
+        }
+        while (pool.length > count && pool[pool.length - 1].fade <= 0)
+            pool.pop();
+    }
+    /** @internal */
+    _shift(particle, dsx, dsy) {
+        particle.x -= dsx * particle.p;
+        particle.y -= dsy * particle.p;
+    }
+    /** @internal */
+    _wrapX(particle, margin) {
+        const W = this._game.width;
+        if (particle.x < -margin)
+            particle.x += W + margin * 2;
+        else if (particle.x > W + margin)
+            particle.x -= W + margin * 2;
+    }
+    /** @internal */
+    _updateRain(dt, dsx, dsy) {
+        const area = (this._game.width * this._game.height) / 1000000;
+        this._fit(this._rain, this._state.rain * RAIN_DENSITY * area * this._budget(), dt, this._spawnRain);
+        const H = this._game.height;
+        const { scrollX, scrollY } = this._game;
+        for (const drop of this._rain) {
+            this._shift(drop, dsx, dsy);
+            drop.vx = this._windX * (0.6 + 0.4 * drop.p);
+            const fromY = drop.y + scrollY;
+            drop.x += drop.vx * dt;
+            drop.y += drop.vy * dt;
+            this._wrapX(drop, 40);
+            const wx = drop.x + scrollX;
+            const wy = drop.y + scrollY;
+            if (drop.p >= 0.8 && drop.p <= 1.2) {
+                const landing = this._landing(wx, fromY, wy);
+                if (landing) {
+                    if (drop.fade > 0.5 && !this._sheltered(wx, landing.y - 1))
+                        this._addSplash(wx, landing.y, drop.p);
+                    this._spawnRain(drop, false);
+                    continue;
+                }
+            }
+            if (drop.y > H + 40 || this._sheltered(wx, wy))
+                this._spawnRain(drop, false);
+        }
+    }
+    /** @internal */
+    _updateSnow(dt, dsx, dsy) {
+        const area = (this._game.width * this._game.height) / 1000000;
+        this._fit(this._snow, this._state.snow * SNOW_DENSITY * area * this._budget(), dt, this._spawnSnow);
+        const H = this._game.height;
+        const { scrollX, scrollY } = this._game;
+        const t = this._time;
+        for (const flake of this._snow) {
+            this._shift(flake, dsx, dsy);
+            const sway = Math.sin(t * flake.spin + flake.phase) * 22;
+            flake.vx = this._windX * (0.5 + 0.5 * flake.p) * 0.9 + sway;
+            const fromY = flake.y + scrollY;
+            flake.x += flake.vx * dt;
+            flake.y += flake.vy * (1 + Math.abs(this._windX) / 1400) * dt;
+            this._wrapX(flake, 40);
+            const wx = flake.x + scrollX;
+            const wy = flake.y + scrollY;
+            if (flake.p >= 0.8 && flake.p <= 1.2) {
+                const landing = this._landing(wx, fromY, wy);
+                if (landing) {
+                    if (this.snowSettles && !this._sheltered(wx, landing.y - 1))
+                        this._settleFlake(landing.line, wx);
+                    this._spawnSnow(flake, false);
+                    continue;
+                }
+            }
+            if (flake.y > H + 20 || this._sheltered(wx, wy))
+                this._spawnSnow(flake, false);
+        }
+    }
+    /** @internal */
+    _spawnDrift(drift) {
+        return (particle, anywhere) => {
+            const W = this._game.width;
+            const H = this._game.height;
+            const o = drift._options;
+            particle.resting = 0;
+            particle.age = 0;
+            particle.x = this._random() * (W + 80) - 40;
+            if (o.motion === "fall")
+                particle.y = anywhere ? this._random() * H : -30 - this._random() * 80;
+            else if (o.motion === "rise" && o.fade)
+                particle.y = H * (anywhere ? this._random() : 0.35 + this._random() * 0.65);
+            else if (o.motion === "rise")
+                particle.y = anywhere ? this._random() * H : H + 20 + this._random() * 60;
+            else
+                particle.y = this._random() * H;
+            const [min, max] = o.size;
+            particle.size = min + this._random() * (max - min);
+            particle.image = Math.floor(this._random() * Math.max(1, o.images.length));
+            particle.spin = (this._random() < 0.5 ? -1 : 1) * (0.6 + this._random() * 0.8);
+            const base = o.motion === "fall" ? 55 + this._random() * 45 : o.motion === "rise" ? 40 + this._random() * 50 : 0;
+            particle.vy = base * o.speed * (0.5 + 0.5 * particle.p) * (o.motion === "rise" ? -1 : 1);
+            particle.life = (2.5 + this._random() * 3.5) / Math.max(0.2, o.speed);
+            particle.vx = 0;
+        };
+    }
+    /** @internal */
+    _updateDrift(drift, dt, dsx, dsy) {
+        const area = (this._game.width * this._game.height) / 1000000;
+        const spawn = this._spawnDrift(drift);
+        this._fit(drift._particles, drift._amount * this._driftDensity(drift) * area * this._budget(), dt, spawn);
+        const o = drift._options;
+        const W = this._game.width;
+        const H = this._game.height;
+        const { scrollX, scrollY } = this._game;
+        const t = this._time;
+        for (const particle of drift._particles) {
+            particle.age += dt;
+            if (particle.resting > 0) {
+                particle.resting -= dt;
+                particle.x = particle.wx - scrollX;
+                particle.y = particle.wy - scrollY;
+                if (particle.resting <= 0)
+                    spawn(particle, false);
+                continue;
+            }
+            this._shift(particle, dsx, dsy);
+            const wind = this._windX * o.wind * (0.5 + 0.5 * particle.p);
+            const sway = Math.sin(t * 1.3 * particle.spin + particle.phase) * 38 * o.sway;
+            if (o.motion === "fall") {
+                particle.vx = wind + sway;
+                particle.rotation += particle.spin * 140 * o.spin * dt + Math.sin(t * 2 + particle.phase) * 40 * o.spin * dt;
+            }
+            else if (o.motion === "rise") {
+                particle.vx = wind + sway * 0.5;
+                particle.vy -= 12 * o.speed * dt;
+                particle.rotation += particle.spin * 60 * o.spin * dt;
+            }
+            else {
+                const n = t * 0.5 * particle.spin + particle.phase;
+                particle.vx = Math.cos(n) * 22 * o.speed + wind * 0.6;
+                particle.vy = Math.sin(n * 1.37) * 16 * o.speed;
+                particle.rotation += particle.spin * 30 * o.spin * dt;
+            }
+            const fromY = particle.y + scrollY;
+            particle.x += particle.vx * dt;
+            particle.y += particle.vy * dt;
+            this._wrapX(particle, 60);
+            const wx = particle.x + scrollX;
+            const wy = particle.y + scrollY;
+            if (o.motion === "fall") {
+                if (particle.p >= 0.8 && particle.p <= 1.2) {
+                    const landing = this._landing(wx, fromY, wy);
+                    if (landing && !this._sheltered(wx, landing.y - 1)) {
+                        particle.wx = wx;
+                        particle.wy = landing.y - particle.size * 0.2;
+                        particle.resting = 2 + this._random() * 3;
+                        particle.life = particle.resting;
+                        continue;
+                    }
+                }
+                if (particle.y > H + 60 || this._sheltered(wx, wy))
+                    spawn(particle, false);
+            }
+            else if (o.motion === "rise") {
+                if (particle.y < -60 || (o.fade && particle.age > particle.life))
+                    spawn(particle, false);
+            }
+            else {
+                if (particle.y < -40)
+                    particle.y += H + 80;
+                else if (particle.y > H + 40)
+                    particle.y -= H + 80;
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Splashes and settled snow
+    // ---------------------------------------------------------------------------
+    /** @internal */
+    _addSplash(wx, wy, p) {
+        if (this._splashes.length >= 90)
+            return;
+        const drops = [];
+        const count = this._random() < 0.5 ? 2 : 3;
+        for (let i = 0; i < count; i++) {
+            drops.push({
+                x: 0,
+                y: 0,
+                vx: (this._random() - 0.5) * 140 + this._windX * 0.1,
+                vy: -(70 + this._random() * 90),
+            });
+        }
+        this._splashes.push({ x: wx, y: wy, age: 0, size: p, drops });
+    }
+    /** @internal */
+    _updateSplashes(dt) {
+        for (let i = this._splashes.length - 1; i >= 0; i--) {
+            const splash = this._splashes[i];
+            splash.age += dt;
+            for (const drop of splash.drops) {
+                drop.vy += 900 * dt;
+                drop.x += drop.vx * dt;
+                drop.y += drop.vy * dt;
+            }
+            if (splash.age > 0.32)
+                this._splashes.splice(i, 1);
+        }
+    }
+    /** @internal */
+    _cover(line) {
+        const columns = Math.max(1, Math.ceil((line.right - line.left) / SNOW_COLUMN));
+        let cover = this._snowCover.get(line.key);
+        if (!cover || cover.depth.length !== columns) {
+            const noise = new Float32Array(columns);
+            let value = this._random();
+            for (let i = 0; i < columns; i++) {
+                value += (this._random() - 0.5) * 0.35;
+                value = Math.max(0, Math.min(1, value));
+                noise[i] = 0.6 + value * 0.8;
+            }
+            cover = { depth: new Float32Array(columns), noise };
+            this._snowCover.set(line.key, cover);
+        }
+        return cover;
+    }
+    /** @internal */
+    _settleFlake(line, wx) {
+        const cover = this._cover(line);
+        const column = Math.floor((wx - line.left) / SNOW_COLUMN);
+        for (let i = -2; i <= 2; i++) {
+            const c = column + i;
+            if (c < 0 || c >= cover.depth.length)
+                continue;
+            cover.depth[c] = Math.min(this._maxSnowDepth, cover.depth[c] + (i === 0 ? 0.25 : 0.1));
+        }
+    }
+    /** @internal */
+    _covered(line, wx) {
+        if (this._sheltered(wx, line.y - 2))
+            return true;
+        for (const other of this._lines) {
+            if (other !== line && wx >= other.left && wx <= other.right && other.y < line.y - 2)
+                return true;
+        }
+        return false;
+    }
+    /** @internal */
+    _updateSnowCover(dt) {
+        const s = this._state;
+        const snowing = this.snowSettles && s.snow > 0.02;
+        if (!snowing && this._snowCover.size === 0)
+            return;
+        const melt = (s.snow < 0.05 || !this.snowSettles ? 0.9 : 0) + s.rain * 4;
+        const viewLeft = this._game.scrollX - 120;
+        const viewRight = this._game.scrollX + this._game.width + 120;
+        for (const line of this._lines) {
+            if (line.right < viewLeft || line.left > viewRight)
+                continue;
+            if (!snowing && !this._snowCover.has(line.key))
+                continue;
+            const cover = this._cover(line);
+            const { depth, noise } = cover;
+            const first = Math.max(0, Math.floor((viewLeft - line.left) / SNOW_COLUMN));
+            const last = Math.min(depth.length - 1, Math.ceil((viewRight - line.left) / SNOW_COLUMN));
+            const grow = snowing ? s.snow * SNOW_SETTLE_SPEED * dt : 0;
+            let any = false;
+            for (let c = first; c <= last; c++) {
+                const wx = line.left + (c + 0.5) * SNOW_COLUMN;
+                let d = depth[c];
+                if (grow > 0 && !this._covered(line, wx))
+                    d += grow * noise[c];
+                d -= melt * dt;
+                // Soften toward the neighbors so the cover reads as drifts, not columns.
+                const left = c > 0 ? depth[c - 1] : d;
+                const right = c < depth.length - 1 ? depth[c + 1] : d;
+                d += ((left + right) / 2 - d) * Math.min(1, dt * 3);
+                depth[c] = Math.max(0, Math.min(this._maxSnowDepth, d));
+                if (depth[c] > 0.05)
+                    any = true;
+            }
+            if (!any && !snowing) {
+                let total = 0;
+                for (let c = 0; c < depth.length; c++)
+                    total += depth[c];
+                if (total < 0.05)
+                    this._snowCover.delete(line.key);
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Fog and stars
+    // ---------------------------------------------------------------------------
+    /** @internal */
+    _createFog() {
+        const W = this._game.width;
+        const H = this._game.height;
+        for (let i = 0; i < 11; i++) {
+            const front = i >= 7;
+            const p = front ? 1.1 + this._random() * 0.3 : 0.3 + this._random() * 0.6;
+            this._fog.push({
+                x: this._random() * W,
+                y: H * (0.25 + this._random() * 0.75),
+                w: (front ? 520 : 380) + this._random() * 380,
+                h: 140 + this._random() * 160,
+                p,
+                alpha: 0.55 + this._random() * 0.45,
+                speed: 6 + this._random() * 10,
+                front,
+            });
+        }
+    }
+    /** @internal */
+    _updateFog(dt, dsx, dsy) {
+        const W = this._game.width;
+        const H = this._game.height;
+        for (const puff of this._fog) {
+            puff.x -= dsx * puff.p;
+            puff.y -= dsy * puff.p * 0.5;
+            puff.x += (this._windX * 0.12 + puff.speed) * puff.p * dt;
+            if (puff.x < -puff.w)
+                puff.x += W + puff.w * 2;
+            else if (puff.x > W + puff.w)
+                puff.x -= W + puff.w * 2;
+            if (puff.y < -puff.h)
+                puff.y += H + puff.h * 2;
+            else if (puff.y > H + puff.h)
+                puff.y -= H + puff.h * 2;
+        }
+    }
+    /** @internal */
+    _createStars() {
+        const W = this._game.width;
+        const H = this._game.height;
+        const count = Math.round((W * H) / 9000);
+        for (let i = 0; i < count; i++) {
+            this._stars.push({
+                x: this._random() * W,
+                y: this._random() * H * 0.75,
+                size: this._random() < 0.7 ? 2 : 3,
+                phase: this._random() * Math.PI * 2,
+                speed: 0.8 + this._random() * 2.2,
+            });
+        }
+    }
+    /** @internal */
+    _updateStars(dsx, dsy) {
+        if (dsx === 0 && dsy === 0)
+            return;
+        const W = this._game.width;
+        for (const star of this._stars) {
+            star.x -= dsx * 0.04;
+            if (star.x < 0)
+                star.x += W;
+            else if (star.x > W)
+                star.x -= W;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Lightning
+    // ---------------------------------------------------------------------------
+    /** @internal */
+    _strikeDelay() {
+        const storm = this._state.storm;
+        const mean = 8 - 7 * storm;
+        return MIN_STRIKE_GAP + -Math.log(1 - this._random()) * mean;
+    }
+    /** @internal */
+    _updateLightning(dt) {
+        for (let i = this._bolts.length - 1; i >= 0; i--) {
+            this._bolts[i].age += dt;
+            if (this._bolts[i].age > 0.35)
+                this._bolts.splice(i, 1);
+        }
+        for (let i = this._flashes.length - 1; i >= 0; i--) {
+            this._flashes[i].at += dt;
+            if (this._flashes[i].at > 0.6)
+                this._flashes.splice(i, 1);
+        }
+        if (this._state.storm < 0.01) {
+            this._nextStrike = Math.max(this._nextStrike, MIN_STRIKE_GAP);
+            return;
+        }
+        this._nextStrike -= dt;
+        if (this._nextStrike > 0)
+            return;
+        this._nextStrike = this._strikeDelay();
+        this._strike();
+    }
+    /** @internal */
+    _strike() {
+        const W = this._game.width;
+        const H = this._game.height;
+        const distance = Math.pow(this._random(), 0.8);
+        const x = W * (0.1 + this._random() * 0.8);
+        const reduced = this.reducedMotion;
+        const peak = reduced ? 0.12 * (1 - distance * 0.5) : 0.6 * (1 - distance * 0.75);
+        this._flashes.push({ at: 0, peak });
+        // A second, weaker flicker for near strikes. Two flashes per strike and a
+        // gap of at least MIN_STRIKE_GAP keep the rate under three per second.
+        if (!reduced && distance < 0.6)
+            this._flashes.push({ at: -0.13, peak: peak * 0.6 });
+        if (distance < 0.8)
+            this._bolts.push(this._makeBolt(x, H * (0.3 + 0.4 * (1 - distance)), 1 + 3 * (1 - distance)));
+        this.onLightning?.({ distance, x });
+    }
+    /** @internal */
+    _makeBolt(x, bottom, width) {
+        const points = [x, -10];
+        const branches = [];
+        let px = x;
+        let py = -10;
+        const steps = 12 + Math.floor(this._random() * 6);
+        const step = (bottom + 10) / steps;
+        for (let i = 0; i < steps; i++) {
+            px += (this._random() - 0.5) * 46;
+            py += step * (0.7 + this._random() * 0.6);
+            points.push(px, py);
+            if (i > 2 && i < steps - 2 && this._random() < 0.18) {
+                const branch = [px, py];
+                let bx = px;
+                let by = py;
+                const dir = this._random() < 0.5 ? -1 : 1;
+                for (let j = 0; j < 4; j++) {
+                    bx += dir * (8 + this._random() * 22);
+                    by += step * (0.4 + this._random() * 0.5);
+                    branch.push(bx, by);
+                }
+                branches.push(branch);
+            }
+        }
+        return { points, branches, age: 0, width };
+    }
+    /** @internal */
+    _flashAlpha() {
+        let alpha = 0;
+        for (const flash of this._flashes) {
+            if (flash.at >= 0)
+                alpha += flash.peak * Math.exp(-flash.at / 0.08);
+        }
+        return Math.min(0.75, alpha);
+    }
+    // ---------------------------------------------------------------------------
+    // Painting
+    // ---------------------------------------------------------------------------
+    /** @internal */
+    _paintBack(ctx) {
+        this._paintStars(ctx);
+        this._paintBolts(ctx);
+        this._paintFog(ctx, false);
+        this._paintRain(ctx, false);
+        this._paintSnow(ctx, false);
+        for (const drift of this._drifts)
+            if (!drift._options.lit)
+                this._paintDrift(ctx, drift, false);
+    }
+    /** @internal */
+    _paintFront(ctx) {
+        const W = this._game.width;
+        const H = this._game.height;
+        const s = this._state;
+        this._paintRain(ctx, true);
+        this._paintSnow(ctx, true);
+        for (const drift of this._drifts)
+            if (!drift._options.lit)
+                this._paintDrift(ctx, drift, true);
+        this._paintSplashes(ctx);
+        this._paintSnowCover(ctx);
+        this._paintFog(ctx, true);
+        if (s.fog > 0.001) {
+            ctx.globalAlpha = s.fog * 0.22;
+            ctx.fillStyle = this._fogColor;
+            ctx.fillRect(0, 0, W, H);
+        }
+        if (s.tint > 0.001) {
+            ctx.globalAlpha = s.tint * 0.5;
+            ctx.fillStyle = s.tintColor;
+            ctx.fillRect(0, 0, W, H);
+        }
+        if (s.darkness > 0.001) {
+            ctx.globalAlpha = s.darkness * 0.82;
+            ctx.fillStyle = "#050a1a";
+            ctx.fillRect(0, 0, W, H);
+        }
+        ctx.globalAlpha = 1;
+        for (const drift of this._drifts) {
+            if (drift._options.lit) {
+                this._paintDrift(ctx, drift, false);
+                this._paintDrift(ctx, drift, true);
+            }
+        }
+        const flash = this._flashAlpha();
+        if (flash > 0.001) {
+            ctx.globalAlpha = flash;
+            ctx.fillStyle = "#eef2ff";
+            ctx.fillRect(0, 0, W, H);
+            ctx.globalAlpha = 1;
+        }
+    }
+    /** @internal */
+    _visibleAt(x, y) {
+        return this._rects.length === 0 || !this._sheltered(x + this._game.scrollX, y + this._game.scrollY);
+    }
+    /** @internal */
+    _paintRain(ctx, front) {
+        if (this._rain.length === 0)
+            return;
+        const buckets = front ? [[1, 1.41]] : [[0, 0.6], [0.6, 1]];
+        const alphas = front ? [0.7] : [0.3, 0.5];
+        const widths = front ? [2.2] : [1, 1.4];
+        ctx.strokeStyle = this._rainColor;
+        ctx.lineCap = "round";
+        for (let b = 0; b < buckets.length; b++) {
+            const [min, max] = buckets[b];
+            ctx.globalAlpha = alphas[b];
+            ctx.lineWidth = widths[b];
+            ctx.beginPath();
+            for (const drop of this._rain) {
+                if (drop.p < min || drop.p >= max || drop.fade <= 0)
+                    continue;
+                const k = 0.02 * drop.fade;
+                ctx.moveTo(drop.x, drop.y);
+                ctx.lineTo(drop.x - drop.vx * k, drop.y - drop.vy * k);
+            }
+            ctx.stroke();
+        }
+        ctx.globalAlpha = 1;
+    }
+    /** @internal */
+    _paintSnow(ctx, front) {
+        if (this._snow.length === 0)
+            return;
+        const buckets = front ? [[1, 1.41]] : [[0, 0.6], [0.6, 1]];
+        const alphas = front ? [0.95] : [0.7, 0.9];
+        ctx.fillStyle = this._snowColor;
+        for (let b = 0; b < buckets.length; b++) {
+            const [min, max] = buckets[b];
+            ctx.globalAlpha = alphas[b];
+            ctx.beginPath();
+            for (const flake of this._snow) {
+                if (flake.p < min || flake.p >= max || flake.fade <= 0)
+                    continue;
+                const r = flake.size * (0.4 + 0.6 * flake.p) * flake.fade;
+                ctx.moveTo(flake.x + r, flake.y);
+                ctx.arc(flake.x, flake.y, r, 0, Math.PI * 2);
+            }
+            ctx.fill();
+        }
+        ctx.globalAlpha = 1;
+    }
+    /** @internal */
+    _paintDrift(ctx, drift, front) {
+        const o = drift._options;
+        const t = this._time;
+        const dot = o.dot ? this._dotTexture(o.dot) : null;
+        const images = dot ? [] : o.images.map((key) => this._game.getImage(key));
+        for (const particle of drift._particles) {
+            if ((particle.p >= 1) !== front || particle.fade <= 0)
+                continue;
+            if (particle.resting <= 0 && o.motion !== "hover" && !this._visibleAt(particle.x, particle.y))
+                continue;
+            let alpha = particle.fade;
+            if (o.twinkle > 0)
+                alpha *= 1 - o.twinkle * 0.5 * (1 + Math.sin(t * 3 * Math.abs(particle.spin) + particle.phase));
+            // A fading riser appears where it spawns, so it fades in as well as out.
+            if (o.motion === "rise" && o.fade)
+                alpha *= Math.max(0, Math.min(1, particle.age / 0.4, (particle.life - particle.age) / (particle.life * 0.4)));
+            if (particle.resting > 0)
+                alpha *= Math.min(1, particle.resting / 0.8);
+            if (alpha <= 0.01)
+                continue;
+            ctx.globalAlpha = alpha;
+            const scale = 0.55 + 0.45 * particle.p;
+            if (dot) {
+                const size = dot.width * scale;
+                ctx.drawImage(dot, particle.x - size / 2, particle.y - size / 2, size, size);
+                continue;
+            }
+            const image = images[particle.image % images.length];
+            if (!image)
+                continue;
+            const longest = Math.max(image.width, image.height) || 1;
+            const k = (particle.size * scale) / longest;
+            const w = image.width * k;
+            const h = image.height * k;
+            ctx.save();
+            ctx.translate(particle.x, particle.y);
+            if (o.spin > 0) {
+                ctx.rotate((particle.rotation * Math.PI) / 180);
+                // A leaf tumbling in three dimensions narrows as it turns edge-on.
+                if (particle.resting <= 0 && o.motion === "fall")
+                    ctx.scale(0.35 + 0.65 * Math.abs(Math.cos(t * 1.7 * particle.spin + particle.phase)), 1);
+            }
+            ctx.drawImage(image, -w / 2, -h / 2, w, h);
+            ctx.restore();
+        }
+        ctx.globalAlpha = 1;
+    }
+    /** @internal */
+    _paintSplashes(ctx) {
+        if (this._splashes.length === 0)
+            return;
+        const { scrollX, scrollY } = this._game;
+        ctx.strokeStyle = this._rainColor;
+        ctx.fillStyle = this._rainColor;
+        ctx.lineWidth = 1.2;
+        for (const splash of this._splashes) {
+            const k = splash.age / 0.32;
+            const x = splash.x - scrollX;
+            const y = splash.y - scrollY;
+            ctx.globalAlpha = (1 - k) * 0.7;
+            ctx.beginPath();
+            ctx.ellipse(x, y, 2 + k * 9 * splash.size, 1 + k * 2.5, 0, 0, Math.PI * 2);
+            ctx.stroke();
+            ctx.beginPath();
+            for (const drop of splash.drops) {
+                ctx.moveTo(x + drop.x + 1.3, y + drop.y);
+                ctx.arc(x + drop.x, y + drop.y, 1.3, 0, Math.PI * 2);
+            }
+            ctx.fill();
+        }
+        ctx.globalAlpha = 1;
+    }
+    /** @internal */
+    _paintSnowCover(ctx) {
+        if (this._snowCover.size === 0)
+            return;
+        const { scrollX, scrollY } = this._game;
+        const W = this._game.width;
+        ctx.fillStyle = this._snowColor;
+        for (const line of this._lines) {
+            const cover = this._snowCover.get(line.key);
+            if (!cover)
+                continue;
+            const left = line.left - scrollX;
+            const top = line.y - scrollY;
+            if (left > W || line.right - scrollX < 0)
+                continue;
+            const { depth } = cover;
+            const first = Math.max(0, Math.floor(-left / SNOW_COLUMN) - 1);
+            const last = Math.min(depth.length - 1, Math.ceil((W - left) / SNOW_COLUMN) + 1);
+            ctx.beginPath();
+            ctx.moveTo(left + first * SNOW_COLUMN, top + 0.5);
+            for (let c = first; c <= last; c++) {
+                ctx.lineTo(left + (c + 0.5) * SNOW_COLUMN, top - depth[c]);
+            }
+            ctx.lineTo(Math.min(line.right - scrollX, left + (last + 1) * SNOW_COLUMN), top + 0.5);
+            ctx.closePath();
+            ctx.globalAlpha = 1;
+            ctx.fill();
+            // A faint blue edge keeps white snow readable against a pale sky.
+            ctx.globalAlpha = 0.25;
+            ctx.strokeStyle = "#9fb4d0";
+            ctx.lineWidth = 1;
+            ctx.stroke();
+        }
+        ctx.globalAlpha = 1;
+    }
+    /** @internal */
+    _paintFog(ctx, front) {
+        const fog = this._state.fog;
+        if (fog <= 0.001)
+            return;
+        const texture = this._fogPuff();
+        for (const puff of this._fog) {
+            if (puff.front !== front)
+                continue;
+            ctx.globalAlpha = fog * puff.alpha * (front ? 0.45 : 0.7);
+            ctx.drawImage(texture, puff.x - puff.w / 2, puff.y - puff.h / 2, puff.w, puff.h);
+        }
+        ctx.globalAlpha = 1;
+    }
+    /** @internal */
+    _paintStars(ctx) {
+        const s = this._state;
+        const cover = Math.min(1, Math.max(s.rain, s.snow * 0.9, s.fog * 0.8) * 1.3);
+        const visible = s.stars * (1 - cover);
+        if (visible <= 0.001)
+            return;
+        ctx.fillStyle = "#ffffff";
+        const t = this._time;
+        const count = Math.round(this._stars.length * Math.min(1, 0.3 + visible));
+        for (let i = 0; i < count; i++) {
+            const star = this._stars[i];
+            ctx.globalAlpha = visible * (0.55 + 0.45 * Math.sin(t * star.speed + star.phase));
+            ctx.fillRect(star.x, star.y, star.size, star.size);
+        }
+        ctx.globalAlpha = 1;
+    }
+    /** @internal */
+    _paintBolts(ctx) {
+        if (this._bolts.length === 0)
+            return;
+        ctx.save();
+        ctx.strokeStyle = "#f4f6ff";
+        ctx.lineJoin = "round";
+        ctx.shadowColor = "#b9c8ff";
+        ctx.shadowBlur = 14;
+        for (const bolt of this._bolts) {
+            const k = bolt.age / 0.35;
+            ctx.globalAlpha = Math.max(0, 1 - k * k);
+            ctx.lineWidth = bolt.width;
+            strokePolyline(ctx, bolt.points);
+            ctx.lineWidth = bolt.width * 0.5;
+            for (const branch of bolt.branches)
+                strokePolyline(ctx, branch);
+        }
+        ctx.restore();
+    }
+    /** @internal */
+    _dotTexture(dot) {
+        const key = `${dot.color}|${dot.radius}|${dot.glow}`;
+        let texture = this._dotTextures.get(key);
+        if (texture)
+            return texture;
+        const radius = dot.radius + dot.glow;
+        const size = Math.max(2, Math.ceil(radius * 2 + 2));
+        texture = document.createElement("canvas");
+        texture.width = size;
+        texture.height = size;
+        const ctx = texture.getContext("2d");
+        if (ctx) {
+            const c = size / 2;
+            if (dot.glow > 0) {
+                const gradient = ctx.createRadialGradient(c, c, 0, c, c, radius);
+                const rgb = parseHex(dot.color);
+                const core = dot.radius / radius;
+                gradient.addColorStop(0, "#ffffff");
+                gradient.addColorStop(Math.max(0.01, core * 0.5), dot.color);
+                gradient.addColorStop(Math.max(0.02, core), `rgba(${rgb.r},${rgb.g},${rgb.b},0.55)`);
+                gradient.addColorStop(1, `rgba(${rgb.r},${rgb.g},${rgb.b},0)`);
+                ctx.fillStyle = gradient;
+                ctx.fillRect(0, 0, size, size);
+            }
+            else {
+                ctx.fillStyle = dot.color;
+                ctx.beginPath();
+                ctx.arc(c, c, dot.radius, 0, Math.PI * 2);
+                ctx.fill();
+            }
+        }
+        this._dotTextures.set(key, texture);
+        return texture;
+    }
+    /** @internal */
+    _fogPuff() {
+        if (this._fogTexture)
+            return this._fogTexture;
+        const texture = document.createElement("canvas");
+        texture.width = 128;
+        texture.height = 128;
+        const ctx = texture.getContext("2d");
+        if (ctx) {
+            const rgb = parseHex(this._fogColor);
+            const gradient = ctx.createRadialGradient(64, 64, 0, 64, 64, 64);
+            gradient.addColorStop(0, `rgba(${rgb.r},${rgb.g},${rgb.b},0.9)`);
+            gradient.addColorStop(0.5, `rgba(${rgb.r},${rgb.g},${rgb.b},0.45)`);
+            gradient.addColorStop(1, `rgba(${rgb.r},${rgb.g},${rgb.b},0)`);
+            ctx.fillStyle = gradient;
+            ctx.fillRect(0, 0, 128, 128);
+        }
+        this._fogTexture = texture;
+        return texture;
+    }
+}
+function strokePolyline(ctx, points) {
+    ctx.beginPath();
+    ctx.moveTo(points[0], points[1]);
+    for (let i = 2; i < points.length; i += 2)
+        ctx.lineTo(points[i], points[i + 1]);
+    ctx.stroke();
+}
+function clamp01(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0;
+}
+function clampField(field, value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return field === "wind" ? Math.max(-1, Math.min(1, value)) : Math.max(0, Math.min(1, value));
+}
+function smooth(k) {
+    return k * k * (3 - 2 * k);
+}
+function parseHex(color) {
+    const hex = color.trim().replace(/^#/, "");
+    const full = hex.length === 3 ? hex.split("").map((c) => c + c).join("") : hex;
+    if (!/^[0-9a-fA-F]{6}$/.test(full)) {
+        throw new Error(`MinimoJS ambient: '${color}' is not a hex color such as "#1b2a55".`);
+    }
+    return {
+        r: parseInt(full.slice(0, 2), 16),
+        g: parseInt(full.slice(2, 4), 16),
+        b: parseInt(full.slice(4, 6), 16),
+    };
+}
+function toHex(rgb) {
+    const part = (v) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, "0");
+    return `#${part(rgb.r)}${part(rgb.g)}${part(rgb.b)}`;
+}
+function prefersReducedMotion() {
+    try {
+        return typeof window !== "undefined" && window.matchMedia?.("(prefers-reduced-motion: reduce)").matches === true;
+    }
+    catch {
+        return false;
+    }
+}
+// mulberry32, the same generator `cards` uses for its seeded shuffle.
+function seededRandom(seed) {
+    let state = Math.floor(seed) >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}