@slot-engine/core 0.1.4 → 0.1.5

package/dist/index.d.mts

@@ -698,6 +698,70 @@ interface GameModeOpts {
     isBonusBuy: boolean;
 }
 
+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 GameService<TGameModes extends AnyGameModes = AnyGameModes, TSymbols extends AnySymbols = AnySymbols, TUserState extends AnyUserData = AnyUserData> extends AbstractService {
     constructor(ctx: () => GameContext<TGameModes, TSymbols, TUserState>);
     /**
@@ -736,6 +800,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 +1256,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[];

package/dist/index.d.ts

@@ -698,6 +698,70 @@ interface GameModeOpts {
     isBonusBuy: boolean;
 }
 
+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 GameService<TGameModes extends AnyGameModes = AnyGameModes, TSymbols extends AnySymbols = AnySymbols, TUserState extends AnyUserData = AnyUserData> extends AbstractService {
     constructor(ctx: () => GameContext<TGameModes, TSymbols, TUserState>);
     /**
@@ -736,6 +800,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 +1256,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[];

package/dist/index.js

@@ -772,6 +772,9 @@ var Board = class {
         newPaddingTopSymbols[ridx].unshift(padSymbol);
       }
     }
+    this.lastDrawnReelStops = this.lastDrawnReelStops.map((stop, ridx) => {
+      return newFirstSymbolPositions[ridx] ?? stop;
+    });
     return {
       newBoardSymbols,
       newPaddingTopSymbols
@@ -1117,6 +1120,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 +1755,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) => {