minimojs 1.0.0-alpha.3 → 1.0.0-alpha.30

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 @@
+export {};

package/dist/internal/AssetSystem.js

@@ -0,0 +1,186 @@
+/** @internal */
+export class AssetSystem {
+    constructor() {
+        /** @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();
+    }
+    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.enqueueImage(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.`);
+                }
+            }
+            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());
+            }
+        }
+        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);
+    }
+    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()");
+        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);
+    }
+    getQueuedImageCount() {
+        let total = 0;
+        for (const key of this._queuedImages.keys()) {
+            if (!this._loadedImages.has(key)) {
+                total++;
+            }
+        }
+        return total;
+    }
+    /**
+     * Loads every queued image that is not loaded yet, settling all of them
+     * before returning instead of stopping at the first failure.
+     *
+     * Loaded images leave the queue; failed ones stay in it, so a retry loads
+     * only them. Returns the keys that failed, empty when all loaded.
+     */
+    async loadQueuedImages(onProgress) {
+        const entries = [...this._queuedImages.entries()].filter(([key]) => !this._loadedImages.has(key));
+        const total = entries.length;
+        let settled = 0;
+        const failed = [];
+        onProgress?.(0, total, null);
+        if (total === 0) {
+            this._queuedImages.clear();
+            return failed;
+        }
+        await Promise.all(entries.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);
+            }
+            settled += 1;
+            onProgress?.(settled, total, 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 key, if any. */
+    getImageSource(key) {
+        return this._imageSources.get(key);
+    }
+    /**
+     * Drops queued images that were not loaded, so a later load does not pick
+     * them up. Their keys may be registered again.
+     */
+    discardQueuedImages() {
+        this._queuedImages.clear();
+    }
+    /** @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 {};

package/dist/internal/CanvasSystem.js

@@ -0,0 +1,51 @@
+/** @internal */
+export class CanvasSystem {
+    constructor(/** @internal */ canvas) {
+        this.canvas = canvas;
+        /** @internal */
+        this.onResize = () => this.applyResponsiveCanvasLayout();
+        /** @internal */
+        this.onViewportChange = () => this.applyResponsiveCanvasLayout();
+    }
+    initialize() {
+        const mountCanvas = () => {
+            if (document.body && !this.canvas.isConnected) {
+                document.body.appendChild(this.canvas);
+            }
+            this.applyResponsiveCanvasLayout();
+        };
+        if (document.body) {
+            mountCanvas();
+        }
+        else {
+            window.addEventListener("DOMContentLoaded", mountCanvas, { once: true });
+        }
+        window.addEventListener("resize", this.onResize);
+        window.visualViewport?.addEventListener("resize", this.onViewportChange);
+        window.visualViewport?.addEventListener("scroll", this.onViewportChange);
+    }
+    /** @internal */
+    applyResponsiveCanvasLayout() {
+        if (!document.body)
+            return;
+        const viewportW = Math.max(1, Math.floor(window.visualViewport?.width ??
+            window.innerWidth ??
+            document.documentElement.clientWidth ??
+            1));
+        const viewportH = Math.max(1, Math.floor(window.visualViewport?.height ??
+            window.innerHeight ??
+            document.documentElement.clientHeight ??
+            1));
+        document.body.style.margin = "0";
+        document.body.style.height = `${viewportH}px`;
+        document.body.style.minHeight = `${viewportH}px`;
+        document.body.style.display = "grid";
+        document.body.style.placeItems = "center";
+        document.body.style.touchAction = "manipulation";
+        document.body.style.overflow = "hidden";
+        const scale = Math.min(viewportW / this.canvas.width, viewportH / this.canvas.height);
+        const safeScale = Number.isFinite(scale) && scale > 0 ? scale : 1;
+        this.canvas.style.width = `${Math.floor(this.canvas.width * safeScale)}px`;
+        this.canvas.style.height = `${Math.floor(this.canvas.height * safeScale)}px`;
+    }
+}

package/dist/internal/DesignNamingCheck.d.ts

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

package/dist/internal/DesignNamingCheck.js

@@ -0,0 +1,7 @@
+// A compile-time check, with no runtime code, that every property of a design
+// object, except `id` and `type`, exists on its runtime class under the same
+// name and with a compatible type (X-002). Designs use the runtime's names so
+// agents learn one vocabulary for code and files. The build fails when a
+// property is misnamed; a property that must be named differently would be
+// declared here as an explicit exception.
+export {};

package/dist/internal/ExplosionSystem.d.ts

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