minimojs 1.0.0-alpha.3 → 1.0.0-alpha.31

package/dist/internal/AnimationSystem.js

@@ -0,0 +1,345 @@
+/** @internal */
+export class AnimationSystem {
+    constructor() {
+        /** @internal */
+        this._animations = [];
+        /** @internal */
+        this._deformAnimations = [];
+        /** @internal */
+        this._motionAnimations = [];
+        /** @internal */
+        this._shakeAnimations = [];
+        /** @internal */
+        this._blinkAnimations = [];
+        /** @internal */
+        this._flickerAnimations = [];
+        /** @internal */
+        this._renderDataSprites = new Set();
+    }
+    update(dtMs) {
+        const animations = this._animations;
+        const toRemove = [];
+        for (let i = 0; i < animations.length; i++) {
+            const anim = animations[i];
+            anim.elapsed += dtMs;
+            const t = Math.min(anim.elapsed / anim.durationMs, 1);
+            anim.sprite[anim.property] = anim.from + (anim.to - anim.from) * t;
+            if (t >= 1) {
+                toRemove.push(i);
+                anim.onComplete?.();
+            }
+        }
+        for (let i = toRemove.length - 1; i >= 0; i--) {
+            animations.splice(toRemove[i], 1);
+        }
+        const deformAnimations = this._deformAnimations;
+        const deformToRemove = [];
+        for (let i = 0; i < deformAnimations.length; i++) {
+            const anim = deformAnimations[i];
+            anim.elapsed += dtMs;
+            const t = Math.min(anim.elapsed / anim.durationMs, 1);
+            if (t >= 1) {
+                deformToRemove.push(i);
+                anim.onComplete?.();
+            }
+        }
+        for (let i = deformToRemove.length - 1; i >= 0; i--) {
+            deformAnimations.splice(deformToRemove[i], 1);
+        }
+        const motionAnimations = this._motionAnimations;
+        const motionToRemove = [];
+        for (let i = 0; i < motionAnimations.length; i++) {
+            const anim = motionAnimations[i];
+            anim.elapsed += dtMs;
+            const t = Math.min(anim.elapsed / anim.durationMs, 1);
+            if (anim.kind === "arc") {
+                anim.sprite.x = anim.fromX + (anim.toX - anim.fromX) * t;
+                anim.sprite.y =
+                    anim.fromY +
+                        (anim.toY - anim.fromY) * t -
+                        anim.magnitude * 4 * t * (1 - t);
+            }
+            else if (anim.kind === "bounce") {
+                anim.sprite.x = anim.fromX;
+                anim.sprite.y = anim.fromY - anim.magnitude * 4 * t * (1 - t);
+            }
+            else {
+                anim.sprite.x = anim.fromX;
+                anim.sprite.y = anim.fromY - Math.sin(t * Math.PI) * anim.magnitude;
+            }
+            if (t >= 1) {
+                motionToRemove.push(i);
+                anim.onComplete?.();
+            }
+        }
+        for (let i = motionToRemove.length - 1; i >= 0; i--) {
+            motionAnimations.splice(motionToRemove[i], 1);
+        }
+        this.rebuildRenderData(dtMs);
+    }
+    animateAlpha(sprite, to, durationMs, onComplete) {
+        const animations = this._animations.filter((a) => !(a.sprite === sprite && a.property === "alpha"));
+        animations.push({
+            sprite,
+            property: "alpha",
+            from: sprite.alpha,
+            to,
+            durationMs,
+            elapsed: 0,
+            onComplete,
+        });
+        this._animations = animations;
+    }
+    animateRotation(sprite, to, durationMs, onComplete) {
+        const animations = this._animations.filter((a) => !(a.sprite === sprite && a.property === "rotation"));
+        animations.push({
+            sprite,
+            property: "rotation",
+            from: sprite.rotation,
+            to,
+            durationMs,
+            elapsed: 0,
+            onComplete,
+        });
+        this._animations = animations;
+    }
+    animateDeform(sprite, toScaleX, toScaleY, pivotX, pivotY, durationMs, onComplete) {
+        const current = sprite._renderData;
+        const fromScaleX = current?.scaleX ?? 1;
+        const fromScaleY = current?.scaleY ?? 1;
+        const deformAnimations = this._deformAnimations.filter((a) => a.sprite !== sprite);
+        deformAnimations.push({
+            sprite,
+            fromScaleX,
+            fromScaleY,
+            toScaleX: this.sanitizeScale(toScaleX),
+            toScaleY: this.sanitizeScale(toScaleY),
+            pivotX: this.sanitizePivot(pivotX),
+            pivotY: this.sanitizePivot(pivotY),
+            durationMs,
+            elapsed: 0,
+            onComplete,
+        });
+        this._deformAnimations = deformAnimations;
+    }
+    animateShake(sprite, intensity, durationMs, onComplete) {
+        const animations = this._shakeAnimations.filter((a) => a.sprite !== sprite);
+        animations.push({
+            sprite,
+            intensity: this.sanitizeNonNegative(intensity),
+            durationMs: this.sanitizeDuration(durationMs),
+            elapsed: 0,
+            onComplete,
+        });
+        this._shakeAnimations = animations;
+    }
+    animateBounce(sprite, height, durationMs, onComplete) {
+        this.replaceMotionAnimation({
+            sprite,
+            kind: "bounce",
+            fromX: sprite.x,
+            fromY: sprite.y,
+            toX: sprite.x,
+            toY: sprite.y,
+            magnitude: this.sanitizeNonNegative(height),
+            durationMs: this.sanitizeDuration(durationMs),
+            elapsed: 0,
+            onComplete,
+        });
+    }
+    animateFloat(sprite, distance, durationMs, onComplete) {
+        this.replaceMotionAnimation({
+            sprite,
+            kind: "float",
+            fromX: sprite.x,
+            fromY: sprite.y,
+            toX: sprite.x,
+            toY: sprite.y,
+            magnitude: this.sanitizeNonNegative(distance),
+            durationMs: this.sanitizeDuration(durationMs),
+            elapsed: 0,
+            onComplete,
+        });
+    }
+    animateArc(sprite, toX, toY, arcHeight, durationMs, onComplete) {
+        this.replaceMotionAnimation({
+            sprite,
+            kind: "arc",
+            fromX: sprite.x,
+            fromY: sprite.y,
+            toX,
+            toY,
+            magnitude: this.sanitizeNonNegative(arcHeight),
+            durationMs: this.sanitizeDuration(durationMs),
+            elapsed: 0,
+            onComplete,
+        });
+    }
+    animateBlink(sprite, times, durationMs, onComplete) {
+        const animations = this._blinkAnimations.filter((a) => a.sprite !== sprite);
+        animations.push({
+            sprite,
+            times: Math.max(1, Math.round(Number.isFinite(times) ? times : 1)),
+            durationMs: this.sanitizeDuration(durationMs),
+            elapsed: 0,
+            onComplete,
+        });
+        this._blinkAnimations = animations;
+    }
+    animateFlicker(sprite, durationMs, onComplete) {
+        const animations = this._flickerAnimations.filter((a) => a.sprite !== sprite);
+        animations.push({
+            sprite,
+            durationMs: this.sanitizeDuration(durationMs),
+            elapsed: 0,
+            onComplete,
+        });
+        this._flickerAnimations = animations;
+    }
+    clearSpriteAnimations(sprite) {
+        this._animations = this._animations.filter((a) => a.sprite !== sprite);
+        this._deformAnimations = this._deformAnimations.filter((a) => a.sprite !== sprite);
+        this._motionAnimations = this._motionAnimations.filter((a) => a.sprite !== sprite);
+        this._shakeAnimations = this._shakeAnimations.filter((a) => a.sprite !== sprite);
+        this._blinkAnimations = this._blinkAnimations.filter((a) => a.sprite !== sprite);
+        this._flickerAnimations = this._flickerAnimations.filter((a) => a.sprite !== sprite);
+        this._renderDataSprites.delete(sprite);
+        sprite._renderData = null;
+    }
+    clearAll() {
+        for (const sprite of this._renderDataSprites) {
+            sprite._renderData = null;
+        }
+        this._animations = [];
+        this._deformAnimations = [];
+        this._motionAnimations = [];
+        this._shakeAnimations = [];
+        this._blinkAnimations = [];
+        this._flickerAnimations = [];
+        this._renderDataSprites.clear();
+    }
+    /** @internal */
+    sanitizeScale(value) {
+        if (!Number.isFinite(value))
+            return 1;
+        return Math.max(0, value);
+    }
+    /** @internal */
+    sanitizeDuration(value) {
+        if (!Number.isFinite(value))
+            return 1;
+        return Math.max(1, value);
+    }
+    /** @internal */
+    sanitizeNonNegative(value) {
+        if (!Number.isFinite(value))
+            return 0;
+        return Math.max(0, value);
+    }
+    /** @internal */
+    sanitizePivot(value) {
+        if (!Number.isFinite(value))
+            return 0.5;
+        return Math.max(0, Math.min(1, value));
+    }
+    /** @internal */
+    replaceMotionAnimation(entry) {
+        const animations = this._motionAnimations.filter((a) => a.sprite !== entry.sprite);
+        animations.push(entry);
+        this._motionAnimations = animations;
+    }
+    /** @internal */
+    rebuildRenderData(dtMs) {
+        const next = new Map();
+        const nextSprites = new Set();
+        const upsert = (sprite) => {
+            let state = next.get(sprite);
+            if (!state) {
+                state = {
+                    scaleX: 1,
+                    scaleY: 1,
+                    pivotX: 0.5,
+                    pivotY: 0.5,
+                    offsetX: 0,
+                    offsetY: 0,
+                    alphaMultiplier: 1,
+                };
+                next.set(sprite, state);
+                nextSprites.add(sprite);
+            }
+            return state;
+        };
+        for (const anim of this._deformAnimations) {
+            const state = upsert(anim.sprite);
+            const t = Math.min(anim.elapsed / anim.durationMs, 1);
+            state.scaleX = anim.fromScaleX + (anim.toScaleX - anim.fromScaleX) * t;
+            state.scaleY = anim.fromScaleY + (anim.toScaleY - anim.fromScaleY) * t;
+            state.pivotX = anim.pivotX;
+            state.pivotY = anim.pivotY;
+        }
+        const shakeToRemove = [];
+        for (let i = 0; i < this._shakeAnimations.length; i++) {
+            const anim = this._shakeAnimations[i];
+            anim.elapsed += dtMs;
+            const t = Math.min(anim.elapsed / anim.durationMs, 1);
+            const decay = 1 - t;
+            const state = upsert(anim.sprite);
+            state.offsetX += (Math.random() * 2 - 1) * anim.intensity * decay;
+            state.offsetY += (Math.random() * 2 - 1) * anim.intensity * decay;
+            if (t >= 1) {
+                shakeToRemove.push(i);
+                anim.onComplete?.();
+            }
+        }
+        for (let i = shakeToRemove.length - 1; i >= 0; i--) {
+            this._shakeAnimations.splice(shakeToRemove[i], 1);
+        }
+        const blinkToRemove = [];
+        for (let i = 0; i < this._blinkAnimations.length; i++) {
+            const anim = this._blinkAnimations[i];
+            anim.elapsed += dtMs;
+            const t = Math.min(anim.elapsed / anim.durationMs, 1);
+            const state = upsert(anim.sprite);
+            const step = Math.floor(t * anim.times * 2);
+            state.alphaMultiplier *= step % 2 === 0 ? 1 : 0;
+            if (t >= 1) {
+                blinkToRemove.push(i);
+                anim.onComplete?.();
+            }
+        }
+        for (let i = blinkToRemove.length - 1; i >= 0; i--) {
+            this._blinkAnimations.splice(blinkToRemove[i], 1);
+        }
+        const flickerToRemove = [];
+        for (let i = 0; i < this._flickerAnimations.length; i++) {
+            const anim = this._flickerAnimations[i];
+            anim.elapsed += dtMs;
+            const t = Math.min(anim.elapsed / anim.durationMs, 1);
+            const state = upsert(anim.sprite);
+            state.alphaMultiplier *= 0.25 + Math.random() * 0.75;
+            if (t >= 1) {
+                flickerToRemove.push(i);
+                anim.onComplete?.();
+            }
+        }
+        for (let i = flickerToRemove.length - 1; i >= 0; i--) {
+            this._flickerAnimations.splice(flickerToRemove[i], 1);
+        }
+        for (const sprite of this._renderDataSprites) {
+            if (!nextSprites.has(sprite)) {
+                sprite._renderData = null;
+            }
+        }
+        for (const [sprite, state] of next.entries()) {
+            const isDefault = state.scaleX === 1 &&
+                state.scaleY === 1 &&
+                state.pivotX === 0.5 &&
+                state.pivotY === 0.5 &&
+                state.offsetX === 0 &&
+                state.offsetY === 0 &&
+                state.alphaMultiplier === 1;
+            sprite._renderData = isDefault ? null : state;
+        }
+        this._renderDataSprites = nextSprites;
+    }
+}

