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

package/dist/internal/SoundSystem.d.ts

@@ -0,0 +1,39 @@
+/** Options for one play of a loaded sound. */
+export interface PlaySoundOptions {
+    /** Repeat the sound until it is stopped. Default `false`. */
+    loop?: boolean;
+    /** Volume from `0`, silent, to `1`, as recorded. Default `1`. */
+    volume?: number;
+}
+/** Where a {@link SoundPlayback} is: playing, paused, or stopped for good. */
+export type SoundPlaybackState = "playing" | "paused" | "stopped";
+/**
+ * One play of a loaded sound, returned by `game.playSound`. Keep it to pause,
+ * resume, or stop that play, such as the game's music:
+ *
+ * ```ts
+ * const music = game.playSound("theme", { loop: true, volume: 0.6 });
+ * music.pause();
+ * music.resume();
+ * music.stop();
+ * ```
+ *
+ * A stopped play cannot be resumed; call `game.playSound` again.
+ */
+export declare class SoundPlayback {
+    /** The key the sound was loaded under. */
+    readonly key: string;
+    /** Whether this play repeats until stopped. */
+    readonly loop: boolean;
+    /** `"playing"`, `"paused"`, or `"stopped"`. A one-shot play stops by itself when it ends. */
+    get state(): SoundPlaybackState;
+    /** This play's volume, from `0` to `1`. Takes effect immediately. */
+    get volume(): number;
+    set volume(value: number);
+    /** Pauses the play where it is. Does nothing unless it is playing. */
+    pause(): void;
+    /** Continues a paused play from where it paused. Does nothing unless it is paused. */
+    resume(): void;
+    /** Stops the play for good. */
+    stop(): void;
+}

package/dist/internal/SoundSystem.js

