minimojs 1.0.0-alpha.12 → 1.0.0-alpha.14

package/dist/internal/ExplosionSystem.js

@@ -1,4 +1,4 @@
-const DEFAULT_OPTIONS = {
+const DEFAULT_EXPLODE_OPTIONS = {
     rows: 3,
     cols: 3,
     durationMs: 500,
@@ -8,43 +8,299 @@ const DEFAULT_OPTIONS = {
     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() {
-        this._explosions = [];
+        this._pieceEffects = [];
+        this._wipes = [];
     }
     animateExplode(sprite, glyphCanvas, options, onComplete) {
-        this.clearSpriteExplosions(sprite);
-        const rows = this.sanitizeCount(options?.rows, DEFAULT_OPTIONS.rows);
-        const cols = this.sanitizeCount(options?.cols, DEFAULT_OPTIONS.cols);
-        const durationMs = this.sanitizeDuration(options?.durationMs, DEFAULT_OPTIONS.durationMs);
-        const speed = this.sanitizeNonNegative(options?.speed, DEFAULT_OPTIONS.speed);
-        const gravityY = this.sanitizeNumber(options?.gravityY, DEFAULT_OPTIONS.gravityY);
-        const spin = this.sanitizeNonNegative(options?.spin, DEFAULT_OPTIONS.spin);
-        const fade = options?.fade ?? DEFAULT_OPTIONS.fade;
-        const destroySprite = options?.destroySprite ?? DEFAULT_OPTIONS.destroySprite;
-        const originalVisible = sprite.visible;
-        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);
-        const absScaleX = Math.abs(signedScaleX);
-        const absScaleY = Math.abs(signedScaleY);
-        const rotationRad = (sprite.rotation * Math.PI) / 180;
-        const baseX = sprite.renderX + pivotOffsetX + offsetX;
-        const baseY = sprite.renderY + pivotOffsetY + offsetY;
-        const baseAlpha = Math.max(0, Math.min(1, sprite.alpha * alphaMultiplier));
+        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 = [];
+    }
+    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,
+        });
+    }
+    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,
+        });
+    }
+    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);
@@ -53,102 +309,142 @@ export class ExplosionSystem {
                 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) * signedScaleX;
-                const localY = (sy + sh / 2 - glyphCanvas.height / 2) * signedScaleY;
+                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 velocity = this.getPieceVelocity(rotated.x, rotated.y, speed);
+                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: baseX + rotated.x,
-                    y: baseY + rotated.y,
-                    rotation: sprite.rotation,
-                    alpha: baseAlpha,
-                    flipX: sprite.flipX,
-                    flipY: sprite.flipY,
-                    sx,
-                    sy,
-                    sw,
-                    sh,
-                    drawWidth: sw * absScaleX,
-                    drawHeight: sh * absScaleY,
-                    vx: velocity.x,
-                    vy: velocity.y,
-                    angularVelocity: (Math.random() * 2 - 1) * spin,
+                    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,
                 });
             }
         }
-        if (!destroySprite) {
-            sprite.visible = false;
-        }
-        this._explosions.push({
-            sprite,
-            canvas: glyphCanvas,
+        return pieces;
+    }
+    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,
-            pieces,
-            elapsedMs: 0,
-            durationMs,
-            gravityY,
-            fade,
-            baseAlpha,
-            restoreVisibility: !destroySprite,
-            originalVisible,
-            onComplete,
-        });
+            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),
+        };
     }
-    update(dt, dtMs) {
-        const explosions = this._explosions;
-        const toRemove = [];
-        for (let i = 0; i < explosions.length; i++) {
-            const explosion = explosions[i];
-            explosion.elapsedMs += dtMs;
-            const t = Math.min(explosion.elapsedMs / explosion.durationMs, 1);
-            for (const piece of explosion.pieces) {
-                piece.vy += explosion.gravityY * dt;
-                piece.x += piece.vx * dt;
-                piece.y += piece.vy * dt;
-                piece.rotation += piece.angularVelocity * dt;
-                piece.alpha = explosion.fade
-                    ? explosion.baseAlpha * (1 - t)
-                    : explosion.baseAlpha;
-            }
-            if (t >= 1) {
-                toRemove.push(i);
-                if (explosion.restoreVisibility) {
-                    explosion.sprite.visible = explosion.originalVisible;
+    clearSpriteEffects(sprite) {
+        const remainingPieces = [];
+        for (const effect of this._pieceEffects) {
+            if (effect.sprite === sprite) {
+                if (effect.restoreVisibility) {
+                    effect.sprite.visible = effect.finalVisible;
                 }
-                explosion.onComplete?.();
             }
-        }
-        for (let i = toRemove.length - 1; i >= 0; i--) {
-            explosions.splice(toRemove[i], 1);
-        }
-    }
-    getRenderEntries() {
-        return this._explosions;
-    }
-    clearAll() {
-        for (const explosion of this._explosions) {
-            if (explosion.restoreVisibility) {
-                explosion.sprite.visible = explosion.originalVisible;
+            else {
+                remainingPieces.push(effect);
             }
         }
-        this._explosions = [];
-    }
-    clearSpriteExplosions(sprite) {
-        const remaining = [];
-        for (const explosion of this._explosions) {
-            if (explosion.sprite === sprite) {
-                if (explosion.restoreVisibility) {
-                    explosion.sprite.visible = explosion.originalVisible;
+        this._pieceEffects = remainingPieces;
+        const remainingWipes = [];
+        for (const wipe of this._wipes) {
+            if (wipe.sprite === sprite) {
+                if (wipe.restoreVisibility) {
+                    wipe.sprite.visible = wipe.finalVisible;
                 }
             }
             else {
-                remaining.push(explosion);
+                remainingWipes.push(wipe);
             }
         }
-        this._explosions = remaining;
+        this._wipes = remainingWipes;
+    }
+    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;
+        }
     }
-    getPieceVelocity(x, y, speed) {
+    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 };
+        }
+    }
+    getRadialVelocity(x, y) {
         const magnitude = Math.hypot(x, y);
         let dirX = 0;
         let dirY = 0;
@@ -162,12 +458,18 @@ export class ExplosionSystem {
             dirY = Math.sin(angle);
         }
         const jitterAngle = (Math.random() - 0.5) * (Math.PI / 2);
-        const jittered = this.rotate(dirX, dirY, jitterAngle);
-        const pieceSpeed = speed * (0.65 + Math.random() * 0.7);
-        return {
-            x: jittered.x * pieceSpeed,
-            y: jittered.y * pieceSpeed,
-        };
+        return this.rotate(dirX, dirY, jitterAngle);
+    }
+    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);
+        }
     }
     rotate(x, y, radians) {
         const cos = Math.cos(radians);
@@ -177,6 +479,9 @@ export class ExplosionSystem {
             y: x * sin + y * cos,
         };
     }
+    lerp(from, to, t) {
+        return from + (to - from) * t;
+    }
     getSafeScale(value) {
         if (!Number.isFinite(value))
             return 1;

package/dist/internal/LoopSystem.js

@@ -27,6 +27,9 @@ export class LoopSystem {
     set onCreate(callback) {
         this._onCreate = callback;
     }
+    get isRunning() {
+        return this._running;
+    }
     start() {
         if (this._running)
             return;