@slot-engine/core 0.0.8 → 0.0.10

package/dist/index.mjs

@@ -13,7 +13,7 @@ function createGameConfig(opts) {
     symbols.set(key, value);
   }
   const getAnticipationTrigger = (spinType) => {
-    return Math.min(...Object.keys(opts.scatterToFreespins[spinType]).map(Number)) - 1;
+    return Math.min(...Object.keys(opts.scatterToFreespins[spinType] || {}).map(Number)) - 1;
   };
   return {
     padSymbols: opts.padSymbols || 1,
@@ -349,6 +349,16 @@ function createGameState(opts) {
   };
 }
 
+// src/recorder/index.ts
+var Recorder = class {
+  records;
+  pendingRecords;
+  constructor() {
+    this.records = [];
+    this.pendingRecords = [];
+  }
+};
+
 // src/board/index.ts
 import assert3 from "assert";
 
@@ -384,6 +394,16 @@ var GameSymbol = class _GameSymbol {
       return true;
     }
   }
+  /**
+   * Creates a clone of this GameSymbol.
+   */
+  clone() {
+    return new _GameSymbol({
+      id: this.id,
+      pays: this.pays ? { ...this.pays } : void 0,
+      properties: Object.fromEntries(this.properties)
+    });
+  }
 };
 
 // src/board/index.ts
@@ -418,6 +438,13 @@ var Board = class {
     this.lastDrawnReelStops = [];
     this.lastUsedReels = [];
   }
