minimojs 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/internal/ExplosionSystem.js

@@ -0,0 +1,540 @@
+const DEFAULT_EXPLODE_OPTIONS = {
+    rows: 3,
+    cols: 3,
+    durationMs: 500,
+    speed: 260,
+    gravityY: 900,
+    spin: 220,
+    fade: true,
+    destroySprite: true,
+};
+const DEFAULT_ASSEMBLE_OPTIONS = {
+    rows: 3,
+    cols: 3,
+    durationMs: 500,
+    speed: 260,
+    gravityY: 900,
+    spin: 220,
+    fade: true,
+};
+const DEFAULT_DISINTEGRATE_OPTIONS = {
+    rows: 4,
+    cols: 4,
+    durationMs: 420,
+    direction: "left-to-right",
+    distance: 42,
+    spin: 120,
+    fade: true,
+    destroySprite: true,
+};
+const DEFAULT_INTEGRATE_OPTIONS = {
+    rows: 4,
+    cols: 4,
+    durationMs: 420,
+    direction: "left-to-right",
+    distance: 42,
+    spin: 120,
+    fade: true,
+};
+const DEFAULT_WIPE_OPTIONS = {
+    mode: "reveal",
+    direction: "left-to-right",
+    durationMs: 360,
+    destroySprite: true,
+};
+/** @internal */
+export class ExplosionSystem {
+    constructor() {
+        /** @internal */
+        this._pieceEffects = [];
+        /** @internal */
+        this._wipes = [];
+    }
+    animateExplode(sprite, glyphCanvas, options, onComplete) {
+        const context = this.buildPieceSpriteContext(sprite, glyphCanvas);
+        this.spawnRadialEffect("explode", sprite, glyphCanvas, context, {
+            rows: this.sanitizeCount(options?.rows, DEFAULT_EXPLODE_OPTIONS.rows),
+            cols: this.sanitizeCount(options?.cols, DEFAULT_EXPLODE_OPTIONS.cols),
+            durationMs: this.sanitizeDuration(options?.durationMs, DEFAULT_EXPLODE_OPTIONS.durationMs),
+            speed: this.sanitizeNonNegative(options?.speed, DEFAULT_EXPLODE_OPTIONS.speed),
+            gravityY: this.sanitizeNumber(options?.gravityY, DEFAULT_EXPLODE_OPTIONS.gravityY),
+            spin: this.sanitizeNonNegative(options?.spin, DEFAULT_EXPLODE_OPTIONS.spin),
+            fade: options?.fade ?? DEFAULT_EXPLODE_OPTIONS.fade,
+        }, false, options?.destroySprite === false, options?.destroySprite === false ? sprite.visible : false, onComplete);
+    }
+    animateAssemble(sprite, glyphCanvas, options, onComplete) {
+        const context = this.buildPieceSpriteContext(sprite, glyphCanvas);
+        this.spawnRadialEffect("assemble", sprite, glyphCanvas, context, {
+            rows: this.sanitizeCount(options?.rows, DEFAULT_ASSEMBLE_OPTIONS.rows),
+            cols: this.sanitizeCount(options?.cols, DEFAULT_ASSEMBLE_OPTIONS.cols),
+            durationMs: this.sanitizeDuration(options?.durationMs, DEFAULT_ASSEMBLE_OPTIONS.durationMs),
+            speed: this.sanitizeNonNegative(options?.speed, DEFAULT_ASSEMBLE_OPTIONS.speed),
+            gravityY: this.sanitizeNumber(options?.gravityY, DEFAULT_ASSEMBLE_OPTIONS.gravityY),
+            spin: this.sanitizeNonNegative(options?.spin, DEFAULT_ASSEMBLE_OPTIONS.spin),
+            fade: options?.fade ?? DEFAULT_ASSEMBLE_OPTIONS.fade,
+        }, true, true, true, onComplete);
+    }
+    animateDisintegrate(sprite, glyphCanvas, options, onComplete) {
+        const context = this.buildPieceSpriteContext(sprite, glyphCanvas);
+        this.spawnDirectionalEffect("disintegrate", sprite, glyphCanvas, context, {
+            rows: this.sanitizeCount(options?.rows, DEFAULT_DISINTEGRATE_OPTIONS.rows),
+            cols: this.sanitizeCount(options?.cols, DEFAULT_DISINTEGRATE_OPTIONS.cols),
+            durationMs: this.sanitizeDuration(options?.durationMs, DEFAULT_DISINTEGRATE_OPTIONS.durationMs),
+            direction: options?.direction ?? DEFAULT_DISINTEGRATE_OPTIONS.direction,
+            distance: this.sanitizeNonNegative(options?.distance, DEFAULT_DISINTEGRATE_OPTIONS.distance),
+            spin: this.sanitizeNonNegative(options?.spin, DEFAULT_DISINTEGRATE_OPTIONS.spin),
+            fade: options?.fade ?? DEFAULT_DISINTEGRATE_OPTIONS.fade,
+        }, false, options?.destroySprite === false, false, onComplete);
+    }
+    animateIntegrate(sprite, glyphCanvas, options, onComplete) {
+        const context = this.buildPieceSpriteContext(sprite, glyphCanvas);
+        this.spawnDirectionalEffect("integrate", sprite, glyphCanvas, context, {
+            rows: this.sanitizeCount(options?.rows, DEFAULT_INTEGRATE_OPTIONS.rows),
+            cols: this.sanitizeCount(options?.cols, DEFAULT_INTEGRATE_OPTIONS.cols),
+            durationMs: this.sanitizeDuration(options?.durationMs, DEFAULT_INTEGRATE_OPTIONS.durationMs),
+            direction: options?.direction ?? DEFAULT_INTEGRATE_OPTIONS.direction,
+            distance: this.sanitizeNonNegative(options?.distance, DEFAULT_INTEGRATE_OPTIONS.distance),
+            spin: this.sanitizeNonNegative(options?.spin, DEFAULT_INTEGRATE_OPTIONS.spin),
+            fade: options?.fade ?? DEFAULT_INTEGRATE_OPTIONS.fade,
+        }, true, true, true, onComplete);
+    }
+    animateWipe(sprite, snapshot, options, onComplete) {
+        this.clearSpriteEffects(sprite);
+        const mode = options?.mode ?? DEFAULT_WIPE_OPTIONS.mode;
+        const durationMs = this.sanitizeDuration(options?.durationMs, DEFAULT_WIPE_OPTIONS.durationMs);
+        const direction = options?.direction ?? DEFAULT_WIPE_OPTIONS.direction;
+        const destroySprite = options?.destroySprite ?? DEFAULT_WIPE_OPTIONS.destroySprite;
+        const restoreVisibility = mode === "reveal";
+        sprite.visible = false;
+        this._wipes.push({
+            sprite,
+            canvas: snapshot.canvas,
+            x: snapshot.x,
+            y: snapshot.y,
+            rotation: snapshot.rotation,
+            alpha: snapshot.alpha,
+            flipX: snapshot.flipX,
+            flipY: snapshot.flipY,
+            drawWidth: snapshot.drawWidth,
+            drawHeight: snapshot.drawHeight,
+            layer: snapshot.layer,
+            ignoreScroll: snapshot.ignoreScroll,
+            mode,
+            direction,
+            progress: mode === "reveal" ? 0 : 1,
+            elapsedMs: 0,
+            durationMs,
+            restoreVisibility,
+            finalVisible: mode === "reveal",
+            onComplete,
+        });
+    }
+    update(_dt, dtMs) {
+        const pieceToRemove = [];
+        for (let i = 0; i < this._pieceEffects.length; i++) {
+            const effect = this._pieceEffects[i];
+            effect.elapsedMs += dtMs;
+            const t = Math.min(effect.elapsedMs / effect.durationMs, 1);
+            for (const piece of effect.pieces) {
+                const localT = t <= piece.delayT ? 0 : Math.min(1, (t - piece.delayT) / (1 - piece.delayT));
+                const eased = this.easePieceProgress(effect.mode, localT);
+                piece.x = this.lerp(piece.startX, piece.endX, eased);
+                piece.y = this.lerp(piece.startY, piece.endY, eased);
+                piece.rotation = this.lerp(piece.startRotation, piece.endRotation, eased);
+                piece.alpha = this.lerp(piece.startAlpha, piece.endAlpha, eased);
+            }
+            if (t >= 1) {
+                pieceToRemove.push(i);
+                if (effect.restoreVisibility) {
+                    effect.sprite.visible = effect.finalVisible;
+                }
+                effect.onComplete?.();
+            }
+        }
+        for (let i = pieceToRemove.length - 1; i >= 0; i--) {
+            this._pieceEffects.splice(pieceToRemove[i], 1);
+        }
+        const wipeToRemove = [];
+        for (let i = 0; i < this._wipes.length; i++) {
+            const wipe = this._wipes[i];
+            wipe.elapsedMs += dtMs;
+            const t = Math.min(wipe.elapsedMs / wipe.durationMs, 1);
+            wipe.progress = wipe.mode === "reveal" ? t : 1 - t;
+            if (t >= 1) {
+                wipeToRemove.push(i);
+                if (wipe.restoreVisibility) {
+                    wipe.sprite.visible = wipe.finalVisible;
+                }
+                wipe.onComplete?.();
+            }
+        }
+        for (let i = wipeToRemove.length - 1; i >= 0; i--) {
+            this._wipes.splice(wipeToRemove[i], 1);
+        }
+    }
+    getRenderEntries() {
+        return this._pieceEffects;
+    }
+    getWipeEntries() {
+        return this._wipes;
+    }
+    clearAll() {
+        for (const effect of this._pieceEffects) {
+            if (effect.restoreVisibility) {
+                effect.sprite.visible = effect.finalVisible;
+            }
+        }
+        for (const wipe of this._wipes) {
+            if (wipe.restoreVisibility) {
+                wipe.sprite.visible = wipe.finalVisible;
+            }
+        }
+        this._pieceEffects = [];
+        this._wipes = [];
+    }
+    /** @internal */
+    spawnRadialEffect(mode, sprite, glyphCanvas, context, options, forceHideSprite, restoreVisibility, finalVisible, onComplete) {
+        this.clearSpriteEffects(sprite);
+        if (forceHideSprite || restoreVisibility) {
+            sprite.visible = false;
+        }
+        const durationSeconds = options.durationMs / 1000;
+        const pieces = this.buildPieceGrid(glyphCanvas, context, options.rows, options.cols, (_row, _col, sx, sy, sw, sh, centerX, centerY) => {
+            const velocity = this.getRadialVelocity(centerX, centerY);
+            const distance = options.speed * durationSeconds * (0.65 + Math.random() * 0.7);
+            const targetX = context.baseX + centerX + velocity.x * distance;
+            const targetY = context.baseY +
+                centerY +
+                velocity.y * distance +
+                0.5 * options.gravityY * durationSeconds * durationSeconds;
+            const assembledX = context.baseX + centerX;
+            const assembledY = context.baseY + centerY;
+            const startRotation = mode === "explode"
+                ? context.rotation
+                : context.rotation + (Math.random() * 2 - 1) * options.spin * durationSeconds;
+            const endRotation = mode === "explode"
+                ? context.rotation + (Math.random() * 2 - 1) * options.spin * durationSeconds
+                : context.rotation;
+            return {
+                sx,
+                sy,
+                sw,
+                sh,
+                assembledX,
+                assembledY,
+                offsetX: targetX - assembledX,
+                offsetY: targetY - assembledY,
+                startRotation,
+                endRotation,
+                delayT: 0,
+                fade: options.fade,
+            };
+        }, mode);
+        this._pieceEffects.push({
+            sprite,
+            canvas: glyphCanvas,
+            layer: context.layer,
+            ignoreScroll: context.ignoreScroll,
+            pieces,
+            elapsedMs: 0,
+            durationMs: options.durationMs,
+            mode,
+            restoreVisibility,
+            finalVisible,
+            onComplete,
+        });
+    }
+    /** @internal */
+    spawnDirectionalEffect(mode, sprite, glyphCanvas, context, options, forceHideSprite, restoreVisibility, finalVisible, onComplete) {
+        this.clearSpriteEffects(sprite);
+        if (forceHideSprite || restoreVisibility) {
+            sprite.visible = false;
+        }
+        const durationSeconds = options.durationMs / 1000;
+        const maxDelayT = 0.58;
+        const inPlace = options.direction === "in-place";
+        const directionalFlow = inPlace
+            ? "left-to-right"
+            : options.direction;
+        const directionVector = inPlace ? { x: 0, y: 0 } : this.getDirectionVector(directionalFlow);
+        const perpendicular = inPlace ? { x: 0, y: 0 } : { x: -directionVector.y, y: directionVector.x };
+        const pieces = this.buildPieceGrid(glyphCanvas, context, options.rows, options.cols, (row, col, sx, sy, sw, sh, centerX, centerY) => {
+            const baseDistance = inPlace ? 0 : options.distance * (0.45 + Math.random() * 0.75);
+            const sidewaysDistance = inPlace ? 0 : options.distance * 0.22 * (Math.random() * 2 - 1);
+            const offsetX = directionVector.x * baseDistance + perpendicular.x * sidewaysDistance;
+            const offsetY = directionVector.y * baseDistance + perpendicular.y * sidewaysDistance;
+            const assembledX = context.baseX + centerX;
+            const assembledY = context.baseY + centerY;
+            const delayT = inPlace
+                ? Math.random() * (maxDelayT + 0.05)
+                : this.getDirectionalProgress(row, col, options.rows, options.cols, directionalFlow) *
+                    maxDelayT +
+                    Math.random() * 0.05;
+            const rotationOffset = inPlace
+                ? 0
+                : (Math.random() * 2 - 1) * options.spin * durationSeconds;
+            return {
+                sx,
+                sy,
+                sw,
+                sh,
+                assembledX,
+                assembledY,
+                offsetX,
+                offsetY,
+                startRotation: mode === "disintegrate" ? context.rotation : context.rotation + rotationOffset,
+                endRotation: mode === "disintegrate" ? context.rotation + rotationOffset : context.rotation,
+                delayT: Math.min(maxDelayT + 0.05, delayT),
+                fade: options.fade,
+            };
+        }, mode);
+        this._pieceEffects.push({
+            sprite,
+            canvas: glyphCanvas,
+            layer: context.layer,
+            ignoreScroll: context.ignoreScroll,
+            pieces,
+            elapsedMs: 0,
+            durationMs: options.durationMs,
+            mode,
+            restoreVisibility,
+            finalVisible,
+            onComplete,
+        });
+    }
+    /** @internal */
+    buildPieceGrid(glyphCanvas, context, rows, cols, builder, mode) {
+        const pieces = [];
+        const rotationRad = (context.rotation * Math.PI) / 180;
+        for (let row = 0; row < rows; row++) {
+            const sy = Math.floor((row * glyphCanvas.height) / rows);
+            const nextSy = Math.floor(((row + 1) * glyphCanvas.height) / rows);
+            const sh = Math.max(1, nextSy - sy);
+            for (let col = 0; col < cols; col++) {
+                const sx = Math.floor((col * glyphCanvas.width) / cols);
+                const nextSx = Math.floor(((col + 1) * glyphCanvas.width) / cols);
+                const sw = Math.max(1, nextSx - sx);
+                const localX = (sx + sw / 2 - glyphCanvas.width / 2) * context.signedScaleX;
+                const localY = (sy + sh / 2 - glyphCanvas.height / 2) * context.signedScaleY;
+                const rotated = this.rotate(localX, localY, rotationRad);
+                const generated = builder(row, col, sx, sy, sw, sh, rotated.x, rotated.y);
+                const startX = mode === "explode" || mode === "disintegrate"
+                    ? generated.assembledX
+                    : generated.assembledX + generated.offsetX;
+                const startY = mode === "explode" || mode === "disintegrate"
+                    ? generated.assembledY
+                    : generated.assembledY + generated.offsetY;
+                const endX = mode === "explode" || mode === "disintegrate"
+                    ? generated.assembledX + generated.offsetX
+                    : generated.assembledX;
+                const endY = mode === "explode" || mode === "disintegrate"
+                    ? generated.assembledY + generated.offsetY
+                    : generated.assembledY;
+                const startAlpha = mode === "explode" || mode === "disintegrate"
+                    ? context.baseAlpha
+                    : generated.fade
+                        ? 0
+                        : context.baseAlpha;
+                const endAlpha = mode === "explode" || mode === "disintegrate"
+                    ? generated.fade
+                        ? 0
+                        : context.baseAlpha
+                    : context.baseAlpha;
+                pieces.push({
+                    x: startX,
+                    y: startY,
+                    rotation: generated.startRotation,
+                    alpha: startAlpha,
+                    flipX: context.flipX,
+                    flipY: context.flipY,
+                    sx: generated.sx,
+                    sy: generated.sy,
+                    sw: generated.sw,
+                    sh: generated.sh,
+                    drawWidth: generated.sw * context.absScaleX,
+                    drawHeight: generated.sh * context.absScaleY,
+                    startX,
+                    startY,
+                    endX,
+                    endY,
+                    startRotation: generated.startRotation,
+                    endRotation: generated.endRotation,
+                    startAlpha,
+                    endAlpha,
+                    delayT: generated.delayT,
+                });
+            }
+        }
+        return pieces;
+    }
+    /** @internal */
+    buildPieceSpriteContext(sprite, glyphCanvas) {
+        const renderData = sprite._renderData;
+        const deformScaleX = this.getSafeScale(renderData?.scaleX);
+        const deformScaleY = this.getSafeScale(renderData?.scaleY);
+        const pivotX = this.getSafePivot(renderData?.pivotX);
+        const pivotY = this.getSafePivot(renderData?.pivotY);
+        const offsetX = this.getSafeNumber(renderData?.offsetX, 0);
+        const offsetY = this.getSafeNumber(renderData?.offsetY, 0);
+        const alphaMultiplier = this.getSafeNumber(renderData?.alphaMultiplier, 1);
+        const baseDisplayWidth = sprite.displayWidth;
+        const baseDisplayHeight = sprite.displayHeight;
+        const pivotOffsetX = (pivotX - 0.5) * baseDisplayWidth * (1 - deformScaleX);
+        const pivotOffsetY = (pivotY - 0.5) * baseDisplayHeight * (1 - deformScaleY);
+        const signedScaleX = this.getSafeScale(sprite.scale) * deformScaleX * (sprite.flipX ? -1 : 1);
+        const signedScaleY = this.getSafeScale(sprite.scale) * deformScaleY * (sprite.flipY ? -1 : 1);
+        return {
+            layer: sprite.layer,
+            ignoreScroll: sprite.ignoreScroll,
+            baseX: sprite.renderX + pivotOffsetX + offsetX,
+            baseY: sprite.renderY + pivotOffsetY + offsetY,
+            rotation: sprite.rotation,
+            baseAlpha: Math.max(0, Math.min(1, sprite.alpha * alphaMultiplier)),
+            flipX: sprite.flipX,
+            flipY: sprite.flipY,
+            signedScaleX,
+            signedScaleY,
+            absScaleX: Math.abs(signedScaleX),
+            absScaleY: Math.abs(signedScaleY),
+        };
+    }
+    /** @internal */
+    clearSpriteEffects(sprite) {
+        const remainingPieces = [];
+        for (const effect of this._pieceEffects) {
+            if (effect.sprite === sprite) {
+                if (effect.restoreVisibility) {
+                    effect.sprite.visible = effect.finalVisible;
+                }
+            }
+            else {
+                remainingPieces.push(effect);
+            }
+        }
+        this._pieceEffects = remainingPieces;
+        const remainingWipes = [];
+        for (const wipe of this._wipes) {
+            if (wipe.sprite === sprite) {
+                if (wipe.restoreVisibility) {
+                    wipe.sprite.visible = wipe.finalVisible;
+                }
+            }
+            else {
+                remainingWipes.push(wipe);
+            }
+        }
+        this._wipes = remainingWipes;
+    }
+    /** @internal */
+    getDirectionalProgress(row, col, rows, cols, direction) {
+        const rowProgress = rows <= 1 ? 0 : row / (rows - 1);
+        const colProgress = cols <= 1 ? 0 : col / (cols - 1);
+        switch (direction) {
+            case "left-to-right":
+                return colProgress;
+            case "right-to-left":
+                return 1 - colProgress;
+            case "top-to-bottom":
+                return rowProgress;
+            case "bottom-to-top":
+                return 1 - rowProgress;
+        }
+    }
+    /** @internal */
+    getDirectionVector(direction) {
+        switch (direction) {
+            case "left-to-right":
+                return { x: 1, y: 0 };
+            case "right-to-left":
+                return { x: -1, y: 0 };
+            case "top-to-bottom":
+                return { x: 0, y: 1 };
+            case "bottom-to-top":
+                return { x: 0, y: -1 };
+        }
+    }
+    /** @internal */
+    getRadialVelocity(x, y) {
+        const magnitude = Math.hypot(x, y);
+        let dirX = 0;
+        let dirY = 0;
+        if (magnitude > 0.001) {
+            dirX = x / magnitude;
+            dirY = y / magnitude;
+        }
+        else {
+            const angle = Math.random() * Math.PI * 2;
+            dirX = Math.cos(angle);
+            dirY = Math.sin(angle);
+        }
+        const jitterAngle = (Math.random() - 0.5) * (Math.PI / 2);
+        return this.rotate(dirX, dirY, jitterAngle);
+    }
+    /** @internal */
+    easePieceProgress(mode, t) {
+        const clamped = Math.max(0, Math.min(1, t));
+        switch (mode) {
+            case "explode":
+            case "disintegrate":
+                return 1 - (1 - clamped) * (1 - clamped);
+            case "assemble":
+            case "integrate":
+                return clamped * clamped * (3 - 2 * clamped);
+        }
+    }
+    /** @internal */
+    rotate(x, y, radians) {
+        const cos = Math.cos(radians);
+        const sin = Math.sin(radians);
+        return {
+            x: x * cos - y * sin,
+            y: x * sin + y * cos,
+        };
+    }
+    /** @internal */
+    lerp(from, to, t) {
+        return from + (to - from) * t;
+    }
+    /** @internal */
+    getSafeScale(value) {
+        if (!Number.isFinite(value))
+            return 1;
+        return Math.max(0, value);
+    }
+    /** @internal */
+    getSafePivot(value) {
+        if (!Number.isFinite(value))
+            return 0.5;
+        return Math.max(0, Math.min(1, value));
+    }
+    /** @internal */
+    getSafeNumber(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return value;
+    }
+    /** @internal */
+    sanitizeCount(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(1, Math.round(value));
+    }
+    /** @internal */
+    sanitizeDuration(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(1, value);
+    }
+    /** @internal */
+    sanitizeNonNegative(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(0, value);
+    }
+    /** @internal */
+    sanitizeNumber(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return value;
+    }
+}

package/dist/internal/InputSystem.d.ts

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