@slot-engine/core 0.2.3 → 0.2.5

package/dist/index.mjs

@@ -44,7 +44,8 @@ function createPermanentFilePaths(basePath) {
     publishFiles: path.join(basePath, "publish_files"),
     simulationSummary: path.join(basePath, "simulation_summary.json"),
     statsPayouts: path.join(basePath, "stats_payouts.json"),
-    statsSummary: path.join(basePath, "stats_summary.json")
+    statsSummary: path.join(basePath, "stats_summary.json"),
+    statsRecords: path.join(basePath, "stats_records.json")
   };
 }
 function createTemporaryFilePaths(basePath, tempFolder) {
@@ -399,11 +400,11 @@ var GameSymbol = class _GameSymbol {
    * 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)
-    });
+    const cloned = Object.create(_GameSymbol.prototype);
+    cloned.id = this.id;
+    cloned.pays = this.pays;
+    cloned.properties = this.properties.size > 0 ? new Map(this.properties) : /* @__PURE__ */ new Map();
+    return cloned;
   }
 };
 
@@ -456,6 +457,9 @@ var Board = class {
   setSymbol(reelIndex, rowIndex, symbol) {
     this.reels[reelIndex] = this.reels[reelIndex] || [];
     this.reels[reelIndex][rowIndex] = symbol;
+    this.updateSymbol(reelIndex, rowIndex, {
+      position: [reelIndex, rowIndex]
+    });
   }
   removeSymbol(reelIndex, rowIndex) {
     if (this.reels[reelIndex]) {
@@ -664,16 +668,19 @@ var Board = class {
       const reelLength = opts.reels[ridx].length;
       for (let p = padSymbols - 1; p >= 0; p--) {
         const topPos = ((reelPos - (p + 1)) % reelLength + reelLength) % reelLength;
-        this.paddingTop[ridx].push(opts.reels[ridx][topPos]);
+        this.paddingTop[ridx].push(opts.reels[ridx][topPos].clone());
         const bottomPos = (reelPos + symbolsPerReel[ridx] + p) % reelLength;
-        this.paddingBottom[ridx].unshift(opts.reels[ridx][bottomPos]);
+        this.paddingBottom[ridx].unshift(opts.reels[ridx][bottomPos].clone());
       }
       for (let row = 0; row < symbolsPerReel[ridx]; row++) {
         const symbol = opts.reels[ridx][(reelPos + row) % reelLength];
         if (!symbol) {
           throw new Error(`Failed to get symbol at pos ${reelPos + row} on reel ${ridx}`);
         }
-        this.reels[ridx][row] = symbol;
+        this.reels[ridx][row] = symbol.clone();
+        this.updateSymbol(ridx, row, {
+          position: [ridx, row]
+        });
       }
     }
     return {
@@ -741,6 +748,7 @@ var Board = class {
           newSymbol = forcedSym;
         }
         assert3(newSymbol, "Failed to get new symbol for tumbling.");
+        newSymbol = newSymbol.clone();
         this.reels[ridx].unshift(newSymbol);
         newFirstSymbolPositions[ridx] = symbolPos;
         if (!newBoardSymbols[ridx]) {
@@ -754,7 +762,7 @@ var Board = class {
       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];
+        const padSymbol = reels[ridx][topPos]?.clone();
         assert3(padSymbol, "Failed to get new padding symbol for tumbling.");
         this.paddingTop[ridx].unshift(padSymbol);
         if (!newPaddingTopSymbols[ridx]) {
@@ -768,6 +776,14 @@ var Board = class {
         return newFirstSymbolPositions[ridx] ?? stop;
       });
     }
+    for (let ridx = 0; ridx < reelsAmount; ridx++) {
+      const reel = this.reels[ridx];
+      for (let rowIdx = 0; rowIdx < reel.length; rowIdx++) {
+        this.updateSymbol(ridx, rowIdx, {
+          position: [ridx, rowIdx]
+        });
+      }
+    }
     return {
       newBoardSymbols,
       newPaddingTopSymbols
@@ -1053,7 +1069,10 @@ var DataService = class extends AbstractService {
    * Calls `ctx.services.data.record()` with the provided data.
    */
   recordSymbolOccurrence(data) {
-    this.record(data);
+    this.record({
+      ...data,
+      spinType: this.ctx().state.currentSpinType
+    });
   }
   /**
    * Adds an event to the book.
@@ -3075,15 +3094,21 @@ function getLessBetHitrate(payoutWeights, cost) {
 
 // src/analysis/index.ts
 import { isMainThread as isMainThread3 } from "worker_threads";
+import chalk3 from "chalk";
 var Analysis = class {
   game;
   constructor(game) {
     this.game = game;
   }
-  async runAnalysis(gameModes) {
+  async runAnalysis(opts) {
+    const { gameModes, recordStats = [] } = opts;
     if (!isMainThread3) return;
+    console.log(chalk3.gray("Starting analysis..."));
     this.getNumberStats(gameModes);
     this.getWinRanges(gameModes);
+    if (recordStats.length > 0) {
+      this.getRecordStats(gameModes, recordStats);
+    }
     console.log("Analysis complete. Files written to build directory.");
   }
   getNumberStats(gameModes) {
@@ -3260,6 +3285,85 @@ var Analysis = class {
     }
     writeJsonFile(meta.paths.statsPayouts, payoutRanges);
   }
+  getRecordStats(gameModes, recordStatsConfig) {
+    const meta = this.game.getMetadata();
+    const allStats = [];
+    for (const modeStr of gameModes) {
+      const lutOptimized = parseLookupTable(
+        fs4.readFileSync(meta.paths.lookupTablePublish(modeStr), "utf-8")
+      );
+      const totalWeight = getTotalLutWeight(lutOptimized);
+      const weightMap = /* @__PURE__ */ new Map();
+      lutOptimized.forEach(([bookId, weight]) => {
+        weightMap.set(bookId, weight);
+      });
+      const forceRecordsPath = meta.paths.forceRecords(modeStr);
+      if (!fs4.existsSync(forceRecordsPath)) continue;
+      const forceRecords = JSON.parse(
+        fs4.readFileSync(forceRecordsPath, "utf-8")
+      );
+      const modeStats = {
+        gameMode: modeStr,
+        groups: []
+      };
+      for (const config of recordStatsConfig) {
+        const groupName = config.name || config.groupBy.join("_");
+        const aggregated = /* @__PURE__ */ new Map();
+        for (const record of forceRecords) {
+          const searchMap = new Map(record.search.map((s) => [s.name, s.value]));
+          if (config.filter) {
+            let matches = true;
+            for (const [key2, value] of Object.entries(config.filter)) {
+              if (searchMap.get(key2) !== value) {
+                matches = false;
+                break;
+              }
+            }
+            if (!matches) continue;
+          }
+          const hasAllProps = config.groupBy.every((prop) => searchMap.has(prop));
+          if (!hasAllProps) continue;
+          const key = config.groupBy.map((prop) => searchMap.get(prop)).join("|");
+          const properties = Object.fromEntries(
+            config.groupBy.map((prop) => [prop, searchMap.get(prop)])
+          );
+          let totalWeight2 = 0;
+          for (const bookId of record.bookIds) {
+            totalWeight2 += weightMap.get(bookId) ?? 0;
+          }
+          const existing = aggregated.get(key);
+          if (existing) {
+            existing.count += record.timesTriggered;
+            existing.totalWeight += totalWeight2;
+          } else {
+            aggregated.set(key, {
+              properties,
+              count: record.timesTriggered,
+              totalWeight: totalWeight2
+            });
+          }
+        }
+        const items = Array.from(aggregated.entries()).map(([key, data]) => {
+          const hitRate = round(totalWeight / data.totalWeight, 4);
+          return {
+            key,
+            properties: data.properties,
+            count: data.count,
+            hitRateString: `1 in ${Math.round(hitRate).toLocaleString()}`,
+            hitRate
+          };
+        }).sort((a, b) => a.hitRate - b.hitRate);
+        modeStats.groups.push({
+          name: groupName,
+          groupBy: config.groupBy,
+          filter: config.filter,
+          items
+        });
+      }
+      allStats.push(modeStats);
+    }
+    writeJsonFile(meta.paths.statsRecords, allStats);
+  }
   getGameModeConfig(mode) {
     const config = this.game.getConfig().gameModes[mode];
     assert6(config, `Game mode "${mode}" not found in game config`);
@@ -3624,7 +3728,7 @@ var SlotGame = class _SlotGame {
    */
   runAnalysis(opts) {
     this.analyzer = new Analysis(this);
-    this.analyzer.runAnalysis(opts.gameModes);
+    this.analyzer.runAnalysis(opts);
   }
   /**
    * Runs the configured tasks: simulation, optimization, and/or analysis.