@@ -0,0 +1,292 @@
+/**
+ * One play of a loaded sound, returned by `game.playSound`. Keep it to pause,
+ * resume, or stop that play, such as the game's music:
+ *
+ * ```ts
+ * const music = game.playSound("theme", { loop: true, volume: 0.6 });
+ * music.pause();
+ * music.resume();
+ * music.stop();
+ * ```
+ *
+ * A stopped play cannot be resumed; call `game.playSound` again.
+ */
+export class SoundPlayback {
+    /** @internal */
+    constructor(
+    /** The key the sound was loaded under. */
+    key, 
+    /** Whether this play repeats until stopped. */
+    loop, volume, 
+    /** @internal */
+    _system, 
+    /** @internal */
+    _buffer) {
+        this.key = key;
+        this.loop = loop;
+        this._system = _system;
+        this._buffer = _buffer;
+        /** @internal */
+        this._state = "playing";
+        /** @internal */
+        this._source = null;
+        /** @internal */
+        this._gain = null;
+        /** Seconds into the sound where the current source started, or where it was paused. @internal */
+        this._offset = 0;
+        /** The context time at which the current source started. @internal */
+        this._startedAt = 0;
+        this._volume = clampVolume(volume);
+        if (!_system || !_buffer) {
+            this._state = "stopped";
+            return;
+        }
+        this._startSource();
+    }
+    /** `"playing"`, `"paused"`, or `"stopped"`. A one-shot play stops by itself when it ends. */
+    get state() {
+        return this._state;
+    }
+    /** This play's volume, from `0` to `1`. Takes effect immediately. */
+    get volume() {
+        return this._volume;
+    }
+    set volume(value) {
+        this._volume = clampVolume(value);
+        if (this._gain) {
+            this._gain.gain.value = this._volume;
+        }
+    }
+    /** Pauses the play where it is. Does nothing unless it is playing. */
+    pause() {
+        if (this._state !== "playing" || !this._system || !this._buffer)
+            return;
+        const elapsed = this._system.context.currentTime - this._startedAt;
+        const position = this._offset + Math.max(0, elapsed);
+        this._offset = this.loop
+            ? position % this._buffer.duration
+            : Math.min(position, this._buffer.duration);
+        this._stopSource();
+        this._state = "paused";
+    }
+    /** Continues a paused play from where it paused. Does nothing unless it is paused. */
+    resume() {
+        if (this._state !== "paused")
+            return;
+        this._state = "playing";
+        this._startSource();
+    }
+    /** Stops the play for good. */
+    stop() {
+        if (this._state === "stopped")
+            return;
+        this._stopSource();
+        this._state = "stopped";
+        this._system?.forget(this);
+    }
+    /** @internal */
+    _startSource() {
+        const system = this._system;
+        const buffer = this._buffer;
+        if (!system || !buffer)
+            return;
+        const ctx = system.context;
+        const gain = ctx.createGain();
+        gain.gain.value = this._volume;
+        gain.connect(ctx.destination);
+        const source = ctx.createBufferSource();
+        source.buffer = buffer;
+        source.loop = this.loop;
+        source.connect(gain);
+        source.onended = () => {
+            if (this._source !== source)
+                return;
+            this._source = null;
+            this._gain = null;
+            gain.disconnect();
+            this._state = "stopped";
+            system.forget(this);
+        };
+        this._source = source;
+        this._gain = gain;
+        this._startedAt = ctx.currentTime;
+        source.start(0, this._offset);
+        system.remember(this);
+    }
+    /** @internal */
+    _stopSource() {
+        const source = this._source;
+        const gain = this._gain;
+        this._source = null;
+        this._gain = null;
+        if (source) {
+            source.onended = null;
+            try {
+                source.stop();
+            }
+            catch {
+                // A source that already ended throws on some browsers.
+            }
+            source.disconnect();
+        }
+        gain?.disconnect();
+    }
+}
+function clampVolume(value) {
+    if (!Number.isFinite(value))
+        return 1;
+    return Math.min(1, Math.max(0, value));
+}
+/** The events that count as the player's first gesture, which lets a page play sound. */
+const UNLOCK_EVENTS = ["pointerdown", "touchend", "mousedown", "keydown"];
+/** @internal */
+export class SoundSystem {
+    constructor() {
+        /** @internal */
+        this._audioCtx = null;
+        /** @internal */
+        this._playing = new Set();
+        /** Whether the page hid while sound could play, so showing it again resumes. @internal */
+        this._suspendedByHiding = false;
+    }
+    sound(freq, durationMs) {
+        const ctx = this.getAudioContext();
+        const oscillator = ctx.createOscillator();
+        const gain = ctx.createGain();
+        oscillator.type = "square";
+        oscillator.frequency.setValueAtTime(freq, ctx.currentTime);
+        gain.gain.setValueAtTime(0.08, ctx.currentTime);
+        gain.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + durationMs / 1000);
+        oscillator.connect(gain);
+        gain.connect(ctx.destination);
+        oscillator.start(ctx.currentTime);
+        oscillator.stop(ctx.currentTime + durationMs / 1000);
+    }
+    soundSequence(...tones) {
+        if (tones.length === 0)
+            return;
+        const ctx = this.getAudioContext();
+        let startTime = ctx.currentTime;
+        for (const [freq, durationMs] of tones) {
+            if (!Number.isFinite(freq) || !Number.isFinite(durationMs))
+                continue;
+            if (freq <= 0 || durationMs <= 0)
+                continue;
+            const durationSec = durationMs / 1000;
+            const oscillator = ctx.createOscillator();
+            const gain = ctx.createGain();
+            oscillator.type = "square";
+            oscillator.frequency.setValueAtTime(freq, startTime);
+            gain.gain.setValueAtTime(0.08, startTime);
+            gain.gain.exponentialRampToValueAtTime(0.001, startTime + durationSec);
+            oscillator.connect(gain);
+            gain.connect(ctx.destination);
+            oscillator.start(startTime);
+            oscillator.stop(startTime + durationSec);
+            startTime += durationSec;
+        }
+    }
+    /**
+     * Fetches and decodes an audio file. Used by the asset system to load the
+     * sounds a game queues, so a file the browser cannot decode fails while the
+     * game loads, with every other file that failed.
+     */
+    async decode(src) {
+        const response = await fetch(src);
+        if (!response.ok) {
+            throw new Error(`MinimoJS: Failed to load sound "${src}" (HTTP ${response.status}).`);
+        }
+        const data = await response.arrayBuffer();
+        const ctx = this.getAudioContext();
+        // The callback form, because older Safari returns no promise.
+        return new Promise((resolve, reject) => {
+            const result = ctx.decodeAudioData(data, resolve, reject);
+            result?.catch?.(reject);
+        });
+    }
+    /**
+     * Plays a decoded sound. Before the player's first gesture the page cannot
+     * play sound: a looping play waits and starts with that gesture, while a
+     * one-shot play is dropped, so effects queued meanwhile do not all sound at
+     * once. A dropped play is returned already stopped.
+     */
+    play(key, buffer, options = {}) {
+        const loop = options.loop === true;
+        const volume = options.volume ?? 1;
+        const ctx = this.getAudioContext();
+        if (!loop && ctx.state !== "running") {
+            return new SoundPlayback(key, loop, volume, null, null);
+        }
+        return new SoundPlayback(key, loop, volume, this, buffer);
+    }
+    /** Stops every play of a loaded sound. Synthesized tones are not affected. */
+    stopAll() {
+        for (const playback of [...this._playing]) {
+            playback.stop();
+        }
+    }
+    /** @internal */
+    get context() {
+        return this.getAudioContext();
+    }
+    /** @internal */
+    remember(playback) {
+        this._playing.add(playback);
+    }
+    /** @internal */
+    forget(playback) {
+        this._playing.delete(playback);
+    }
+    /** @internal */
+    getAudioContext() {
+        if (!this._audioCtx) {
+            this._audioCtx = new AudioContext();
+            this.listenForUnlockAndVisibility();
+        }
+        const ctx = this._audioCtx;
+        if (ctx.state === "suspended" && !this._suspendedByHiding) {
+            void ctx.resume().catch(() => { });
+        }
+        return ctx;
+    }
+    /**
+     * Resumes the context on the player's first gesture, which is what lets a
+     * browser play sound, and pauses all sound while the page is hidden.
+     *
+     * @internal
+     */
+    listenForUnlockAndVisibility() {
+        if (typeof window === "undefined")
+            return;
+        const unlock = () => {
+            const ctx = this._audioCtx;
+            if (!ctx || this._suspendedByHiding)
+                return;
+            if (ctx.state === "running") {
+                for (const type of UNLOCK_EVENTS)
+                    window.removeEventListener(type, unlock, true);
+                return;
+            }
+            void ctx.resume().catch(() => { });
+        };
+        for (const type of UNLOCK_EVENTS)
+            window.addEventListener(type, unlock, true);
+        if (typeof document === "undefined")
+            return;
+        document.addEventListener("visibilitychange", () => {
+            const ctx = this._audioCtx;
+            if (!ctx)
+                return;
+            if (document.visibilityState === "hidden") {
+                if (ctx.state === "running") {
+                    this._suspendedByHiding = true;
+                    void ctx.suspend().catch(() => { });
+                }
+            }
+            else if (this._suspendedByHiding) {
+                this._suspendedByHiding = false;
+                void ctx.resume().catch(() => { });
+            }
+        });
+    }
+}

