@slot-engine/core 0.1.3 → 0.1.4

package/dist/index.d.mts

@@ -89,8 +89,9 @@ declare class Simulation {
     private debug;
     private actualSims;
     private library;
-    private recorder;
     private wallet;
+    private recordsWriteStream;
+    private hasWrittenRecord;
     constructor(opts: SimulationOptions, gameConfigOpts: GameConfigOptions);
     runSimulation(opts: SimulationConfigOptions): Promise<void>;
     /**
@@ -148,13 +149,11 @@ declare class Simulation {
     private writeRecords;
     private writeIndexJson;
     private writeBooksJson;
-    private logSymbolOccurrences;
     /**
      * Compiles user configured game to JS for use in different Node processes
      */
     private preprocessFiles;
     private getSimRangesForChunks;
-    private mergeRecords;
     /**
      * Generates reelset CSV files for all game modes.
      */
@@ -1580,4 +1579,4 @@ interface StandaloneBoardOptions {
     padSymbols: number;
 }
 
-export { type AnyGameModes, type AnySymbols, type AnyUserData, ClusterWinType, type GameContext, type GameHooks, GameMode, GameSymbol, GeneratedReelSet, type InferGameType, LinesWinType, ManywaysWinType, OptimizationConditions, OptimizationParameters, OptimizationScaling, type Reels, ResultSet, SPIN_TYPE, type SpinType, StandaloneBoard, StaticReelSet, createSlotGame, defineGameModes, defineSymbols, defineUserState };
+export { type AnyGameModes, type AnySymbols, type AnyUserData, ClusterWinType, type GameContext, type GameHooks, GameMode, GameSymbol, GeneratedReelSet, type InferGameType, LinesWinType, ManywaysWinType, OptimizationConditions, OptimizationParameters, OptimizationScaling, type Reels, ResultSet, SPIN_TYPE, type SpinType, StandaloneBoard, StaticReelSet, type WinCombination, createSlotGame, defineGameModes, defineSymbols, defineUserState };

package/dist/index.d.ts

@@ -89,8 +89,9 @@ declare class Simulation {
     private debug;
     private actualSims;
     private library;
-    private recorder;
     private wallet;
+    private recordsWriteStream;
+    private hasWrittenRecord;
     constructor(opts: SimulationOptions, gameConfigOpts: GameConfigOptions);
     runSimulation(opts: SimulationConfigOptions): Promise<void>;
     /**
@@ -148,13 +149,11 @@ declare class Simulation {
     private writeRecords;
     private writeIndexJson;
     private writeBooksJson;
-    private logSymbolOccurrences;
     /**
      * Compiles user configured game to JS for use in different Node processes
      */
     private preprocessFiles;
     private getSimRangesForChunks;
-    private mergeRecords;
     /**
      * Generates reelset CSV files for all game modes.
      */
@@ -1580,4 +1579,4 @@ interface StandaloneBoardOptions {
     padSymbols: number;
 }
 
-export { type AnyGameModes, type AnySymbols, type AnyUserData, ClusterWinType, type GameContext, type GameHooks, GameMode, GameSymbol, GeneratedReelSet, type InferGameType, LinesWinType, ManywaysWinType, OptimizationConditions, OptimizationParameters, OptimizationScaling, type Reels, ResultSet, SPIN_TYPE, type SpinType, StandaloneBoard, StaticReelSet, createSlotGame, defineGameModes, defineSymbols, defineUserState };
+export { type AnyGameModes, type AnySymbols, type AnyUserData, ClusterWinType, type GameContext, type GameHooks, GameMode, GameSymbol, GeneratedReelSet, type InferGameType, LinesWinType, ManywaysWinType, OptimizationConditions, OptimizationParameters, OptimizationScaling, type Reels, ResultSet, SPIN_TYPE, type SpinType, StandaloneBoard, StaticReelSet, type WinCombination, createSlotGame, defineGameModes, defineSymbols, defineUserState };

package/dist/index.js

@@ -86,6 +86,7 @@ var import_fs2 = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_assert6 = __toESM(require("assert"));
 var import_zlib = __toESM(require("zlib"));
+var import_readline2 = __toESM(require("readline"));
 var import_esbuild = require("esbuild");
 var import_worker_threads = require("worker_threads");
 
@@ -253,6 +254,7 @@ var RandomNumberGenerator = class {
 
 // utils.ts
 var import_fs = __toESM(require("fs"));
+var import_readline = __toESM(require("readline"));
 function createDirIfNotExists(dirPath) {
   if (!import_fs.default.existsSync(dirPath)) {
     import_fs.default.mkdirSync(dirPath, { recursive: true });
@@ -284,6 +286,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 = import_fs.default.createWriteStream(outputPath, { encoding: "utf-8" });
+    writeStream.write("[\n");
+    const rl = import_readline.default.createInterface({
+      input: import_fs.default.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
@@ -1464,8 +1489,10 @@ var Wallet = class {
 };
 
 // src/simulation/index.ts
+var import_promises = require("stream/promises");
 var completedSimulations = 0;
 var TEMP_FILENAME = "__temp_compiled_src_IGNORE.js";
+var TEMP_FOLDER = "temp_files";
 var Simulation = class {
   gameConfigOpts;
   gameConfig;
@@ -1474,15 +1501,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);
     (0, import_assert6.default)(
@@ -1508,7 +1535,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}`);
@@ -1520,8 +1547,59 @@ Simulating game mode: ${mode}`);
             `Tried to simulate game mode "${mode}", but it's not configured in the game config.`
           );
         }
+        const booksPath = import_path.default.join(
+          this.gameConfig.rootDir,
+          this.gameConfig.outputDir,
+          `books_${mode}.jsonl`
+        );
+        const tempRecordsPath = import_path.default.join(
+          this.gameConfig.rootDir,
+          this.gameConfig.outputDir,
+          TEMP_FOLDER,
+          `temp_records_${mode}.jsonl`
+        );
+        createDirIfNotExists(
+          import_path.default.join(this.gameConfig.rootDir, this.gameConfig.outputDir)
+        );
+        createDirIfNotExists(
+          import_path.default.join(this.gameConfig.rootDir, this.gameConfig.outputDir, TEMP_FOLDER)
+        );
+        this.recordsWriteStream = import_fs2.default.createWriteStream(tempRecordsPath);
         const simNumsToCriteria = ResultSet.assignCriteriaToSimulations(this, mode);
         await this.spawnWorkersForGameMode({ mode, simNumsToCriteria });
+        const finalBookStream = import_fs2.default.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 = import_path.default.join(
+            this.gameConfig.rootDir,
+            this.gameConfig.outputDir,
+            TEMP_FOLDER,
+            `temp_books_${mode}_${i}.jsonl`
+          );
+          if (import_fs2.default.existsSync(tempBookPath)) {
+            if (!isFirstChunk) {
+              finalBookStream.write("\n");
+            }
+            const content = import_fs2.default.createReadStream(tempBookPath);
+            for await (const chunk of content) {
+              finalBookStream.write(chunk);
+            }
+            import_fs2.default.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(
           import_path.default.join(
             this.gameConfig.rootDir,
@@ -1532,11 +1610,13 @@ Simulating game mode: ${mode}`);
         createDirIfNotExists(
           import_path.default.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();
@@ -1615,6 +1695,12 @@ Simulating game mode: ${mode}`);
           index
         }
       });
+      const tempBookPath = import_path.default.join(
+        basePath,
+        TEMP_FOLDER,
+        `temp_books_${mode}_${index}.jsonl`
+      );
+      const bookStream = import_fs2.default.createWriteStream(tempBookPath);
       worker.on("message", (msg) => {
         if (msg.type === "log") {
         } else if (msg.type === "complete") {
@@ -1623,9 +1709,23 @@ 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);
         }
@@ -1768,16 +1868,61 @@ Simulating game mode: ${mode}`);
     writeFile(outputFilePath, rows.join("\n"));
     return outputFilePath;
   }
-  writeRecords(gameMode) {
-    const outputFileName = `force_record_${gameMode}.json`;
-    const outputFilePath = import_path.default.join(
+  async writeRecords(mode) {
+    const tempRecordsPath = import_path.default.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 = import_path.default.join(
+      this.gameConfig.rootDir,
+      this.gameConfig.outputDir,
+      `force_record_${mode}.json`
+    );
+    const aggregatedRecords = /* @__PURE__ */ new Map();
+    if (import_fs2.default.existsSync(tempRecordsPath)) {
+      const fileStream = import_fs2.default.createReadStream(tempRecordsPath);
+      const rl = import_readline2.default.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);
+        }
+      }
+    }
+    import_fs2.default.rmSync(forceRecordsPath, { force: true });
+    const writeStream = import_fs2.default.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());
+    });
+    import_fs2.default.rmSync(tempRecordsPath, { force: true });
   }
   writeIndexJson() {
     const outputFilePath = import_path.default.join(
@@ -1799,54 +1944,25 @@ Simulating game mode: ${mode}`);
     writeFile(outputFilePath, JSON.stringify({ modes }, null, 2));
   }
   async writeBooksJson(gameMode) {
-    const outputFileName = `books_${gameMode}.jsonl`;
     const outputFilePath = import_path.default.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 = import_path.default.join(
       this.gameConfig.rootDir,
       this.gameConfig.outputDir,
       "publish_files",
-      compressedFileName
+      `books_${gameMode}.jsonl.zst`
     );
     import_fs2.default.rmSync(compressedFilePath, { force: true });
-    const compressed = import_zlib.default.zstdCompressSync(Buffer.from(contents));
-    import_fs2.default.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 (import_fs2.default.existsSync(outputFilePath)) {
+      await (0, import_promises.pipeline)(
+        import_fs2.default.createReadStream(outputFilePath),
+        import_zlib.default.createZstdCompress(),
+        import_fs2.default.createWriteStream(compressedFilePath)
+      );
+    }
   }
   /**
    * Compiles user configured game to JS for use in different Node processes
@@ -1884,32 +2000,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.
    */
@@ -2523,11 +2613,6 @@ var Optimizer = class {
           );
         }
       }
