@slot-engine/core 0.0.2 → 0.0.3

package/dist/index.mjs

@@ -1,4 +1,5 @@
 // src/GameConfig.ts
+import assert from "assert";
 var GameConfig = class _GameConfig {
   config;
   constructor(opts) {
@@ -22,14 +23,12 @@ var GameConfig = class _GameConfig {
       userState: opts.userState,
       outputDir: "__build__"
     };
-    for (const symbol of opts.symbols) {
-      if (!this.config.symbols.has(symbol.id)) {
-        this.config.symbols.set(symbol.id, symbol);
-      } else {
-        console.warn(
-          `Symbol with id "${symbol.id}" already exists in the game config. Skipping duplicate. This is probably not intentional.`
-        );
-      }
+    for (const [key, value] of Object.entries(opts.symbols)) {
+      assert(
+        value.id === key,
+        `Symbol key "${key}" does not match symbol id "${value.id}"`
+      );
+      this.config.symbols.set(key, value);
     }
     function getAnticipationTrigger(spinType) {
       return Math.min(...Object.keys(opts.scatterToFreespins[spinType]).map(Number)) - 1;
@@ -1773,7 +1772,7 @@ var ManywaysWinType = class extends WinType {
 };
 
 // src/optimizer/OptimizationConditions.ts
-import assert from "assert";
+import assert2 from "assert";
 var OptimizationConditions = class {
   rtp;
   avgWin;
@@ -1784,14 +1783,14 @@ var OptimizationConditions = class {
   constructor(opts) {
     let { rtp, avgWin, hitRate, searchConditions, priority } = opts;
     if (rtp == void 0 || rtp === "x") {
-      assert(avgWin !== void 0 && hitRate !== void 0, "If RTP is not specified, hit-rate (hr) and average win amount (av_win) must be given.");
+      assert2(avgWin !== void 0 && hitRate !== void 0, "If RTP is not specified, hit-rate (hr) and average win amount (av_win) must be given.");
       rtp = Math.round(avgWin / Number(hitRate) * 1e5) / 1e5;
     }
     let noneCount = 0;
     for (const val of [rtp, avgWin, hitRate]) {
       if (val === void 0) noneCount++;
     }
-    assert(noneCount <= 1, "Invalid combination of optimization conditions.");
+    assert2(noneCount <= 1, "Invalid combination of optimization conditions.");
     this.searchRange = [-1, -1];
     this.forceSearch = {};
     if (typeof searchConditions === "number") {
@@ -1871,41 +1870,11 @@ var OptimizationParameters = class _OptimizationParameters {
 
 // src/Simulation.ts
 import fs3 from "fs";
-import path3 from "path";
-import assert2 from "assert";
+import path2 from "path";
+import assert3 from "assert";
+import zlib from "zlib";
 import { buildSync } from "esbuild";
 import { Worker, isMainThread as isMainThread2, parentPort, workerData } from "worker_threads";
-
-// src/utils/zstd.ts
-import path2 from "path";
-import { spawn } from "child_process";
-async function zstd(...args) {
-  return new Promise((resolve, reject) => {
-    const task = spawn(path2.join(__dirname, "./lib/zstd.exe"), args);
-    task.on("error", (error) => {
-      console.error("Error:", error);
-      reject(error);
-    });
-    task.on("exit", () => {
-      resolve(true);
-    });
-    task.on("close", () => {
-      resolve(true);
-    });
-    task.stdout.on("data", (data) => {
-      console.log(data.toString());
-    });
-    task.stderr.on("data", (data) => {
-      console.log(data.toString());
-    });
-    task.stdout.on("error", (data) => {
-      console.log(data.toString());
-      reject(data.toString());
-    });
-  });
-}
-
-// src/Simulation.ts
 var completedSimulations = 0;
 var TEMP_FILENAME = "__temp_compiled_src_IGNORE.js";
 var Simulation = class _Simulation {
@@ -1926,7 +1895,7 @@ var Simulation = class _Simulation {
     this.library = /* @__PURE__ */ new Map();
     this.records = [];
     const gameModeKeys = Object.keys(this.gameConfig.config.gameModes);
-    assert2(
+    assert3(
       Object.values(this.gameConfig.config.gameModes).map((m) => gameModeKeys.includes(m.name)).every((v) => v === true),
       "Game mode name must match its key in the gameModes object."
     );
@@ -1963,14 +1932,14 @@ Simulating game mode: ${mode}`);
         const simNumsToCriteria = ResultSet.assignCriteriaToSimulations(this, mode);
         await this.spawnWorkersForGameMode({ mode, simNumsToCriteria });
         createDirIfNotExists(
-          path3.join(
+          path2.join(
             process.cwd(),
             this.gameConfig.config.outputDir,
             "optimization_files"
           )
         );
         createDirIfNotExists(
-          path3.join(process.cwd(), this.gameConfig.config.outputDir, "publish_files")
+          path2.join(process.cwd(), this.gameConfig.config.outputDir, "publish_files")
         );
         _Simulation.writeLookupTableCSV({
           gameMode: mode,
@@ -2066,7 +2035,7 @@ Simulating game mode: ${mode}`);
       }
     }
     return new Promise((resolve, reject) => {
-      const scriptPath = path3.join(process.cwd(), basePath, TEMP_FILENAME);
+      const scriptPath = path2.join(process.cwd(), basePath, TEMP_FILENAME);
       const worker = new Worker(scriptPath, {
         workerData: {
           mode,
@@ -2114,10 +2083,10 @@ Simulating game mode: ${mode}`);
     }
     rows.sort((a, b) => Number(a.split(",")[0]) - Number(b.split(",")[0]));
     let outputFileName = `lookUpTable_${gameMode}.csv`;
-    let outputFilePath = path3.join(gameConfig.outputDir, outputFileName);
+    let outputFilePath = path2.join(gameConfig.outputDir, outputFileName);
     writeFile(outputFilePath, rows.join("\n"));
     outputFileName = `lookUpTable_${gameMode}_0.csv`;
-    outputFilePath = path3.join(gameConfig.outputDir, outputFileName);
+    outputFilePath = path2.join(gameConfig.outputDir, outputFileName);
     writeFile(outputFilePath, rows.join("\n"));
     return outputFilePath;
   }
@@ -2134,21 +2103,21 @@ Simulating game mode: ${mode}`);
     }
     rows.sort((a, b) => Number(a.split(",")[0]) - Number(b.split(",")[0]));
     const outputFileName = `lookUpTableSegmented_${gameMode}.csv`;
-    const outputFilePath = path3.join(gameConfig.outputDir, outputFileName);
+    const outputFilePath = path2.join(gameConfig.outputDir, outputFileName);
     writeFile(outputFilePath, rows.join("\n"));
     return outputFilePath;
   }
   static writeRecords(opts) {
     const { gameMode, fileNameWithoutExtension, records, gameConfig, debug } = opts;
     const outputFileName = fileNameWithoutExtension ? `${fileNameWithoutExtension}.json` : `force_record_${gameMode}.json`;
-    const outputFilePath = path3.join(gameConfig.outputDir, outputFileName);
+    const outputFilePath = path2.join(gameConfig.outputDir, outputFileName);
     writeFile(outputFilePath, JSON.stringify(records, null, 2));
     if (debug) _Simulation.logSymbolOccurrences(records);
     return outputFilePath;
   }
   static writeIndexJson(opts) {
     const { gameConfig } = opts;
-    const outputFilePath = path3.join(
+    const outputFilePath = path2.join(
       process.cwd(),
       gameConfig.outputDir,
       "publish_files",
@@ -2165,7 +2134,7 @@ Simulating game mode: ${mode}`);
   static async writeBooksJson(opts) {
     const { gameMode, fileNameWithoutExtension, library, gameConfig } = opts;
     const outputFileName = fileNameWithoutExtension ? `${fileNameWithoutExtension}.jsonl` : `books_${gameMode}.jsonl`;
-    const outputFilePath = path3.join(gameConfig.outputDir, outputFileName);
+    const outputFilePath = path2.join(gameConfig.outputDir, outputFileName);
     const books = Array.from(library.values()).map((b) => b.serialize()).map((b) => ({
       id: b.id,
       payoutMultiplier: b.payout,
@@ -2174,14 +2143,15 @@ Simulating game mode: ${mode}`);
     const contents = JSONL.stringify(books);
     writeFile(outputFilePath, contents);
     const compressedFileName = fileNameWithoutExtension ? `${fileNameWithoutExtension}.jsonl.zst` : `books_${gameMode}.jsonl.zst`;
-    const compressedFilePath = path3.join(
+    const compressedFilePath = path2.join(
       process.cwd(),
       gameConfig.outputDir,
       "publish_files",
       compressedFileName
     );
     fs3.rmSync(compressedFilePath, { force: true });
-    await zstd("-f", outputFilePath, "-o", compressedFilePath);
+    const compressed = zlib.zstdCompressSync(Buffer.from(contents));
+    fs3.writeFileSync(compressedFilePath, compressed);
   }
   static logSymbolOccurrences(records) {
     const validRecords = records.filter(
@@ -2212,14 +2182,14 @@ Simulating game mode: ${mode}`);
    * Compiles user configured game to JS for use in different Node processes
    */
   preprocessFiles() {
-    const builtFilePath = path3.join(this.gameConfig.config.outputDir, TEMP_FILENAME);
+    const builtFilePath = path2.join(this.gameConfig.config.outputDir, TEMP_FILENAME);
     fs3.rmSync(builtFilePath, { force: true });
     buildSync({
       entryPoints: [process.cwd()],
       bundle: true,
       platform: "node",
-      outfile: path3.join(this.gameConfig.config.outputDir, TEMP_FILENAME),
-      external: ["esbuild", "@mongodb-js/zstd"]
+      outfile: path2.join(this.gameConfig.config.outputDir, TEMP_FILENAME),
+      external: ["esbuild"]
     });
   }
   getSimRangesForChunks(total, chunks) {
@@ -2327,8 +2297,8 @@ var SimulationContext = class extends Board {
 
 // src/analysis/index.ts
 import fs4 from "fs";
-import path4 from "path";
-import assert3 from "assert";
+import path3 from "path";
+import assert4 from "assert";
 
 // src/analysis/utils.ts
 function parseLookupTable(content) {
@@ -2372,8 +2342,11 @@ function getPayoutWeights(lut, opts = {}) {
 }
 function getNonZeroHitrate(payoutWeights) {
   const totalWeight = getTotalWeight(payoutWeights);
-  const nonZeroWeight = totalWeight - (payoutWeights[0] ?? 0) * totalWeight;
-  return nonZeroWeight / totalWeight;
+  if (Math.min(...Object.keys(payoutWeights).map(Number)) == 0) {
+    return totalWeight / (totalWeight - (payoutWeights[0] ?? 0) / totalWeight);
+  } else {
+    return 1;
+  }
 }
 function getNullHitrate(payoutWeights) {
   return payoutWeights[0] ?? 0;
@@ -2434,6 +2407,7 @@ function getLessBetHitrate(payoutWeights, cost) {
 }
 
 // src/analysis/index.ts
+import { isMainThread as isMainThread3 } from "worker_threads";
 var Analysis = class {
   gameConfig;
   optimizerConfig;
@@ -2444,6 +2418,7 @@ var Analysis = class {
     this.filePaths = {};
   }
   async runAnalysis(gameModes) {
+    if (!isMainThread3) return;
     this.filePaths = this.getPathsForModes(gameModes);
     this.getNumberStats(gameModes);
     this.getWinRanges(gameModes);
@@ -2453,28 +2428,28 @@ var Analysis = class {
     const rootPath = process.cwd();
     const paths = {};
     for (const modeStr of gameModes) {
-      const lut = path4.join(
+      const lut = path3.join(
         rootPath,
         this.gameConfig.outputDir,
         `lookUpTable_${modeStr}.csv`
       );
-      const lutSegmented = path4.join(
+      const lutSegmented = path3.join(
         rootPath,
         this.gameConfig.outputDir,
         `lookUpTableSegmented_${modeStr}.csv`
       );
-      const lutOptimized = path4.join(
+      const lutOptimized = path3.join(
         rootPath,
         this.gameConfig.outputDir,
         "publish_files",
         `lookUpTable_${modeStr}_0.csv`
       );
-      const booksJsonl = path4.join(
+      const booksJsonl = path3.join(
         rootPath,
         this.gameConfig.outputDir,
         `books_${modeStr}.jsonl`
       );
-      const booksJsonlCompressed = path4.join(
+      const booksJsonlCompressed = path3.join(
         rootPath,
         this.gameConfig.outputDir,
         "publish_files",
@@ -2488,7 +2463,7 @@ var Analysis = class {
         booksJsonlCompressed
       };
       for (const p of Object.values(paths[modeStr])) {
-        assert3(
+        assert4(
           fs4.existsSync(p),
           `File "${p}" does not exist. Run optimization to auto-create it.`
         );
@@ -2522,7 +2497,7 @@ var Analysis = class {
       });
     }
     writeJsonFile(
-      path4.join(process.cwd(), this.gameConfig.outputDir, "stats_summary.json"),
+      path3.join(process.cwd(), this.gameConfig.outputDir, "stats_summary.json"),
       stats
     );
   }
@@ -2560,13 +2535,13 @@ var Analysis = class {
   }
   getGameModeConfig(mode) {
     const config = this.gameConfig.gameModes[mode];
-    assert3(config, `Game mode "${mode}" not found in game config`);
+    assert4(config, `Game mode "${mode}" not found in game config`);
     return config;
   }
 };
 
 // src/utils/math-config.ts
-import path5 from "path";
+import path4 from "path";
 function makeMathConfig(optimizer, opts = {}) {
   const game = optimizer.getGameConfig();
   const gameModesCfg = optimizer.getOptimizerGameModes();
@@ -2610,14 +2585,14 @@ function makeMathConfig(optimizer, opts = {}) {
     }))
   };
   if (writeToFile) {
-    const outPath = path5.join(process.cwd(), game.outputDir, "math_config.json");
+    const outPath = path4.join(process.cwd(), game.outputDir, "math_config.json");
     writeJsonFile(outPath, config);
   }
   return config;
 }
 
 // src/utils/setup-file.ts
-import path6 from "path";
+import path5 from "path";
 function makeSetupFile(optimizer, gameMode) {
   const gameConfig = optimizer.getGameConfig();
   const optimizerGameModes = optimizer.getOptimizerGameModes();
@@ -2653,19 +2628,19 @@ function makeSetupFile(optimizer, gameMode) {
 `;
   content += `simulation_trials;${params.simulationTrials}
 `;
-  content += `user_game_build_path;${path6.join(process.cwd(), gameConfig.outputDir)}
+  content += `user_game_build_path;${path5.join(process.cwd(), gameConfig.outputDir)}
 `;
   content += `pmb_rtp;${params.pmbRtp}
 `;
-  const outPath = path6.join(__dirname, "./optimizer-rust/src", "setup.txt");
+  const outPath = path5.join(__dirname, "./optimizer-rust/src", "setup.txt");
   writeFile(outPath, content);
 }
 
 // src/optimizer/index.ts
-import { spawn as spawn2 } from "child_process";
-import path7 from "path";
-import assert4 from "assert";
-import { isMainThread as isMainThread3 } from "worker_threads";
+import { spawn } from "child_process";
+import path6 from "path";
+import assert5 from "assert";
+import { isMainThread as isMainThread4 } from "worker_threads";
 var Optimizer = class {
   gameConfig;
   gameModes;
@@ -2678,12 +2653,13 @@ var Optimizer = class {
    * Runs the optimization process, and runs analysis after.
    */
   async runOptimization({ gameModes }) {
-    if (!isMainThread3) return;
+    if (!isMainThread4) return;
     const mathConfig = makeMathConfig(this, { writeToFile: true });
     for (const mode of gameModes) {
       const setupFile = makeSetupFile(this, mode);
       await this.runSingleOptimization();
     }
+    console.log("Optimization complete. Files written to build directory.");
   }
   async runSingleOptimization() {
     return await rustProgram();
@@ -2707,7 +2683,7 @@ var Optimizer = class {
         }
       }
       const criteria = configMode.resultSets.map((r) => r.criteria);
-      assert4(
+      assert5(
         conditions.every((c) => criteria.includes(c)),
         `Not all ResultSet criteria in game mode "${k}" are defined as optimization conditions.`
       );
@@ -2719,7 +2695,7 @@ var Optimizer = class {
       }
       gameModeRtp = Math.round(gameModeRtp * 1e3) / 1e3;
       paramRtp = Math.round(paramRtp * 1e3) / 1e3;
-      assert4(
+      assert5(
         gameModeRtp === paramRtp,
         `Sum of all RTP conditions (${paramRtp}) does not match the game mode RTP (${gameModeRtp}) in game mode "${k}".`
       );
@@ -2734,9 +2710,9 @@ var Optimizer = class {
 };
 async function rustProgram(...args) {
   return new Promise((resolve, reject) => {
-    const task = spawn2("cargo", ["run", "--release", ...args], {
+    const task = spawn("cargo", ["run", "--release", ...args], {
       shell: true,
-      cwd: path7.join(__dirname, "./optimizer-rust"),
+      cwd: path6.join(__dirname, "./optimizer-rust"),
       stdio: "pipe"
     });
     task.on("error", (error) => {