package/dist/internal/SpriteSystem.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/SpriteSystem.js

@@ -0,0 +1,32 @@
+/** @internal */
+export class SpriteSystem {
+    constructor(
+    /** @internal */ animationSystem, 
+    /** @internal */ game) {
+        this.animationSystem = animationSystem;
+        this.game = game;
+        /** @internal */
+        this._sprites = [];
+    }
+    add(sprite) {
+        sprite._setGame(this.game);
+        this._sprites.push(sprite);
+        return sprite;
+    }
+    destroySprite(sprite) {
+        const idx = this._sprites.indexOf(sprite);
+        if (idx !== -1) {
+            this._sprites.splice(idx, 1);
+        }
+        this.animationSystem.clearSpriteAnimations(sprite);
+    }
+    getSprites() {
+        return [...this._sprites];
+    }
+    getMutableSprites() {
+        return this._sprites;
+    }
+    clearAll() {
+        this._sprites = [];
+    }
+}

package/dist/internal/TextSystem.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/TextSystem.js

@@ -0,0 +1,16 @@
+/** @internal */
+export class TextSystem {
+    constructor() {
+        /** @internal */
+        this._entries = [];
+    }
+    drawText(text, x, y, fontSize, color = "#ffffff", centered = false) {
+        this._entries.push({ text, x, y, fontSize, color, centered });
+    }
+    getEntries() {
+        return this._entries;
+    }
+    clear() {
+        this._entries = [];
+    }
+}

