@slot-engine/core 0.2.9 → 0.2.10

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
     });
   }
   /**
@@ -3956,13 +3961,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 +4004,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 +4101,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 +4282,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 +4293,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 +4309,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