+  getSymbol(reelIndex, rowIndex) {
+    return this.reels[reelIndex]?.[rowIndex];
+  }
+  setSymbol(reelIndex, rowIndex, symbol) {
+    this.reels[reelIndex] = this.reels[reelIndex] || [];
+    this.reels[reelIndex][rowIndex] = symbol;
+  }
   makeEmptyReels(opts) {
     const length = opts.reelsAmount ?? opts.ctx.services.game.getCurrentGameMode().reelsAmount;
     assert3(length, "Cannot make empty reels without context or reelsAmount.");
@@ -680,6 +707,18 @@ var BoardService = class extends AbstractService {
   getAnticipation() {
     return this.board.anticipation;
   }
+  /**
+   * Gets the symbol at the specified reel and row index.
+   */
+  getSymbol(reelIndex, rowIndex) {
+    return this.board.getSymbol(reelIndex, rowIndex);
+  }
+  /**
+   * Sets the symbol at the specified reel and row index.
+   */
+  setSymbol(reelIndex, rowIndex, symbol) {
+    this.board.setSymbol(reelIndex, rowIndex, symbol);
+  }
   resetReels() {
     this.board.resetReels({
       ctx: this.ctx()
@@ -1105,16 +1144,6 @@ var Book = class _Book {
   }
 };
 
-// src/recorder/index.ts
-var Recorder = class {
-  records;
-  pendingRecords;
-  constructor() {
-    this.records = [];
-    this.pendingRecords = [];
-  }
-};
-
 // src/wallet/index.ts
 var Wallet = class {
   /**
@@ -2028,14 +2057,39 @@ var Analysis = class {
       [15e3, 19999.99],
       [2e4, 24999.99]
     ];
+    const payoutRanges = {};
     for (const modeStr of gameModes) {
-      const mode = this.getGameModeConfig(modeStr);
+      payoutRanges[modeStr] = {};
       const lutOptimized = parseLookupTable(
         fs3.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
       );
-      const totalWeight = getTotalLutWeight(lutOptimized);
-      const payoutWeights = getPayoutWeights(lutOptimized);
+      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][rangeKey]) {
+              payoutRanges[modeStr][rangeKey] = 0;
+            }
+            payoutRanges[modeStr][rangeKey] += 1;
+            break;
+          }
+        }
+      });
+      const orderedRanges = {};
+      Object.keys(payoutRanges[modeStr]).sort((a, b) => {
+        const [aMin] = a.split("-").map(Number);
+        const [bMin] = b.split("-").map(Number);
+        return aMin - bMin;
+      }).forEach((key) => {
+        orderedRanges[key] = payoutRanges[modeStr][key];
+      });
+      payoutRanges[modeStr] = orderedRanges;
     }
+    writeJsonFile(
+      path2.join(process.cwd(), this.gameConfig.outputDir, "stats_payouts.json"),
+      payoutRanges
+    );
   }
   getGameModeConfig(mode) {
     const config = this.gameConfig.gameModes[mode];
@@ -2502,9 +2556,20 @@ var WinType = class {
   isWild(symbol) {
     return !!this.wildSymbol && symbol.compare(this.wildSymbol);
   }
+  getSymbolPayout(symbol, count) {
+    if (!symbol.pays) return 0;
+    let clusterSize = 0;
+    const sizes = Object.keys(symbol.pays).map((s) => parseInt(s, 10)).filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+    for (const size of sizes) {
+      if (size > count) break;
+      clusterSize = size;
+    }
+    return symbol.pays[clusterSize] || 0;
+  }
 };
 
 // src/win-types/LinesWinType.ts
+import assert11 from "assert";
 var LinesWinType = class extends WinType {
   lines;
   constructor(opts) {
@@ -2545,106 +2610,335 @@ var LinesWinType = class extends WinType {
   evaluateWins(board) {
     this.validateConfig();
     const lineWins = [];
-    let payout = 0;
     const reels = board;
-    for (const [lineNumStr, lineDef] of Object.entries(this.lines)) {
+    for (const [lineNumStr, line] of Object.entries(this.lines)) {
       const lineNum = Number(lineNumStr);
-      let baseSymbol = null;
-      let leadingWilds = 0;
-      const chain = [];
-      const details = [];
-      for (let ridx = 0; ridx < reels.length; ridx++) {
-        const rowIdx = lineDef[ridx];
-        const sym = reels[ridx][rowIdx];
-        if (!sym) throw new Error("Encountered an invalid symbol while evaluating wins.");
-        const wild = this.isWild(sym);
-        if (ridx === 0) {
-          chain.push(sym);
-          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: wild });
-          if (wild) leadingWilds++;
-          else baseSymbol = sym;
-          continue;
-        }
-        if (wild) {
-          chain.push(sym);
-          details.push({
-            reelIndex: ridx,
-            posIndex: rowIdx,
-            symbol: sym,
-            isWild: true,
-            substitutedFor: baseSymbol || void 0
-          });
-          continue;
-        }
+      let baseSymbol;
+      const potentialWinLine = [];
+      const potentialWildLine = [];
+      for (const [ridx, reel] of reels.entries()) {
+        const sidx = line[ridx];
+        const thisSymbol = reel[sidx];
         if (!baseSymbol) {
-          baseSymbol = sym;
-          chain.push(sym);
-          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: false });
+          baseSymbol = thisSymbol;
+        }
+        assert11(baseSymbol, `No symbol found at line ${lineNum}, reel ${ridx}`);
+        assert11(thisSymbol, `No symbol found at line ${lineNum}, reel ${ridx}`);
+        if (potentialWinLine.length == 0) {
+          if (this.isWild(thisSymbol)) {
+            potentialWildLine.push({ reel: ridx, row: sidx, symbol: thisSymbol });
+          }
+          potentialWinLine.push({ reel: ridx, row: sidx, symbol: thisSymbol });
           continue;
         }
-        if (sym.id === baseSymbol.id) {
-          chain.push(sym);
-          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: false });
+        if (this.isWild(baseSymbol)) {
+          if (this.isWild(thisSymbol)) {
+            potentialWildLine.push({ reel: ridx, row: sidx, symbol: thisSymbol });
+          } else {
+            baseSymbol = thisSymbol;
+          }
+          potentialWinLine.push({ reel: ridx, row: sidx, symbol: thisSymbol });
           continue;
         }
-        break;
-      }
-      if (chain.length === 0) continue;
-      const allWild = chain.every((s) => this.isWild(s));
-      const wildRepresentative = this.wildSymbol instanceof GameSymbol ? this.wildSymbol : null;
-      const len = chain.length;
-      let bestPayout = 0;
-      let bestType = null;
-      let payingSymbol = null;
-      if (baseSymbol?.pays && baseSymbol.pays[len]) {
-        bestPayout = baseSymbol.pays[len];
-        bestType = "substituted";
-        payingSymbol = baseSymbol;
-      }
-      if (allWild && wildRepresentative?.pays && wildRepresentative.pays[len]) {
-        const wildPay = wildRepresentative.pays[len];
-        if (wildPay > bestPayout) {
-          bestPayout = wildPay;
-          bestType = "pure-wild";
-          payingSymbol = wildRepresentative;
+        if (baseSymbol.compare(thisSymbol) || this.isWild(thisSymbol)) {
+          potentialWinLine.push({ reel: ridx, row: sidx, symbol: thisSymbol });
         }
       }
-      if (!bestPayout || !bestType || !payingSymbol) continue;
-      const minLen = payingSymbol.pays ? Math.min(...Object.keys(payingSymbol.pays).map(Number)) : Infinity;
-      if (len < minLen) continue;
-      const wildCount = details.filter((d) => d.isWild).length;
-      const nonWildCount = len - wildCount;
-      lineWins.push({
+      const minSymLine = Math.min(
+        ...Object.keys(baseSymbol.pays || {}).map((k) => parseInt(k, 10))
+      );
+      if (potentialWinLine.length < minSymLine) continue;
+      const linePayout = this.getLinePayout(potentialWinLine);
+      const wildLinePayout = this.getLinePayout(potentialWildLine);
+      let finalLine = {
+        kind: potentialWinLine.length,
+        baseSymbol,
+        symbols: potentialWinLine.map((s) => ({
+          symbol: s.symbol,
+          isWild: this.isWild(s.symbol),
+          reelIndex: s.reel,
+          posIndex: s.row
+        })),
         lineNumber: lineNum,
-        kind: len,
-        payout: bestPayout,
-        symbol: payingSymbol,
-        winType: bestType,
-        substitutedBaseSymbol: bestType === "pure-wild" ? null : baseSymbol,
-        symbols: details,
-        stats: { wildCount, nonWildCount, leadingWilds }
-      });
-      payout += bestPayout;
+        payout: linePayout
+      };
+      if (wildLinePayout > linePayout) {
+        baseSymbol = potentialWildLine[0]?.symbol;
+        finalLine = {
+          kind: potentialWildLine.length,
+          baseSymbol,
+          symbols: potentialWildLine.map((s) => ({
+            symbol: s.symbol,
+            isWild: this.isWild(s.symbol),
+            reelIndex: s.reel,
+            posIndex: s.row
+          })),
+          lineNumber: lineNum,
+          payout: wildLinePayout
+        };
+      }
+      lineWins.push(finalLine);
     }
     for (const win of lineWins) {
       this.ctx.services.data.recordSymbolOccurrence({
         kind: win.kind,
-        symbolId: win.symbol.id,
+        symbolId: win.baseSymbol.id,
         spinType: this.ctx.state.currentSpinType
       });
     }
-    this.payout = payout;
+    this.payout = lineWins.reduce((sum, l) => sum + l.payout, 0);
     this.winCombinations = lineWins;
     return this;
   }
+  getLinePayout(line) {
+    if (line.length === 0) return 0;
+    let baseSymbol = line.find((s) => !this.isWild(s.symbol))?.symbol;
+    if (!baseSymbol) baseSymbol = line[0].symbol;
+    const kind = line.length;
+    const payout = this.getSymbolPayout(baseSymbol, kind);
+    return payout;
+  }
 };
 
 // src/win-types/ClusterWinType.ts
 var ClusterWinType = class extends WinType {
+  _checked = [];
+  _checkedWilds = [];
+  _currentBoard = [];
+  constructor(opts) {
+    super(opts);
+  }
+  validateConfig() {
+  }
+  /**
+   * Calculates wins based on symbol cluster size and provided board state.\
+   * Retrieve the results using `getWins()` after.
+   */
+  evaluateWins(board) {
+    this.validateConfig();
+    this._checked = [];
+    this._currentBoard = board;
+    const clusterWins = [];
+    const potentialClusters = [];
+    for (const [ridx, reel] of board.entries()) {
+      for (const [sidx, symbol] of reel.entries()) {
+        this._checkedWilds = [];
+        if (this.isWild(symbol)) continue;
+        if (this.isChecked(ridx, sidx)) {
+          continue;
+        }
+        const thisSymbol = { reel: ridx, row: sidx, symbol };
+        this._checked.push(thisSymbol);
+        const neighbors = this.getNeighbors(ridx, sidx);
+        const matchingSymbols = this.evaluateCluster(symbol, neighbors);
+        if (matchingSymbols.size >= 1) {
+          potentialClusters.push([thisSymbol, ...matchingSymbols.values()]);
+        }
+      }
+    }
+    for (const [ridx, reel] of board.entries()) {
+      for (const [sidx, symbol] of reel.entries()) {
+        this._checkedWilds = [];
+        if (!this.isWild(symbol)) continue;
+        if (this.isChecked(ridx, sidx)) {
+          continue;
+        }
+        const thisSymbol = { reel: ridx, row: sidx, symbol };
+        this._checked.push(thisSymbol);
+        const neighbors = this.getNeighbors(ridx, sidx);
+        const matchingSymbols = this.evaluateCluster(symbol, neighbors);
+        if (matchingSymbols.size >= 1) {
+          potentialClusters.push([thisSymbol, ...matchingSymbols.values()]);
+        }
+      }
+    }
+    potentialClusters.forEach((cluster) => {
+      const kind = cluster.length;
+      let baseSymbol = cluster.find((s) => !this.isWild(s.symbol))?.symbol;
+      if (!baseSymbol) baseSymbol = cluster[0].symbol;
+      const payout = this.getSymbolPayout(baseSymbol, kind);
+      if (!baseSymbol.pays || Object.keys(baseSymbol.pays).length === 0) {
+        return;
+      }
+      clusterWins.push({
+        payout,
+        kind,
+        baseSymbol,
+        symbols: cluster.map((s) => ({
+          symbol: s.symbol,
+          isWild: this.isWild(s.symbol),
+          reelIndex: s.reel,
+          posIndex: s.row
+        }))
+      });
+    });
+    for (const win of clusterWins) {
+      this.ctx.services.data.recordSymbolOccurrence({
+        kind: win.kind,
+        symbolId: win.baseSymbol.id,
+        spinType: this.ctx.state.currentSpinType
+      });
+    }
+    this.payout = clusterWins.reduce((sum, c) => sum + c.payout, 0);
+    this.winCombinations = clusterWins;
+    return this;
+  }
+  getNeighbors(ridx, sidx) {
+    const board = this._currentBoard;
+    const neighbors = [];
+    const potentialNeighbors = [
+      [ridx - 1, sidx],
+      [ridx + 1, sidx],
+      [ridx, sidx - 1],
+      [ridx, sidx + 1]
+    ];
+    potentialNeighbors.forEach(([nridx, nsidx]) => {
+      if (board[nridx] && board[nridx][nsidx]) {
+        neighbors.push({ reel: nridx, row: nsidx, symbol: board[nridx][nsidx] });
+      }
+    });
+    return neighbors;
+  }
+  evaluateCluster(rootSymbol, neighbors) {
+    const matchingSymbols = /* @__PURE__ */ new Map();
+    neighbors.forEach((neighbor) => {
+      const { reel, row, symbol } = neighbor;
+      if (this.isChecked(reel, row)) return;
+      if (this.isCheckedWild(reel, row)) return;
+      if (this.isWild(symbol) || symbol.compare(rootSymbol)) {
+        const key = `${reel}-${row}`;
+        matchingSymbols.set(key, { reel, row, symbol });
+        if (symbol.compare(rootSymbol)) {
+          this._checked.push(neighbor);
+        }
+        if (this.isWild(symbol)) {
+          this._checkedWilds.push(neighbor);
+        }
+        const neighbors2 = this.getNeighbors(reel, row);
+        const nestedMatches = this.evaluateCluster(rootSymbol, neighbors2);
+        nestedMatches.forEach((nsym) => {
+          const nkey = `${nsym.reel}-${nsym.row}`;
+          matchingSymbols.set(nkey, nsym);
+        });
+      }
+    });
+    return matchingSymbols;
+  }
+  isChecked(ridx, sidx) {
+    return !!this._checked.find((c) => c.reel === ridx && c.row === sidx);
+  }
+  isCheckedWild(ridx, sidx) {
+    return !!this._checkedWilds.find((c) => c.reel === ridx && c.row === sidx);
+  }
 };
 
 // src/win-types/ManywaysWinType.ts
 var ManywaysWinType = class extends WinType {
+  _checked = [];
+  _checkedWilds = [];
+  constructor(opts) {
+    super(opts);
+  }
+  validateConfig() {
+  }
+  /**
+   * Calculates wins based on the defined paylines and provided board state.\
+   * Retrieve the results using `getWins()` after.
+   */
+  evaluateWins(board) {
+    this.validateConfig();
+    const waysWins = [];
+    const reels = board;
+    const possibleWaysWins = /* @__PURE__ */ new Map();
+    const candidateSymbols = /* @__PURE__ */ new Map();
+    let searchReelIdx = 0;
+    let searchActive = true;
+    while (searchActive && searchReelIdx < reels.length) {
+      const reel = reels[searchReelIdx];
+      let hasWild = false;
+      for (const symbol of reel) {
+        candidateSymbols.set(symbol.id, symbol);
+        if (this.isWild(symbol)) {
+          hasWild = true;
+        }
+      }
+      if (!hasWild) {
+        searchActive = false;
+      }
+      searchReelIdx++;
+    }
+    for (const baseSymbol of candidateSymbols.values()) {
+      let symbolList = {};
+      let isInterrupted = false;
+      for (const [ridx, reel] of reels.entries()) {
+        if (isInterrupted) break;
+        for (const [sidx, symbol] of reel.entries()) {
+          const isMatch = baseSymbol.compare(symbol) || this.isWild(symbol);
+          if (isMatch) {
+            if (!symbolList[ridx]) {
+              symbolList[ridx] = [];
+            }
+            symbolList[ridx].push({ reel: ridx, row: sidx, symbol });
+          }
+        }
+        if (!symbolList[ridx]) {
+          isInterrupted = true;
+          break;
+        }
+      }
+      const minSymLine = Math.min(
+        ...Object.keys(baseSymbol.pays || {}).map((k) => parseInt(k, 10))
+      );
+      const wayLength = this.getWayLength(symbolList);
+      if (wayLength >= minSymLine) {
+        possibleWaysWins.set(baseSymbol.id, symbolList);
+      }
+    }
+    for (const [baseSymbolId, symbolList] of possibleWaysWins.entries()) {
+      const wayLength = this.getWayLength(symbolList);
+      let baseSymbol = Object.values(symbolList).flatMap((l) => l.map((s) => s)).find((s) => !this.isWild(s.symbol))?.symbol;
+      if (!baseSymbol) baseSymbol = symbolList[0][0].symbol;
+      const singleWayPayout = this.getSymbolPayout(baseSymbol, wayLength);
+      const totalWays = Object.values(symbolList).reduce(
+        (ways, syms) => ways * syms.length,
+        1
+      );
+      const totalPayout = singleWayPayout * totalWays;
+      waysWins.push({
+        kind: wayLength,
+        baseSymbol,
+        symbols: Object.values(symbolList).flatMap(
+          (reel) => reel.map((s) => ({
+            symbol: s.symbol,
+            isWild: this.isWild(s.symbol),
+            reelIndex: s.reel,
+            posIndex: s.row
+          }))
+        ),
+        ways: totalWays,
+        payout: totalPayout
+      });
+    }
+    for (const win of waysWins) {
+      this.ctx.services.data.recordSymbolOccurrence({
+        kind: win.kind,
+        symbolId: win.baseSymbol.id,
+        spinType: this.ctx.state.currentSpinType
+      });
+    }
+    this.payout = waysWins.reduce((sum, l) => sum + l.payout, 0);
+    this.winCombinations = waysWins;
+    return this;
+  }
+  getWayLength(symbolList) {
+    return Math.max(...Object.keys(symbolList).map((k) => parseInt(k, 10))) + 1;
+  }
+  isChecked(ridx, sidx) {
+    return !!this._checked.find((c) => c.reel === ridx && c.row === sidx);
+  }
+  isCheckedWild(ridx, sidx) {
+    return !!this._checkedWilds.find((c) => c.reel === ridx && c.row === sidx);
+  }
 };
 
 // src/reel-set/GeneratedReelSet.ts
@@ -3005,7 +3299,7 @@ var GeneratedReelSet = class extends ReelSet {
 };
 
 // src/reel-set/StaticReelSet.ts
-import assert11 from "assert";
+import assert12 from "assert";
 var StaticReelSet = class extends ReelSet {
   reels;
   csvPath;
@@ -3015,7 +3309,7 @@ var StaticReelSet = class extends ReelSet {
     this.reels = [];
     this._strReels = opts.reels || [];
     this.csvPath = opts.csvPath || "";
-    assert11(
+    assert12(
       opts.reels || opts.csvPath,
       `Either 'reels' or 'csvPath' must be provided for StaticReelSet ${this.id}`
     );
@@ -3091,6 +3385,18 @@ var StandaloneBoard = class {
   getPaddingBottom() {
     return this.board.paddingBottom;
   }
+  /**
+   * Gets the symbol at the specified reel and row index.
+   */
+  getSymbol(reelIndex, rowIndex) {
+    return this.board.getSymbol(reelIndex, rowIndex);
+  }
+  /**
+   * Sets the symbol at the specified reel and row index.
+   */
+  setSymbol(reelIndex, rowIndex, symbol) {
+    this.board.setSymbol(reelIndex, rowIndex, symbol);
+  }
   resetReels() {
     this.board.resetReels({
       ctx: this.ctx