package/dist/internal/TimerSystem.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/TimerSystem.js

@@ -0,0 +1,43 @@
+/** @internal */
+export class TimerSystem {
+    constructor() {
+        /** @internal */
+        this._timers = [];
+        /** @internal */
+        this._timerIdCounter = 0;
+    }
+    update(dtMs) {
+        const timers = this._timers;
+        const toRemove = new Set();
+        const toFire = [];
+        for (const timer of timers) {
+            timer.elapsed += dtMs;
+            if (timer.elapsed >= timer.delayMs) {
+                toFire.push(timer);
+                if (timer.repeat) {
+                    timer.elapsed -= timer.delayMs;
+                }
+                else {
+                    toRemove.add(timer.id);
+                }
+            }
+        }
+        if (toRemove.size > 0) {
+            this._timers = timers.filter((t) => !toRemove.has(t.id));
+        }
+        for (const timer of toFire) {
+            timer.callback();
+        }
+    }
+    addTimer(delayMs, repeat, callback) {
+        const id = ++this._timerIdCounter;
+        this._timers.push({ id, delayMs, elapsed: 0, repeat, callback });
+        return id;
+    }
+    clearTimer(id) {
+        this._timers = this._timers.filter((t) => t.id !== id);
+    }
+    clearAll() {
+        this._timers = [];
+    }
+}

package/dist/internal/TrailSystem.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/TrailSystem.js

@@ -0,0 +1,116 @@
+const DEFAULT_OPTIONS = {
+    durationMs: 300,
+    spacingMs: 40,
+    fadeMs: 180,
+    alpha: 0.45,
+    scaleTo: 0.8,
+};
+/** @internal */
+export class TrailSystem {
+    constructor() {
+        /** @internal */
+        this._emitters = [];
+        /** @internal */
+        this._ghosts = [];
+    }
+    animateTrail(sprite, options, onComplete) {
+        const durationMs = this.sanitizeDuration(options?.durationMs, DEFAULT_OPTIONS.durationMs);
+        const spacingMs = this.sanitizeDuration(options?.spacingMs, DEFAULT_OPTIONS.spacingMs);
+        const fadeMs = this.sanitizeDuration(options?.fadeMs, DEFAULT_OPTIONS.fadeMs);
+        const alpha = this.sanitizeAlpha(options?.alpha, DEFAULT_OPTIONS.alpha);
+        const scaleTo = this.sanitizeScale(options?.scaleTo, DEFAULT_OPTIONS.scaleTo);
+        const emitters = this._emitters.filter((entry) => entry.sprite !== sprite);
+        emitters.push({
+            sprite,
+            elapsedMs: 0,
+            durationMs,
+            timeUntilNextEmitMs: 0,
+            spacingMs,
+            fadeMs,
+            alpha,
+            scaleTo,
+            onComplete,
+        });
+        this._emitters = emitters;
+    }
+    update(dtMs, getSnapshot) {
+        const emitters = this._emitters;
+        const toRemove = [];
+        for (let i = 0; i < emitters.length; i++) {
+            const emitter = emitters[i];
+            emitter.elapsedMs += dtMs;
+            emitter.timeUntilNextEmitMs -= dtMs;
+            while (emitter.timeUntilNextEmitMs <= 0 && emitter.elapsedMs <= emitter.durationMs) {
+                const snapshot = getSnapshot(emitter.sprite);
+                this._ghosts.push({
+                    canvas: snapshot.canvas,
+                    layer: snapshot.layer,
+                    ignoreScroll: snapshot.ignoreScroll,
+                    x: snapshot.x,
+                    y: snapshot.y,
+                    rotation: snapshot.rotation,
+                    alpha: snapshot.alpha * emitter.alpha,
+                    flipX: snapshot.flipX,
+                    flipY: snapshot.flipY,
+                    drawWidth: snapshot.drawWidth,
+                    drawHeight: snapshot.drawHeight,
+                    ageMs: 0,
+                    fadeMs: emitter.fadeMs,
+                    startAlpha: snapshot.alpha * emitter.alpha,
+                    baseDrawWidth: snapshot.drawWidth,
+                    baseDrawHeight: snapshot.drawHeight,
+                    scaleTo: emitter.scaleTo,
+                });
+                emitter.timeUntilNextEmitMs += emitter.spacingMs;
+            }
+            if (emitter.elapsedMs >= emitter.durationMs) {
+                toRemove.push(i);
+                emitter.onComplete?.();
+            }
+        }
+        for (let i = toRemove.length - 1; i >= 0; i--) {
+            emitters.splice(toRemove[i], 1);
+        }
+        const ghosts = this._ghosts;
+        for (let i = ghosts.length - 1; i >= 0; i--) {
+            const ghost = ghosts[i];
+            ghost.ageMs += dtMs;
+            const t = Math.min(ghost.ageMs / ghost.fadeMs, 1);
+            const scale = 1 + (ghost.scaleTo - 1) * t;
+            ghost.alpha = ghost.startAlpha * (1 - t);
+            ghost.drawWidth = ghost.baseDrawWidth * scale;
+            ghost.drawHeight = ghost.baseDrawHeight * scale;
+            if (t >= 1) {
+                ghosts.splice(i, 1);
+            }
+        }
+    }
+    getRenderEntries() {
+        return this._ghosts;
+    }
+    clearSpriteTrails(sprite) {
+        this._emitters = this._emitters.filter((entry) => entry.sprite !== sprite);
+    }
+    clearAll() {
+        this._emitters = [];
+        this._ghosts = [];
+    }
+    /** @internal */
+    sanitizeDuration(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(1, value);
+    }
+    /** @internal */
+    sanitizeAlpha(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(0, Math.min(1, value));
+    }
+    /** @internal */
+    sanitizeScale(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(0, value);
+    }
+}

