@slot-engine/core 0.0.9 → 0.0.11

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.");
@@ -571,7 +598,11 @@ var Board = class {
       for (const [r, stopPos] of Object.entries(opts.forcedStops)) {
         const reelIdx = Number(r);
         const symCount = symbolsPerReel[reelIdx];
-        finalReelStops[reelIdx] = stopPos - Math.round(opts.ctx.services.rng.randomFloat(0, symCount - 1));
+        if (opts.forcedStopsOffset !== false) {
+          finalReelStops[reelIdx] = stopPos - Math.round(opts.ctx.services.rng.randomFloat(0, symCount - 1));
+        } else {
+          finalReelStops[reelIdx] = stopPos;
+        }
         if (finalReelStops[reelIdx] < 0) {
           finalReelStops[reelIdx] = opts.reels[reelIdx].length + finalReelStops[reelIdx];
         }
@@ -614,7 +645,8 @@ var Board = class {
       );
     }
     const reels = this.lastUsedReels;
-    opts.symbolsToDelete.forEach(({ reelIdx, rowIdx }) => {
+    const sortedDeletions = [...opts.symbolsToDelete].sort((a, b) => b.rowIdx - a.rowIdx);
+    sortedDeletions.forEach(({ reelIdx, rowIdx }) => {
       this.reels[reelIdx].splice(rowIdx, 1);
     });
     const newFirstSymbolPositions = {};
@@ -640,6 +672,7 @@ var Board = class {
     }
     for (let ridx = 0; ridx < reelsAmount; ridx++) {
       const firstSymbolPos = newFirstSymbolPositions[ridx];
+      if (firstSymbolPos === void 0) continue;
       for (let p = 1; p <= padSymbols; p++) {
         const topPos = (firstSymbolPos - p + reels[ridx].length) % reels[ridx].length;
         const padSymbol = reels[ridx][topPos];
@@ -680,6 +713,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()
@@ -754,8 +799,8 @@ var BoardService = class extends AbstractService {
   /**
    * Draws a board using specified reel stops.
    */
-  drawBoardWithForcedStops(reels, forcedStops) {
-    this.drawBoardMixed(reels, forcedStops);
+  drawBoardWithForcedStops(opts) {
+    this.drawBoardMixed(opts.reels, opts.forcedStops, opts.randomOffset);
   }
   /**
    * Draws a board using random reel stops.
@@ -763,11 +808,12 @@ var BoardService = class extends AbstractService {
   drawBoardWithRandomStops(reels) {
     this.drawBoardMixed(reels);
   }
-  drawBoardMixed(reels, forcedStops) {
+  drawBoardMixed(reels, forcedStops, forcedStopsOffset) {
     this.board.drawBoardMixed({
       ctx: this.ctx(),
       reels,
-      forcedStops
+      forcedStops,
+      forcedStopsOffset
     });
   }
   /**
@@ -867,6 +913,25 @@ var GameService = class extends AbstractService {
   constructor(ctx) {
     super(ctx);
   }
+  /**
+   * Intended for internal use only.\
+   * Generates reels for all reel sets in the game configuration.
+   */
+  _generateReels() {
+    const config = this.ctx().config;
+    for (const mode of Object.values(config.gameModes)) {
+      if (mode.reelSets && mode.reelSets.length > 0) {
+        for (const reelSet of Object.values(mode.reelSets)) {
+          reelSet.associatedGameModeName = mode.name;
+          reelSet.generateReels(config);
+        }
+      } else {
+        throw new Error(
+          `Game mode "${mode.name}" has no reel sets defined. Cannot generate reelset files.`
+        );
+      }
+    }
+  }
   /**
    * Retrieves a reel set by its ID within a specific game mode.
    */
@@ -1105,16 +1170,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 {
   /**
@@ -1758,7 +1813,7 @@ Simulating game mode: ${mode}`);
       if (mode.reelSets && mode.reelSets.length > 0) {
         for (const reelSet of Object.values(mode.reelSets)) {
           reelSet.associatedGameModeName = mode.name;
-          reelSet.generateReels(this);
+          reelSet.generateReels(this.gameConfig);
         }
       } else {
         throw new Error(
@@ -2527,9 +2582,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) {
@@ -2570,106 +2636,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;
+      let baseSymbol;
+      const potentialWinLine = [];
+      const potentialWildLine = [];
+      for (const [ridx, reel] of reels.entries()) {
+        const sidx = line[ridx];
+        const thisSymbol = reel[sidx];
+        if (!baseSymbol) {
+          baseSymbol = thisSymbol;
         }
-        if (wild) {
-          chain.push(sym);
-          details.push({
-            reelIndex: ridx,
-            posIndex: rowIdx,
-            symbol: sym,
-            isWild: true,
-            substitutedFor: baseSymbol || void 0
-          });
+        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 (!baseSymbol) {
-          baseSymbol = sym;
-          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;
         }
-        if (sym.id === baseSymbol.id) {
-          chain.push(sym);
-          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: false });
-          continue;
+        if (baseSymbol.compare(thisSymbol) || this.isWild(thisSymbol)) {
+          potentialWinLine.push({ reel: ridx, row: sidx, symbol: thisSymbol });
         }
-        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 (!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
@@ -2692,7 +2987,7 @@ var ReelSet = class {
     this.rng = new RandomNumberGenerator();
     this.rng.setSeed(opts.seed ?? 0);
   }
-  generateReels(simulation) {
+  generateReels(config) {
     throw new Error("Not implemented");
   }
   /**
@@ -2864,7 +3159,7 @@ var GeneratedReelSet = class extends ReelSet {
     }
     return false;
   }
-  generateReels({ gameConfig: config }) {
+  generateReels(config) {
     this.validateConfig(config);
     const gameMode = config.gameModes[this.associatedGameModeName];
     if (!gameMode) {
@@ -2879,7 +3174,7 @@ var GeneratedReelSet = class extends ReelSet {
     const exists = fs5.existsSync(filePath);
     if (exists && !this.overrideExisting) {
       this.reels = this.parseReelsetCSV(filePath, config);
-      return;
+      return this;
     }
     if (!exists && this.symbolWeights.size === 0) {
       throw new Error(
@@ -3026,11 +3321,12 @@ var GeneratedReelSet = class extends ReelSet {
         `Generated reelset ${this.id} for game mode ${this.associatedGameModeName}`
       );
     }
+    return this;
   }
 };
 
 // src/reel-set/StaticReelSet.ts
-import assert11 from "assert";
+import assert12 from "assert";
 var StaticReelSet = class extends ReelSet {
   reels;
   csvPath;
@@ -3040,7 +3336,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}`
     );
@@ -3061,7 +3357,7 @@ var StaticReelSet = class extends ReelSet {
       );
     }
   }
-  generateReels({ gameConfig: config }) {
+  generateReels(config) {
     this.validateConfig(config);
     if (this._strReels.length > 0) {
       this.reels = this._strReels.map((reel) => {
@@ -3079,6 +3375,7 @@ var StaticReelSet = class extends ReelSet {
     if (this.csvPath) {
       this.reels = this.parseReelsetCSV(this.csvPath, config);
     }
+    return this;
   }
 };
 
@@ -3116,6 +3413,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
@@ -3191,8 +3500,8 @@ var StandaloneBoard = class {
   /**
    * Draws a board using specified reel stops.
    */
-  drawBoardWithForcedStops(reels, forcedStops) {
-    this.drawBoardMixed(reels, forcedStops);
+  drawBoardWithForcedStops(opts) {
+    this.drawBoardMixed(opts.reels, opts.forcedStops, opts.randomOffset);
   }
   /**
    * Draws a board using random reel stops.
@@ -3200,11 +3509,12 @@ var StandaloneBoard = class {
   drawBoardWithRandomStops(reels) {
     this.drawBoardMixed(reels);
   }
-  drawBoardMixed(reels, forcedStops) {
+  drawBoardMixed(reels, forcedStops, forcedStopsOffset) {
     this.board.drawBoardMixed({
       ctx: this.ctx,
       reels,
       forcedStops,
+      forcedStopsOffset,
       reelsAmount: this.reelsAmount,
       symbolsPerReel: this.symbolsPerReel,
       padSymbols: this.padSymbols