@slot-engine/core 0.1.3 → 0.1.5

package/dist/index.mjs

@@ -34,6 +34,7 @@ import fs2 from "fs";
 import path from "path";
 import assert6 from "assert";
 import zlib from "zlib";
+import readline2 from "readline";
 import { buildSync } from "esbuild";
 import { Worker, isMainThread, parentPort, workerData } from "worker_threads";
 
@@ -201,6 +202,7 @@ var RandomNumberGenerator = class {
 
 // utils.ts
 import fs from "fs";
+import readline from "readline";
 function createDirIfNotExists(dirPath) {
   if (!fs.existsSync(dirPath)) {
     fs.mkdirSync(dirPath, { recursive: true });
@@ -232,6 +234,29 @@ var JSONL = class {
   static parse(jsonl) {
     return jsonl.split("\n").filter((s) => s !== "").map((str) => JSON.parse(str));
   }
+  static async convertToJson(inputPath, outputPath) {
+    const writeStream = fs.createWriteStream(outputPath, { encoding: "utf-8" });
+    writeStream.write("[\n");
+    const rl = readline.createInterface({
+      input: fs.createReadStream(inputPath),
+      crlfDelay: Infinity
+    });
+    let isFirst = true;
+    for await (const line of rl) {
+      if (line.trim() === "") continue;
+      if (!isFirst) {
+        writeStream.write(",\n");
+      }
+      writeStream.write(line);
+      isFirst = false;
+    }
+    writeStream.write("\n]");
+    writeStream.end();
+    return new Promise((resolve, reject) => {
+      writeStream.on("finish", () => resolve());
+      writeStream.on("error", reject);
+    });
+  }
 };
 
 // src/result-set/index.ts
@@ -695,6 +720,9 @@ var Board = class {
         newPaddingTopSymbols[ridx].unshift(padSymbol);
       }
     }
+    this.lastDrawnReelStops = this.lastDrawnReelStops.map((stop, ridx) => {
+      return newFirstSymbolPositions[ridx] ?? stop;
+    });
     return {
       newBoardSymbols,
       newPaddingTopSymbols
@@ -1040,6 +1068,27 @@ var GameService = class extends AbstractService {
     this.ctx().state.totalFreespinAmount += amount;
     this.ctx().state.triggeredFreespins = true;
   }
+  /**
+   * Dedupes win symbols.
+   *
+   * Since it may be possible that multiple win combinations include the same symbol (e.g. Wilds),\
+   * this method ensures that each symbol is only listed once.
+   * 
+   * If you want to tumble based on winning symbols, run them through this method first.
+   */
+  dedupeWinSymbols(winCombinations) {
+    const symbolsMap = /* @__PURE__ */ new Map();
+    winCombinations.forEach((wc) => {
+      wc.symbols.forEach((s) => {
+        symbolsMap.set(`${s.reelIndex},${s.posIndex}`, {
+          reelIdx: s.reelIndex,
+          rowIdx: s.posIndex
+        });
+      });
+    });
+    const symbolsToRemove = Array.from(symbolsMap.values());
+    return symbolsToRemove;
+  }
 };
 
 // src/service/wallet.ts
@@ -1412,8 +1461,10 @@ var Wallet = class {
 };
 
 // src/simulation/index.ts
+import { pipeline } from "stream/promises";
 var completedSimulations = 0;
 var TEMP_FILENAME = "__temp_compiled_src_IGNORE.js";
+var TEMP_FOLDER = "temp_files";
 var Simulation = class {
   gameConfigOpts;
   gameConfig;
@@ -1422,15 +1473,15 @@ var Simulation = class {
   debug = false;
   actualSims = 0;
   library;
-  recorder;
   wallet;
+  recordsWriteStream;
+  hasWrittenRecord = false;
   constructor(opts, gameConfigOpts) {
     this.gameConfig = createGameConfig(gameConfigOpts);
     this.gameConfigOpts = gameConfigOpts;
     this.simRunsAmount = opts.simRunsAmount || {};
     this.concurrency = (opts.concurrency || 6) >= 2 ? opts.concurrency || 6 : 2;
     this.library = /* @__PURE__ */ new Map();
-    this.recorder = new Recorder();
     this.wallet = new Wallet();
     const gameModeKeys = Object.keys(this.gameConfig.gameModes);
     assert6(
@@ -1456,7 +1507,7 @@ var Simulation = class {
         completedSimulations = 0;
         this.wallet = new Wallet();
         this.library = /* @__PURE__ */ new Map();
-        this.recorder = new Recorder();
+        this.hasWrittenRecord = false;
         debugDetails[mode] = {};
         console.log(`
 Simulating game mode: ${mode}`);
@@ -1468,8 +1519,59 @@ Simulating game mode: ${mode}`);
             `Tried to simulate game mode "${mode}", but it's not configured in the game config.`
           );
         }
+        const booksPath = path.join(
+          this.gameConfig.rootDir,
+          this.gameConfig.outputDir,
+          `books_${mode}.jsonl`
+        );
+        const tempRecordsPath = path.join(
+          this.gameConfig.rootDir,
+          this.gameConfig.outputDir,
+          TEMP_FOLDER,
+          `temp_records_${mode}.jsonl`
+        );
+        createDirIfNotExists(
+          path.join(this.gameConfig.rootDir, this.gameConfig.outputDir)
+        );
+        createDirIfNotExists(
+          path.join(this.gameConfig.rootDir, this.gameConfig.outputDir, TEMP_FOLDER)
+        );
+        this.recordsWriteStream = fs2.createWriteStream(tempRecordsPath);
         const simNumsToCriteria = ResultSet.assignCriteriaToSimulations(this, mode);
         await this.spawnWorkersForGameMode({ mode, simNumsToCriteria });
+        const finalBookStream = fs2.createWriteStream(booksPath);
+        const numSims = Object.keys(simNumsToCriteria).length;
+        const chunks = this.getSimRangesForChunks(numSims, this.concurrency);
+        let isFirstChunk = true;
+        for (let i = 0; i < chunks.length; i++) {
+          const tempBookPath = path.join(
+            this.gameConfig.rootDir,
+            this.gameConfig.outputDir,
+            TEMP_FOLDER,
+            `temp_books_${mode}_${i}.jsonl`
+          );
+          if (fs2.existsSync(tempBookPath)) {
+            if (!isFirstChunk) {
+              finalBookStream.write("\n");
+            }
+            const content = fs2.createReadStream(tempBookPath);
+            for await (const chunk of content) {
+              finalBookStream.write(chunk);
+            }
+            fs2.rmSync(tempBookPath);
+            isFirstChunk = false;
+          }
+        }
+        finalBookStream.end();
+        await new Promise((resolve) => finalBookStream.on("finish", resolve));
+        if (this.recordsWriteStream) {
+          await new Promise((resolve) => {
+            this.recordsWriteStream.end(() => {
+              resolve();
+            });
+          });
+          this.recordsWriteStream = void 0;
+        }
         createDirIfNotExists(
           path.join(
             this.gameConfig.rootDir,
@@ -1480,11 +1582,13 @@ Simulating game mode: ${mode}`);
         createDirIfNotExists(
           path.join(this.gameConfig.rootDir, this.gameConfig.outputDir, "publish_files")
         );
+        console.log(`Writing final files for game mode: ${mode} ...`);
         this.writeLookupTableCSV(mode);
         this.writeLookupTableSegmentedCSV(mode);
         this.writeRecords(mode);
         await this.writeBooksJson(mode);
         this.writeIndexJson();
+        console.log(`Mode ${mode} done!`);
         debugDetails[mode].rtp = this.wallet.getCumulativeWins() / (runs * this.gameConfig.gameModes[mode].cost);
         debugDetails[mode].wins = this.wallet.getCumulativeWins();
         debugDetails[mode].winsPerSpinType = this.wallet.getCumulativeWinsPerSpinType();
@@ -1563,6 +1667,12 @@ Simulating game mode: ${mode}`);
           index
         }
       });
+      const tempBookPath = path.join(
+        basePath,
+        TEMP_FOLDER,
+        `temp_books_${mode}_${index}.jsonl`
+      );
+      const bookStream = fs2.createWriteStream(tempBookPath);
       worker.on("message", (msg) => {
         if (msg.type === "log") {
         } else if (msg.type === "complete") {
@@ -1571,15 +1681,34 @@ Simulating game mode: ${mode}`);
             logArrowProgress(completedSimulations, totalSims);
           }
           const book = Book.fromSerialized(msg.book);
+          const bookData = {
+            id: book.id,
+            payoutMultiplier: book.payout,
+            events: book.events
+          };
+          const prefix = book.id === simStart ? "" : "\n";
+          bookStream.write(prefix + JSONL.stringify([bookData]));
+          book.events = [];
           this.library.set(book.id, book);
+          if (this.recordsWriteStream) {
+            for (const record of msg.records) {
+              const recordPrefix = this.hasWrittenRecord ? "\n" : "";
+              this.recordsWriteStream.write(recordPrefix + JSONL.stringify([record]));
+              this.hasWrittenRecord = true;
+            }
+          }
           this.wallet.mergeSerialized(msg.wallet);
-          this.mergeRecords(msg.records);
         } else if (msg.type === "done") {
           resolve(true);
         }
       });
       worker.on("error", (error) => {
-        console.error("Error:", error);
+        process.stdout.write(`
+${error.message}
+`);
+        process.stdout.write(`
+${error.stack}
+`);
         reject(error);
       });
       worker.on("exit", (code) => {
@@ -1716,16 +1845,61 @@ Simulating game mode: ${mode}`);
     writeFile(outputFilePath, rows.join("\n"));
     return outputFilePath;
   }
-  writeRecords(gameMode) {
-    const outputFileName = `force_record_${gameMode}.json`;
-    const outputFilePath = path.join(
+  async writeRecords(mode) {
+    const tempRecordsPath = path.join(
       this.gameConfig.rootDir,
       this.gameConfig.outputDir,
-      outputFileName
+      TEMP_FOLDER,
+      `temp_records_${mode}.jsonl`
     );
-    writeFile(outputFilePath, JSON.stringify(this.recorder.records, null, 2));
-    if (this.debug) this.logSymbolOccurrences();
-    return outputFilePath;
+    const forceRecordsPath = path.join(
+      this.gameConfig.rootDir,
+      this.gameConfig.outputDir,
+      `force_record_${mode}.json`
+    );
+    const aggregatedRecords = /* @__PURE__ */ new Map();
+    if (fs2.existsSync(tempRecordsPath)) {
+      const fileStream = fs2.createReadStream(tempRecordsPath);
+      const rl = readline2.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+      });
+      for await (const line of rl) {
+        if (line.trim() === "") continue;
+        const record = JSON.parse(line);
+        const key = JSON.stringify(record.search);
+        let existing = aggregatedRecords.get(key);
+        if (!existing) {
+          existing = {
+            search: record.search,
+            timesTriggered: 0,
+            bookIds: []
+          };
+          aggregatedRecords.set(key, existing);
+        }
+        existing.timesTriggered += record.timesTriggered;
+        for (const bookId of record.bookIds) {
+          existing.bookIds.push(bookId);
+        }
+      }
+    }
+    fs2.rmSync(forceRecordsPath, { force: true });
+    const writeStream = fs2.createWriteStream(forceRecordsPath, { encoding: "utf-8" });
+    writeStream.write("[\n");
+    let isFirst = true;
+    for (const record of aggregatedRecords.values()) {
+      if (!isFirst) {
+        writeStream.write(",\n");
+      }
+      writeStream.write(JSON.stringify(record));
+      isFirst = false;
+    }
+    writeStream.write("\n]");
+    writeStream.end();
+    await new Promise((resolve) => {
+      writeStream.on("finish", () => resolve());
+    });
+    fs2.rmSync(tempRecordsPath, { force: true });
   }
   writeIndexJson() {
     const outputFilePath = path.join(
@@ -1747,54 +1921,25 @@ Simulating game mode: ${mode}`);
     writeFile(outputFilePath, JSON.stringify({ modes }, null, 2));
   }
   async writeBooksJson(gameMode) {
-    const outputFileName = `books_${gameMode}.jsonl`;
     const outputFilePath = path.join(
       this.gameConfig.rootDir,
       this.gameConfig.outputDir,
-      outputFileName
+      `books_${gameMode}.jsonl`
     );
-    const books = Array.from(this.library.values()).map((b) => b.serialize()).map((b) => ({
-      id: b.id,
-      payoutMultiplier: b.payout,
-      events: b.events
-    })).sort((a, b) => a.id - b.id);
-    const contents = JSONL.stringify(books);
-    writeFile(outputFilePath, contents);
-    const compressedFileName = `books_${gameMode}.jsonl.zst`;
     const compressedFilePath = path.join(
       this.gameConfig.rootDir,
       this.gameConfig.outputDir,
       "publish_files",
-      compressedFileName
+      `books_${gameMode}.jsonl.zst`
     );
     fs2.rmSync(compressedFilePath, { force: true });
-    const compressed = zlib.zstdCompressSync(Buffer.from(contents));
-    fs2.writeFileSync(compressedFilePath, compressed);
-  }
-  logSymbolOccurrences() {
-    const validRecords = this.recorder.records.filter(
-      (r) => r.search.some((s) => s.name === "symbolId") && r.search.some((s) => s.name === "kind")
-    );
-    const structuredRecords = validRecords.map((r) => {
-      const symbolEntry = r.search.find((s) => s.name === "symbolId");
-      const kindEntry = r.search.find((s) => s.name === "kind");
-      const spinTypeEntry = r.search.find((s) => s.name === "spinType");
-      return {
-        symbol: symbolEntry ? symbolEntry.value : "unknown",
-        kind: kindEntry ? kindEntry.value : "unknown",
-        spinType: spinTypeEntry ? spinTypeEntry.value : "unknown",
-        timesTriggered: r.timesTriggered
-      };
-    }).sort((a, b) => {
-      if (a.symbol < b.symbol) return -1;
-      if (a.symbol > b.symbol) return 1;
-      if (a.kind < b.kind) return -1;
-      if (a.kind > b.kind) return 1;
-      if (a.spinType < b.spinType) return -1;
-      if (a.spinType > b.spinType) return 1;
-      return 0;
-    });
-    console.table(structuredRecords);
+    if (fs2.existsSync(outputFilePath)) {
+      await pipeline(
+        fs2.createReadStream(outputFilePath),
+        zlib.createZstdCompress(),
+        fs2.createWriteStream(compressedFilePath)
+      );
+    }
   }
   /**
    * Compiles user configured game to JS for use in different Node processes
@@ -1832,32 +1977,6 @@ Simulating game mode: ${mode}`);
     }
     return result;
   }
-  mergeRecords(otherRecords) {
-    for (const otherRecord of otherRecords) {
-      let record = this.recorder.records.find((r) => {
-        if (r.search.length !== otherRecord.search.length) return false;
-        for (let i = 0; i < r.search.length; i++) {
-          if (r.search[i].name !== otherRecord.search[i].name) return false;
-          if (r.search[i].value !== otherRecord.search[i].value) return false;
-        }
-        return true;
-      });
-      if (!record) {
-        record = {
-          search: otherRecord.search,
-          timesTriggered: 0,
-          bookIds: []
-        };
-        this.recorder.records.push(record);
-      }
-      record.timesTriggered += otherRecord.timesTriggered;
-      for (const bookId of otherRecord.bookIds) {
-        if (!record.bookIds.includes(bookId)) {
-          record.bookIds.push(bookId);
-        }
-      }
-    }
-  }
   /**
    * Generates reelset CSV files for all game modes.
    */
@@ -2471,11 +2590,6 @@ var Optimizer = class {
           );
         }
       }
-      const criteria = configMode.resultSets.map((r) => r.criteria);
-      assert9(
-        conditions.every((c) => criteria.includes(c)),
-        `Not all ResultSet criteria in game mode "${k}" are defined as optimization conditions.`
-      );
       let gameModeRtp = configMode.rtp;
       let paramRtp = 0;
       for (const cond of conditions) {
@@ -2528,6 +2642,7 @@ async function rustProgram(...args) {
 }
 
 // src/slot-game/index.ts
+import { isMainThread as isMainThread4 } from "worker_threads";
 var SlotGame = class {
   configOpts;
   simulation;
@@ -2603,6 +2718,7 @@ var SlotGame = class {
     if (opts.doAnalysis) {
       await this.runAnalysis(opts.analysisOpts || { gameModes: [] });
     }
+    if (isMainThread4) console.log("Finishing up...");
   }
   /**
    * Gets the game configuration.
@@ -2884,13 +3000,14 @@ var ClusterWinType = class extends WinType {
         }
       }
     }
-    potentialClusters.forEach((cluster) => {
+    for (const cluster of potentialClusters) {
       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 (payout === 0) continue;
       if (!baseSymbol.pays || Object.keys(baseSymbol.pays).length === 0) {
-        return;
+        continue;
       }
       clusterWins.push({
         payout,
@@ -2903,7 +3020,7 @@ var ClusterWinType = class extends WinType {
           posIndex: s.row
         }))
       });
-    });
+    }
     for (const win of clusterWins) {
       this.ctx.services.data.recordSymbolOccurrence({
         kind: win.kind,
@@ -3068,7 +3185,7 @@ var ManywaysWinType = class extends WinType {
 // src/reel-set/GeneratedReelSet.ts
 import fs5 from "fs";
 import path7 from "path";
-import { isMainThread as isMainThread4 } from "worker_threads";
+import { isMainThread as isMainThread5 } from "worker_threads";
 
 // src/reel-set/index.ts
 import fs4 from "fs";
@@ -3413,7 +3530,7 @@ var GeneratedReelSet = class extends ReelSet {
       }
     }
     const csvString = csvRows.map((row) => row.join(",")).join("\n");
-    if (isMainThread4) {
+    if (isMainThread5) {
       fs5.writeFileSync(filePath, csvString);
       this.reels = this.parseReelsetCSV(filePath, config);
       console.log(