@slot-engine/core 0.1.4 → 0.1.6

package/dist/index.d.mts

@@ -365,6 +365,70 @@ interface GameSymbolOpts {
     properties?: Record<string, any>;
 }
 
+declare class WinType {
+    protected payout: number;
+    protected winCombinations: WinCombination[];
+    protected ctx: GameContext;
+    protected readonly wildSymbol?: WildSymbol;
+    constructor(opts: WinTypeOpts);
+    /**
+     * Implementation of win evaluation logic. Sets `this.payout` and `this.winCombinations`.
+     */
+    evaluateWins(board: Reels): this;
+    /**
+     * Custom post-processing of wins, e.g. for handling multipliers.
+     */
+    postProcess(func: PostProcessFn<typeof this.winCombinations>): this;
+    /**
+     * Returns the total payout and detailed win combinations.
+     */
+    getWins(): {
+        payout: number;
+        winCombinations: WinCombination[];
+    };
+    protected isWild(symbol: GameSymbol): boolean;
+    protected getSymbolPayout(symbol: GameSymbol, count: number): number;
+}
+interface WinTypeOpts {
+    /**
+     * A reference to the game context.
+     */
+    ctx: GameContext<any, any, any>;
+    /**
+     * Configuration used to identify wild symbols on the board.\
+     * You can either provide a specific `GameSymbol` instance or a set of properties to match against symbols on the board.
+     *
+     * @example
+     * If you have different wild symbols, each with a property `isWild: true`, you can define:
+     * ```ts
+     * wildSymbol: { isWild: true }
+     * ```
+     *
+     * @example
+     * If you have a single wild symbol instance, you can define:
+     * ```ts
+     * wildSymbol: myWildSymbol
+     * ```
+     */
+    wildSymbol?: WildSymbol;
+}
+type WinCombination = {
+    payout: number;
+    kind: number;
+    baseSymbol: GameSymbol;
+    symbols: Array<{
+        symbol: GameSymbol;
+        isWild: boolean;
+        substitutedFor?: GameSymbol;
+        reelIndex: number;
+        posIndex: number;
+    }>;
+};
+type PostProcessFn<TWinCombs extends WinCombination[]> = (wins: TWinCombs, ctx: GameContext) => {
+    winCombinations: TWinCombs;
+};
+type WildSymbol = GameSymbol | Record<string, any>;
+
 declare class BoardService<TGameModes extends AnyGameModes = AnyGameModes, TSymbols extends AnySymbols = AnySymbols, TUserState extends AnyUserData = AnyUserData> extends AbstractService {
     private board;
     constructor(ctx: () => GameContext<TGameModes, TSymbols, TUserState>);
@@ -454,6 +518,17 @@ declare class BoardService<TGameModes extends AnyGameModes = AnyGameModes, TSymb
         newBoardSymbols: Record<string, GameSymbol[]>;
         newPaddingTopSymbols: Record<string, GameSymbol[]>;
     };
