@slot-engine/core 0.2.10 → 0.2.12

package/dist/index.mjs

@@ -45,7 +45,8 @@ function createPermanentFilePaths(basePath) {
     simulationSummary: path.join(basePath, "simulation_summary.json"),
     statsPayouts: path.join(basePath, "stats_payouts.json"),
     statsSummary: path.join(basePath, "stats_summary.json"),
-    statsRecords: path.join(basePath, "stats_records.json")
+    statsRecords: path.join(basePath, "stats_records.json"),
+    frontendConfig: path.join(basePath, "frontend_config.json")
   };
 }
 function createTemporaryFilePaths(basePath, tempFolder) {
@@ -1419,19 +1420,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
@@ -1600,7 +1588,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;
@@ -2405,9 +2393,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)
         );
@@ -2488,50 +2476,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) {
@@ -2540,15 +2529,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 });
@@ -2639,9 +2623,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({
@@ -2649,12 +2635,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() {
@@ -3700,6 +3698,43 @@ async function rustProgram(...args) {
 
 // src/slot-game/index.ts
 import { isMainThread as isMainThread5, workerData as workerData2 } from "worker_threads";
+
+// src/utils/frontend-config.ts
+function createFrontendConfig(config, meta) {
+  const path9 = meta.paths.frontendConfig;
+  const gameModes = Object.values(config.gameModes).map((gm) => ({
+    name: gm.name,
+    cost: gm.cost,
+    rtp: gm.rtp
+  }));
+  const reelSets = /* @__PURE__ */ new Map();
+  Object.values(config.gameModes).forEach((gm) => {
+    gm.reelSets.forEach((reelSet) => {
+      reelSet.associatedGameModeName = gm.name;
+      reelSet.generateReels(config);
+      if (!reelSets.has(reelSet.id)) {
+        reelSets.set(
+          reelSet.id,
+          reelSet.reels.map((reel) => reel.map((s) => s.id))
+        );
+      }
+    });
+  });
+  const frontendConfig = {
+    name: config.name,
+    maxWin: config.maxWinX,
+    padSymbols: config.padSymbols,
+    symbols: Array.from(config.symbols.values()).map((s) => ({
+      id: s.id,
+      pays: s.pays
+    })),
+    gameModes,
+    reelSets: Object.fromEntries(reelSets)
+  };
+  writeJsonFile(path9, frontendConfig);
+}
+
+// src/slot-game/index.ts
 var SlotGame = class _SlotGame {
   configOpts;
   simulation;
@@ -3787,7 +3822,10 @@ var SlotGame = class _SlotGame {
         this.runAnalysis(opts.analysisOpts || { gameModes: [] });
       }
     }
-    if (isMainThread5) console.log("Done!");
+    if (isMainThread5) {
+      createFrontendConfig(this.getConfig(), this.getMetadata());
+      console.log("Done!");
+    }
   }
   /**
    * Gets the game configuration.