-      const criteria = configMode.resultSets.map((r) => r.criteria);
-      (0, import_assert9.default)(
-        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) {
@@ -2580,6 +2665,7 @@ async function rustProgram(...args) {
 }
 
 // src/slot-game/index.ts
+var import_worker_threads4 = require("worker_threads");
 var SlotGame = class {
   configOpts;
   simulation;
@@ -2655,6 +2741,7 @@ var SlotGame = class {
     if (opts.doAnalysis) {
       await this.runAnalysis(opts.analysisOpts || { gameModes: [] });
     }
+    if (import_worker_threads4.isMainThread) console.log("Finishing up...");
   }
   /**
    * Gets the game configuration.
@@ -2936,13 +3023,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,
@@ -2955,7 +3043,7 @@ var ClusterWinType = class extends WinType {
           posIndex: s.row
         }))
       });
-    });
+    }
     for (const win of clusterWins) {
       this.ctx.services.data.recordSymbolOccurrence({
         kind: win.kind,
@@ -3120,7 +3208,7 @@ var ManywaysWinType = class extends WinType {
 // src/reel-set/GeneratedReelSet.ts
 var import_fs5 = __toESM(require("fs"));
 var import_path7 = __toESM(require("path"));
-var import_worker_threads4 = require("worker_threads");
+var import_worker_threads5 = require("worker_threads");
 
 // src/reel-set/index.ts
 var import_fs4 = __toESM(require("fs"));
@@ -3465,7 +3553,7 @@ var GeneratedReelSet = class extends ReelSet {
       }
     }
     const csvString = csvRows.map((row) => row.join(",")).join("\n");
-    if (import_worker_threads4.isMainThread) {
+    if (import_worker_threads5.isMainThread) {
       import_fs5.default.writeFileSync(filePath, csvString);
       this.reels = this.parseReelsetCSV(filePath, config);
       console.log(