+    /**
+     * Dedupes win symbols for tumble.\
+     * Returns a list of symbols to remove from the board based on the given win combinations.
+     *
+     * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+     * this method ensures that each symbol is only listed once for removal. Otherwise tumbling may break.
+     */
+    dedupeWinSymbolsForTumble(winCombinations: WinCombination[]): {
+        reelIdx: number;
+        rowIdx: number;
+    }[];
 }
 
 declare class Recorder {
@@ -736,6 +811,18 @@ declare class GameService<TGameModes extends AnyGameModes = AnyGameModes, TSymbo
      * Also sets `state.triggeredFreespins` to true.
      */
     awardFreespins(amount: number): void;
+    /**
+     * Dedupes win symbols.
+     *
+     * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+     * this method ensures that each symbol is only listed once.
+     *
+     * If you want to tumble based on winning symbols, run them through this method first.
+     */
+    dedupeWinSymbols(winCombinations: WinCombination[]): {
+        reelIdx: number;
+        rowIdx: number;
+    }[];
 }
 
 declare class Wallet {
@@ -1180,70 +1267,6 @@ declare const defineUserState: <TUserState extends AnyUserData>(data: TUserState
 declare const defineSymbols: <TSymbols extends AnySymbols>(symbols: TSymbols) => TSymbols;
 declare const defineGameModes: <TGameModes extends AnyGameModes>(gameModes: TGameModes) => TGameModes;
 
-declare class WinType {
-    protected payout: number;
-    protected winCombinations: WinCombination[];
-    protected ctx: GameContext;
-    protected readonly wildSymbol?: WildSymbol;
-    constructor(opts: WinTypeOpts);
-    /**
-     * Implementation of win evaluation logic. Sets `this.payout` and `this.winCombinations`.
-     */
-    evaluateWins(board: Reels): this;
-    /**
-     * Custom post-processing of wins, e.g. for handling multipliers.
-     */
-    postProcess(func: PostProcessFn<typeof this.winCombinations>): this;
-    /**
-     * Returns the total payout and detailed win combinations.
-     */
-    getWins(): {
-        payout: number;
-        winCombinations: WinCombination[];
-    };
-    protected isWild(symbol: GameSymbol): boolean;
-    protected getSymbolPayout(symbol: GameSymbol, count: number): number;
-}
-interface WinTypeOpts {
-    /**
-     * A reference to the game context.
-     */
-    ctx: GameContext<any, any, any>;
-    /**
-     * Configuration used to identify wild symbols on the board.\
-     * You can either provide a specific `GameSymbol` instance or a set of properties to match against symbols on the board.
-     *
-     * @example
-     * If you have different wild symbols, each with a property `isWild: true`, you can define:
-     * ```ts
-     * wildSymbol: { isWild: true }
-     * ```
-     *
-     * @example
-     * If you have a single wild symbol instance, you can define:
-     * ```ts
-     * wildSymbol: myWildSymbol
-     * ```
-     */
-    wildSymbol?: WildSymbol;
-}
-type WinCombination = {
-    payout: number;
-    kind: number;
-    baseSymbol: GameSymbol;
-    symbols: Array<{
-        symbol: GameSymbol;
-        isWild: boolean;
-        substitutedFor?: GameSymbol;
-        reelIndex: number;
-        posIndex: number;
-    }>;
-};
-type PostProcessFn<TWinCombs extends WinCombination[]> = (wins: TWinCombs, ctx: GameContext) => {
-    winCombinations: TWinCombs;
-};
-type WildSymbol = GameSymbol | Record<string, any>;
-
 declare class LinesWinType extends WinType {
     protected lines: Record<number, number[]>;
     protected winCombinations: LineWinCombination[];
@@ -1571,6 +1594,17 @@ declare class StandaloneBoard {
         newBoardSymbols: Record<string, GameSymbol[]>;
         newPaddingTopSymbols: Record<string, GameSymbol[]>;
     };
+    /**
+     * Dedupes win symbols for tumble.\
+     * Returns a list of symbols to remove from the board based on the given win combinations.
+     *
+     * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+     * this method ensures that each symbol is only listed once for removal. Otherwise tumbling may break.
+     */
+    dedupeWinSymbolsForTumble(winCombinations: WinCombination[]): {
+        reelIdx: number;
+        rowIdx: number;
+    }[];
 }
 interface StandaloneBoardOptions {
     ctx: GameContext;

package/dist/index.d.ts

@@ -365,6 +365,70 @@ interface GameSymbolOpts {
     properties?: Record<string, any>;
 }
 
+declare class WinType {
+    protected payout: number;
+    protected winCombinations: WinCombination[];
+    protected ctx: GameContext;
+    protected readonly wildSymbol?: WildSymbol;
+    constructor(opts: WinTypeOpts);
+    /**
+     * Implementation of win evaluation logic. Sets `this.payout` and `this.winCombinations`.
+     */
+    evaluateWins(board: Reels): this;
+    /**
+     * Custom post-processing of wins, e.g. for handling multipliers.
+     */
+    postProcess(func: PostProcessFn<typeof this.winCombinations>): this;
+    /**
+     * Returns the total payout and detailed win combinations.
+     */
+    getWins(): {
+        payout: number;
+        winCombinations: WinCombination[];
+    };
+    protected isWild(symbol: GameSymbol): boolean;
+    protected getSymbolPayout(symbol: GameSymbol, count: number): number;
+}
+interface WinTypeOpts {
+    /**
+     * A reference to the game context.
+     */
+    ctx: GameContext<any, any, any>;
+    /**
+     * Configuration used to identify wild symbols on the board.\
+     * You can either provide a specific `GameSymbol` instance or a set of properties to match against symbols on the board.
+     *
+     * @example
+     * If you have different wild symbols, each with a property `isWild: true`, you can define:
+     * ```ts
+     * wildSymbol: { isWild: true }
+     * ```
+     *
+     * @example
+     * If you have a single wild symbol instance, you can define:
+     * ```ts
+     * wildSymbol: myWildSymbol
+     * ```
+     */
+    wildSymbol?: WildSymbol;
+}
+type WinCombination = {
+    payout: number;
+    kind: number;
+    baseSymbol: GameSymbol;
+    symbols: Array<{
+        symbol: GameSymbol;
+        isWild: boolean;
+        substitutedFor?: GameSymbol;
+        reelIndex: number;
+        posIndex: number;
+    }>;
+};
+type PostProcessFn<TWinCombs extends WinCombination[]> = (wins: TWinCombs, ctx: GameContext) => {
+    winCombinations: TWinCombs;
+};
+type WildSymbol = GameSymbol | Record<string, any>;
+
 declare class BoardService<TGameModes extends AnyGameModes = AnyGameModes, TSymbols extends AnySymbols = AnySymbols, TUserState extends AnyUserData = AnyUserData> extends AbstractService {
     private board;
     constructor(ctx: () => GameContext<TGameModes, TSymbols, TUserState>);
@@ -454,6 +518,17 @@ declare class BoardService<TGameModes extends AnyGameModes = AnyGameModes, TSymb
         newBoardSymbols: Record<string, GameSymbol[]>;
         newPaddingTopSymbols: Record<string, GameSymbol[]>;
     };
+    /**
+     * Dedupes win symbols for tumble.\
+     * Returns a list of symbols to remove from the board based on the given win combinations.
+     *
+     * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+     * this method ensures that each symbol is only listed once for removal. Otherwise tumbling may break.
+     */
+    dedupeWinSymbolsForTumble(winCombinations: WinCombination[]): {
+        reelIdx: number;
+        rowIdx: number;
+    }[];
 }
 
 declare class Recorder {
@@ -736,6 +811,18 @@ declare class GameService<TGameModes extends AnyGameModes = AnyGameModes, TSymbo
      * Also sets `state.triggeredFreespins` to true.
      */
     awardFreespins(amount: number): void;
+    /**
+     * Dedupes win symbols.
+     *
+     * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+     * this method ensures that each symbol is only listed once.
+     *
+     * If you want to tumble based on winning symbols, run them through this method first.
+     */
+    dedupeWinSymbols(winCombinations: WinCombination[]): {
+        reelIdx: number;
+        rowIdx: number;
+    }[];
 }
 
 declare class Wallet {
@@ -1180,70 +1267,6 @@ declare const defineUserState: <TUserState extends AnyUserData>(data: TUserState
 declare const defineSymbols: <TSymbols extends AnySymbols>(symbols: TSymbols) => TSymbols;
 declare const defineGameModes: <TGameModes extends AnyGameModes>(gameModes: TGameModes) => TGameModes;
 
-declare class WinType {
-    protected payout: number;
-    protected winCombinations: WinCombination[];
-    protected ctx: GameContext;
-    protected readonly wildSymbol?: WildSymbol;
-    constructor(opts: WinTypeOpts);
-    /**
-     * Implementation of win evaluation logic. Sets `this.payout` and `this.winCombinations`.
-     */
-    evaluateWins(board: Reels): this;
-    /**
-     * Custom post-processing of wins, e.g. for handling multipliers.
-     */
-    postProcess(func: PostProcessFn<typeof this.winCombinations>): this;
-    /**
-     * Returns the total payout and detailed win combinations.
-     */
-    getWins(): {
-        payout: number;
-        winCombinations: WinCombination[];
-    };
-    protected isWild(symbol: GameSymbol): boolean;
-    protected getSymbolPayout(symbol: GameSymbol, count: number): number;
-}
-interface WinTypeOpts {
-    /**
-     * A reference to the game context.
-     */
-    ctx: GameContext<any, any, any>;
-    /**
-     * Configuration used to identify wild symbols on the board.\
-     * You can either provide a specific `GameSymbol` instance or a set of properties to match against symbols on the board.
-     *
-     * @example
-     * If you have different wild symbols, each with a property `isWild: true`, you can define:
-     * ```ts
-     * wildSymbol: { isWild: true }
-     * ```
-     *
-     * @example
-     * If you have a single wild symbol instance, you can define:
-     * ```ts
-     * wildSymbol: myWildSymbol
-     * ```
-     */
-    wildSymbol?: WildSymbol;
-}
-type WinCombination = {
-    payout: number;
-    kind: number;
-    baseSymbol: GameSymbol;
-    symbols: Array<{
-        symbol: GameSymbol;
-        isWild: boolean;
-        substitutedFor?: GameSymbol;
-        reelIndex: number;
-        posIndex: number;
-    }>;
-};
-type PostProcessFn<TWinCombs extends WinCombination[]> = (wins: TWinCombs, ctx: GameContext) => {
-    winCombinations: TWinCombs;
-};
-type WildSymbol = GameSymbol | Record<string, any>;
-
 declare class LinesWinType extends WinType {
     protected lines: Record<number, number[]>;
     protected winCombinations: LineWinCombination[];
@@ -1571,6 +1594,17 @@ declare class StandaloneBoard {
         newBoardSymbols: Record<string, GameSymbol[]>;
         newPaddingTopSymbols: Record<string, GameSymbol[]>;
     };
+    /**
+     * Dedupes win symbols for tumble.\
+     * Returns a list of symbols to remove from the board based on the given win combinations.
+     *
+     * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+     * this method ensures that each symbol is only listed once for removal. Otherwise tumbling may break.
+     */
+    dedupeWinSymbolsForTumble(winCombinations: WinCombination[]): {
+        reelIdx: number;
+        rowIdx: number;
+    }[];
 }
 interface StandaloneBoardOptions {
     ctx: GameContext;

package/dist/index.js

@@ -697,14 +697,15 @@ var Board = class {
     this.lastUsedReels = opts.reels;
     for (let ridx = 0; ridx < reelsAmount; ridx++) {
       const reelPos = finalReelStops[ridx];
+      const reelLength = opts.reels[ridx].length;
       for (let p = padSymbols - 1; p >= 0; p--) {
-        const topPos = (reelPos - (p + 1)) % opts.reels[ridx].length;
+        const topPos = ((reelPos - (p + 1)) % reelLength + reelLength) % reelLength;
         this.paddingTop[ridx].push(opts.reels[ridx][topPos]);
-        const bottomPos = (reelPos + symbolsPerReel[ridx] + p) % opts.reels[ridx].length;
+        const bottomPos = (reelPos + symbolsPerReel[ridx] + p) % reelLength;
         this.paddingBottom[ridx].unshift(opts.reels[ridx][bottomPos]);
       }
       for (let row = 0; row < symbolsPerReel[ridx]; row++) {
-        const symbol = opts.reels[ridx][(reelPos + row) % opts.reels[ridx].length];
+        const symbol = opts.reels[ridx][(reelPos + row) % reelLength];
         if (!symbol) {
           throw new Error(`Failed to get symbol at pos ${reelPos + row} on reel ${ridx}`);
         }
@@ -772,11 +773,27 @@ var Board = class {
         newPaddingTopSymbols[ridx].unshift(padSymbol);
       }
     }
+    this.lastDrawnReelStops = this.lastDrawnReelStops.map((stop, ridx) => {
+      return newFirstSymbolPositions[ridx] ?? stop;
+    });
     return {
       newBoardSymbols,
       newPaddingTopSymbols
     };
   }
+  dedupeWinSymbolsForTumble(winCombinations) {
+    const symbolsMap = /* @__PURE__ */ new Map();
+    winCombinations.forEach((wc) => {
+      wc.symbols.forEach((s) => {
+        symbolsMap.set(`${s.reelIndex},${s.posIndex}`, {
+          reelIdx: s.reelIndex,
+          rowIdx: s.posIndex
+        });
+      });
+    });
+    const symbolsToRemove = Array.from(symbolsMap.values());
+    return symbolsToRemove;
+  }
 };
 
 // src/service/board.ts
@@ -921,6 +938,16 @@ var BoardService = class extends AbstractService {
       symbolsToDelete
     });
   }
+  /**
+   * Dedupes win symbols for tumble.\
+   * Returns a list of symbols to remove from the board based on the given win combinations.
+   *
+   * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+   * this method ensures that each symbol is only listed once for removal. Otherwise tumbling may break.
+   */
+  dedupeWinSymbolsForTumble(winCombinations) {
+    return this.board.dedupeWinSymbolsForTumble(winCombinations);
+  }
 };
 
 // src/service/data.ts
@@ -1117,6 +1144,27 @@ var GameService = class extends AbstractService {
     this.ctx().state.totalFreespinAmount += amount;
     this.ctx().state.triggeredFreespins = true;
   }
+  /**
+   * Dedupes win symbols.
+   *
+   * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+   * this method ensures that each symbol is only listed once.
+   * 
+   * If you want to tumble based on winning symbols, run them through this method first.
+   */
+  dedupeWinSymbols(winCombinations) {
+    const symbolsMap = /* @__PURE__ */ new Map();
+    winCombinations.forEach((wc) => {
+      wc.symbols.forEach((s) => {
+        symbolsMap.set(`${s.reelIndex},${s.posIndex}`, {
+          reelIdx: s.reelIndex,
+          rowIdx: s.posIndex
+        });
+      });
+    });
+    const symbolsToRemove = Array.from(symbolsMap.values());
+    return symbolsToRemove;
+  }
 };
 
 // src/service/wallet.ts
@@ -1731,7 +1779,12 @@ Simulating game mode: ${mode}`);
         }
       });
       worker.on("error", (error) => {
-        console.error("Error:", error);
+        process.stdout.write(`
+${error.message}
+`);
+        process.stdout.write(`
+${error.stack}
+`);
         reject(error);
       });
       worker.on("exit", (code) => {
@@ -2293,28 +2346,12 @@ var Analysis = class {
     const payoutRanges = {};
     for (const modeStr of gameModes) {
       payoutRanges[modeStr] = { overall: {}, criteria: {} };
-      const lutOptimized = parseLookupTable(
-        import_fs3.default.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
-      );
       const lutSegmented = parseLookupTableSegmented(
         import_fs3.default.readFileSync(this.filePaths[modeStr].lutSegmented, "utf-8")
       );
-      lutOptimized.forEach(([, , p]) => {
-        const payout = p / 100;
-        for (const [min, max] of winRanges) {
-          if (payout >= min && payout <= max) {
-            const rangeKey = `${min}-${max}`;
-            if (!payoutRanges[modeStr].overall[rangeKey]) {
-              payoutRanges[modeStr].overall[rangeKey] = 0;
-            }
-            payoutRanges[modeStr].overall[rangeKey] += 1;
-            break;
-          }
-        }
-      });
       lutSegmented.forEach(([, criteria, bp, fsp]) => {
-        const basePayout = bp / 100;
-        const freeSpinPayout = fsp / 100;
+        const basePayout = bp;
+        const freeSpinPayout = fsp;
         const payout = basePayout + freeSpinPayout;
         for (const [min, max] of winRanges) {
           if (payout >= min && payout <= max) {
@@ -3771,6 +3808,16 @@ var StandaloneBoard = class {
       padSymbols: this.padSymbols
     });
   }
+  /**
+   * Dedupes win symbols for tumble.\
+   * Returns a list of symbols to remove from the board based on the given win combinations.
+   * 
+   * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+   * this method ensures that each symbol is only listed once for removal. Otherwise tumbling may break.
+   */
+  dedupeWinSymbolsForTumble(winCombinations) {
+    return this.board.dedupeWinSymbolsForTumble(winCombinations);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {