@energy8platform/game-engine 0.16.0 → 0.18.0

package/dist/slot.cjs.js

@@ -0,0 +1,998 @@
+'use strict';
+
+var pixi_js = require('pixi.js');
+
+/**
+ * Collection of easing functions for use with Tween and Timeline.
+ *
+ * All functions take a progress value t (0..1) and return the eased value.
+ */
+const Easing = {
+    linear: (t) => t,
+    easeOutQuad: (t) => t * (2 - t),
+    easeOutCubic: (t) => --t * t * t + 1,
+    easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+    easeInBack: (t) => {
+        const c1 = 1.70158;
+        const c3 = c1 + 1;
+        return c3 * t * t * t - c1 * t * t;
+    },
+    easeOutBack: (t) => {
+        const c1 = 1.70158;
+        const c3 = c1 + 1;
+        return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+    },
+    easeOutBounce: (t) => {
+        const n1 = 7.5625;
+        const d1 = 2.75;
+        if (t < 1 / d1)
+            return n1 * t * t;
+        if (t < 2 / d1)
+            return n1 * (t -= 1.5 / d1) * t + 0.75;
+        if (t < 2.5 / d1)
+            return n1 * (t -= 2.25 / d1) * t + 0.9375;
+        return n1 * (t -= 2.625 / d1) * t + 0.984375;
+    }};
+
+/**
+ * Lightweight tween system integrated with PixiJS Ticker.
+ * Zero external dependencies — no GSAP required.
+ *
+ * All tweens return a Promise that resolves on completion.
+ *
+ * @example
+ * ```ts
+ * // Fade in a sprite
+ * await Tween.to(sprite, { alpha: 1, y: 100 }, 500, Easing.easeOutBack);
+ *
+ * // Move and wait
+ * await Tween.to(sprite, { x: 500 }, 300);
+ *
+ * // From a starting value
+ * await Tween.from(sprite, { scale: 0, alpha: 0 }, 400);
+ * ```
+ */
+class Tween {
+    static _tweens = [];
+    static _tickerAdded = false;
+    /**
+     * Animate properties from current values to target values.
+     *
+     * @param target - Object to animate (Sprite, Container, etc.)
+     * @param props - Target property values
+     * @param duration - Duration in milliseconds
+     * @param easing - Easing function (default: easeOutQuad)
+     * @param onUpdate - Progress callback (0..1)
+     */
+    static to(target, props, duration, easing, onUpdate) {
+        return new Promise((resolve) => {
+            // Capture starting values
+            const from = {};
+            for (const key of Object.keys(props)) {
+                from[key] = Tween.getProperty(target, key);
+            }
+            const tween = {
+                target,
+                from,
+                to: { ...props },
+                duration: Math.max(1, duration),
+                easing: easing ?? Easing.easeOutQuad,
+                elapsed: 0,
+                delay: 0,
+                resolve,
+                onUpdate,
+            };
+            Tween._tweens.push(tween);
+            Tween.ensureTicker();
+        });
+    }
+    /**
+     * Animate properties from given values to current values.
+     */
+    static from(target, props, duration, easing, onUpdate) {
+        // Capture current values as "to"
+        const to = {};
+        for (const key of Object.keys(props)) {
+            to[key] = Tween.getProperty(target, key);
+            Tween.setProperty(target, key, props[key]);
+        }
+        return Tween.to(target, to, duration, easing, onUpdate);
+    }
+    /**
+     * Animate from one set of values to another.
+     */
+    static fromTo(target, fromProps, toProps, duration, easing, onUpdate) {
+        // Set starting values
+        for (const key of Object.keys(fromProps)) {
+            Tween.setProperty(target, key, fromProps[key]);
+        }
+        return Tween.to(target, toProps, duration, easing, onUpdate);
+    }
+    /**
+     * Wait for a given duration (useful in timelines).
+     * Uses PixiJS Ticker for consistent timing with other tweens.
+     */
+    static delay(ms) {
+        return new Promise((resolve) => {
+            let elapsed = 0;
+            const onTick = (ticker) => {
+                elapsed += ticker.deltaMS;
+                if (elapsed >= ms) {
+                    pixi_js.Ticker.shared.remove(onTick);
+                    resolve();
+                }
+            };
+            pixi_js.Ticker.shared.add(onTick);
+        });
+    }
+    /**
+     * Kill all tweens on a target.
+     */
+    static killTweensOf(target) {
+        Tween._tweens = Tween._tweens.filter((tw) => {
+            if (tw.target === target) {
+                tw.resolve();
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Kill all active tweens.
+     */
+    static killAll() {
+        for (const tw of Tween._tweens) {
+            tw.resolve();
+        }
+        Tween._tweens.length = 0;
+    }
+    /** Number of active tweens */
+    static get activeTweens() {
+        return Tween._tweens.length;
+    }
+    /**
+     * Reset the tween system — kill all tweens and remove the ticker.
+     * Useful for cleanup between game instances, tests, or hot-reload.
+     */
+    static reset() {
+        for (const tw of Tween._tweens) {
+            tw.resolve();
+        }
+        Tween._tweens.length = 0;
+        if (Tween._tickerAdded) {
+            pixi_js.Ticker.shared.remove(Tween.tick);
+            Tween._tickerAdded = false;
+        }
+    }
+    // ─── Internal ──────────────────────────────────────────
+    static ensureTicker() {
+        if (Tween._tickerAdded)
+            return;
+        Tween._tickerAdded = true;
+        pixi_js.Ticker.shared.add(Tween.tick);
+    }
+    static tick = (ticker) => {
+        const dt = ticker.deltaMS;
+        const completed = [];
+        for (const tw of Tween._tweens) {
+            tw.elapsed += dt;
+            if (tw.elapsed < tw.delay)
+                continue;
+            const raw = Math.min((tw.elapsed - tw.delay) / tw.duration, 1);
+            const t = tw.easing(raw);
+            // Interpolate each property
+            for (const key of Object.keys(tw.to)) {
+                const start = tw.from[key];
+                const end = tw.to[key];
+                const value = start + (end - start) * t;
+                Tween.setProperty(tw.target, key, value);
+            }
+            tw.onUpdate?.(raw);
+            if (raw >= 1) {
+                completed.push(tw);
+            }
+        }
+        // Remove completed tweens
+        for (const tw of completed) {
+            const idx = Tween._tweens.indexOf(tw);
+            if (idx !== -1)
+                Tween._tweens.splice(idx, 1);
+            tw.resolve();
+        }
+        // Remove ticker when no active tweens
+        if (Tween._tweens.length === 0 && Tween._tickerAdded) {
+            pixi_js.Ticker.shared.remove(Tween.tick);
+            Tween._tickerAdded = false;
+        }
+    };
+    /**
+     * Get a potentially nested property (supports 'scale.x', 'position.y', etc.)
+     */
+    static getProperty(target, key) {
+        const parts = key.split('.');
+        let obj = target;
+        for (let i = 0; i < parts.length - 1; i++) {
+            obj = obj[parts[i]];
+        }
+        return obj[parts[parts.length - 1]] ?? 0;
+    }
+    /**
+     * Set a potentially nested property.
+     */
+    static setProperty(target, key, value) {
+        const parts = key.split('.');
+        let obj = target;
+        for (let i = 0; i < parts.length - 1; i++) {
+            obj = obj[parts[i]];
+        }
+        obj[parts[parts.length - 1]] = value;
+    }
+}
+
+/**
+ * Helper for creating frame-based animations from spritesheets.
+ *
+ * Wraps PixiJS `AnimatedSprite` with a convenient API for
+ * common iGaming effects: coin showers, symbol animations,
+ * sparkle trails, win celebrations.
+ *
+ * Cheaper than Spine for simple frame sequences.
+ *
+ * @example
+ * ```ts
+ * // From an array of textures
+ * const coinAnim = SpriteAnimation.create(coinTextures, {
+ *   fps: 30,
+ *   loop: true,
+ * });
+ * scene.addChild(coinAnim);
+ *
+ * // From a spritesheet with a naming pattern
+ * const sheet = Assets.get('effects');
+ * const sparkle = SpriteAnimation.fromSpritesheet(sheet, 'sparkle_');
+ * sparkle.play();
+ *
+ * // From a numbered range
+ * const explosion = SpriteAnimation.fromRange(sheet, 'explosion_{i}', 0, 24, {
+ *   fps: 60,
+ *   loop: false,
+ *   onComplete: () => explosion.destroy(),
+ * });
+ * ```
+ */
+class SpriteAnimation {
+    /**
+     * Create an animated sprite from an array of textures.
+     *
+     * @param textures - Array of PixiJS Textures
+     * @param config - Animation options
+     * @returns Configured AnimatedSprite
+     */
+    static create(textures, config = {}) {
+        const sprite = new pixi_js.AnimatedSprite(textures);
+        // Configure
+        sprite.animationSpeed = (config.fps ?? 24) / 60; // PixiJS uses speed relative to 60fps ticker
+        sprite.loop = config.loop ?? true;
+        // Anchor
+        if (config.anchor !== undefined) {
+            if (typeof config.anchor === 'number') {
+                sprite.anchor.set(config.anchor);
+            }
+            else {
+                sprite.anchor.set(config.anchor.x, config.anchor.y);
+            }
+        }
+        else {
+            sprite.anchor.set(0.5);
+        }
+        // Complete callback
+        if (config.onComplete) {
+            sprite.onComplete = config.onComplete;
+        }
+        // Auto-play
+        if (config.autoPlay !== false) {
+            sprite.play();
+        }
+        return sprite;
+    }
+    /**
+     * Create an animated sprite from a spritesheet using a name prefix.
+     *
+     * Collects all textures whose keys start with `prefix`, sorted alphabetically.
+     *
+     * @param sheet - PixiJS Spritesheet instance
+     * @param prefix - Texture name prefix (e.g., 'coin_')
+     * @param config - Animation options
+     * @returns Configured AnimatedSprite
+     */
+    static fromSpritesheet(sheet, prefix, config = {}) {
+        const textures = SpriteAnimation.getTexturesByPrefix(sheet, prefix);
+        if (textures.length === 0) {
+            console.warn(`[SpriteAnimation] No textures found with prefix "${prefix}"`);
+        }
+        return SpriteAnimation.create(textures, config);
+    }
+    /**
+     * Create an animated sprite from a numbered range of frames.
+     *
+     * The `pattern` string should contain `{i}` as a placeholder for the frame number.
+     * Numbers are zero-padded to match the length of `start`.
+     *
+     * @param sheet - PixiJS Spritesheet instance
+     * @param pattern - Frame name pattern, e.g. 'explosion_{i}'
+     * @param start - Start frame index (inclusive)
+     * @param end - End frame index (inclusive)
+     * @param config - Animation options
+     * @returns Configured AnimatedSprite
+     */
+    static fromRange(sheet, pattern, start, end, config = {}) {
+        const textures = [];
+        const padLength = String(end).length;
+        for (let i = start; i <= end; i++) {
+            const name = pattern.replace('{i}', String(i).padStart(padLength, '0'));
+            const texture = sheet.textures[name];
+            if (texture) {
+                textures.push(texture);
+            }
+            else {
+                console.warn(`[SpriteAnimation] Missing frame: "${name}"`);
+            }
+        }
+        if (textures.length === 0) {
+            console.warn(`[SpriteAnimation] No textures found for pattern "${pattern}" [${start}..${end}]`);
+        }
+        return SpriteAnimation.create(textures, config);
+    }
+    /**
+     * Create an AnimatedSprite from texture aliases (loaded via AssetManager).
+     *
+     * @param aliases - Array of texture aliases
+     * @param config - Animation options
+     * @returns Configured AnimatedSprite
+     */
+    static fromAliases(aliases, config = {}) {
+        const textures = aliases.map((alias) => {
+            const tex = pixi_js.Texture.from(alias);
+            return tex;
+        });
+        return SpriteAnimation.create(textures, config);
+    }
+    /**
+     * Play a one-shot animation and auto-destroy when complete.
+     * Useful for fire-and-forget effects like coin bursts.
+     *
+     * @param textures - Array of textures
+     * @param config - Animation options (loop will be forced to false)
+     * @returns Promise that resolves when animation completes
+     */
+    static playOnce(textures, config = {}) {
+        const finished = new Promise((resolve) => {
+            config = {
+                ...config,
+                loop: false,
+                onComplete: () => {
+                    config.onComplete?.();
+                    sprite.destroy();
+                    resolve();
+                },
+            };
+        });
+        const sprite = SpriteAnimation.create(textures, config);
+        return { sprite, finished };
+    }
+    // ─── Utility ───────────────────────────────────────────
+    /**
+     * Get all textures from a spritesheet that start with a given prefix.
+     * Results are sorted alphabetically by key.
+     */
+    static getTexturesByPrefix(sheet, prefix) {
+        const keys = Object.keys(sheet.textures)
+            .filter((k) => k.startsWith(prefix))
+            .sort();
+        return keys.map((k) => sheet.textures[k]);
+    }
+}
+
+/** Built-in SymbolView: a static base sprite with optional idle/win spritesheet frames. */
+class AnimatedSymbol extends pixi_js.Container {
+    _base;
+    _anim = null;
+    _textures;
+    _size;
+    _fps;
+    constructor(config) {
+        super();
+        this._textures = config.textures;
+        this._size = config.size;
+        this._fps = config.fps ?? 24;
+        this._base = new pixi_js.Sprite(config.textures.base);
+        this._base.anchor.set(0.5);
+        this.addChild(this._base);
+        this.resize(this._size);
+    }
+    setTextures(t) {
+        this._textures = t;
+        this._base.texture = t.base;
+        this.showStatic();
+    }
+    resize(size) {
+        this._size = size;
+        this._base.width = size;
+        this._base.height = size;
+        if (this._anim) {
+            this._anim.width = size;
+            this._anim.height = size;
+        }
+    }
+    showStatic() {
+        if (this._anim) {
+            this._anim.destroy();
+            this._anim = null;
+        }
+        this._base.visible = true;
+    }
+    playIdle() {
+        if (!this._textures.idle?.length)
+            return;
+        this._swap(this._textures.idle, true);
+    }
+    playWin() {
+        if (!this._textures.win?.length)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            this._swap(this._textures.win, false, () => { this.showStatic(); resolve(); });
+        });
+    }
+    _swap(frames, loop, onComplete) {
+        if (this._anim) {
+            this._anim.destroy();
+            this._anim = null;
+        }
+        this._base.visible = false;
+        const a = SpriteAnimation.create(frames, { loop, autoPlay: true, onComplete });
+        a.anchor.set(0.5);
+        a.width = this._size;
+        a.height = this._size;
+        a.animationSpeed = this._fps / 60;
+        this.addChild(a);
+        this._anim = a;
+    }
+}
+
+const DEFAULT_STYLE = {
+    radius: 8,
+    idle: { color: 0x223047, alpha: 0.34 },
+    winning: { color: 0x00d4ff, alpha: 0.95 },
+    removed: { color: 0x223047, alpha: 0.12 },
+    fresh: { color: 0xffffff, alpha: 0.6 },
+};
+class SymbolCell extends pixi_js.Container {
+    __uiComponent = true;
+    _size;
+    _resolve;
+    _style;
+    _frame;
+    _view = null;
+    _badges = new pixi_js.Container();
+    _multBadge = null;
+    _bonusBadge = null;
+    /** Last applied state key — exposed for tests/inspection. */
+    frameStyleKey = 'idle';
+    constructor(config) {
+        super();
+        this._size = config.size;
+        this._resolve = config.resolve;
+        this._style = { ...DEFAULT_STYLE, ...(config.frameStyle ?? {}) };
+        this._frame = new pixi_js.Graphics();
+        this.addChild(this._frame);
+        this.addChild(this._badges);
+        this._drawFrame('idle');
+    }
+    get view() { return this._view; }
+    setData(data) {
+        // symbol view
+        if (data.symbol == null) {
+            if (this._view) {
+                this._view.destroy();
+                this._view = null;
+            }
+        }
+        else {
+            if (this._view) {
+                this._view.destroy();
+                this._view = null;
+            }
+            const v = this._resolve(data.symbol);
+            if (v) {
+                v.resize?.(this._size);
+                this.addChildAt(v, 1); // above frame, below badges
+                this._view = v;
+            }
+        }
+        // badges
+        this._setMultiplier(data.multiplier);
+        this._setBonus(data.bonus);
+    }
+    setState(state) {
+        const key = state.winning ? 'winning' : state.removed ? 'removed' : state.fresh ? 'fresh' : 'idle';
+        this.frameStyleKey = key;
+        this._drawFrame(key);
+    }
+    playWin() {
+        if (this._view?.playWin)
+            return this._view.playWin();
+        // default: scale pop
+        const target = this._view ?? this;
+        return Tween.to(target, { 'scale.x': 1.15, 'scale.y': 1.15 }, 160, Easing.easeOutBack)
+            .then(() => Tween.to(target, { 'scale.x': 1, 'scale.y': 1 }, 140, Easing.easeOutQuad));
+    }
+    playIdle() { this._view?.playIdle?.(); }
+    hasBadge(kind) {
+        return kind === 'multiplier' ? this._multBadge != null : this._bonusBadge != null;
+    }
+    _drawFrame(key) {
+        const s = this._style[key];
+        this._frame.clear();
+        this._frame
+            .roundRect(-this._size / 2, -this._size / 2, this._size, this._size, this._style.radius)
+            .fill({ color: s.color, alpha: s.alpha });
+        // store the colour as tint for cheap inspection/testing
+        this._frame.tint = s.color;
+    }
+    _setMultiplier(value) {
+        if (this._multBadge) {
+            this._multBadge.destroy();
+            this._multBadge = null;
+        }
+        if (!value || value <= 1)
+            return;
+        this._multBadge = this._badge(`×${value}`, 0xffd24a);
+        this._multBadge.position.set(this._size / 2 - 12, -this._size / 2 + 12);
+        this._badges.addChild(this._multBadge);
+    }
+    _setBonus(value) {
+        if (this._bonusBadge) {
+            this._bonusBadge.destroy();
+            this._bonusBadge = null;
+        }
+        if (!value || value <= 0)
+            return;
+        this._bonusBadge = this._badge(`+${value}`, 0x7ad7ff);
+        this._bonusBadge.position.set(-this._size / 2 + 12, -this._size / 2 + 12);
+        this._badges.addChild(this._bonusBadge);
+    }
+    _badge(label, color) {
+        const c = new pixi_js.Container();
+        const t = new pixi_js.Text({ text: label, style: { fontSize: 18, fill: color, fontWeight: '700' } });
+        t.anchor.set(0.5);
+        c.addChild(t);
+        return c;
+    }
+}
+
+class ReelGrid extends pixi_js.Container {
+    __uiComponent = true;
+    _cols;
+    _rows;
+    _cellSize;
+    _gap;
+    _cells = [];
+    _cellLayer = new pixi_js.Container();
+    constructor(config) {
+        super();
+        this._cols = config.cols;
+        this._rows = config.rows;
+        this._cellSize = config.cellSize;
+        this._gap = config.gap ?? 0;
+        if (config.decoration) {
+            const pad = config.decoration.padding ?? 0;
+            const w = this._cols * (this._cellSize + this._gap) - this._gap + pad * 2;
+            const h = this._rows * (this._cellSize + this._gap) - this._gap + pad * 2;
+            if (config.decoration.texture) {
+                const deco = new pixi_js.Sprite(config.decoration.texture);
+                deco.width = w;
+                deco.height = h;
+                deco.position.set(-pad - this._cellSize / 2, -pad - this._cellSize / 2);
+                this.addChild(deco);
+            }
+        }
+        this.addChild(this._cellLayer);
+        for (let c = 0; c < this._cols; c++) {
+            this._cells[c] = [];
+            for (let r = 0; r < this._rows; r++) {
+                const cell = new SymbolCell({ size: this._cellSize, resolve: config.resolve, frameStyle: config.frameStyle });
+                const { x, y } = this.cellPosition(c, r);
+                cell.position.set(x, y);
+                this._cellLayer.addChild(cell);
+                this._cells[c][r] = cell;
+            }
+        }
+        if (config.mask) {
+            const w = this._cols * (this._cellSize + this._gap) - this._gap;
+            const h = this._rows * (this._cellSize + this._gap) - this._gap;
+            const m = new pixi_js.Graphics()
+                .rect(-this._cellSize / 2, -this._cellSize / 2, w, h)
+                .fill(0xffffff);
+            this._cellLayer.mask = m;
+            this.addChild(m);
+        }
+    }
+    get cols() { return this._cols; }
+    get rows() { return this._rows; }
+    cellPosition(col, row) {
+        const step = this._cellSize + this._gap;
+        return { x: col * step, y: row * step };
+    }
+    getCell(col, row) { return this._cells[col][row]; }
+    setGrid(cells) {
+        for (let c = 0; c < this._cols; c++) {
+            for (let r = 0; r < this._rows; r++) {
+                this._cells[c]?.[r]?.setData(cells[c]?.[r] ?? { symbol: null });
+            }
+        }
+    }
+    resize(cellSize) {
+        this._cellSize = cellSize;
+        for (let c = 0; c < this._cols; c++) {
+            for (let r = 0; r < this._rows; r++) {
+                const { x, y } = this.cellPosition(c, r);
+                this._cells[c][r].position.set(x, y);
+            }
+        }
+    }
+}
+
+// packages/game-engine/src/slot/anim/easing-map.ts
+/** Resolve a descriptor's string easing name to the engine's easing function. */
+const EASING_BY_NAME = {
+    linear: Easing.linear,
+    easeOutQuad: Easing.easeOutQuad,
+    easeOutCubic: Easing.easeOutCubic,
+    easeOutBack: Easing.easeOutBack,
+    easeOutBounce: Easing.easeOutBounce,
+    easeInBack: Easing.easeInBack,
+    easeInOutCubic: Easing.easeInOutCubic,
+};
+
+// packages/game-engine/src/slot/anim/CascadeController.ts
+const DEFAULT_TIMINGS$1 = { reveal: 300, highlight: 400, remove: 250, drop: 200, refill: 220, wait: 150 };
+class CascadeController {
+    _grid;
+    _t;
+    _killed = false;
+    constructor(grid, timings) {
+        this._grid = grid;
+        this._t = { ...DEFAULT_TIMINGS$1, ...(timings ?? {}) };
+    }
+    /** PURE: ordered animation descriptors for a cascade step. */
+    plan(step, opts) {
+        const f = opts?.turbo ? 0.5 : 1;
+        const out = [];
+        for (const w of step.winningCells) {
+            out.push({ col: w.col, row: w.row, phase: 'highlight', scale: 1.08, duration: this._t.highlight * f, easing: 'easeOutQuad' });
+        }
+        for (const w of step.winningCells) {
+            out.push({ col: w.col, row: w.row, phase: 'remove', scale: 0, alpha: 0, duration: this._t.remove * f, easing: 'easeInBack' });
+        }
+        // new cells drop from two row-heights above their target, staggered per column.
+        // Row height is derived purely from public geometry (no private grid access).
+        const rowStep = this._grid.cellPosition(0, 1).y - this._grid.cellPosition(0, 0).y;
+        const perCol = {};
+        for (const n of step.newCells) {
+            const to = this._grid.cellPosition(n.col, n.row);
+            const from = { x: to.x, y: to.y - rowStep * 2 };
+            const idx = (perCol[n.col] = (perCol[n.col] ?? 0) + 1);
+            out.push({ col: n.col, row: n.row, phase: 'drop', from, to, duration: this._t.drop * f, easing: 'easeOutBounce', delay: idx * 30 * f });
+        }
+        return out;
+    }
+    /** Execute the plan via Tween. Not unit-tested (Ticker doesn't tick in node). */
+    async run(step, opts) {
+        this._killed = false;
+        const plan = this.plan(step, opts);
+        // highlight + remove first
+        for (const a of plan.filter((p) => p.phase === 'highlight')) {
+            if (this._killed)
+                return;
+            const cell = this._grid.getCell(a.col, a.row);
+            cell.setState({ winning: true });
+            await Tween.to(cell, { 'scale.x': a.scale, 'scale.y': a.scale }, a.duration, EASING_BY_NAME[a.easing ?? 'easeOutQuad']);
+        }
+        for (const a of plan.filter((p) => p.phase === 'remove')) {
+            if (this._killed)
+                return;
+            const cell = this._grid.getCell(a.col, a.row);
+            await Tween.to(cell, { 'scale.x': 0, 'scale.y': 0, alpha: 0 }, a.duration, EASING_BY_NAME[a.easing ?? 'easeInBack']);
+        }
+        // settle data, then drop new cells in
+        this._grid.setGrid(step.settledGrid);
+        await Promise.all(plan.filter((p) => p.phase === 'drop').map(async (a) => {
+            if (this._killed)
+                return;
+            const cell = this._grid.getCell(a.col, a.row);
+            cell.alpha = 1;
+            cell.scale.set(1);
+            cell.position.set(a.from.x, a.from.y);
+            if (a.delay)
+                await Tween.delay(a.delay);
+            await Tween.to(cell, { 'position.y': a.to.y }, a.duration, EASING_BY_NAME[a.easing ?? 'easeOutBounce']);
+        }));
+    }
+    _killOwnTweens() {
+        for (let c = 0; c < this._grid.cols; c++) {
+            for (let r = 0; r < this._grid.rows; r++) {
+                Tween.killTweensOf(this._grid.getCell(c, r));
+            }
+        }
+    }
+    skip() { this._killOwnTweens(); }
+    kill() { this._killed = true; this._killOwnTweens(); }
+}
+
+// packages/game-engine/src/slot/anim/ReelSpinController.ts
+const DEFAULT_TIMINGS = { spinUp: 500, hold: 200, stopStagger: 120, settle: 240 };
+class ReelSpinController {
+    _grid;
+    _t;
+    _killed = false;
+    constructor(grid, timings) {
+        this._grid = grid;
+        this._t = { ...DEFAULT_TIMINGS, ...(timings ?? {}) };
+    }
+    /** PURE: per-reel stop timing + landing window. No Pixi mutation. */
+    plan(data, opts) {
+        const f = opts?.turbo ? 0.5 : 1;
+        const out = [];
+        for (let reel = 0; reel < this._grid.cols; reel++) {
+            out.push({
+                reel,
+                stopTime: this._t.spinUp * f + reel * this._t.stopStagger * f,
+                landing: data.targetGrid[reel] ?? [],
+                settle: { amp: 7, ms: this._t.settle * f },
+            });
+        }
+        return out;
+    }
+    /** Execute the spin: scroll each reel, decelerate, land on target, settle-bounce. Not unit-tested. */
+    async run(data, opts) {
+        this._killed = false;
+        const plan = this.plan(data, opts);
+        await Promise.all(plan.map(async (p) => {
+            if (this._killed)
+                return;
+            const strip = data.strip?.(p.reel) ?? p.landing.map((c) => c.symbol ?? '');
+            // texture-swap spin: cycle symbols quickly while decelerating, then land
+            const cells = Array.from({ length: this._grid.rows }, (_, r) => this._grid.getCell(p.reel, r));
+            const ticks = Math.max(6, Math.floor(p.stopTime / 60));
+            for (let i = 0; i < ticks; i++) {
+                if (this._killed)
+                    break;
+                for (let r = 0; r < cells.length; r++) {
+                    const sym = strip[(i + r) % strip.length] || null;
+                    cells[r].setData({ symbol: sym });
+                }
+                await Tween.delay(Math.min(60, p.stopTime / ticks));
+            }
+            // land on the real target
+            for (let r = 0; r < cells.length; r++)
+                cells[r].setData(p.landing[r] ?? { symbol: null });
+            // settle bounce on the column parent
+            if (!this._killed && cells[0]?.parent) {
+                const colY = cells[0].parent.y;
+                await Tween.fromTo(cells[0].parent, { y: colY - p.settle.amp }, { y: colY }, p.settle.ms, Easing.easeOutBack);
+            }
+        }));
+    }
+    _killOwnTweens() {
+        for (let c = 0; c < this._grid.cols; c++) {
+            for (let r = 0; r < this._grid.rows; r++) {
+                Tween.killTweensOf(this._grid.getCell(c, r));
+            }
+        }
+    }
+    skip() { this._killed = true; this._killOwnTweens(); }
+}
+
+/** Highest tier whose minMultiplier <= win/bet, or null if below the lowest. */
+function pickTier(tiers, win, bet) {
+    if (bet <= 0)
+        return null;
+    const mult = win / bet;
+    let chosen = null;
+    for (const t of tiers) {
+        if (mult >= t.minMultiplier && (!chosen || t.minMultiplier >= chosen.minMultiplier))
+            chosen = t;
+    }
+    return chosen;
+}
+/** Index into `tiers` for the running value (or -1 below the lowest tier). */
+function tierIndexAtValue(tiers, runningValue, bet) {
+    if (bet <= 0)
+        return -1;
+    const mult = runningValue / bet;
+    let idx = -1;
+    for (let i = 0; i < tiers.length; i++)
+        if (mult >= tiers[i].minMultiplier)
+            idx = i;
+    return idx;
+}
+
+/** PURE eased interpolation 0→target over duration (ms). Clamped to [0, target]. */
+function valueAt(elapsed, target, duration) {
+    if (duration <= 0 || elapsed >= duration)
+        return target;
+    if (elapsed <= 0)
+        return 0;
+    const p = elapsed / duration;
+    const eased = 1 - Math.pow(1 - p, 3); // easeOutCubic
+    return target * eased;
+}
+class CountUpDisplay extends pixi_js.Container {
+    __uiComponent = true;
+    _text;
+    _format;
+    _value = 0;
+    constructor(config) {
+        super();
+        this._format = config.format;
+        this._text = new pixi_js.Text({
+            text: this._format(0),
+            style: { fontFamily: 'sans-serif', fontSize: 48, fill: 0xffffff, fontWeight: '800', ...config.style },
+        });
+        this._text.anchor.set(0.5);
+        this.addChild(this._text);
+    }
+    get text() { return this._text.text; }
+    setValue(v) {
+        this._value = v;
+        this._text.text = this._format(v);
+    }
+    /** Swap the value formatter and immediately re-render the current value. */
+    setFormat(format) {
+        this._format = format;
+        this._text.text = this._format(this._value);
+    }
+    /** Animate the value to target over duration; fires onTier on each tier-index increase. */
+    async countTo(target, duration, onTier) {
+        const holder = { v: 0 };
+        await Tween.to(holder, { v: target }, duration, Easing.easeOutCubic, () => {
+            this.setValue(holder.v);
+        });
+        this.setValue(target);
+    }
+    skip() { Tween.killTweensOf(this); }
+}
+
+const DEFAULT_DURATION = (win) => Math.min(2500, Math.max(800, win * 20));
+class BigWinOverlay extends pixi_js.Container {
+    __uiComponent = true;
+    _cfg;
+    _dim;
+    _banner = null;
+    _title;
+    _count;
+    constructor(config) {
+        super();
+        this._cfg = config;
+        this.visible = false;
+        this._dim = new pixi_js.Graphics();
+        this.addChild(this._dim);
+        this._title = new pixi_js.Text({ text: '', style: { fontFamily: 'sans-serif', fontSize: 72, fill: 0xffffff, fontWeight: '900' } });
+        this._title.anchor.set(0.5);
+        this.addChild(this._title);
+        this._count = new CountUpDisplay({ format: config.formatMoney });
+        this.addChild(this._count);
+        this.resize(config.width, config.height);
+    }
+    /** Pure helper (testable): the tier title for a given win/bet, or null below the lowest tier. */
+    tierTitleFor(win, bet) {
+        return pickTier(this._cfg.tiers, win, bet)?.title ?? null;
+    }
+    resize(width, height) {
+        this._cfg.width = width;
+        this._cfg.height = height;
+        this._dim.clear();
+        this._dim.rect(0, 0, width, height).fill({ color: 0x000000, alpha: 0.72 });
+        this._title.position.set(width / 2, height * 0.4);
+        this._count.position.set(width / 2, height * 0.56);
+    }
+    async show(win, bet, format) {
+        const tier = pickTier(this._cfg.tiers, win, bet);
+        if (!tier)
+            return;
+        if (format)
+            this._count.setFormat(format);
+        this.visible = true;
+        this.alpha = 0;
+        this._title.text = tier.title;
+        this._title.style.fill = tier.accentColor;
+        if (this._banner) {
+            this._banner.destroy();
+            this._banner = null;
+        }
+        if (tier.bannerTexture) {
+            this._banner = new pixi_js.Sprite(tier.bannerTexture);
+            this._banner.anchor.set(0.5);
+            this._banner.position.set(this._cfg.width / 2, this._cfg.height * 0.4);
+            this.addChildAt(this._banner, 1);
+        }
+        await Tween.to(this, { alpha: 1 }, 200, Easing.easeOutQuad);
+        const dur = (this._cfg.countUpDuration ?? DEFAULT_DURATION)(win);
+        let lastIdx = tierIndexAtValue(this._cfg.tiers, 0, bet);
+        await this._count.countTo(win, dur, undefined);
+        // tier-promotion title updates as the value climbs (sampled at the end for simplicity)
+        const finalIdx = tierIndexAtValue(this._cfg.tiers, win, bet);
+        if (finalIdx > lastIdx && this._cfg.tiers[finalIdx]) {
+            this._title.text = this._cfg.tiers[finalIdx].title;
+        }
+    }
+    skip() { Tween.killTweensOf(this); this._count.skip(); }
+    hide() { this.visible = false; Tween.killTweensOf(this); }
+}
+
+/** Headless free-spins state machine. The scene drives it; rendering/HUD reflect it. */
+class FreeSpinsSession {
+    remaining;
+    total;
+    totalWin = 0;
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.remaining = cfg.initialSpins;
+        this.total = cfg.initialSpins;
+    }
+    award(extra) {
+        if (extra > 0) {
+            this.remaining += extra;
+            this.total += extra;
+        }
+    }
+    /** Convenience: award using the configured retrigger rule. */
+    applyRetrigger(result) {
+        this.award(this.cfg.retrigger?.(result) ?? 0);
+    }
+    addWin(amount) { this.totalWin += amount; }
+    consume() { if (this.remaining > 0)
+        this.remaining -= 1; }
+    get isComplete() {
+        return this.remaining <= 0 || (this.cfg.isMaxWin?.() ?? false);
+    }
+}
+
+// How long each policy survives: cascade (shortest) < spin < session (longest).
+const RANK = { cascade: 0, spin: 1, session: 2 };
+/**
+ * Headless sticky/collector multiplier — the unified abstraction behind
+ * kitsunebi / recipe / orb / stage multipliers. reset(boundary) clears the
+ * value only when the boundary is at or above the configured policy scope.
+ */
+class MultiplierAccumulator {
+    value;
+    base;
+    policy;
+    constructor(cfg) {
+        this.policy = cfg.policy;
+        this.base = cfg.base ?? 1;
+        this.value = this.base;
+    }
+    add(delta) { this.value += delta; }
+    set(value) { this.value = value; }
+    reset(boundary) {
+        if (RANK[boundary] >= RANK[this.policy])
+            this.value = this.base;
+    }
+}
+
+exports.AnimatedSymbol = AnimatedSymbol;
+exports.BigWinOverlay = BigWinOverlay;
+exports.CascadeController = CascadeController;
+exports.CountUpDisplay = CountUpDisplay;
+exports.FreeSpinsSession = FreeSpinsSession;
+exports.MultiplierAccumulator = MultiplierAccumulator;
+exports.ReelGrid = ReelGrid;
+exports.ReelSpinController = ReelSpinController;
+exports.SymbolCell = SymbolCell;
+exports.pickTier = pickTier;
+exports.tierIndexAtValue = tierIndexAtValue;
+exports.valueAt = valueAt;
+//# sourceMappingURL=slot.cjs.js.map