package/dist/internal/TransitionSystem.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/TransitionSystem.js

@@ -0,0 +1,74 @@
+const DEFAULT_DURATION_MS = 420;
+const DEFAULT_DIRECTION = "left-to-right";
+const DEFAULT_PIXEL_SIZE = 28;
+/** @internal */
+export class TransitionSystem {
+    constructor() {
+        /** @internal */
+        this._active = null;
+    }
+    get isActive() {
+        return this._active !== null;
+    }
+    start(fromCanvas, toCanvas, width, height, options, onComplete) {
+        const type = options.type;
+        const durationMs = this.sanitizeDuration(options.durationMs, DEFAULT_DURATION_MS);
+        const color = typeof options.color === "string" && options.color.trim()
+            ? options.color
+            : type === "flash"
+                ? "#ffffff"
+                : "#000000";
+        const centerX = this.sanitizeCoordinate(options.centerX, width / 2);
+        const centerY = this.sanitizeCoordinate(options.centerY, height / 2);
+        const pixelSize = this.sanitizePixelSize(options.pixelSize, DEFAULT_PIXEL_SIZE);
+        this._active = {
+            fromCanvas,
+            toCanvas,
+            type,
+            progress: 0,
+            color,
+            direction: options.direction ?? DEFAULT_DIRECTION,
+            centerX,
+            centerY,
+            pixelSize,
+            elapsedMs: 0,
+            durationMs,
+            onComplete,
+        };
+    }
+    update(dtMs) {
+        if (!this._active)
+            return;
+        this._active.elapsedMs += dtMs;
+        this._active.progress = Math.max(0, Math.min(1, this._active.elapsedMs / this._active.durationMs));
+        if (this._active.progress >= 1) {
+            const onComplete = this._active.onComplete;
+            this._active = null;
+            onComplete?.();
+        }
+    }
+    getRenderEntry() {
+        return this._active;
+    }
+    clear() {
+        this._active = null;
+    }
+    /** @internal */
+    sanitizeDuration(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(1, value);
+    }
+    /** @internal */
+    sanitizeCoordinate(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return value;
+    }
+    /** @internal */
+    sanitizePixelSize(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(2, Math.round(value));
+    }
+}

package/dist/internal/arcade-racer/ArcadeRacerCollisionSystem.d.ts

@@ -0,0 +1 @@
+export {};