@slot-engine/core 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -645,14 +645,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}`);
         }
@@ -720,11 +721,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
@@ -869,6 +886,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
@@ -1065,6 +1092,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
@@ -1679,7 +1727,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) => {
@@ -2241,28 +2294,12 @@ var Analysis = class {
     const payoutRanges = {};
     for (const modeStr of gameModes) {
       payoutRanges[modeStr] = { overall: {}, criteria: {} };
-      const lutOptimized = parseLookupTable(
-        fs3.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
-      );
       const lutSegmented = parseLookupTableSegmented(
         fs3.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) {
@@ -3719,6 +3756,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);
+  }
 };
 export {
   ClusterWinType,