@slot-engine/core 0.2.9 → 0.2.11

package/dist/index.mjs

@@ -371,7 +371,10 @@ var GameSymbol = class _GameSymbol {
   constructor(opts) {
     this.id = opts.id;
     this.pays = opts.pays;
-    this.properties = new Map(Object.entries(opts.properties || {}));
+    this.properties = /* @__PURE__ */ new Map();
+    for (const prop in opts.properties) {
+      this.properties.set(prop, opts.properties[prop]);
+    }
     if (this.pays && Object.keys(this.pays).length === 0) {
       throw new Error(`GameSymbol "${this.id}" must have pays defined.`);
     }
@@ -387,8 +390,8 @@ var GameSymbol = class _GameSymbol {
     if (symbolOrProperties instanceof _GameSymbol) {
       return this.id === symbolOrProperties.id;
     } else {
-      for (const [key, value] of Object.entries(symbolOrProperties)) {
-        if (!this.properties.has(key) || this.properties.get(key) !== value) {
+      for (const prop in symbolOrProperties) {
+        if (!this.properties.has(prop) || this.properties.get(prop) !== symbolOrProperties[prop]) {
           return false;
         }
       }
@@ -468,8 +471,8 @@ var Board = class {
   updateSymbol(reelIndex, rowIndex, properties) {
     const symbol = this.getSymbol(reelIndex, rowIndex);
     if (symbol) {
-      for (const [key, value] of Object.entries(properties)) {
-        symbol.properties.set(key, value);
+      for (const prop in properties) {
+        symbol.properties.set(prop, properties[prop]);
       }
     }
   }
@@ -485,8 +488,8 @@ var Board = class {
       if (symbolOrProperties instanceof GameSymbol) {
         if (symbol.id !== symbolOrProperties.id) matches = false;
       } else {
-        for (const [key, value] of Object.entries(symbolOrProperties)) {
-          if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
+        for (const prop in symbolOrProperties) {
+          if (!symbol.properties.has(prop) || symbol.properties.get(prop) !== symbolOrProperties[prop]) {
             matches = false;
             break;
           }
@@ -508,8 +511,8 @@ var Board = class {
           if (symbol.id !== symbolOrProperties.id) continue;
         } else {
           let matches = true;
-          for (const [key, value] of Object.entries(symbolOrProperties)) {
-            if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
+          for (const prop in symbolOrProperties) {
+            if (!symbol.properties.has(prop) || symbol.properties.get(prop) !== symbolOrProperties[prop]) {
               matches = false;
               break;
             }
@@ -1056,11 +1059,13 @@ var DataService = class extends AbstractService {
    * Record data for statistical analysis.
    */
   record(data) {
+    const properties = {};
+    for (const key in data) {
+      properties[key] = String(data[key]);
+    }
     this.recorder.pendingRecords.push({
       bookId: this.ctx().state.currentSimulationId,
-      properties: Object.fromEntries(
-        Object.entries(data).map(([k, v]) => [k, String(v)])
-      )
+      properties
     });
   }
   /**
@@ -1414,19 +1419,6 @@ var Book = class {
       data: copy(event.data)
     });
   }
-  /**
-   * Intended for internal use only.
-   */
-  _serialize() {
-    return {
-      id: this.id,
-      criteria: this.criteria,
-      events: this.events,
-      payout: this.payout,
-      basegameWins: this.basegameWins,
-      freespinsWins: this.freespinsWins
-    };
-  }
 };
 
 // src/wallet/index.ts
@@ -1595,7 +1587,7 @@ var Wallet = class {
     this.currentWin = process2(this.currentWin);
     this.cumulativeWins += this.currentWin;
     let spinTypeWins = 0;
-    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
+    for (const spinType in this.currentWinPerSpinType) {
       const st = spinType;
       const spinTypeWin = process2(this.currentWinPerSpinType[st]);
       this.cumulativeWinsPerSpinType[st] += spinTypeWin;
@@ -2400,9 +2392,9 @@ var Simulation = class {
         }
         const chunkIndex = this.bookChunkIndexes.get(index);
         const bookChunkPath = this.PATHS.booksChunk(mode, index, chunkIndex);
-        const data = this.bookBuffers.get(index).join("\n") + "\n";
+        const bookLines = this.bookBuffers.get(index);
         await pipeline(
-          Readable.from([Buffer.from(data, "utf8")]),
+          Readable.from(bookLines),
           zlib.createZstdCompress(),
           fs3.createWriteStream(bookChunkPath)
         );
@@ -2483,50 +2475,51 @@ var Simulation = class {
             }
           }
           writeChain = writeChain.then(async () => {
-            const book = msg.book;
-            const bookData = {
-              id: book.id,
-              payoutMultiplier: book.payout,
-              events: book.events
-            };
-            if (!this.summary[mode]?.criteria[book.criteria]) {
-              this.summary[mode].criteria[book.criteria] = {
+            const bookId = msg.bookId;
+            const bookCriteria = msg.bookCriteria;
+            const bookPayout = msg.bookPayout;
+            const bookBasegameWins = msg.bookBasegameWins;
+            const bookFreespinsWins = msg.bookFreespinsWins;
+            const bookLine = msg.bookLine;
+            const bookLineWithNewline = bookLine + "\n";
+            if (!this.summary[mode]?.criteria[bookCriteria]) {
+              this.summary[mode].criteria[bookCriteria] = {
                 numSims: 0,
                 bsWins: 0,
                 fsWins: 0,
                 rtp: 0
               };
             }
-            const bsWins = round(book.basegameWins, 4);
-            const fsWins = round(book.freespinsWins, 4);
-            this.summary[mode].criteria[book.criteria].numSims += 1;
+            const bsWins = round(bookBasegameWins, 4);
+            const fsWins = round(bookFreespinsWins, 4);
+            const criteria = this.summary[mode].criteria[bookCriteria];
+            criteria.numSims += 1;
             this.summary[mode].total.bsWins += bsWins;
             this.summary[mode].total.fsWins += fsWins;
-            this.summary[mode].criteria[book.criteria].bsWins += bsWins;
-            this.summary[mode].criteria[book.criteria].fsWins += fsWins;
-            const bookLine = JSON.stringify(bookData);
-            const lineSize = Buffer.byteLength(bookLine + "\n", "utf8");
+            criteria.bsWins += bsWins;
+            criteria.fsWins += fsWins;
+            const lineSize = Buffer.byteLength(bookLineWithNewline, "utf8");
             if (this.bookBuffers.has(index)) {
-              this.bookBuffers.get(index).push(bookLine);
+              this.bookBuffers.get(index).push(bookLineWithNewline);
               this.bookBufferSizes.set(
                 index,
                 this.bookBufferSizes.get(index) + lineSize
               );
             } else {
-              this.bookBuffers.set(index, [bookLine]);
+              this.bookBuffers.set(index, [bookLineWithNewline]);
               this.bookBufferSizes.set(index, lineSize);
             }
             if (!this.tempBookIndexPaths.includes(booksIndexPath)) {
               this.tempBookIndexPaths.push(booksIndexPath);
             }
             booksIndexBatch.push(
-              `${book.id},${index},${this.bookChunkIndexes.get(index) || 0}
+              `${bookId},${index},${this.bookChunkIndexes.get(index) || 0}
 `
             );
-            lookupBatch.push(`${book.id},1,${Math.round(book.payout)}
+            lookupBatch.push(`${bookId},1,${Math.round(bookPayout)}
 `);
             lookupSegBatch.push(
-              `${book.id},${book.criteria},${book.basegameWins},${book.freespinsWins}
+              `${bookId},${bookCriteria},${bookBasegameWins},${bookFreespinsWins}
 `
             );
             if (booksIndexBatch.length >= WRITE_BATCH_SIZE) {
@@ -2535,15 +2528,10 @@ var Simulation = class {
             if (this.bookBufferSizes.get(index) >= 10 * 1024 * 1024) {
               await flushBookChunk();
             }
-            if (this.recordsWriteStream) {
-              for (const record of msg.records) {
-                const recordPrefix = this.hasWrittenRecord ? "\n" : "";
-                await write(
-                  this.recordsWriteStream,
-                  recordPrefix + JSON.stringify(record)
-                );
-                this.hasWrittenRecord = true;
-              }
+            if (this.recordsWriteStream && typeof msg.recordsLines === "string" && msg.recordsLines.length) {
+              const recordPrefix = this.hasWrittenRecord ? "\n" : "";
+              await write(this.recordsWriteStream, recordPrefix + msg.recordsLines);
+              this.hasWrittenRecord = true;
             }
             this.wallet.mergeSerialized(msg.wallet);
             worker.postMessage({ type: "credit", amount: 1 });
@@ -2634,9 +2622,11 @@ var Simulation = class {
         });
       }
     }
-    ctx.services.wallet._getWallet().writePayoutToBook(ctx);
-    ctx.services.wallet._getWallet().confirmWins(ctx);
-    if (ctx.services.data._getBook().payout >= ctx.config.maxWinX) {
+    const wallet = ctx.services.wallet._getWallet();
+    wallet.writePayoutToBook(ctx);
+    wallet.confirmWins(ctx);
+    const book = ctx.services.data._getBook();
+    if (book.payout >= ctx.config.maxWinX) {
       ctx.state.triggeredMaxWin = true;
     }
     ctx.services.data.record({
@@ -2644,12 +2634,24 @@ var Simulation = class {
     });
     ctx.config.hooks.onSimulationAccepted?.(ctx);
     this.confirmRecords(ctx);
+    const bookLine = JSON.stringify({
+      id: book.id,
+      payoutMultiplier: book.payout,
+      events: book.events
+    });
+    const records = ctx.services.data._getRecords();
+    const recordsLines = records.length > 0 ? records.map((r) => JSON.stringify(r)).join("\n") : "";
     parentPort2?.postMessage({
       type: "complete",
       simId,
-      book: ctx.services.data._getBook()._serialize(),
-      wallet: ctx.services.wallet._getWallet().serialize(),
-      records: ctx.services.data._getRecords()
+      bookLine,
+      bookId: book.id,
+      bookCriteria: book.criteria,
+      bookPayout: book.payout,
+      bookBasegameWins: book.basegameWins,
+      bookFreespinsWins: book.freespinsWins,
+      wallet: wallet.serialize(),
+      recordsLines
     });
   }
   initCreditListener() {
@@ -3956,13 +3958,19 @@ var LinesWinType = class extends WinType {
     this.validateConfig();
     const lineWins = [];
     const reels = board;
-    for (const [lineNumStr, line] of Object.entries(this.lines)) {
+    const reelsLength = reels.length;
+    const lineNumbers = Object.keys(this.lines);
+    const numLines = lineNumbers.length;
+    for (let lidx = 0; lidx < numLines; lidx++) {
+      const lineNumStr = lineNumbers[lidx];
       const lineNum = Number(lineNumStr);
+      const line = this.lines[lineNum];
       let baseSymbol;
       const potentialWinLine = [];
       const potentialWildLine = [];
       let isInterrupted = false;
-      for (const [ridx, reel] of reels.entries()) {
+      for (let ridx = 0; ridx < reelsLength; ridx++) {
+        const reel = reels[ridx];
         const sidx = line[ridx];
         const thisSymbol = reel[sidx];
         if (!baseSymbol) {
@@ -3993,66 +4001,91 @@ var LinesWinType = class extends WinType {
           break;
         }
       }
-      const minSymLine = Math.min(
-        ...Object.keys(baseSymbol.pays || {}).map((k) => parseInt(k, 10))
-      );
+      const pays = baseSymbol.pays || {};
+      let minSymLine = Infinity;
+      for (const key in pays) {
+        const num = parseInt(key, 10);
+        if (num < minSymLine) minSymLine = num;
+      }
       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,
-        payout: linePayout
-      };
+      let finalLine;
       if (wildLinePayout > linePayout) {
         baseSymbol = potentialWildLine[0]?.symbol;
+        const wildSymbols = [];
+        const wildLineLength = potentialWildLine.length;
+        for (let i = 0; i < wildLineLength; i++) {
+          const s = potentialWildLine[i];
+          wildSymbols.push({
+            symbol: s.symbol,
+            isWild: this.isWild(s.symbol),
+            reelIndex: s.reel,
+            posIndex: s.row
+          });
+        }
         finalLine = {
-          kind: potentialWildLine.length,
+          kind: wildLineLength,
           baseSymbol,
-          symbols: potentialWildLine.map((s) => ({
+          symbols: wildSymbols,
+          lineNumber: lineNum,
+          payout: wildLinePayout
+        };
+      } else {
+        const symbols = [];
+        const lineLength = potentialWinLine.length;
+        for (let i = 0; i < lineLength; i++) {
+          const s = potentialWinLine[i];
+          symbols.push({
             symbol: s.symbol,
             isWild: this.isWild(s.symbol),
             reelIndex: s.reel,
             posIndex: s.row
-          })),
+          });
+        }
+        finalLine = {
+          kind: lineLength,
+          baseSymbol,
+          symbols,
           lineNumber: lineNum,
-          payout: wildLinePayout
+          payout: linePayout
         };
       }
       lineWins.push(finalLine);
-    }
-    for (const win of lineWins) {
       this.ctx.services.data.recordSymbolOccurrence({
-        kind: win.kind,
-        symbolId: win.baseSymbol.id,
+        kind: finalLine.kind,
+        symbolId: finalLine.baseSymbol.id,
         spinType: this.ctx.state.currentSpinType
       });
     }
-    this.payout = lineWins.reduce((sum, l) => sum + l.payout, 0);
+    let totalPayout = 0;
+    for (let i = 0; i < lineWins.length; i++) {
+      totalPayout += lineWins[i].payout;
+    }
+    this.payout = totalPayout;
     this.winCombinations = lineWins;
     return this;
   }
   getLinePayout(line) {
-    if (line.length === 0) return 0;
-    let baseSymbol = line.find((s) => !this.isWild(s.symbol))?.symbol;
+    const lineLength = line.length;
+    if (lineLength === 0) return 0;
+    let baseSymbol;
+    for (let i = 0; i < lineLength; i++) {
+      const s = line[i];
+      if (!this.isWild(s.symbol)) {
+        baseSymbol = s.symbol;
+        break;
+      }
+    }
     if (!baseSymbol) baseSymbol = line[0].symbol;
-    const kind = line.length;
-    const payout = this.getSymbolPayout(baseSymbol, kind);
-    return payout;
+    return this.getSymbolPayout(baseSymbol, lineLength);
   }
 };
 
 // src/win-types/ClusterWinType.ts
 var ClusterWinType = class extends WinType {
-  _checked = [];
-  _checkedWilds = [];
+  _checked = /* @__PURE__ */ new Set();
+  _checkedWilds = /* @__PURE__ */ new Set();
   _currentBoard = [];
   constructor(opts) {
     super(opts);
@@ -4065,121 +4098,169 @@ var ClusterWinType = class extends WinType {
    */
   evaluateWins(board) {
     this.validateConfig();
-    this._checked = [];
+    this._checked.clear();
     this._currentBoard = board;
     const clusterWins = [];
     const potentialClusters = [];
-    for (const [ridx, reel] of board.entries()) {
-      for (const [sidx, symbol] of reel.entries()) {
-        this._checkedWilds = [];
+    const boardLength = board.length;
+    for (let ridx = 0; ridx < boardLength; ridx++) {
+      const reel = board[ridx];
+      const reelLength = reel.length;
+      for (let sidx = 0; sidx < reelLength; sidx++) {
+        const symbol = reel[sidx];
+        this._checkedWilds.clear();
         if (this.isWild(symbol)) continue;
-        if (this.isChecked(ridx, sidx)) {
+        const posKey = ridx * 1e4 + sidx;
+        if (this._checked.has(posKey)) {
           continue;
         }
         const thisSymbol = { reel: ridx, row: sidx, symbol };
-        this._checked.push(thisSymbol);
+        this._checked.add(posKey);
         const neighbors = this.getNeighbors(ridx, sidx);
         const matchingSymbols = this.evaluateCluster(symbol, neighbors);
-        if (matchingSymbols.size >= 1) {
-          potentialClusters.push([thisSymbol, ...matchingSymbols.values()]);
+        const matchingSize = matchingSymbols.size;
+        if (matchingSize >= 1) {
+          const cluster = [thisSymbol];
+          for (const sym of matchingSymbols.values()) {
+            cluster.push(sym);
+          }
+          potentialClusters.push(cluster);
         }
       }
     }
-    for (const [ridx, reel] of board.entries()) {
-      for (const [sidx, symbol] of reel.entries()) {
-        this._checkedWilds = [];
+    for (let ridx = 0; ridx < boardLength; ridx++) {
+      const reel = board[ridx];
+      const reelLength = reel.length;
+      for (let sidx = 0; sidx < reelLength; sidx++) {
+        const symbol = reel[sidx];
+        this._checkedWilds.clear();
         if (!this.isWild(symbol)) continue;
-        if (this.isChecked(ridx, sidx)) {
+        const posKey = ridx * 1e4 + sidx;
+        if (this._checked.has(posKey)) {
           continue;
         }
         const thisSymbol = { reel: ridx, row: sidx, symbol };
-        this._checked.push(thisSymbol);
+        this._checked.add(posKey);
         const neighbors = this.getNeighbors(ridx, sidx);
         const matchingSymbols = this.evaluateCluster(symbol, neighbors);
-        if (matchingSymbols.size >= 1) {
-          potentialClusters.push([thisSymbol, ...matchingSymbols.values()]);
+        const matchingSize = matchingSymbols.size;
+        if (matchingSize >= 1) {
+          const cluster = [thisSymbol];
+          for (const sym of matchingSymbols.values()) {
+            cluster.push(sym);
+          }
+          potentialClusters.push(cluster);
         }
       }
     }
-    for (const cluster of potentialClusters) {
+    const numClusters = potentialClusters.length;
+    for (let i = 0; i < numClusters; i++) {
+      const cluster = potentialClusters[i];
       const kind = cluster.length;
-      let baseSymbol = cluster.find((s) => !this.isWild(s.symbol))?.symbol;
+      let baseSymbol;
+      for (let j = 0; j < kind; j++) {
+        const sym = cluster[j].symbol;
+        if (!this.isWild(sym)) {
+          baseSymbol = sym;
+          break;
+        }
+      }
       if (!baseSymbol) baseSymbol = cluster[0].symbol;
       const payout = this.getSymbolPayout(baseSymbol, kind);
       if (payout === 0) continue;
-      if (!baseSymbol.pays || Object.keys(baseSymbol.pays).length === 0) {
-        continue;
+      const pays = baseSymbol.pays;
+      if (!pays) continue;
+      let hasPays = false;
+      for (const _ in pays) {
+        hasPays = true;
+        break;
       }
-      clusterWins.push({
-        payout,
-        kind,
-        baseSymbol,
-        symbols: cluster.map((s) => ({
+      if (!hasPays) continue;
+      const symbols = [];
+      for (let j = 0; j < kind; j++) {
+        const s = cluster[j];
+        symbols.push({
           symbol: s.symbol,
           isWild: this.isWild(s.symbol),
           reelIndex: s.reel,
           posIndex: s.row
-        }))
+        });
+      }
+      clusterWins.push({
+        payout,
+        kind,
+        baseSymbol,
+        symbols
       });
-    }
-    for (const win of clusterWins) {
       this.ctx.services.data.recordSymbolOccurrence({
-        kind: win.kind,
-        symbolId: win.baseSymbol.id,
+        kind,
+        symbolId: baseSymbol.id,
         spinType: this.ctx.state.currentSpinType
       });
     }
-    this.payout = clusterWins.reduce((sum, c) => sum + c.payout, 0);
+    let totalPayout = 0;
+    for (let i = 0; i < clusterWins.length; i++) {
+      totalPayout += clusterWins[i].payout;
+    }
+    this.payout = totalPayout;
     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] });
+    if (ridx > 0) {
+      const leftReel = board[ridx - 1];
+      const leftSymbol = leftReel[sidx];
+      if (leftSymbol !== void 0) {
+        neighbors.push({ reel: ridx - 1, row: sidx, symbol: leftSymbol });
       }
-    });
+    }
+    const rightReel = board[ridx + 1];
+    if (rightReel !== void 0) {
+      const rightSymbol = rightReel[sidx];
+      if (rightSymbol !== void 0) {
+        neighbors.push({ reel: ridx + 1, row: sidx, symbol: rightSymbol });
+      }
+    }
+    const currentReel = board[ridx];
+    const topSymbol = currentReel[sidx - 1];
+    if (topSymbol !== void 0) {
+      neighbors.push({ reel: ridx, row: sidx - 1, symbol: topSymbol });
+    }
+    const bottomSymbol = currentReel[sidx + 1];
+    if (bottomSymbol !== void 0) {
+      neighbors.push({ reel: ridx, row: sidx + 1, symbol: bottomSymbol });
+    }
     return neighbors;
   }
   evaluateCluster(rootSymbol, neighbors) {
     const matchingSymbols = /* @__PURE__ */ new Map();
-    neighbors.forEach((neighbor) => {
+    const numNeighbors = neighbors.length;
+    for (let i = 0; i < numNeighbors; i++) {
+      const neighbor = neighbors[i];
       const { reel, row, symbol } = neighbor;
-      if (this.isChecked(reel, row)) return;
-      if (this.isCheckedWild(reel, row)) return;
+      const posKey = reel * 1e4 + row;
+      if (this._checked.has(posKey)) continue;
+      if (this._checkedWilds.has(posKey)) continue;
       if (this.isWild(symbol) || symbol.compare(rootSymbol)) {
-        const key = `${reel}-${row}`;
+        const key = String(posKey);
         matchingSymbols.set(key, { reel, row, symbol });
         if (symbol.compare(rootSymbol)) {
-          this._checked.push(neighbor);
+          this._checked.add(posKey);
         }
         if (this.isWild(symbol)) {
-          this._checkedWilds.push(neighbor);
+          this._checkedWilds.add(posKey);
         }
-        const neighbors2 = this.getNeighbors(reel, row);
-        const nestedMatches = this.evaluateCluster(rootSymbol, neighbors2);
-        nestedMatches.forEach((nsym) => {
-          const nkey = `${nsym.reel}-${nsym.row}`;
+        const nestedNeighbors = this.getNeighbors(reel, row);
+        const nestedMatches = this.evaluateCluster(rootSymbol, nestedNeighbors);
+        for (const [nkey, nsym] of nestedMatches.entries()) {
           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
@@ -4198,7 +4279,7 @@ var ManywaysWinType = class extends WinType {
     const { jumpGaps = false } = opts;
     const waysWins = [];
     const reels = board;
-    const possibleWaysWins = /* @__PURE__ */ new Map();
+    const numReels = reels.length;
     const candidateSymbols = /* @__PURE__ */ new Map();
     if (jumpGaps) {
       for (const reel of reels) {
@@ -4209,7 +4290,7 @@ var ManywaysWinType = class extends WinType {
     } else {
       let searchReelIdx = 0;
       let searchActive = true;
-      while (searchActive && searchReelIdx < reels.length) {
+      while (searchActive && searchReelIdx < numReels) {
         const reel = reels[searchReelIdx];
         let hasWild = false;
         for (const symbol of reel) {
@@ -4225,71 +4306,78 @@ var ManywaysWinType = class extends WinType {
       }
     }
     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 symbolList = [];
+      let wayLength = 0;
+      let firstNonWildSymbol;
+      let totalWays = 1;
+      for (let ridx = 0; ridx < numReels; ridx++) {
+        const reel = reels[ridx];
+        let reelMatches;
+        for (let sidx = 0; sidx < reel.length; sidx++) {
+          const symbol = reel[sidx];
           const isMatch = baseSymbol.compare(symbol) || this.isWild(symbol);
           if (isMatch) {
-            if (!symbolList[ridx]) {
-              symbolList[ridx] = [];
+            if (!reelMatches) {
+              reelMatches = [];
+            }
+            reelMatches.push({ reel: ridx, row: sidx, symbol });
+            if (!firstNonWildSymbol && !this.isWild(symbol)) {
+              firstNonWildSymbol = symbol;
             }
-            symbolList[ridx].push({ reel: ridx, row: sidx, symbol });
           }
         }
-        if (!symbolList[ridx] && !jumpGaps) {
-          isInterrupted = true;
+        if (reelMatches) {
+          symbolList[wayLength++] = reelMatches;
+          totalWays *= reelMatches.length;
+        } else if (!jumpGaps) {
           break;
         }
       }
-      const minSymLine = Math.min(
-        ...Object.keys(baseSymbol.pays || {}).map((k) => parseInt(k, 10))
-      );
-      const wayLength = this.getWayLength(symbolList);
+      const pays = baseSymbol.pays || {};
+      let minSymLine = Infinity;
+      for (const key in pays) {
+        const num = parseInt(key, 10);
+        if (num < minSymLine) minSymLine = num;
+      }
       if (wayLength >= minSymLine) {
-        possibleWaysWins.set(baseSymbol.id, symbolList);
+        const winBaseSymbol = firstNonWildSymbol || symbolList[0][0].symbol;
+        const singleWayPayout = this.getSymbolPayout(winBaseSymbol, wayLength);
+        const totalPayout2 = singleWayPayout * totalWays;
+        const symbols = [];
+        for (let i = 0; i < wayLength; i++) {
+          const reelSyms = symbolList[i];
+          for (let j = 0; j < reelSyms.length; j++) {
+            const s = reelSyms[j];
+            symbols.push({
+              symbol: s.symbol,
+              isWild: this.isWild(s.symbol),
+              reelIndex: s.reel,
+              posIndex: s.row
+            });
+          }
+        }
+        waysWins.push({
+          kind: wayLength,
+          baseSymbol: winBaseSymbol,
+          symbols,
+          ways: totalWays,
+          payout: totalPayout2
+        });
+        this.ctx.services.data.recordSymbolOccurrence({
+          kind: wayLength,
+          symbolId: winBaseSymbol.id,
+          spinType: this.ctx.state.currentSpinType
+        });
       }
     }
-    for (const [, 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[Object.keys(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
-      });
+    let totalPayout = 0;
+    for (let i = 0; i < waysWins.length; i++) {
+      totalPayout += waysWins[i].payout;
     }
-    this.payout = waysWins.reduce((sum, l) => sum + l.payout, 0);
+    this.payout = totalPayout;
     this.winCombinations = waysWins;
     return this;
   }
-  getWayLength(symbolList) {
-    return Object.keys(symbolList).length;
-  }
 };
 
 // src/reel-set/GeneratedReelSet.ts