@energy8platform/game-engine 0.40.0 → 0.41.0

package/dist/slot.d.ts

@@ -494,6 +494,8 @@ interface AnticipationOverride {
     slowdown?: PerReel<number>;
     /** Extra hold before landing. Scalar, or per-reel indexed by reel index. */
     holdMs?: PerReel<number>;
+    /** Growth of the gap between successive cells within a reel. Scalar, or per-reel. */
+    cellStaggerRamp?: PerReel<number>;
 }
 interface AnticipationConfig {
     enabled: boolean;
@@ -522,6 +524,16 @@ interface AnticipationConfig {
     progressiveSlowdown: number;
     /** Extra hold (ms) added per successive anticipated reel: reel #i gets `holdMs + i * this`. */
     progressiveHoldMs: number;
+    /**
+     * `cascade-drop`: how the gap between SUCCESSIVE CELLS grows inside an anticipated reel. The
+     * gap before cell #i is `cellStagger * <reel slowdown> * progressiveCellStagger ** i`, so 1
+     * (the default) keeps the reel's cells evenly spaced and > 1 makes each symbol land later than
+     * the last — the drip that turns a reel into a countdown.
+     *
+     * It compounds with `progressiveSlowdown`: that widens the base gap reel by reel, this widens
+     * it cell by cell, so a later reel drips both slower AND with a steeper ramp.
+     */
+    progressiveCellStagger: number;
     /** Optional grid zoom while anticipating (magnum-opus uses 1.3×). */
     zoom: {
         enabled: boolean;
@@ -766,6 +778,12 @@ interface SpinRunOpts {
     anticipateSlowdown?: PerReel<number>;
     /** Extra hold (ms) for anticipated reels. Scalar, or per-reel indexed by reel. */
     anticipateHoldMs?: PerReel<number>;
+    /**
+     * `cascade-drop`: growth of the gap between successive cells inside an anticipated reel — the
+     * gap before cell #i is `cellStagger * <reel slowdown> * ramp ** i`. 1 keeps the reel evenly
+     * spaced. Scalar, or per-reel indexed by reel.
+     */
+    anticipateCellStaggerRamp?: PerReel<number>;
     /**
      * Reels whose tape runs normally but whose landing is NOT handed back. The engine stops and
      * disposes of the tape as usual and leaves the real cells hidden and unseated; the caller owns
@@ -854,6 +872,8 @@ interface AnticipationDecision {
     slowdown: PerReel<number>;
     /** Extra hold before landing. Scalar or per-reel array, same as `slowdown`. */
     holdMs: PerReel<number>;
+    /** `cascade-drop`: growth of the gap between successive cells inside the reel (1 = even). */
+    cellStaggerRamp: PerReel<number>;
 }
 declare class AnticipationController {
     private _cfg;

package/dist/slot.esm.js

@@ -1142,6 +1142,7 @@ const DEFAULT_REEL_CONFIG = {
         decide: null,
         progressiveSlowdown: 1,
         progressiveHoldMs: 0,
+        progressiveCellStagger: 1,
         zoom: { enabled: false, scale: 1.15, ms: 600 },
     },
     cascade: {
@@ -1572,6 +1573,7 @@ class SpinEngine {
         const anticipate = new Set(opts?.anticipateReels ?? []);
         const defer = new Set(opts?.deferReveal ?? []);
         const holds = [];
+        const ramps = [];
         const out = [];
         for (let reel = 0; reel < cols; reel++) {
             const idx = order(reel);
@@ -1590,6 +1592,7 @@ class SpinEngine {
             const hold = isAnticipated ? perReelValue(opts?.anticipateHoldMs, reel, 0) * f : 0;
             stopTime += hold;
             holds[reel] = hold;
+            ramps[reel] = isAnticipated ? perReelValue(opts?.anticipateCellStaggerRamp, reel, 1) : 1;
             const speed = isAnticipated ? perReelValue(opts?.anticipateSlowdown, reel, 1) : 1;
             out.push({
                 reel,
@@ -1602,7 +1605,7 @@ class SpinEngine {
             });
         }
         if (this._cfg.style === 'cascade-drop')
-            this._planDrop(out, holds, f, order);
+            this._planDrop(out, holds, ramps, f, order);
         return out;
     }
     /**
@@ -1611,7 +1614,7 @@ class SpinEngine {
      * reel has fully landed and fill in `cellStopTimes`, so `plan()` stays the single source of truth
      * for WHEN anything happens — `_runDrop` below only executes these numbers.
      */
-    _planDrop(out, holds, f, order) {
+    _planDrop(out, holds, ramps, f, order) {
         const bottomUp = this._cfg.dropOrder === 'bottom-up';
         // walk the reels in STOP order, so `stopOrder: 'rtl'` reverses the drop as well
         const byPosition = [];
@@ -1633,10 +1636,15 @@ class SpinEngine {
             // by formula while reels may overlap; queued behind the previous reel once the chain starts
             const chained = chainFrom >= 0 && position > 0 && position >= chainFrom;
             const start = (chained ? previousEnd + gap : position * gap) + (holds[p.reel] ?? 0);
+            // The gap before cell #i is `cellStagger * scale * ramp**i` — accumulate rather than
+            // multiply, so a ramp of 1 stays exactly the old evenly-spaced schedule.
+            const ramp = ramps[p.reel] ?? 1;
             const cells = [];
+            let offset = 0;
             for (let i = 0; i < rows; i++) {
                 const row = bottomUp ? rows - 1 - i : i;
-                cells[row] = start + i * this._cfg.cellStagger * scale + fall;
+                cells[row] = start + offset + fall;
+                offset += this._cfg.cellStagger * scale * Math.pow(ramp, i);
             }
             p.cellStopTimes = cells;
             p.stopTime = cells.length ? Math.max(...cells) : start;
@@ -1892,7 +1900,13 @@ class SpinEngine {
 // Decides which trailing reels get the "anticipation" slow-down treatment, based purely on
 // the already-resolved landing grid (presentation only — never a secondary outcome decision).
 /** Fresh "nothing to anticipate" decision (fresh, so callers may mutate `reels` freely). */
-const none = () => ({ active: false, reels: [], slowdown: 1, holdMs: 0 });
+const none = () => ({
+    active: false,
+    reels: [],
+    slowdown: 1,
+    holdMs: 0,
+    cellStaggerRamp: 1,
+});
 class AnticipationController {
     _cfg;
     constructor(cfg) {
@@ -1925,7 +1939,7 @@ class AnticipationController {
             const o = Array.isArray(custom) ? { reels: custom } : custom;
             if (!o.reels?.length)
                 return none();
-            return this.build(o.reels.slice(), o.slowdown, o.holdMs);
+            return this.build(o.reels.slice(), o.slowdown, o.holdMs, o.cellStaggerRamp);
         }
         if (Array.isArray(this._cfg.reels)) {
             // explicit reel list — arm only if the threshold is met somewhere on the board
@@ -1954,10 +1968,11 @@ class AnticipationController {
         return this.build(reels);
     }
     /** Assemble a decision, applying the configured progression unless the caller pinned values. */
-    build(reels, slowdown, holdMs) {
+    build(reels, slowdown, holdMs, cellStaggerRamp) {
         return {
             active: true,
             reels,
+            cellStaggerRamp: cellStaggerRamp ?? this._cfg.progressiveCellStagger,
             slowdown: slowdown ??
                 this.ramp(reels, this._cfg.slowdownFactor, (base, i) => i === 0 ? base : base * Math.pow(this._cfg.progressiveSlowdown, i)),
             holdMs: holdMs ??
@@ -3037,12 +3052,13 @@ function createReelSystem(opts) {
         if (!explicit)
             return anticipation.decide(target);
         if (!explicit.length)
-            return { active: false, reels: [], slowdown: 1, holdMs: 0 };
+            return { active: false, reels: [], slowdown: 1, holdMs: 0, cellStaggerRamp: 1 };
         return {
             active: true,
             reels: explicit.slice(),
             slowdown: runOpts?.anticipateSlowdown ?? config.anticipation.slowdownFactor,
             holdMs: runOpts?.anticipateHoldMs ?? config.anticipation.holdMs,
+            cellStaggerRamp: runOpts?.anticipateCellStaggerRamp ?? config.anticipation.progressiveCellStagger,
         };
     }
     /** Fold a resolved decision back onto the caller's run options (everything else passes through). */
@@ -3052,6 +3068,7 @@ function createReelSystem(opts) {
             anticipateReels: decision.active ? decision.reels : undefined,
             anticipateSlowdown: decision.slowdown,
             anticipateHoldMs: decision.holdMs,
+            anticipateCellStaggerRamp: decision.cellStaggerRamp,
         };
     }
     buildGrid();