package/dist/internal/AssetSystem.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fetches and decodes one audio file. The engine passes one backed by its
+ * `AudioContext`; the asset system only stores what it returns, so it needs no
+ * audio API of its own and runs in tests without a browser.
+ */
+export type SoundLoader = (src: string) => Promise<unknown>;

package/dist/internal/AssetSystem.js

@@ -0,0 +1,273 @@
+/**
+ * Images and sounds, loaded by key. Both kinds share one queue, one progress
+ * count, one failure report, and one namespace of keys, so a game's loading
+ * screen and its retry cover every file it loads.
+ *
+ * @internal
+ */
+export class AssetSystem {
+    constructor(_soundLoader = null) {
+        this._soundLoader = _soundLoader;
+        /** @internal */
+        this._queuedImages = new Map();
+        /** @internal */
+        this._loadedImages = new Map();
+        /** @internal */
+        this._imageSources = new Map();
+        /** @internal */
+        this._imageVersions = new Map();
+        /**
+         * The asset file that declared each key, as the object passed to
+         * `loadAssets`. Keys are unique in the whole game, so a key belongs to
+         * exactly one asset file, or to `loadImage` and `createTexture`.
+         *
+         * @internal
+         */
+        this._assetFileByKey = new Map();
+        /** @internal */
+        this._registeredAssetFiles = new WeakSet();
+        /** @internal */
+        this._queuedSounds = new Map();
+        /** @internal */
+        this._loadedSounds = new Map();
+        /** @internal */
+        this._soundSources = new Map();
+    }
+    queueImage(key, src) {
+        const safeKey = key.trim();
+        const safeSrc = src.trim();
+        if (safeKey.length === 0) {
+            throw new Error("MinimoJS: Image keys must be non-empty strings.");
+        }
+        if (safeSrc.length === 0) {
+            throw new Error("MinimoJS: Image sources must be non-empty strings.");
+        }
+        this.refuseAssetFileKey(safeKey, "loadImage()");
+        this.refuseSoundKey(safeKey, "loadImage()");
+        this.enqueueImage(safeKey, safeSrc);
+    }
+    queueSound(key, src) {
+        const safeKey = key.trim();
+        const safeSrc = src.trim();
+        if (safeKey.length === 0) {
+            throw new Error("MinimoJS: Sound keys must be non-empty strings.");
+        }
+        if (safeSrc.length === 0) {
+            throw new Error("MinimoJS: Sound sources must be non-empty strings.");
+        }
+        this.refuseAssetFileKey(safeKey, "loadSound()");
+        if (this._imageSources.has(safeKey) || this._loadedImages.has(safeKey)) {
+            throw new Error(`MinimoJS: loadSound() cannot use the key "${safeKey}", which an image uses. Keys must be unique in the whole game.`);
+        }
+        this.enqueueSound(safeKey, safeSrc);
+    }
+    /**
+     * Registers a parsed asset file and queues its images. `source` is the
+     * object the game passed, which identifies the file, so loading the same
+     * file again, as a scene's `onPreload()` does on every entry, only queues
+     * images that are not loaded.
+     *
+     * Every key is checked before anything is queued, so a refused file
+     * registers nothing. Returns `true` the first time a file is registered.
+     */
+    registerAssetFile(file, source) {
+        for (const entry of file.assets) {
+            const owner = this._assetFileByKey.get(entry.key);
+            if (owner === undefined) {
+                if (this._imageSources.has(entry.key) || this._loadedImages.has(entry.key)) {
+                    throw new Error(`MinimoJS: Asset key "${entry.key}" is already registered with loadImage() or createTexture(). Keys must be unique in the whole game.`);
+                }
+                if (this._soundSources.has(entry.key)) {
+                    throw new Error(`MinimoJS: Asset key "${entry.key}" is already registered with loadSound(). Keys must be unique in the whole game.`);
+                }
+            }
+            else if (owner !== source) {
+                throw new Error(`MinimoJS: Asset key "${entry.key}" is declared by two asset files. Keys must be unique in the whole game.`);
+            }
+        }
+        for (const entry of file.assets) {
+            this._assetFileByKey.set(entry.key, source);
+            if (entry.type === "image") {
+                this.enqueueImage(entry.key, entry.src.trim());
+            }
+            else if (entry.type === "sound") {
+                this.enqueueSound(entry.key, entry.src.trim());
+            }
+        }
+        const isFirstRegistration = !this._registeredAssetFiles.has(source);
+        this._registeredAssetFiles.add(source);
+        return isFirstRegistration;
+    }
+    /** @internal */
+    enqueueImage(safeKey, safeSrc) {
+        const existingSrc = this._imageSources.get(safeKey);
+        if (existingSrc !== undefined && existingSrc !== safeSrc) {
+            throw new Error(`MinimoJS: Image key "${safeKey}" is already registered with a different source.`);
+        }
+        this._imageSources.set(safeKey, safeSrc);
+        this._queuedImages.set(safeKey, safeSrc);
+    }
+    /** @internal */
+    enqueueSound(safeKey, safeSrc) {
+        const existingSrc = this._soundSources.get(safeKey);
+        if (existingSrc !== undefined && existingSrc !== safeSrc) {
+            throw new Error(`MinimoJS: Sound key "${safeKey}" is already registered with a different source.`);
+        }
+        this._soundSources.set(safeKey, safeSrc);
+        if (!this._loadedSounds.has(safeKey)) {
+            this._queuedSounds.set(safeKey, safeSrc);
+        }
+    }
+    createTexture(key, width, height, painter) {
+        const safeKey = key.trim();
+        if (safeKey.length === 0) {
+            throw new Error("MinimoJS: Texture keys must be non-empty strings.");
+        }
+        if (typeof painter !== "function") {
+            throw new Error("MinimoJS: createTexture() requires a painter function.");
+        }
+        this.refuseAssetFileKey(safeKey, "createTexture()");
+        this.refuseSoundKey(safeKey, "createTexture()");
+        const canvas = document.createElement("canvas");
+        canvas.width = Math.max(1, Math.round(Number.isFinite(width) ? width : 1));
+        canvas.height = Math.max(1, Math.round(Number.isFinite(height) ? height : 1));
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+            throw new Error("MinimoJS: Could not acquire a texture rendering context.");
+        }
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        painter(ctx, canvas);
+        this._queuedImages.delete(safeKey);
+        this._imageSources.delete(safeKey);
+        this._loadedImages.set(safeKey, canvas);
+        this.bumpImageVersion(safeKey);
+        return canvas;
+    }
+    getImage(key) {
+        return this._loadedImages.get(key);
+    }
+    getImageVersion(key) {
+        return this._imageVersions.get(key) ?? 0;
+    }
+    hasImage(key) {
+        return this._loadedImages.has(key);
+    }
+    /** Returns a decoded sound, as the sound loader returned it, if it is loaded. */
+    getSound(key) {
+        return this._loadedSounds.get(key);
+    }
+    hasSound(key) {
+        return this._loadedSounds.has(key);
+    }
+    /** Counts the queued images and sounds that are not loaded yet. */
+    getQueuedAssetCount() {
+        let total = 0;
+        for (const key of this._queuedImages.keys()) {
+            if (!this._loadedImages.has(key)) {
+                total++;
+            }
+        }
+        for (const key of this._queuedSounds.keys()) {
+            if (!this._loadedSounds.has(key)) {
+                total++;
+            }
+        }
+        return total;
+    }
+    /**
+     * Loads every queued image and sound that is not loaded yet, settling all
+     * of them before returning instead of stopping at the first failure.
+     *
+     * Loaded files leave the queue; failed ones stay in it, so a retry loads
+     * only them. Returns the keys that failed, empty when all loaded.
+     */
+    async loadQueuedAssets(onProgress) {
+        const images = [...this._queuedImages.entries()].filter(([key]) => !this._loadedImages.has(key));
+        const sounds = [...this._queuedSounds.entries()].filter(([key]) => !this._loadedSounds.has(key));
+        const total = images.length + sounds.length;
+        let settled = 0;
+        const failed = [];
+        onProgress?.(0, total, null);
+        if (total === 0) {
+            this._queuedImages.clear();
+            this._queuedSounds.clear();
+            return failed;
+        }
+        const settle = (key) => {
+            settled += 1;
+            onProgress?.(settled, total, key);
+        };
+        await Promise.all([
+            ...images.map(async ([key, src]) => {
+                try {
+                    const image = await this.loadImage(src);
+                    this._loadedImages.set(key, image);
+                    this.bumpImageVersion(key);
+                    this._queuedImages.delete(key);
+                }
+                catch {
+                    failed.push(key);
+                }
+                settle(key);
+            }),
+            ...sounds.map(async ([key, src]) => {
+                try {
+                    if (!this._soundLoader) {
+                        throw new Error("MinimoJS: This game cannot load sounds.");
+                    }
+                    this._loadedSounds.set(key, await this._soundLoader(src));
+                    this._queuedSounds.delete(key);
+                }
+                catch {
+                    failed.push(key);
+                }
+                settle(key);
+            }),
+        ]);
+        for (const key of [...this._queuedImages.keys()]) {
+            if (this._loadedImages.has(key)) {
+                this._queuedImages.delete(key);
+            }
+        }
+        return failed;
+    }
+    /** Returns the source registered for an image or sound key, if any. */
+    getAssetSource(key) {
+        return this._imageSources.get(key) ?? this._soundSources.get(key);
+    }
+    /**
+     * Drops queued images and sounds that were not loaded, so a later load does
+     * not pick them up. Their keys may be registered again.
+     */
+    discardQueuedAssets() {
+        this._queuedImages.clear();
+        this._queuedSounds.clear();
+    }
+    /** @internal */
+    refuseSoundKey(safeKey, caller) {
+        if (this._soundSources.has(safeKey)) {
+            throw new Error(`MinimoJS: ${caller} cannot use the key "${safeKey}", which a sound uses. Keys must be unique in the whole game.`);
+        }
+    }
+    /** @internal */
+    refuseAssetFileKey(safeKey, caller) {
+        if (this._assetFileByKey.has(safeKey)) {
+            throw new Error(`MinimoJS: ${caller} cannot use the key "${safeKey}", which an asset file declares. Keys must be unique in the whole game.`);
+        }
+    }
+    /** @internal */
+    loadImage(src) {
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.onload = () => resolve(image);
+            image.onerror = () => {
+                reject(new Error(`MinimoJS: Failed to load image "${src}".`));
+            };
+            image.src = src;
+        });
+    }
+    /** @internal */
+    bumpImageVersion(key) {
+        this._imageVersions.set(key, (this._imageVersions.get(key) ?? 0) + 1);
+    }
+}

package/dist/internal/BackgroundSystem.d.ts

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

package/dist/internal/BackgroundSystem.js

@@ -0,0 +1,26 @@
+/** @internal */
+export class BackgroundSystem {
+    constructor() {
+        /** @internal */
+        this._layers = [];
+    }
+    add(layer) {
+        this._layers.push(layer);
+        return layer;
+    }
+    destroyLayer(layer) {
+        const index = this._layers.indexOf(layer);
+        if (index !== -1) {
+            this._layers.splice(index, 1);
+        }
+    }
+    getLayers() {
+        return [...this._layers];
+    }
+    getMutableLayers() {
+        return this._layers;
+    }
+    clearAll() {
+        this._layers = [];
+    }
+}

package/dist/internal/CanvasSystem.d.ts

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