@slot-engine/core 0.0.5 → 0.0.7

package/dist/index.js

@@ -31,257 +31,104 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ClusterWinType: () => ClusterWinType,
-  GameConfig: () => GameConfig,
   GameMode: () => GameMode,
   GameSymbol: () => GameSymbol,
+  GeneratedReelSet: () => GeneratedReelSet,
   LinesWinType: () => LinesWinType,
   ManywaysWinType: () => ManywaysWinType,
   OptimizationConditions: () => OptimizationConditions,
   OptimizationParameters: () => OptimizationParameters,
   OptimizationScaling: () => OptimizationScaling,
-  ReelGenerator: () => ReelGenerator,
   ResultSet: () => ResultSet,
+  SPIN_TYPE: () => SPIN_TYPE,
   StandaloneBoard: () => StandaloneBoard,
-  WinType: () => WinType,
+  StaticReelSet: () => StaticReelSet,
   createSlotGame: () => createSlotGame,
   defineGameModes: () => defineGameModes,
-  defineReelSets: () => defineReelSets,
   defineSymbols: () => defineSymbols,
-  defineUserState: () => defineUserState,
-  weightedRandom: () => weightedRandom
+  defineUserState: () => defineUserState
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/GameConfig.ts
+// src/constants.ts
+var SPIN_TYPE = {
+  BASE_GAME: "basegame",
+  FREE_SPINS: "freespins"
+};
+
+// src/game-config/index.ts
 var import_assert = __toESM(require("assert"));
-var GameConfig = class _GameConfig {
-  config;
-  constructor(opts) {
-    this.config = {
-      id: opts.id,
-      name: opts.name,
-      gameModes: opts.gameModes,
-      symbols: /* @__PURE__ */ new Map(),
-      padSymbols: opts.padSymbols || 0,
-      scatterToFreespins: opts.scatterToFreespins,
-      anticipationTriggers: {
-        [_GameConfig.SPIN_TYPE.BASE_GAME]: getAnticipationTrigger(
-          _GameConfig.SPIN_TYPE.BASE_GAME
-        ),
-        [_GameConfig.SPIN_TYPE.FREE_SPINS]: getAnticipationTrigger(
-          _GameConfig.SPIN_TYPE.FREE_SPINS
-        )
-      },
-      maxWinX: opts.maxWinX,
-      hooks: opts.hooks,
-      userState: opts.userState,
-      outputDir: "__build__"
-    };
-    for (const [key, value] of Object.entries(opts.symbols)) {
-      (0, import_assert.default)(
-        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;
-    }
-  }
+function createGameConfig(opts) {
+  const symbols = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(opts.symbols)) {
+    (0, import_assert.default)(value.id === key, `Symbol key "${key}" does not match symbol id "${value.id}"`);
+    symbols.set(key, value);
+  }
+  const getAnticipationTrigger = (spinType) => {
+    return Math.min(...Object.keys(opts.scatterToFreespins[spinType]).map(Number)) - 1;
+  };
+  return {
+    padSymbols: opts.padSymbols || 1,
+    userState: opts.userState || {},
+    ...opts,
+    symbols,
+    anticipationTriggers: {
+      [SPIN_TYPE.BASE_GAME]: getAnticipationTrigger(SPIN_TYPE.BASE_GAME),
+      [SPIN_TYPE.FREE_SPINS]: getAnticipationTrigger(SPIN_TYPE.FREE_SPINS)
+    },
+    outputDir: "__build__"
+  };
+}
+
+// src/simulation/index.ts
+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_esbuild = require("esbuild");
+var import_worker_threads = require("worker_threads");
+
+// src/result-set/index.ts
+var import_assert2 = __toESM(require("assert"));
+
+// src/service/index.ts
+var AbstractService = class {
   /**
-   * Generates reelset CSV files for all game modes.
+   * Function that returns the current game context.
    */
-  generateReelsetFiles() {
-    for (const mode of Object.values(this.config.gameModes)) {
-      if (mode.reelSets && mode.reelSets.length > 0) {
-        for (const reelGenerator of Object.values(mode.reelSets)) {
-          reelGenerator.associatedGameModeName = mode.name;
-          reelGenerator.generateReels(this);
-        }
-      } else {
-        throw new Error(
-          `Game mode "${mode.name}" has no reel sets defined. Cannot generate reelset files.`
-        );
-      }
-    }
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+};
+
+// src/service/rng.ts
+var RngService = class extends AbstractService {
+  rng = new RandomNumberGenerator();
+  constructor(ctx) {
+    super(ctx);
   }
   /**
-   * Retrieves a reel set by its ID within a specific game mode.
+   * Random weighted selection from a set of items.
    */
-  getReelsetById(gameMode, id) {
-    const reelSet = this.config.gameModes[gameMode].reelSets.find((rs) => rs.id === id);
-    if (!reelSet) {
-      throw new Error(
-        `Reel set with id "${id}" not found in game mode "${gameMode}". Available reel sets: ${this.config.gameModes[gameMode].reelSets.map((rs) => rs.id).join(", ")}`
-      );
-    }
-    return reelSet.reels;
-  }
+  weightedRandom = this.rng.weightedRandom.bind(this.rng);
   /**
-   * Retrieves the number of free spins awarded for a given spin type and scatter count.
+   * Selects a random item from an array.
    */
-  getFreeSpinsForScatters(spinType, scatterCount) {
-    const freespinsConfig = this.config.scatterToFreespins[spinType];
-    if (!freespinsConfig) {
-      throw new Error(
-        `No free spins configuration found for spin type "${spinType}". Please check your game configuration.`
-      );
-    }
-    return freespinsConfig[scatterCount] || 0;
-  }
+  randomItem = this.rng.randomItem.bind(this.rng);
   /**
-   * Retrieves a result set by its criteria within a specific game mode.
+   * Shuffles an array.
    */
-  getResultSetByCriteria(mode, criteria) {
-    const gameMode = this.config.gameModes[mode];
-    if (!gameMode) {
-      throw new Error(`Game mode "${mode}" not found in game config.`);
-    }
-    const resultSet = gameMode.resultSets.find((rs) => rs.criteria === criteria);
-    if (!resultSet) {
-      throw new Error(
-        `Criteria "${criteria}" not found in game mode "${mode}". Available criteria: ${gameMode.resultSets.map((rs) => rs.criteria).join(", ")}`
-      );
-    }
-    return resultSet;
-  }
+  shuffle = this.rng.shuffle.bind(this.rng);
   /**
-   * Returns all configured symbols as an array.
+   * Generates a random float between two values.
    */
-  getSymbolArray() {
-    return Array.from(this.config.symbols).map(([n, v]) => v);
-  }
-  static SPIN_TYPE = {
-    BASE_GAME: "basegame",
-    FREE_SPINS: "freespins"
-  };
-};
-
-// src/GameMode.ts
-var import_assert2 = __toESM(require("assert"));
-var GameMode = class {
-  name;
-  reelsAmount;
-  symbolsPerReel;
-  cost;
-  rtp;
-  reelSets;
-  resultSets;
-  isBonusBuy;
-  constructor(opts) {
-    this.name = opts.name;
-    this.reelsAmount = opts.reelsAmount;
-    this.symbolsPerReel = opts.symbolsPerReel;
-    this.cost = opts.cost;
-    this.rtp = opts.rtp;
-    this.reelSets = opts.reelSets;
-    this.resultSets = opts.resultSets;
-    this.isBonusBuy = opts.isBonusBuy;
-    (0, import_assert2.default)(this.rtp >= 0.9 && this.rtp <= 0.99, "RTP must be between 0.9 and 0.99");
-    (0, import_assert2.default)(
-      this.symbolsPerReel.length === this.reelsAmount,
-      "symbolsPerReel length must match reelsAmount."
-    );
-    (0, import_assert2.default)(this.reelSets.length > 0, "GameMode must have at least one ReelSet defined.");
-  }
-};
-
-// src/GameSymbol.ts
-var GameSymbol = class _GameSymbol {
-  id;
-  pays;
-  properties;
-  constructor(opts) {
-    this.id = opts.id;
-    this.pays = opts.pays;
-    this.properties = new Map(Object.entries(opts.properties || {}));
-    if (this.pays && Object.keys(this.pays).length === 0) {
-      throw new Error(`GameSymbol "${this.id}" must have pays defined.`);
-    }
-  }
+  randomFloat = this.rng.randomFloat.bind(this.rng);
   /**
-   * Compares this symbol to another symbol or a set of properties.
+   * Sets the seed for the RNG.
    */
-  compare(symbolOrProperties) {
-    if (!symbolOrProperties) {
-      console.warn("No symbol or properties provided for comparison.");
-      return false;
-    }
-    if (symbolOrProperties instanceof _GameSymbol) {
-      return this.id === symbolOrProperties.id;
-    } else {
-      for (const [key, value] of Object.entries(symbolOrProperties)) {
-        if (!this.properties.has(key) || this.properties.get(key) !== value) {
-          return false;
-        }
-      }
-      return true;
-    }
-  }
+  setSeedIfDifferent = this.rng.setSeedIfDifferent.bind(this.rng);
 };
-
-// src/ReelGenerator.ts
-var import_fs2 = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-
-// utils.ts
-var import_fs = __toESM(require("fs"));
-function weightedRandom(weights, rng) {
-  const totalWeight = Object.values(weights).reduce(
-    (sum, weight) => sum + weight,
-    0
-  );
-  const randomValue = rng.randomFloat(0, 1) * totalWeight;
-  let cumulativeWeight = 0;
-  for (const [key, weight] of Object.entries(weights)) {
-    cumulativeWeight += weight;
-    if (randomValue < cumulativeWeight) {
-      return key;
-    }
-  }
-  throw new Error("No item selected in weighted random selection.");
-}
-function randomItem(array, rng) {
-  if (array.length === 0) {
-    throw new Error("Cannot select a random item from an empty array.");
-  }
-  const randomIndex = Math.floor(rng.randomFloat(0, 1) * array.length);
-  return array[randomIndex];
-}
-function createDirIfNotExists(dirPath) {
-  if (!import_fs.default.existsSync(dirPath)) {
-    import_fs.default.mkdirSync(dirPath, { recursive: true });
-  }
-}
-function shuffle(array, rng) {
-  const newArray = [...array];
-  let currentIndex = newArray.length, randomIndex;
-  while (currentIndex != 0) {
-    randomIndex = Math.floor(rng.randomFloat(0, 1) * currentIndex);
-    currentIndex--;
-    [newArray[currentIndex], newArray[randomIndex]] = [
-      newArray[randomIndex],
-      newArray[currentIndex]
-    ];
-  }
-  return newArray;
-}
-function writeJsonFile(filePath, data) {
-  try {
-    import_fs.default.writeFileSync(filePath, JSON.stringify(data, null, 2), {
-      encoding: "utf8"
-    });
-  } catch (error) {
-    throw new Error(`Failed to write JSON file at ${filePath}: ${error}`);
-  }
-}
-function writeFile(filePath, data) {
-  try {
-    import_fs.default.writeFileSync(filePath, data, { encoding: "utf8" });
-  } catch (error) {
-    throw new Error(`Failed to write file at ${filePath}: ${error}`);
-  }
-}
 var RandomNumberGenerator = class {
   mIdum;
   mIy;
@@ -366,7 +213,66 @@ var RandomNumberGenerator = class {
     }
     return float * (high - low) + low;
   }
+  weightedRandom(weights) {
+    const totalWeight = Object.values(weights).reduce(
+      (sum, weight) => sum + weight,
+      0
+    );
+    const randomValue = this.randomFloat(0, 1) * totalWeight;
+    let cumulativeWeight = 0;
+    for (const [key, weight] of Object.entries(weights)) {
+      cumulativeWeight += weight;
+      if (randomValue < cumulativeWeight) {
+        return key;
+      }
+    }
+    throw new Error("No item selected in weighted random selection.");
+  }
+  randomItem(array) {
+    if (array.length === 0) {
+      throw new Error("Cannot select a random item from an empty array.");
+    }
+    const randomIndex = Math.floor(this.randomFloat(0, 1) * array.length);
+    return array[randomIndex];
+  }
+  shuffle(array) {
+    const newArray = [...array];
+    let currentIndex = newArray.length, randomIndex;
+    while (currentIndex != 0) {
+      randomIndex = Math.floor(this.randomFloat(0, 1) * currentIndex);
+      currentIndex--;
+      [newArray[currentIndex], newArray[randomIndex]] = [
+        newArray[randomIndex],
+        newArray[currentIndex]
+      ];
+    }
+    return newArray;
+  }
 };
+
+// utils.ts
+var import_fs = __toESM(require("fs"));
+function createDirIfNotExists(dirPath) {
+  if (!import_fs.default.existsSync(dirPath)) {
+    import_fs.default.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function writeJsonFile(filePath, data) {
+  try {
+    import_fs.default.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+      encoding: "utf8"
+    });
+  } catch (error) {
+    throw new Error(`Failed to write JSON file at ${filePath}: ${error}`);
+  }
+}
+function writeFile(filePath, data) {
+  try {
+    import_fs.default.writeFileSync(filePath, data, { encoding: "utf8" });
+  } catch (error) {
+    throw new Error(`Failed to write file at ${filePath}: ${error}`);
+  }
+}
 function copy(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
@@ -379,814 +285,709 @@ var JSONL = class {
   }
 };
 
-// src/ReelGenerator.ts
-var import_worker_threads = require("worker_threads");
-var ReelGenerator = class {
-  id;
-  associatedGameModeName = "";
-  symbolWeights = /* @__PURE__ */ new Map();
-  rowsAmount;
-  reels = [];
-  limitSymbolsToReels;
-  spaceBetweenSameSymbols;
-  spaceBetweenSymbols;
-  preferStackedSymbols;
-  symbolStacks;
-  symbolQuotas;
-  csvPath = "";
-  overrideExisting;
-  rng;
+// src/result-set/index.ts
+var ResultSet = class {
+  criteria;
+  quota;
+  multiplier;
+  reelWeights;
+  userData;
+  forceMaxWin;
+  forceFreespins;
+  evaluate;
   constructor(opts) {
-    this.id = opts.id;
-    this.symbolWeights = new Map(Object.entries(opts.symbolWeights));
-    this.rowsAmount = opts.rowsAmount || 250;
-    if (opts.limitSymbolsToReels) this.limitSymbolsToReels = opts.limitSymbolsToReels;
-    this.overrideExisting = opts.overrideExisting || false;
-    this.spaceBetweenSameSymbols = opts.spaceBetweenSameSymbols;
-    this.spaceBetweenSymbols = opts.spaceBetweenSymbols;
-    this.preferStackedSymbols = opts.preferStackedSymbols;
-    this.symbolStacks = opts.symbolStacks;
-    this.symbolQuotas = opts.symbolQuotas;
-    if (typeof this.spaceBetweenSameSymbols == "number" && (this.spaceBetweenSameSymbols < 1 || this.spaceBetweenSameSymbols > 8) || typeof this.spaceBetweenSameSymbols == "object" && Object.values(this.spaceBetweenSameSymbols).some((v) => v < 1 || v > 8)) {
-      throw new Error(
-        `spaceBetweenSameSymbols must be between 1 and 8, got ${this.spaceBetweenSameSymbols}.`
-      );
+    this.criteria = opts.criteria;
+    this.quota = opts.quota;
+    this.multiplier = opts.multiplier;
+    this.reelWeights = opts.reelWeights;
+    this.userData = opts.userData;
+    this.forceMaxWin = opts.forceMaxWin;
+    this.forceFreespins = opts.forceFreespins;
+    this.evaluate = opts.evaluate;
+  }
+  static assignCriteriaToSimulations(ctx, gameModeName) {
+    const rng = new RandomNumberGenerator();
+    rng.setSeed(0);
+    (0, import_assert2.default)(ctx.simRunsAmount, "Simulation configuration is not set.");
+    const simNums = ctx.simRunsAmount[gameModeName];
+    const resultSets = ctx.gameConfig.gameModes[gameModeName]?.resultSets;
+    if (!resultSets || resultSets.length === 0) {
+      throw new Error(`No ResultSets found for game mode: ${gameModeName}.`);
     }
-    if (Object.values(this.spaceBetweenSymbols || {}).some(
-      (o) => Object.values(o).some((v) => v < 1 || v > 8)
-    )) {
-      throw new Error(
-        `spaceBetweenSymbols must be between 1 and 8, got ${this.spaceBetweenSymbols}.`
-      );
+    if (simNums === void 0 || simNums <= 0) {
+      throw new Error(`No simulations configured for game mode "${gameModeName}".`);
     }
-    if (this.preferStackedSymbols && (this.preferStackedSymbols < 0 || this.preferStackedSymbols > 100)) {
-      throw new Error(
-        `preferStackedSymbols must be between 0 and 100, got ${this.preferStackedSymbols}.`
+    const totalQuota = resultSets.reduce((sum, rs) => sum + rs.quota, 0);
+    const numberOfSimsForCriteria = Object.fromEntries(
+      resultSets.map((rs) => {
+        const normalizedQuota = totalQuota > 0 ? rs.quota / totalQuota : 0;
+        return [rs.criteria, Math.max(Math.floor(normalizedQuota * simNums), 1)];
+      })
+    );
+    let totalSims = Object.values(numberOfSimsForCriteria).reduce(
+      (sum, num) => sum + num,
+      0
+    );
+    let reduceSims = totalSims > simNums;
+    const criteriaToWeights = Object.fromEntries(
+      resultSets.map((rs) => [rs.criteria, rs.quota])
+    );
+    while (totalSims != simNums) {
+      const rs = rng.weightedRandom(criteriaToWeights);
+      if (reduceSims && numberOfSimsForCriteria[rs] > 1) {
+        numberOfSimsForCriteria[rs] -= 1;
+      } else if (!reduceSims) {
+        numberOfSimsForCriteria[rs] += 1;
+      }
+      totalSims = Object.values(numberOfSimsForCriteria).reduce(
+        (sum, num) => sum + num,
+        0
       );
+      reduceSims = totalSims > simNums;
     }
-    this.rng = new RandomNumberGenerator();
-    this.rng.setSeed(opts.seed ?? 0);
-  }
-  validateConfig({ config }) {
-    this.symbolWeights.forEach((_, symbol) => {
-      if (!config.symbols.has(symbol)) {
-        throw new Error(
-          `Symbol "${symbol}" of the reel generator ${this.id} for mode ${this.associatedGameModeName} is not defined in the game config`
-        );
+    let allCriteria = [];
+    const simNumsToCriteria = {};
+    Object.entries(numberOfSimsForCriteria).forEach(([criteria, num]) => {
+      for (let i = 0; i <= num; i++) {
+        allCriteria.push(criteria);
       }
     });
-    if (this.limitSymbolsToReels && Object.keys(this.limitSymbolsToReels).length == 0) {
-      this.limitSymbolsToReels = void 0;
+    allCriteria = rng.shuffle(allCriteria);
+    for (let i = 1; i <= Math.min(simNums, allCriteria.length); i++) {
+      simNumsToCriteria[i] = allCriteria[i];
     }
+    return simNumsToCriteria;
   }
-  isSymbolAllowedOnReel(symbolId, reelIdx) {
-    if (!this.limitSymbolsToReels) return true;
-    const allowedReels = this.limitSymbolsToReels[symbolId];
-    if (!allowedReels || allowedReels.length === 0) return true;
-    return allowedReels.includes(reelIdx);
-  }
-  resolveStacking(symbolId, reelIdx) {
-    const cfg = this.symbolStacks?.[symbolId];
-    if (!cfg) return null;
-    const STACKING_MIN = 1;
-    const STACKING_MAX = 4;
-    const chance = typeof cfg.chance === "number" ? cfg.chance : cfg.chance?.[reelIdx] ?? 0;
-    if (chance <= 0) return null;
-    let min = typeof cfg.min === "number" ? cfg.min : cfg.min?.[reelIdx] ?? STACKING_MIN;
-    let max = typeof cfg.max === "number" ? cfg.max : cfg.max?.[reelIdx] ?? STACKING_MAX;
-    return { chance, min, max };
+  /**
+   * Checks if core criteria is met, e.g. target multiplier or max win.
+   */
+  meetsCriteria(ctx) {
+    const customEval = this.evaluate?.(copy(ctx));
+    const freespinsMet = this.forceFreespins ? ctx.state.triggeredFreespins : true;
+    const wallet = ctx.services.wallet._getWallet();
+    const multiplierMet = this.multiplier !== void 0 ? wallet.getCurrentWin() === this.multiplier && !this.forceMaxWin : wallet.getCurrentWin() > 0 && (!this.forceMaxWin || true);
+    const maxWinMet = this.forceMaxWin ? wallet.getCurrentWin() >= ctx.config.maxWinX : true;
+    const coreCriteriaMet = freespinsMet && multiplierMet && maxWinMet;
+    const finalResult = customEval !== void 0 ? coreCriteriaMet && customEval === true : coreCriteriaMet;
+    if (this.forceMaxWin && maxWinMet) {
+      ctx.services.data.record({
+        maxwin: true
+      });
+    }
+    return finalResult;
   }
-  tryPlaceStack(reel, gameConf, reelIdx, symbolId, startIndex, maxStack) {
-    if (!this.isSymbolAllowedOnReel(symbolId, reelIdx)) return 0;
-    let canPlace = 0;
-    for (let j = 0; j < maxStack; j++) {
-      const idx = (startIndex + j) % this.rowsAmount;
-      if (reel[idx] !== null) break;
-      canPlace++;
+};
+
+// src/game-state/index.ts
+function createGameState(opts) {
+  return {
+    currentSimulationId: opts?.currentSimulationId || 0,
+    currentGameMode: opts?.currentGameMode || "N/A",
+    currentSpinType: opts?.currentSpinType || SPIN_TYPE.BASE_GAME,
+    currentResultSet: opts?.currentResultSet || new ResultSet({
+      criteria: "N/A",
+      quota: 0,
+      reelWeights: {
+        [SPIN_TYPE.BASE_GAME]: {},
+        [SPIN_TYPE.FREE_SPINS]: {}
+      }
+    }),
+    isCriteriaMet: opts?.isCriteriaMet || false,
+    currentFreespinAmount: opts?.currentFreespinAmount || 0,
+    totalFreespinAmount: opts?.totalFreespinAmount || 0,
+    userData: opts?.userData || {},
+    triggeredMaxWin: opts?.triggeredMaxWin || false,
+    triggeredFreespins: opts?.triggeredFreespins || false
+  };
+}
+
+// src/board/index.ts
+var import_assert3 = __toESM(require("assert"));
+
+// src/game-symbol/index.ts
+var GameSymbol = class _GameSymbol {
+  id;
+  pays;
+  properties;
+  constructor(opts) {
+    this.id = opts.id;
+    this.pays = opts.pays;
+    this.properties = new Map(Object.entries(opts.properties || {}));
+    if (this.pays && Object.keys(this.pays).length === 0) {
+      throw new Error(`GameSymbol "${this.id}" must have pays defined.`);
     }
-    if (canPlace === 0) return 0;
-    const symObj = gameConf.config.symbols.get(symbolId);
-    if (!symObj) {
-      throw new Error(
-        `Symbol with id "${symbolId}" not found in the game config symbols map.`
-      );
+  }
+  /**
+   * Compares this symbol to another symbol or a set of properties.
+   */
+  compare(symbolOrProperties) {
+    if (!symbolOrProperties) {
+      console.warn("No symbol or properties provided for comparison.");
+      return false;
     }
-    for (let j = 0; j < canPlace; j++) {
-      const idx = (startIndex + j) % reel.length;
-      reel[idx] = symObj;
+    if (symbolOrProperties instanceof _GameSymbol) {
+      return this.id === symbolOrProperties.id;
+    } else {
+      for (const [key, value] of Object.entries(symbolOrProperties)) {
+        if (!this.properties.has(key) || this.properties.get(key) !== value) {
+          return false;
+        }
+      }
+      return true;
     }
-    return canPlace;
   }
+};
+
+// src/board/index.ts
+var Board = class {
   /**
-   * Checks if a symbol can be placed at the target index without violating spacing rules.
+   * The current reels on the board.\
+   * Includes only the visible symbols (without padding).
    */
-  violatesSpacing(reel, symbolId, targetIndex) {
-    const circDist = (a, b) => {
-      const diff = Math.abs(a - b);
-      return Math.min(diff, this.rowsAmount - diff);
-    };
-    const spacingType = this.spaceBetweenSameSymbols ?? void 0;
-    const sameSpacing = typeof spacingType === "number" ? spacingType : spacingType?.[symbolId] ?? 0;
-    for (let i = 0; i <= reel.length; i++) {
-      const placed = reel[i];
-      if (!placed) continue;
-      const dist = circDist(targetIndex, i);
-      if (sameSpacing >= 1 && placed.id === symbolId) {
-        if (dist <= sameSpacing) return true;
+  reels;
+  /**
+   * The top padding symbols on the board.\
+   * These are the symbols above the visible area.
+   */
+  paddingTop;
+  /**
+   * The bottom padding symbols on the board.\
+   * These are the symbols below the visible area.
+   */
+  paddingBottom;
+  /**
+   * The anticipation values for each reel on the board.\
+   * Used for triggering anticipation effects.
+   */
+  anticipation;
+  lastDrawnReelStops;
+  lastUsedReels;
+  constructor() {
+    this.reels = [];
+    this.paddingTop = [];
+    this.paddingBottom = [];
+    this.anticipation = [];
+    this.lastDrawnReelStops = [];
+    this.lastUsedReels = [];
+  }
+  makeEmptyReels(opts) {
+    const length = opts.reelsAmount ?? opts.ctx.services.game.getCurrentGameMode().reelsAmount;
+    (0, import_assert3.default)(length, "Cannot make empty reels without context or reelsAmount.");
+    return Array.from({ length }, () => []);
+  }
+  countSymbolsOnReel(symbolOrProperties, reelIndex) {
+    let total = 0;
+    for (const symbol of this.reels[reelIndex]) {
+      let matches = true;
+      if (symbolOrProperties instanceof GameSymbol) {
+        if (symbol.id !== symbolOrProperties.id) matches = false;
+      } else {
+        for (const [key, value] of Object.entries(symbolOrProperties)) {
+          if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
+            matches = false;
+            break;
+          }
+        }
       }
-      if (this.spaceBetweenSymbols) {
-        const forward = this.spaceBetweenSymbols[symbolId]?.[placed.id] ?? 0;
-        if (forward >= 1 && dist <= forward) return true;
-        const reverse = this.spaceBetweenSymbols[placed.id]?.[symbolId] ?? 0;
-        if (reverse >= 1 && dist <= reverse) return true;
+      if (matches) {
+        total++;
       }
     }
-    return false;
+    return total;
   }
-  generateReels(gameConf) {
-    this.validateConfig(gameConf);
-    const gameMode = gameConf.config.gameModes[this.associatedGameModeName];
-    if (!gameMode) {
-      throw new Error(
-        `Error generating reels for game mode "${this.associatedGameModeName}". It's not defined in the game config.`
-      );
+  countSymbolsOnBoard(symbolOrProperties) {
+    let total = 0;
+    const onReel = {};
+    for (const [ridx, reel] of this.reels.entries()) {
+      for (const symbol of reel) {
+        let matches = true;
+        if (symbolOrProperties instanceof GameSymbol) {
+          if (symbol.id !== symbolOrProperties.id) matches = false;
+        } else {
+          for (const [key, value] of Object.entries(symbolOrProperties)) {
+            if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
+              matches = false;
+              break;
+            }
+          }
+        }
+        if (matches) {
+          total++;
+          if (onReel[ridx] === void 0) {
+            onReel[ridx] = 1;
+          } else {
+            onReel[ridx]++;
+          }
+        }
+      }
     }
-    const filePath = import_path.default.join(
-      gameConf.config.outputDir,
-      `reels_${this.associatedGameModeName}-${this.id}.csv`
-    );
-    this.csvPath = filePath;
-    const exists = import_fs2.default.existsSync(filePath);
-    if (exists && !this.overrideExisting) {
-      this.reels = this.parseReelsetCSV(filePath, gameConf);
-      return;
+    return [total, onReel];
+  }
+  isSymbolOnAnyReelMultipleTimes(symbol) {
+    for (const reel of this.reels) {
+      let count = 0;
+      for (const sym of reel) {
+        if (sym.id === symbol.id) {
+          count++;
+        }
+        if (count > 1) {
+          return true;
+        }
+      }
     }
-    if (!exists && this.symbolWeights.size === 0) {
-      throw new Error(
-        `Cannot generate reels for generator "${this.id}" of mode "${this.associatedGameModeName}" because the symbol weights are empty.`
-      );
+    return false;
+  }
+  getReelStopsForSymbol(reels, symbol) {
+    const reelStops = [];
+    for (let ridx = 0; ridx < reels.length; ridx++) {
+      const reel = reels[ridx];
+      const positions = [];
+      for (let pos = 0; pos < reel.length; pos++) {
+        if (reel[pos].id === symbol.id) {
+          positions.push(pos);
+        }
+      }
+      reelStops.push(positions);
     }
-    const reelsAmount = gameMode.reelsAmount;
-    const weightsObj = Object.fromEntries(this.symbolWeights);
+    return reelStops;
+  }
+  combineReelStops(opts) {
+    const reelsAmount = opts.reelsAmount ?? opts.ctx.services.game.getCurrentGameMode().reelsAmount;
+    (0, import_assert3.default)(reelsAmount, "Cannot combine reel stops without context or reelsAmount.");
+    const combined = [];
     for (let ridx = 0; ridx < reelsAmount; ridx++) {
-      const reel = new Array(this.rowsAmount).fill(null);
-      const reelQuotas = {};
-      const quotaCounts = {};
-      let totalReelsQuota = 0;
-      for (const [sym, quotaConf] of Object.entries(this.symbolQuotas || {})) {
-        const q = typeof quotaConf === "number" ? quotaConf : quotaConf[ridx];
-        if (!q) continue;
-        reelQuotas[sym] = q;
-        totalReelsQuota += q;
-      }
-      if (totalReelsQuota > 100) {
-        throw new Error(
-          `Total symbol quotas for reel ${ridx} exceed 100%. Adjust your configuration on ReelGenerator "${this.id}".`
-        );
-      }
-      if (totalReelsQuota > 0) {
-        for (const [sym, quota] of Object.entries(reelQuotas)) {
-          const quotaCount = Math.max(1, Math.floor(this.rowsAmount * quota / 100));
-          quotaCounts[sym] = quotaCount;
-        }
+      combined[ridx] = [];
+      for (const stops of opts.reelStops) {
+        combined[ridx] = combined[ridx].concat(stops[ridx]);
       }
-      for (const [sym, targetCount] of Object.entries(quotaCounts)) {
-        let remaining = targetCount;
-        let attempts = 0;
-        while (remaining > 0) {
-          if (attempts++ > this.rowsAmount * 10) {
-            throw new Error(
-              `Failed to place ${targetCount} of symbol ${sym} on reel ${ridx} (likely spacing/stacking too strict).`
-            );
-          }
-          const pos = Math.round(this.rng.randomFloat(0, this.rowsAmount - 1));
-          const stackCfg = this.resolveStacking(sym, ridx);
-          let placed = 0;
-          if (stackCfg && Math.round(this.rng.randomFloat(1, 100)) <= stackCfg.chance) {
-            const stackSize = Math.max(
-              0,
-              Math.round(this.rng.randomFloat(stackCfg.min, stackCfg.max))
-            );
-            const toPlace = Math.min(stackSize, remaining);
-            placed = this.tryPlaceStack(reel, gameConf, ridx, sym, pos, toPlace);
-          }
-          if (placed === 0 && reel[pos] === null && this.isSymbolAllowedOnReel(sym, ridx) && !this.violatesSpacing(reel, sym, pos)) {
-            reel[pos] = gameConf.config.symbols.get(sym);
-            placed = 1;
-          }
-          remaining -= placed;
+    }
+    return combined;
+  }
+  getRandomReelStops(opts) {
+    const reelsAmount = opts.reelsAmount ?? opts.ctx.services.game.getCurrentGameMode().reelsAmount;
+    (0, import_assert3.default)(reelsAmount, "Cannot get random reel stops without context or reelsAmount.");
+    const symProbsOnReels = [];
+    const stopPositionsForReels = {};
+    for (let ridx = 0; ridx < reelsAmount; ridx++) {
+      symProbsOnReels.push(opts.reelStops[ridx].length / opts.reels[ridx].length);
+    }
+    while (Object.keys(stopPositionsForReels).length !== opts.amount) {
+      const possibleReels = [];
+      for (let i = 0; i < reelsAmount; i++) {
+        if (symProbsOnReels[i] > 0) {
+          possibleReels.push(i);
         }
       }
-      for (let r = 0; r < this.rowsAmount; r++) {
-        if (reel[r] !== null) continue;
-        let chosenSymbolId = weightedRandom(weightsObj, this.rng);
-        const nextHasStackCfg = !!this.resolveStacking(chosenSymbolId, ridx);
-        if (!nextHasStackCfg && this.preferStackedSymbols && reel.length > 0) {
-          const prevSymbol = r - 1 >= 0 ? reel[r - 1] : reel[reel.length - 1];
-          if (prevSymbol && Math.round(this.rng.randomFloat(1, 100)) <= this.preferStackedSymbols && (!this.spaceBetweenSameSymbols || !this.violatesSpacing(reel, prevSymbol.id, r))) {
-            chosenSymbolId = prevSymbol.id;
-          }
-        }
-        if (this.preferStackedSymbols && reel.length > 0) {
-          const prevSymbol = r - 1 >= 0 ? reel[r - 1] : reel[reel.length - 1];
-          if (Math.round(this.rng.randomFloat(1, 100)) <= this.preferStackedSymbols && (!this.spaceBetweenSameSymbols || !this.violatesSpacing(reel, prevSymbol.id, r))) {
-            chosenSymbolId = prevSymbol.id;
-          }
-        }
-        const stackCfg = this.resolveStacking(chosenSymbolId, ridx);
-        if (stackCfg && this.isSymbolAllowedOnReel(chosenSymbolId, ridx)) {
-          const roll = Math.round(this.rng.randomFloat(1, 100));
-          if (roll <= stackCfg.chance) {
-            const desiredSize = Math.max(
-              1,
-              Math.round(this.rng.randomFloat(stackCfg.min, stackCfg.max))
-            );
-            const placed = this.tryPlaceStack(
-              reel,
-              gameConf,
-              ridx,
-              chosenSymbolId,
-              r,
-              desiredSize
-            );
-            if (placed > 0) {
-              r += placed - 1;
-              continue;
-            }
-          }
-        }
-        let tries = 0;
-        const maxTries = 2500;
-        while (!this.isSymbolAllowedOnReel(chosenSymbolId, ridx) || this.violatesSpacing(reel, chosenSymbolId, r)) {
-          if (++tries > maxTries) {
-            throw new Error(
-              [
-                `Failed to place a symbol on reel ${ridx} at position ${r} after ${maxTries} attempts.
-`,
-                "Try to change the seed or adjust your configuration.\n"
-              ].join(" ")
-            );
-          }
-          chosenSymbolId = weightedRandom(weightsObj, this.rng);
-          const hasStackCfg = !!this.resolveStacking(chosenSymbolId, ridx);
-          if (!hasStackCfg && this.preferStackedSymbols && reel.length > 0) {
-            const prevSymbol = r - 1 >= 0 ? reel[r - 1] : reel[reel.length - 1];
-            if (prevSymbol && Math.round(this.rng.randomFloat(1, 100)) <= this.preferStackedSymbols && (!this.spaceBetweenSameSymbols || !this.violatesSpacing(reel, prevSymbol.id, r))) {
-              chosenSymbolId = prevSymbol.id;
-            }
-          }
-        }
-        const symbol = gameConf.config.symbols.get(chosenSymbolId);
-        if (!symbol) {
-          throw new Error(
-            `Symbol with id "${chosenSymbolId}" not found in the game config symbols map.`
-          );
+      const possibleProbs = symProbsOnReels.filter((p) => p > 0);
+      const weights = Object.fromEntries(
+        possibleReels.map((ridx, idx) => [ridx, possibleProbs[idx]])
+      );
+      const chosenReel = opts.ctx.services.rng.weightedRandom(weights);
+      const chosenStop = opts.ctx.services.rng.randomItem(
+        opts.reelStops[Number(chosenReel)]
+      );
+      symProbsOnReels[Number(chosenReel)] = 0;
+      stopPositionsForReels[Number(chosenReel)] = chosenStop;
+    }
+    return stopPositionsForReels;
+  }
+  getRandomReelset(ctx) {
+    const weights = ctx.state.currentResultSet.reelWeights;
+    const evalWeights = ctx.state.currentResultSet.reelWeights.evaluate?.(ctx);
+    let reelSetId = "";
+    if (evalWeights) {
+      reelSetId = ctx.services.rng.weightedRandom(evalWeights);
+    } else {
+      reelSetId = ctx.services.rng.weightedRandom(weights[ctx.state.currentSpinType]);
+    }
+    const reelSet = ctx.services.game.getReelsetById(ctx.state.currentGameMode, reelSetId);
+    return reelSet;
+  }
+  resetReels(opts) {
+    const length = opts.reelsAmount ?? opts.ctx.services.game.getCurrentGameMode().reelsAmount;
+    this.reels = this.makeEmptyReels(opts);
+    this.anticipation = Array.from({ length }, () => false);
+    this.paddingTop = this.makeEmptyReels(opts);
+    this.paddingBottom = this.makeEmptyReels(opts);
+  }
+  drawBoardMixed(opts) {
+    this.resetReels(opts);
+    const reelsAmount = opts.reelsAmount ?? opts.ctx.services.game.getCurrentGameMode().reelsAmount;
+    const symbolsPerReel = opts.symbolsPerReel ?? opts.ctx.services.game.getCurrentGameMode().symbolsPerReel;
+    const padSymbols = opts.padSymbols ?? opts.ctx.config.padSymbols;
+    const finalReelStops = Array.from(
+      { length: reelsAmount },
+      () => null
+    );
+    if (opts.forcedStops) {
+      for (const [r, stopPos] of Object.entries(opts.forcedStops)) {
+        const reelIdx = Number(r);
+        const symCount = symbolsPerReel[reelIdx];
+        finalReelStops[reelIdx] = stopPos - Math.round(opts.ctx.services.rng.randomFloat(0, symCount - 1));
+        if (finalReelStops[reelIdx] < 0) {
+          finalReelStops[reelIdx] = opts.reels[reelIdx].length + finalReelStops[reelIdx];
         }
-        reel[r] = symbol;
       }
-      if (reel.some((s) => s === null)) {
-        throw new Error(`Reel ${ridx} has unfilled positions after generation.`);
+    }
+    for (let i = 0; i < finalReelStops.length; i++) {
+      if (finalReelStops[i] === null) {
+        finalReelStops[i] = Math.floor(
+          opts.ctx.services.rng.randomFloat(0, opts.reels[i].length - 1)
+        );
       }
-      this.reels.push(reel);
     }
-    const csvRows = Array.from(
-      { length: this.rowsAmount },
-      () => Array.from({ length: reelsAmount }, () => "")
-    );
+    this.lastDrawnReelStops = finalReelStops.map((pos) => pos);
+    this.lastUsedReels = opts.reels;
     for (let ridx = 0; ridx < reelsAmount; ridx++) {
-      for (let r = 0; r < this.rowsAmount; r++) {
-        csvRows[r][ridx] = this.reels[ridx][r].id;
+      const reelPos = finalReelStops[ridx];
+      for (let p = padSymbols - 1; p >= 0; p--) {
+        const topPos = (reelPos - (p + 1)) % opts.reels[ridx].length;
+        this.paddingTop[ridx].push(opts.reels[ridx][topPos]);
+        const bottomPos = (reelPos + symbolsPerReel[ridx] + p) % opts.reels[ridx].length;
+        this.paddingBottom[ridx].unshift(opts.reels[ridx][bottomPos]);
       }
-    }
-    const csvString = csvRows.map((row) => row.join(",")).join("\n");
-    if (import_worker_threads.isMainThread) {
-      import_fs2.default.writeFileSync(filePath, csvString);
-      this.reels = this.parseReelsetCSV(filePath, gameConf);
-      console.log(
-        `Generated reelset ${this.id} for game mode ${this.associatedGameModeName}`
-      );
-    }
-  }
-  /**
-   * Reads a reelset CSV file and returns the reels as arrays of GameSymbols.
-   */
-  parseReelsetCSV(reelSetPath, { config }) {
-    const csvData = import_fs2.default.readFileSync(reelSetPath, "utf8");
-    const rows = csvData.split("\n").filter((line) => line.trim() !== "");
-    const reels = Array.from(
-      { length: config.gameModes[this.associatedGameModeName].reelsAmount },
-      () => []
-    );
-    rows.forEach((row) => {
-      const symsInRow = row.split(",").map((symbolId) => {
-        const symbol = config.symbols.get(symbolId.trim());
+      for (let row = 0; row < symbolsPerReel[ridx]; row++) {
+        const symbol = opts.reels[ridx][(reelPos + row) % opts.reels[ridx].length];
         if (!symbol) {
-          throw new Error(`Symbol with id "${symbolId}" not found in game config.`);
+          throw new Error(`Failed to get symbol at pos ${reelPos + row} on reel ${ridx}`);
         }
-        return symbol;
-      });
-      symsInRow.forEach((symbol, ridx) => {
-        reels[ridx].push(symbol);
-      });
-    });
-    const reelLengths = reels.map((r) => r.length);
-    const uniqueLengths = new Set(reelLengths);
-    if (uniqueLengths.size > 1) {
-      throw new Error(
-        `Inconsistent reel lengths in reelset CSV at ${reelSetPath}: ${[
-          ...uniqueLengths
-        ].join(", ")}`
-      );
+        this.reels[ridx][row] = symbol;
+      }
     }
-    return reels;
-  }
-};
-
-// src/ResultSet.ts
-var import_assert3 = __toESM(require("assert"));
-var ResultSet = class {
-  criteria;
-  quota;
-  multiplier;
-  reelWeights;
-  userData;
-  forceMaxWin;
-  forceFreespins;
-  evaluate;
-  constructor(opts) {
-    this.criteria = opts.criteria;
-    this.quota = opts.quota;
-    this.multiplier = opts.multiplier;
-    this.reelWeights = opts.reelWeights;
-    this.userData = opts.userData;
-    this.forceMaxWin = opts.forceMaxWin;
-    this.forceFreespins = opts.forceFreespins;
-    this.evaluate = opts.evaluate;
   }
-  static assignCriteriaToSimulations(ctx, gameModeName) {
-    const rng = new RandomNumberGenerator();
-    rng.setSeed(0);
-    (0, import_assert3.default)(ctx.simRunsAmount, "Simulation configuration is not set.");
-    const simNums = ctx.simRunsAmount[gameModeName];
-    const resultSets = ctx.gameConfig.config.gameModes[gameModeName]?.resultSets;
-    if (!resultSets || resultSets.length === 0) {
-      throw new Error(`No ResultSets found for game mode: ${gameModeName}.`);
-    }
-    if (simNums === void 0 || simNums <= 0) {
-      throw new Error(`No simulations configured for game mode "${gameModeName}".`);
+  tumbleBoard(opts) {
+    (0, import_assert3.default)(this.lastDrawnReelStops.length > 0, "Cannot tumble board before drawing it.");
+    const reelsAmount = opts.reelsAmount ?? opts.ctx.services.game.getCurrentGameMode().reelsAmount;
+    const symbolsPerReel = opts.symbolsPerReel ?? opts.ctx.services.game.getCurrentGameMode().symbolsPerReel;
+    const padSymbols = opts.padSymbols ?? opts.ctx.config.padSymbols;
+    if (!opts.ctx && !reelsAmount && !symbolsPerReel) {
+      throw new Error(
+        "If ctx is not provided, reelsAmount and symbolsPerReel must be given."
+      );
     }
-    const totalQuota = resultSets.reduce((sum, rs) => sum + rs.quota, 0);
-    const numberOfSimsForCriteria = Object.fromEntries(
-      resultSets.map((rs) => {
-        const normalizedQuota = totalQuota > 0 ? rs.quota / totalQuota : 0;
-        return [rs.criteria, Math.max(Math.floor(normalizedQuota * simNums), 1)];
-      })
-    );
-    let totalSims = Object.values(numberOfSimsForCriteria).reduce(
-      (sum, num) => sum + num,
-      0
-    );
-    let reduceSims = totalSims > simNums;
-    const criteriaToWeights = Object.fromEntries(
-      resultSets.map((rs) => [rs.criteria, rs.quota])
-    );
-    while (totalSims != simNums) {
-      const rs = weightedRandom(criteriaToWeights, rng);
-      if (reduceSims && numberOfSimsForCriteria[rs] > 1) {
-        numberOfSimsForCriteria[rs] -= 1;
-      } else if (!reduceSims) {
-        numberOfSimsForCriteria[rs] += 1;
+    const reels = this.lastUsedReels;
+    opts.symbolsToDelete.forEach(({ reelIdx, rowIdx }) => {
+      this.reels[reelIdx].splice(rowIdx, 1);
+    });
+    const newFirstSymbolPositions = {};
+    for (let ridx = 0; ridx < reelsAmount; ridx++) {
+      while (this.reels[ridx].length < symbolsPerReel[ridx]) {
+        const padSymbol = this.paddingTop[ridx].pop();
+        if (padSymbol) {
+          this.reels[ridx].unshift(padSymbol);
+        } else {
+          break;
+        }
+      }
+      const previousStop = this.lastDrawnReelStops[ridx];
+      const stopBeforePad = previousStop - padSymbols - 1;
+      const symbolsNeeded = symbolsPerReel[ridx] - this.reels[ridx].length;
+      for (let s = 0; s < symbolsNeeded; s++) {
+        const symbolPos = (stopBeforePad - s + reels[ridx].length) % reels[ridx].length;
+        const newSymbol = reels[ridx][symbolPos];
+        (0, import_assert3.default)(newSymbol, "Failed to get new symbol for tumbling.");
+        this.reels[ridx].unshift(newSymbol);
+        newFirstSymbolPositions[ridx] = symbolPos;
       }
-      totalSims = Object.values(numberOfSimsForCriteria).reduce(
-        (sum, num) => sum + num,
-        0
-      );
-      reduceSims = totalSims > simNums;
     }
-    let allCriteria = [];
-    const simNumsToCriteria = {};
-    Object.entries(numberOfSimsForCriteria).forEach(([criteria, num]) => {
-      for (let i = 0; i <= num; i++) {
-        allCriteria.push(criteria);
+    for (let ridx = 0; ridx < reelsAmount; ridx++) {
+      const firstSymbolPos = newFirstSymbolPositions[ridx];
+      for (let p = 1; p <= padSymbols; p++) {
+        const topPos = (firstSymbolPos - p + reels[ridx].length) % reels[ridx].length;
+        const padSymbol = reels[ridx][topPos];
+        (0, import_assert3.default)(padSymbol, "Failed to get new padding symbol for tumbling.");
+        this.paddingTop[ridx].unshift(padSymbol);
       }
-    });
-    allCriteria = shuffle(allCriteria, rng);
-    for (let i = 1; i <= Math.min(simNums, allCriteria.length); i++) {
-      simNumsToCriteria[i] = allCriteria[i];
     }
-    return simNumsToCriteria;
+  }
+};
+
+// src/service/board.ts
+var BoardService = class extends AbstractService {
+  board;
+  constructor(ctx) {
+    super(ctx);
+    this.board = new Board();
   }
   /**
-   * Checks if core criteria is met, e.g. target multiplier or max win.
+   * Resets the board to an empty state.\
+   * This is called before drawing a new board.
    */
-  meetsCriteria(ctx) {
-    const customEval = this.evaluate?.(copy(ctx));
-    const freespinsMet = this.forceFreespins ? ctx.state.triggeredFreespins : true;
-    const multiplierMet = this.multiplier !== void 0 ? ctx.wallet.getCurrentWin() === this.multiplier && !this.forceMaxWin : ctx.wallet.getCurrentWin() > 0 && (!this.forceMaxWin || true);
-    const maxWinMet = this.forceMaxWin ? ctx.wallet.getCurrentWin() >= ctx.config.maxWinX : true;
-    const coreCriteriaMet = freespinsMet && multiplierMet && maxWinMet;
-    const finalResult = customEval !== void 0 ? coreCriteriaMet && customEval === true : coreCriteriaMet;
-    if (this.forceMaxWin && maxWinMet) {
-      ctx.record({
-        maxwin: true
-      });
-    }
-    return finalResult;
+  resetBoard() {
+    this.resetReels();
+    this.board.lastDrawnReelStops = [];
   }
-};
-
-// src/Wallet.ts
-var Wallet = class {
-  /**
-   * Total win amount (as the bet multiplier) from all simulations.
-   */
-  cumulativeWins = 0;
-  /**
-   * Total win amount (as the bet multiplier) per spin type.
-   *
-   * @example
-   * ```ts
-   * {
-   *   basegame: 50,
-   *   freespins: 100,
-   *   superfreespins: 200,
-   * }
-   * ```
-   */
-  cumulativeWinsPerSpinType = {
-    [GameConfig.SPIN_TYPE.BASE_GAME]: 0,
-    [GameConfig.SPIN_TYPE.FREE_SPINS]: 0
-  };
-  /**
-   * Current win amount (as the bet multiplier) for the ongoing simulation.
-   */
-  currentWin = 0;
   /**
-   * Current win amount (as the bet multiplier) for the ongoing simulation per spin type.
-   *
-   * @example
-   * ```ts
-   * {
-   *   basegame: 50,
-   *   freespins: 100,
-   *   superfreespins: 200,
-   * }
-   * ```
+   * Gets the current reels and symbols on the board.
    */
-  currentWinPerSpinType = {
-    [GameConfig.SPIN_TYPE.BASE_GAME]: 0,
-    [GameConfig.SPIN_TYPE.FREE_SPINS]: 0
-  };
+  getBoardReels() {
+    return this.board.reels;
+  }
+  getPaddingTop() {
+    return this.board.paddingTop;
+  }
+  getPaddingBottom() {
+    return this.board.paddingBottom;
+  }
+  getAnticipation() {
+    return this.board.anticipation;
+  }
+  resetReels() {
+    this.board.resetReels({
+      ctx: this.ctx()
+    });
+  }
   /**
-   * Holds the current win amount for a single (free) spin.\
-   * After each spin, this amount is added to `currentWinPerSpinType` and then reset to zero.
+   * Sets the anticipation value for a specific reel.
    */
-  currentSpinWin = 0;
+  setAnticipationForReel(reelIndex, value) {
+    this.board.anticipation[reelIndex] = value;
+  }
   /**
-   * Current win amount (as the bet multiplier) for the ongoing tumble sequence.
+   * Counts how many symbols matching the criteria are on a specific reel.
    */
-  currentTumbleWin = 0;
-  constructor() {
+  countSymbolsOnReel(symbolOrProperties, reelIndex) {
+    return this.board.countSymbolsOnReel(symbolOrProperties, reelIndex);
   }
   /**
-   * Updates the win for the current spin.
+   * Counts how many symbols matching the criteria are on the board.
    *
-   * Should be called after each tumble event, if applicable.\
-   * Or generally call this to add wins during a spin.
+   * Passing a GameSymbol will compare by ID, passing a properties object will compare by properties.
    *
-   * After each (free) spin, this amount should be added to `currentWinPerSpinType` via `confirmSpinWin()`
+   * Returns a tuple where the first element is the total count, and the second element is a record of counts per reel index.
    */
-  addSpinWin(amount) {
-    this.currentSpinWin += amount;
+  countSymbolsOnBoard(symbolOrProperties) {
+    return this.board.countSymbolsOnBoard(symbolOrProperties);
   }
   /**
-   * Assigns a win amount to the given spin type.
+   * Checks if a symbol appears more than once on any reel in the current reel set.
    *
-   * Should be called after `addSpinWin()`, and after your tumble events are played out,\
-   * and after a (free) spin is played out to finalize the win.
+   * Useful to check for "forbidden" generations, e.g. 2 scatters on one reel.
    */
-  confirmSpinWin(spinType) {
-    if (!Object.keys(this.currentWinPerSpinType).includes(spinType)) {
-      throw new Error(`Spin type "${spinType}" does not exist in the wallet.`);
-    }
-    this.currentWinPerSpinType[spinType] += this.currentSpinWin;
-    this.currentWin += this.currentSpinWin;
-    this.currentSpinWin = 0;
+  isSymbolOnAnyReelMultipleTimes(symbol) {
+    return this.board.isSymbolOnAnyReelMultipleTimes(symbol);
   }
   /**
-   * Returns the accumulated win amount (as the bet multiplier) from all simulations.
+   * Gets all reel stops (positions) where the specified symbol appears in the current reel set.\
+   * Returns an array of arrays, where each inner array contains the positions for the corresponding reel.
    */
-  getCumulativeWins() {
-    return this.cumulativeWins;
+  getReelStopsForSymbol(reels, symbol) {
+    return this.board.getReelStopsForSymbol(reels, symbol);
   }
   /**
-   * Returns the accumulated win amount (as the bet multiplier) per spin type from all simulations.
+   * Combines multiple arrays of reel stops into a single array of reel stops.\
    */
-  getCumulativeWinsPerSpinType() {
-    return this.cumulativeWinsPerSpinType;
+  combineReelStops(...reelStops) {
+    return this.board.combineReelStops({
+      ctx: this.ctx(),
+      reelStops
+    });
   }
   /**
-   * Returns the current win amount (as the bet multiplier) for the ongoing simulation.
+   * From a list of reel stops on reels, selects a random stop for a speficied number of random symbols.
+   *
+   * Mostly useful for placing scatter symbols on the board.
    */
-  getCurrentWin() {
-    return this.currentWin;
+  getRandomReelStops(reels, reelStops, amount) {
+    return this.board.getRandomReelStops({
+      ctx: this.ctx(),
+      reels,
+      reelStops,
+      amount
+    });
   }
   /**
-   * Returns the current win amount (as the bet multiplier) per spin type for the ongoing simulation.
+   * Selects a random reel set based on the configured weights of the current result set.\
+   * Returns the reels as arrays of GameSymbols.
    */
-  getCurrentWinPerSpinType() {
-    return this.currentWinPerSpinType;
+  getRandomReelset() {
+    return this.board.getRandomReelset(this.ctx());
   }
   /**
-   * Adds a win to `currentSpinWin` and `currentTumbleWin`.
-   *
-   * After each (free) spin, this amount should be added to `currentWinPerSpinType` via `confirmSpinWin()`
+   * Draws a board using specified reel stops.
    */
-  addTumbleWin(amount) {
-    this.currentTumbleWin += amount;
-    this.addSpinWin(amount);
+  drawBoardWithForcedStops(reels, forcedStops) {
+    this.drawBoardMixed(reels, forcedStops);
   }
   /**
-   * Resets the current win amounts to zero.
+   * Draws a board using random reel stops.
    */
-  resetCurrentWin() {
-    this.currentWin = 0;
-    this.currentSpinWin = 0;
-    this.currentTumbleWin = 0;
-    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
-      this.currentWinPerSpinType[spinType] = 0;
-    }
+  drawBoardWithRandomStops(reels) {
+    this.drawBoardMixed(reels);
+  }
+  drawBoardMixed(reels, forcedStops) {
+    this.board.drawBoardMixed({
+      ctx: this.ctx(),
+      reels,
+      forcedStops
+    });
   }
   /**
-   * Adds current wins to cumulative wins and resets current wins to zero.
+   * Tumbles the board. All given symbols will be deleted and new symbols will fall from the top.
    */
-  confirmWins(ctx) {
-    function process2(number) {
-      return Math.round(Math.min(number, ctx.config.maxWinX) * 100) / 100;
-    }
-    ctx.state.book.writePayout(ctx);
-    this.currentWin = process2(this.currentWin);
-    this.cumulativeWins += this.currentWin;
-    let spinTypeWins = 0;
-    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
-      const st = spinType;
-      const spinTypeWin = process2(this.currentWinPerSpinType[st]);
-      this.cumulativeWinsPerSpinType[st] += spinTypeWin;
-      spinTypeWins += spinTypeWin;
-    }
-    if (process2(spinTypeWins) !== this.currentWin) {
-      throw new Error(
-        `Inconsistent wallet state: currentWin (${this.currentWin}) does not equal spinTypeWins (${spinTypeWins}).`
-      );
-    }
-    this.resetCurrentWin();
-  }
-  serialize() {
-    return {
-      cumulativeWins: this.cumulativeWins,
-      cumulativeWinsPerSpinType: this.cumulativeWinsPerSpinType,
-      currentWin: this.currentWin,
-      currentWinPerSpinType: this.currentWinPerSpinType,
-      currentSpinWin: this.currentSpinWin,
-      currentTumbleWin: this.currentTumbleWin
-    };
-  }
-  merge(wallet) {
-    this.cumulativeWins += wallet.getCumulativeWins();
-    const otherWinsPerSpinType = wallet.getCumulativeWinsPerSpinType();
-    for (const spinType of Object.keys(this.cumulativeWinsPerSpinType)) {
-      this.cumulativeWinsPerSpinType[spinType] += otherWinsPerSpinType[spinType] || 0;
-    }
-  }
-  mergeSerialized(data) {
-    this.cumulativeWins += data.cumulativeWins;
-    for (const spinType of Object.keys(this.cumulativeWinsPerSpinType)) {
-      this.cumulativeWinsPerSpinType[spinType] += data.cumulativeWinsPerSpinType[spinType] || 0;
-    }
-    this.currentWin += data.currentWin;
-    this.currentSpinWin += data.currentSpinWin;
-    this.currentTumbleWin += data.currentTumbleWin;
-    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
-      this.currentWinPerSpinType[spinType] += data.currentWinPerSpinType[spinType] || 0;
-    }
+  tumbleBoard(symbolsToDelete) {
+    this.board.tumbleBoard({
+      ctx: this.ctx(),
+      symbolsToDelete
+    });
   }
 };
 
-// src/Book.ts
-var Book = class _Book {
-  id;
-  criteria = "N/A";
-  events = [];
-  payout = 0;
-  basegameWins = 0;
-  freespinsWins = 0;
-  constructor(opts) {
-    this.id = opts.id;
+// src/service/data.ts
+var import_assert4 = __toESM(require("assert"));
+var DataService = class extends AbstractService {
+  recorder;
+  book;
+  constructor(ctx) {
+    super(ctx);
+  }
+  ensureRecorder() {
+    (0, import_assert4.default)(this.recorder, "Recorder not set in DataService. Call setRecorder() first.");
+  }
+  ensureBook() {
+    (0, import_assert4.default)(this.book, "Book not set in DataService. Call setBook() first.");
   }
   /**
-   * Adds an event to the book.
+   * Intended for internal use only.
    */
-  addEvent(event) {
-    const index = this.events.length + 1;
-    this.events.push({ index, ...event });
+  _setRecorder(recorder) {
+    this.recorder = recorder;
   }
   /**
-   * Transfers the win data from the wallet to the book.
+   * Intended for internal use only.
    */
-  writePayout(ctx) {
-    function process2(number) {
-      return Math.round(Math.min(number, ctx.config.maxWinX) * 100) / 100;
-    }
-    this.payout = Math.round(process2(ctx.wallet.getCurrentWin()) * 100);
-    this.basegameWins = process2(
-      ctx.wallet.getCurrentWinPerSpinType()[GameConfig.SPIN_TYPE.BASE_GAME] || 0
-    );
-    this.freespinsWins = process2(
-      ctx.wallet.getCurrentWinPerSpinType()[GameConfig.SPIN_TYPE.FREE_SPINS] || 0
-    );
-  }
-  getPayout() {
-    return this.payout;
-  }
-  getBasegameWins() {
-    return this.basegameWins;
-  }
-  getFreespinsWins() {
-    return this.freespinsWins;
-  }
-  serialize() {
-    return {
-      id: this.id,
-      criteria: this.criteria,
-      events: this.events,
-      payout: this.payout,
-      basegameWins: this.basegameWins,
-      freespinsWins: this.freespinsWins
-    };
+  _getBook() {
+    return this.book;
   }
-  static fromSerialized(data) {
-    const book = new _Book({ id: data.id });
-    book.criteria = data.criteria;
-    book.events = data.events;
-    book.payout = data.payout;
-    book.basegameWins = data.basegameWins;
-    book.freespinsWins = data.freespinsWins;
-    return book;
-  }
-};
-
-// src/GameState.ts
-var GameState = class extends GameConfig {
-  state;
   /**
-   * The wallet stores win data for the current and all simulations, respectively.
+   * Intended for internal use only.
    */
-  wallet;
+  _setBook(book) {
+    this.book = book;
+  }
   /**
-   * Recorder for statistical analysis (e.g. symbol occurrences, etc.).
+   * Intended for internal use only.
    */
-  recorder;
-  constructor(opts) {
-    super(opts);
-    this.state = {
-      currentSpinType: GameConfig.SPIN_TYPE.BASE_GAME,
-      library: /* @__PURE__ */ new Map(),
-      book: new Book({ id: 0 }),
-      currentGameMode: "N/A",
-      currentSimulationId: 0,
-      isCriteriaMet: false,
-      currentFreespinAmount: 0,
-      totalFreespinAmount: 0,
-      rng: new RandomNumberGenerator(),
-      userData: opts.userState || {},
-      triggeredMaxWin: false,
-      triggeredFreespins: false,
-      // This is a placeholder ResultSet to avoid null checks elsewhere.
-      currentResultSet: new ResultSet({
-        criteria: "N/A",
-        quota: 0,
-        reelWeights: {
-          [GameConfig.SPIN_TYPE.BASE_GAME]: {},
-          [GameConfig.SPIN_TYPE.FREE_SPINS]: {}
-        }
-      })
-    };
-    this.wallet = new Wallet();
-    this.recorder = {
-      pendingRecords: [],
-      records: []
-    };
+  _getRecorder() {
+    return this.recorder;
   }
   /**
-   * Gets the configuration for the current game mode.
+   * Intended for internal use only.
    */
-  getCurrentGameMode() {
-    return this.config.gameModes[this.state.currentGameMode];
-  }
-  resetState() {
-    this.state.rng.setSeedIfDifferent(this.state.currentSimulationId);
-    this.state.book = new Book({ id: this.state.currentSimulationId });
-    this.state.currentSpinType = GameConfig.SPIN_TYPE.BASE_GAME;
-    this.state.currentFreespinAmount = 0;
-    this.state.totalFreespinAmount = 0;
-    this.state.triggeredMaxWin = false;
-    this.state.triggeredFreespins = false;
-    this.wallet.resetCurrentWin();
-    this.clearPendingRecords();
-    this.state.userData = this.config.userState || {};
+  _getRecords() {
+    this.ensureRecorder();
+    return this.recorder.records;
   }
   /**
-   * Empties the list of pending records in the recorder.
+   * Record data for statistical analysis.
    */
-  clearPendingRecords() {
-    this.recorder.pendingRecords = [];
+  record(data) {
+    this.ensureRecorder();
+    this.recorder.pendingRecords.push({
+      bookId: this.ctx().state.currentSimulationId,
+      properties: Object.fromEntries(
+        Object.entries(data).map(([k, v]) => [k, String(v)])
+      )
+    });
   }
   /**
-   * Confirms all pending records and adds them to the main records list.
+   * Records a symbol occurrence for statistical analysis.
+   *
+   * Calls `ctx.services.data.record()` with the provided data.
    */
-  confirmRecords() {
-    for (const pendingRecord of this.recorder.pendingRecords) {
-      const search = Object.entries(pendingRecord.properties).map(([name, value]) => ({ name, value })).sort((a, b) => a.name.localeCompare(b.name));
-      let record = this.recorder.records.find((r) => {
-        if (r.search.length !== search.length) return false;
-        for (let i = 0; i < r.search.length; i++) {
-          if (r.search[i].name !== search[i].name) return false;
-          if (r.search[i].value !== search[i].value) return false;
-        }
-        return true;
-      });
-      if (!record) {
-        record = {
-          search,
-          timesTriggered: 0,
-          bookIds: []
-        };
-        this.recorder.records.push(record);
-      }
-      record.timesTriggered++;
-      if (!record.bookIds.includes(pendingRecord.bookId)) {
-        record.bookIds.push(pendingRecord.bookId);
-      }
-    }
-    this.clearPendingRecords();
+  recordSymbolOccurrence(data) {
+    this.record(data);
   }
   /**
-   * Record data for statistical analysis.
+   * Adds an event to the book.
    */
-  record(data) {
-    this.recorder.pendingRecords.push({
-      bookId: this.state.currentSimulationId,
-      properties: Object.fromEntries(
-        Object.entries(data).map(([k, v]) => [k, String(v)])
-      )
-    });
+  addBookEvent(event) {
+    this.ensureBook();
+    this.book.addEvent(event);
   }
   /**
-   * Records a symbol occurrence for statistical analysis.
-   *
-   * Calls `this.record()` with the provided data.
+   * Intended for internal use only.
    */
-  recordSymbolOccurrence(data) {
-    this.record(data);
+  _clearPendingRecords() {
+    this.ensureRecorder();
+    this.recorder.pendingRecords = [];
+  }
+};
+
+// src/service/game.ts
+var GameService = class extends AbstractService {
+  constructor(ctx) {
+    super(ctx);
   }
   /**
-   * Gets all confirmed records.
+   * Retrieves a reel set by its ID within a specific game mode.
    */
-  getRecords() {
-    return this.recorder.records;
+  getReelsetById(gameMode, id) {
+    const reelSet = this.ctx().config.gameModes[gameMode].reelSets.find(
+      (rs) => rs.id === id
+    );
+    if (!reelSet) {
+      throw new Error(
+        `Reel set with id "${id}" not found in game mode "${gameMode}". Available reel sets: ${this.ctx().config.gameModes[gameMode].reelSets.map((rs) => rs.id).join(", ")}`
+      );
+    }
+    return reelSet.reels;
   }
   /**
-   * Moves the current book to the library and resets the current book.
+   * Retrieves the number of free spins awarded for a given spin type and scatter count.
    */
-  moveBookToLibrary() {
-    this.state.library.set(this.state.book.id.toString(), this.state.book);
-    this.state.book = new Book({ id: 0 });
+  getFreeSpinsForScatters(spinType, scatterCount) {
+    const freespinsConfig = this.ctx().config.scatterToFreespins[spinType];
+    if (!freespinsConfig) {
+      throw new Error(
+        `No free spins configuration found for spin type "${spinType}". Please check your game configuration.`
+      );
+    }
+    return freespinsConfig[scatterCount] || 0;
   }
   /**
-   * Increases the freespin count by the specified amount.
-   *
-   * Also sets `state.triggeredFreespins` to true.
+   * Retrieves a result set by its criteria within a specific game mode.
    */
-  awardFreespins(amount) {
-    this.state.currentFreespinAmount += amount;
-    this.state.totalFreespinAmount += amount;
-    this.state.triggeredFreespins = true;
+  getResultSetByCriteria(mode, criteria) {
+    const gameMode = this.ctx().config.gameModes[mode];
+    if (!gameMode) {
+      throw new Error(`Game mode "${mode}" not found in game config.`);
+    }
+    const resultSet = gameMode.resultSets.find((rs) => rs.criteria === criteria);
+    if (!resultSet) {
+      throw new Error(
+        `Criteria "${criteria}" not found in game mode "${mode}". Available criteria: ${gameMode.resultSets.map((rs) => rs.criteria).join(", ")}`
+      );
+    }
+    return resultSet;
+  }
+  /**
+   * Returns all configured symbols as an array.
+   */
+  getSymbolArray() {
+    return Array.from(this.ctx().config.symbols).map(([n, v]) => v);
+  }
+  /**
+   * Gets the configuration for the current game mode.
+   */
+  getCurrentGameMode() {
+    return this.ctx().config.gameModes[this.ctx().state.currentGameMode];
   }
   /**
    * Ensures the requested number of scatters is valid based on the game configuration.\
    * Returns a valid number of scatters.
    */
   verifyScatterCount(numScatters) {
-    const scatterCounts = this.config.scatterToFreespins[this.state.currentSpinType];
+    const scatterCounts = this.ctx().config.scatterToFreespins[this.ctx().state.currentSpinType];
     if (!scatterCounts) {
       throw new Error(
-        `No scatter counts defined for spin type "${this.state.currentSpinType}". Please check your game configuration.`
+        `No scatter counts defined for spin type "${this.ctx().state.currentSpinType}". Please check your game configuration.`
       );
     }
     const validCounts = Object.keys(scatterCounts).map((key) => parseInt(key, 10));
     if (validCounts.length === 0) {
       throw new Error(
-        `No scatter counts defined for spin type "${this.state.currentSpinType}". Please check your game configuration.`
+        `No scatter counts defined for spin type "${this.ctx().state.currentSpinType}". Please check your game configuration.`
       );
     }
     if (numScatters < Math.min(...validCounts)) {
@@ -1197,766 +998,442 @@ var GameState = class extends GameConfig {
     }
     return numScatters;
   }
+  /**
+   * Increases the freespin count by the specified amount.
+   *
+   * Also sets `state.triggeredFreespins` to true.
+   */
+  awardFreespins(amount) {
+    this.ctx().state.currentFreespinAmount += amount;
+    this.ctx().state.totalFreespinAmount += amount;
+    this.ctx().state.triggeredFreespins = true;
+  }
 };
 
-// src/Board.ts
-var StandaloneBoard = class {
-  reels;
-  paddingTop;
-  paddingBottom;
-  anticipation;
-  ctx;
-  constructor(opts) {
-    this.reels = [];
-    this.paddingTop = [];
-    this.paddingBottom = [];
-    this.anticipation = [];
-    this.ctx = opts.ctx;
+// src/service/wallet.ts
+var import_assert5 = __toESM(require("assert"));
+var WalletService = class extends AbstractService {
+  wallet;
+  constructor(ctx) {
+    super(ctx);
+  }
+  ensureWallet() {
+    (0, import_assert5.default)(this.wallet, "Wallet not set in WalletService. Call setWallet() first.");
   }
   /**
-   * Updates the context used by this board instance.
+   * Intended for internal use only.
    */
-  context(ctx) {
-    this.ctx = ctx;
+  _getWallet() {
+    this.ensureWallet();
+    return this.wallet;
   }
   /**
-   * Resets the board to an empty state.\
-   * This is called before drawing a new board.
+   * Intended for internal use only.
    */
-  resetBoard() {
-    this.resetReels();
-  }
-  makeEmptyReels() {
-    return Array.from({ length: this.ctx.getCurrentGameMode().reelsAmount }, () => []);
-  }
-  resetReels() {
-    this.reels = this.makeEmptyReels();
-    this.anticipation = Array.from(
-      { length: this.ctx.getCurrentGameMode().reelsAmount },
-      () => 0
-    );
-    if (this.ctx.config.padSymbols && this.ctx.config.padSymbols > 0) {
-      this.paddingTop = this.makeEmptyReels();
-      this.paddingBottom = this.makeEmptyReels();
-    }
+  _setWallet(wallet) {
+    this.wallet = wallet;
   }
   /**
-   * Counts how many symbols matching the criteria are on a specific reel.
+   * Adds the given amount to the wallet state.
+   *
+   * After calculating the win for a board, call this method to update the wallet state.\
+   * If your game has tumbling mechanics, you should call this method again after every new tumble and win calculation.
    */
-  countSymbolsOnReel(symbolOrProperties, reelIndex) {
-    let total = 0;
-    for (const symbol of this.reels[reelIndex]) {
-      let matches = true;
-      if (symbolOrProperties instanceof GameSymbol) {
-        if (symbol.id !== symbolOrProperties.id) matches = false;
-      } else {
-        for (const [key, value] of Object.entries(symbolOrProperties)) {
-          if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
-            matches = false;
-            break;
-          }
-        }
-      }
-      if (matches) {
-        total++;
-      }
-    }
-    return total;
+  addSpinWin(amount) {
+    this.ensureWallet();
+    this.wallet.addSpinWin(amount);
   }
   /**
-   * Counts how many symbols matching the criteria are on the board.
+   * Helps to add tumble wins to the wallet state.
    *
-   * Passing a GameSymbol will compare by ID, passing a properties object will compare by properties.
-   *
-   * Returns a tuple where the first element is the total count, and the second element is a record of counts per reel index.
+   * This also calls `addSpinWin()` internally, to add the tumble win to the overall spin win.
    */
-  countSymbolsOnBoard(symbolOrProperties) {
-    let total = 0;
-    const onReel = {};
-    for (const [ridx, reel] of this.reels.entries()) {
-      for (const symbol of reel) {
-        let matches = true;
-        if (symbolOrProperties instanceof GameSymbol) {
-          if (symbol.id !== symbolOrProperties.id) matches = false;
-        } else {
-          for (const [key, value] of Object.entries(symbolOrProperties)) {
-            if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
-              matches = false;
-              break;
-            }
-          }
-        }
-        if (matches) {
-          total++;
-          if (onReel[ridx] === void 0) {
-            onReel[ridx] = 1;
-          } else {
-            onReel[ridx]++;
-          }
-        }
-      }
-    }
-    return [total, onReel];
+  addTumbleWin(amount) {
+    this.ensureWallet();
+    this.wallet.addTumbleWin(amount);
   }
   /**
-   * Checks if a symbol appears more than once on any reel in the current reel set.
+   * Confirms the wins of the current spin.
    *
-   * Useful to check for "forbidden" generations, e.g. 2 scatters on one reel.
+   * Should be called after `addSpinWin()`, and after your tumble events are played out,\
+   * and after a (free) spin is played out to finalize the win.
    */
-  isSymbolOnAnyReelMultipleTimes(symbol) {
-    for (const reel of this.reels) {
-      let count = 0;
-      for (const sym of reel) {
-        if (sym.id === symbol.id) {
-          count++;
-        }
-        if (count > 1) {
-          return true;
-        }
-      }
-    }
-    return false;
+  confirmSpinWin() {
+    this.ensureWallet();
+    this.wallet.confirmSpinWin(this.ctx().state.currentSpinType);
   }
   /**
-   * Draws a board using specified reel stops.
+   * Gets the total win amount of the current simulation.
    */
-  drawBoardWithForcedStops(reels, forcedStops) {
-    this.drawBoardMixed(reels, forcedStops);
+  getCurrentWin() {
+    this.ensureWallet();
+    return this.wallet.getCurrentWin();
   }
   /**
-   * Draws a board using random reel stops.
+   * Gets the current spin win amount of the ongoing spin.
    */
-  drawBoardWithRandomStops(reels) {
-    this.drawBoardMixed(reels);
+  getCurrentSpinWin() {
+    this.ensureWallet();
+    return this.wallet.getCurrentSpinWin();
   }
-  drawBoardMixed(reels, forcedStops) {
-    this.resetReels();
-    const finalReelStops = Array.from(
-      { length: this.ctx.getCurrentGameMode().reelsAmount },
-      () => null
-    );
-    if (forcedStops) {
-      for (const [r, stopPos] of Object.entries(forcedStops)) {
-        const reelIdx = Number(r);
-        const symCount = this.ctx.getCurrentGameMode().symbolsPerReel[reelIdx];
-        finalReelStops[reelIdx] = stopPos - Math.round(this.ctx.state.rng.randomFloat(0, symCount - 1));
-      }
-    }
-    for (let i = 0; i < finalReelStops.length; i++) {
-      if (finalReelStops[i] === null) {
-        finalReelStops[i] = Math.floor(
-          this.ctx.state.rng.randomFloat(0, reels[i].length - 1)
-        );
-      }
-    }
-    for (let ridx = 0; ridx < this.ctx.getCurrentGameMode().reelsAmount; ridx++) {
-      const reelPos = finalReelStops[ridx];
-      if (this.ctx.config.padSymbols && this.ctx.config.padSymbols > 0) {
-        for (let p = this.ctx.config.padSymbols - 1; p >= 0; p--) {
-          const topPos = (reelPos - (p + 1)) % reels[ridx].length;
-          this.paddingTop[ridx].push(reels[ridx][topPos]);
-          const bottomPos = (reelPos + this.ctx.getCurrentGameMode().symbolsPerReel[ridx] + p) % reels[ridx].length;
-          this.paddingBottom[ridx].unshift(reels[ridx][bottomPos]);
-        }
-      }
-      for (let row = 0; row < this.ctx.getCurrentGameMode().symbolsPerReel[ridx]; row++) {
-        const symbol = reels[ridx][(reelPos + row) % reels[ridx].length];
-        if (!symbol) {
-          throw new Error(`Failed to get symbol at pos ${reelPos + row} on reel ${ridx}`);
-        }
-        this.reels[ridx][row] = symbol;
-      }
-    }
+  /**
+   * Gets the current tumble win amount of the ongoing spin.
+   */
+  getCurrentTumbleWin() {
+    this.ensureWallet();
+    return this.wallet.getCurrentTumbleWin();
   }
 };
-var Board = class extends GameState {
-  board;
-  constructor(opts) {
-    super(opts);
-    this.board = {
-      reels: [],
-      paddingTop: [],
-      paddingBottom: [],
-      anticipation: []
+
+// src/game-context/index.ts
+function createGameContext(opts) {
+  const context = {
+    config: opts.config,
+    state: createGameState(opts.state),
+    services: {}
+  };
+  const getContext = () => context;
+  function createServices() {
+    return {
+      game: new GameService(getContext),
+      data: new DataService(getContext),
+      board: new BoardService(getContext),
+      wallet: new WalletService(getContext),
+      rng: new RngService(getContext),
+      ...opts.services
     };
   }
+  context.services = createServices();
+  return context;
+}
+
+// src/book/index.ts
+var Book = class _Book {
+  id;
+  criteria = "N/A";
+  events = [];
+  payout = 0;
+  basegameWins = 0;
+  freespinsWins = 0;
+  constructor(opts) {
+    this.id = opts.id;
+  }
   /**
-   * Resets the board to an empty state.\
-   * This is called before drawing a new board.
+   * Intended for internal use only.
    */
-  resetBoard() {
-    this.resetReels();
+  setCriteria(criteria) {
+    this.criteria = criteria;
   }
-  makeEmptyReels() {
-    return Array.from({ length: this.getCurrentGameMode().reelsAmount }, () => []);
-  }
-  resetReels() {
-    this.board.reels = this.makeEmptyReels();
-    this.board.anticipation = Array.from(
-      { length: this.getCurrentGameMode().reelsAmount },
-      () => 0
-    );
-    if (this.config.padSymbols && this.config.padSymbols > 0) {
-      this.board.paddingTop = this.makeEmptyReels();
-      this.board.paddingBottom = this.makeEmptyReels();
-    }
+  /**
+   * Adds an event to the book.
+   */
+  addEvent(event) {
+    const index = this.events.length + 1;
+    this.events.push({ index, ...event });
   }
   /**
-   * Counts how many symbols matching the criteria are on a specific reel.
+   * Intended for internal use only.
    */
-  countSymbolsOnReel(symbolOrProperties, reelIndex) {
-    let total = 0;
-    for (const symbol of this.board.reels[reelIndex]) {
-      let matches = true;
-      if (symbolOrProperties instanceof GameSymbol) {
-        if (symbol.id !== symbolOrProperties.id) matches = false;
-      } else {
-        for (const [key, value] of Object.entries(symbolOrProperties)) {
-          if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
-            matches = false;
-            break;
-          }
-        }
-      }
-      if (matches) {
-        total++;
-      }
-    }
-    return total;
+  serialize() {
+    return {
+      id: this.id,
+      criteria: this.criteria,
+      events: this.events,
+      payout: this.payout,
+      basegameWins: this.basegameWins,
+      freespinsWins: this.freespinsWins
+    };
   }
   /**
-   * Counts how many symbols matching the criteria are on the board.
-   *
-   * Passing a GameSymbol will compare by ID, passing a properties object will compare by properties.
-   *
-   * Returns a tuple where the first element is the total count, and the second element is a record of counts per reel index.
+   * Intended for internal use only.
    */
-  countSymbolsOnBoard(symbolOrProperties) {
-    let total = 0;
-    const onReel = {};
-    for (const [ridx, reel] of this.board.reels.entries()) {
-      for (const symbol of reel) {
-        let matches = true;
-        if (symbolOrProperties instanceof GameSymbol) {
-          if (symbol.id !== symbolOrProperties.id) matches = false;
-        } else {
-          for (const [key, value] of Object.entries(symbolOrProperties)) {
-            if (!symbol.properties.has(key) || symbol.properties.get(key) !== value) {
-              matches = false;
-              break;
-            }
-          }
-        }
-        if (matches) {
-          total++;
-          if (onReel[ridx] === void 0) {
-            onReel[ridx] = 1;
-          } else {
-            onReel[ridx]++;
-          }
-        }
-      }
-    }
-    return [total, onReel];
+  static fromSerialized(data) {
+    const book = new _Book({ id: data.id, criteria: data.criteria });
+    book.events = data.events;
+    book.payout = data.payout;
+    book.basegameWins = data.basegameWins;
+    book.freespinsWins = data.freespinsWins;
+    return book;
+  }
+};
+
+// src/recorder/index.ts
+var Recorder = class {
+  records;
+  pendingRecords;
+  constructor() {
+    this.records = [];
+    this.pendingRecords = [];
   }
+};
+
+// src/wallet/index.ts
+var Wallet = class {
   /**
-   * Checks if a symbol appears more than once on any reel in the current reel set.
+   * Total win amount (as the bet multiplier) from all simulations.
+   */
+  cumulativeWins = 0;
+  /**
+   * Total win amount (as the bet multiplier) per spin type.
    *
-   * Useful to check for "forbidden" generations, e.g. 2 scatters on one reel.
+   * @example
+   * ```ts
+   * {
+   *   basegame: 50,
+   *   freespins: 100,
+   *   superfreespins: 200,
+   * }
+   * ```
    */
-  isSymbolOnAnyReelMultipleTimes(symbol) {
-    for (const reel of this.board.reels) {
-      let count = 0;
-      for (const sym of reel) {
-        if (sym.id === symbol.id) {
-          count++;
-        }
-        if (count > 1) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
+  cumulativeWinsPerSpinType = {
+    [SPIN_TYPE.BASE_GAME]: 0,
+    [SPIN_TYPE.FREE_SPINS]: 0
+  };
   /**
-   * Gets all reel stops (positions) where the specified symbol appears in the current reel set.\
-   * Returns an array of arrays, where each inner array contains the positions for the corresponding reel.
+   * Current win amount (as the bet multiplier) for the ongoing simulation.
    */
-  getReelStopsForSymbol(reels, symbol) {
-    const reelStops = [];
-    for (let ridx = 0; ridx < reels.length; ridx++) {
-      const reel = reels[ridx];
-      const positions = [];
-      for (let pos = 0; pos < reel.length; pos++) {
-        if (reel[pos].id === symbol.id) {
-          positions.push(pos);
-        }
-      }
-      reelStops.push(positions);
-    }
-    return reelStops;
-  }
+  currentWin = 0;
   /**
-   * Combines multiple arrays of reel stops into a single array of reel stops.\
+   * Current win amount (as the bet multiplier) for the ongoing simulation per spin type.
+   *
+   * @example
+   * ```ts
+   * {
+   *   basegame: 50,
+   *   freespins: 100,
+   *   superfreespins: 200,
+   * }
+   * ```
    */
-  combineReelStops(...reelStops) {
-    const combined = [];
-    for (let ridx = 0; ridx < this.getCurrentGameMode().reelsAmount; ridx++) {
-      combined[ridx] = [];
-      for (const stops of reelStops) {
-        combined[ridx] = combined[ridx].concat(stops[ridx]);
-      }
-    }
-    return combined;
+  currentWinPerSpinType = {
+    [SPIN_TYPE.BASE_GAME]: 0,
+    [SPIN_TYPE.FREE_SPINS]: 0
+  };
+  /**
+   * Holds the current win amount for a single (free) spin.\
+   * After each spin, this amount is added to `currentWinPerSpinType` and then reset to zero.
+   */
+  currentSpinWin = 0;
+  /**
+   * Current win amount (as the bet multiplier) for the ongoing tumble sequence.
+   */
+  currentTumbleWin = 0;
+  constructor() {
   }
   /**
-   * From a list of reel stops on reels, selects a random stop for a speficied number of random symbols.
+   * Updates the win for the current spin.
    *
-   * Mostly useful for placing scatter symbols on the board.
+   * Should be called after each tumble event, if applicable.\
+   * Or generally call this to add wins during a spin.
+   *
+   * After each (free) spin, this amount should be added to `currentWinPerSpinType` via `confirmSpinWin()`
    */
-  getRandomReelStops(reels, reelStops, amount) {
-    const reelsAmount = this.getCurrentGameMode().reelsAmount;
-    const symProbsOnReels = [];
-    const stopPositionsForReels = {};
-    for (let ridx = 0; ridx < reelsAmount; ridx++) {
-      symProbsOnReels.push(reelStops[ridx].length / reels[ridx].length);
-    }
-    while (Object.keys(stopPositionsForReels).length !== amount) {
-      const possibleReels = [];
-      for (let i = 0; i < reelsAmount; i++) {
-        if (symProbsOnReels[i] > 0) {
-          possibleReels.push(i);
-        }
-      }
-      const possibleProbs = symProbsOnReels.filter((p) => p > 0);
-      const weights = Object.fromEntries(
-        possibleReels.map((ridx, idx) => [ridx, possibleProbs[idx]])
-      );
-      const chosenReel = weightedRandom(weights, this.state.rng);
-      const chosenStop = randomItem(reelStops[Number(chosenReel)], this.state.rng);
-      symProbsOnReels[Number(chosenReel)] = 0;
-      stopPositionsForReels[chosenReel] = chosenStop;
-    }
-    return stopPositionsForReels;
+  addSpinWin(amount) {
+    this.currentSpinWin += amount;
   }
   /**
-   * Selects a random reel set based on the configured weights of the current result set.\
-   * Returns the reels as arrays of GameSymbols.
+   * Confirms the wins of the current spin.
+   *
+   * Should be called after `addSpinWin()`, and after your tumble events are played out,\
+   * and after a (free) spin is played out to finalize the win.
    */
-  getRandomReelset() {
-    const weights = this.state.currentResultSet.reelWeights;
-    const evalWeights = this.state.currentResultSet.reelWeights.evaluate?.(
-      this
-    );
-    let reelSetId = "";
-    if (evalWeights) {
-      reelSetId = weightedRandom(evalWeights, this.state.rng);
-    } else {
-      reelSetId = weightedRandom(weights[this.state.currentSpinType], this.state.rng);
+  confirmSpinWin(spinType) {
+    if (!Object.keys(this.currentWinPerSpinType).includes(spinType)) {
+      throw new Error(`Spin type "${spinType}" does not exist in the wallet.`);
     }
-    const reelSet = this.getReelsetById(this.state.currentGameMode, reelSetId);
-    return reelSet;
+    this.currentWinPerSpinType[spinType] += this.currentSpinWin;
+    this.currentWin += this.currentSpinWin;
+    this.currentSpinWin = 0;
+    this.currentTumbleWin = 0;
   }
   /**
-   * Draws a board using specified reel stops.
+   * Returns the accumulated win amount (as the bet multiplier) from all simulations.
    */
-  drawBoardWithForcedStops(reels, forcedStops) {
-    this.drawBoardMixed(reels, forcedStops);
+  getCumulativeWins() {
+    return this.cumulativeWins;
   }
   /**
-   * Draws a board using random reel stops.
+   * Returns the accumulated win amount (as the bet multiplier) per spin type from all simulations.
    */
-  drawBoardWithRandomStops(reels) {
-    this.drawBoardMixed(reels);
-  }
-  drawBoardMixed(reels, forcedStops) {
-    this.resetReels();
-    const finalReelStops = Array.from(
-      { length: this.getCurrentGameMode().reelsAmount },
-      () => null
-    );
-    if (forcedStops) {
-      for (const [r, stopPos] of Object.entries(forcedStops)) {
-        const reelIdx = Number(r);
-        const symCount = this.getCurrentGameMode().symbolsPerReel[reelIdx];
-        finalReelStops[reelIdx] = stopPos - Math.round(this.state.rng.randomFloat(0, symCount - 1));
-        if (finalReelStops[reelIdx] < 0) {
-          finalReelStops[reelIdx] = reels[reelIdx].length + finalReelStops[reelIdx];
-        }
-      }
-    }
-    for (let i = 0; i < finalReelStops.length; i++) {
-      if (finalReelStops[i] === null) {
-        finalReelStops[i] = Math.floor(
-          this.state.rng.randomFloat(0, reels[i].length - 1)
-        );
-      }
-    }
-    for (let ridx = 0; ridx < this.getCurrentGameMode().reelsAmount; ridx++) {
-      const reelPos = finalReelStops[ridx];
-      if (this.config.padSymbols && this.config.padSymbols > 0) {
-        for (let p = this.config.padSymbols - 1; p >= 0; p--) {
-          const topPos = (reelPos - (p + 1)) % reels[ridx].length;
-          this.board.paddingTop[ridx].push(reels[ridx][topPos]);
-          const bottomPos = (reelPos + this.getCurrentGameMode().symbolsPerReel[ridx] + p) % reels[ridx].length;
-          this.board.paddingBottom[ridx].unshift(reels[ridx][bottomPos]);
-        }
-      }
-      for (let row = 0; row < this.getCurrentGameMode().symbolsPerReel[ridx]; row++) {
-        const symbol = reels[ridx][(reelPos + row) % reels[ridx].length];
-        if (!symbol) {
-          throw new Error(`Failed to get symbol at pos ${reelPos + row} on reel ${ridx}`);
-        }
-        this.board.reels[ridx][row] = symbol;
-      }
-    }
-  }
-};
-
-// src/WinType.ts
-var WinType = class {
-  payout;
-  winCombinations;
-  ctx;
-  wildSymbol;
-  constructor(opts) {
-    this.payout = 0;
-    this.winCombinations = [];
-    this.wildSymbol = opts?.wildSymbol;
+  getCumulativeWinsPerSpinType() {
+    return this.cumulativeWinsPerSpinType;
   }
   /**
-   * Sets the simulation context for this WinType instance.
-   * 
-   * This gives the WinType access to the current board.
+   * Returns the current win amount (as the bet multiplier) for the ongoing simulation.
    */
-  context(ctx) {
-    this.ctx = ctx;
-    return this;
+  getCurrentWin() {
+    return this.currentWin;
   }
-  ensureContext() {
-    if (!this.ctx) {
-      throw new Error("WinType context is not set. Call context(ctx) first.");
-    }
+  /**
+   * Returns the current spin win amount (as the bet multiplier) for the ongoing simulation.
+   */
+  getCurrentSpinWin() {
+    return this.currentSpinWin;
   }
   /**
-   * Implementation of win evaluation logic. Sets `this.payout` and `this.winCombinations`.
+   * Returns the current tumble win amount (as the bet multiplier) for the ongoing simulation.
    */
-  evaluateWins() {
-    this.ensureContext();
-    return this;
+  getCurrentTumbleWin() {
+    return this.currentTumbleWin;
   }
   /**
-   * Custom post-processing of wins, e.g. for handling multipliers.
+   * Returns the current win amount (as the bet multiplier) per spin type for the ongoing simulation.
    */
-  postProcess(func) {
-    this.ensureContext();
-    const result = func(this, this.ctx);
-    this.payout = result.payout;
-    this.winCombinations = result.winCombinations;
-    return this;
+  getCurrentWinPerSpinType() {
+    return this.currentWinPerSpinType;
   }
   /**
-   * Returns the total payout and detailed win combinations.
+   * Adds a win to `currentSpinWin` and `currentTumbleWin`.
+   *
+   * After each (free) spin, this amount should be added to `currentWinPerSpinType` via `confirmSpinWin()`
    */
-  getWins() {
-    return {
-      payout: this.payout,
-      winCombinations: this.winCombinations
-    };
+  addTumbleWin(amount) {
+    this.currentTumbleWin += amount;
+    this.addSpinWin(amount);
   }
-};
-
-// src/winTypes/LinesWinType.ts
-var LinesWinType = class extends WinType {
-  lines;
-  constructor(opts) {
-    super(opts);
-    this.lines = opts.lines;
-    if (Object.keys(this.lines).length === 0) {
-      throw new Error("LinesWinType must have at least one line defined.");
+  /**
+   * Intended for internal use only.
+   * 
+   * Resets the current win amounts to zero.
+   */
+  resetCurrentWin() {
+    this.currentWin = 0;
+    this.currentSpinWin = 0;
+    this.currentTumbleWin = 0;
+    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
+      this.currentWinPerSpinType[spinType] = 0;
     }
   }
-  validateConfig() {
-    const reelsAmount = this.ctx.getCurrentGameMode().reelsAmount;
-    const symsPerReel = this.ctx.getCurrentGameMode().symbolsPerReel;
-    for (const [lineNum, positions] of Object.entries(this.lines)) {
-      if (positions.length !== reelsAmount) {
-        throw new Error(
-          `Line ${lineNum} has ${positions.length} positions, but the current game mode has ${reelsAmount} reels.`
-        );
-      }
-      for (let i = 0; i < positions.length; i++) {
-        if (positions[i] < 0 || positions[i] >= symsPerReel[i]) {
-          throw new Error(
-            `Line ${lineNum} has an invalid position ${positions[i]} on reel ${i}. Valid range is 0 to ${symsPerReel[i] - 1}.`
-          );
-        }
-      }
+  /**
+   * Intended for internal use only.
+   * 
+   * Adds current wins to cumulative wins and resets current wins to zero.
+   */
+  confirmWins(ctx) {
+    function process2(number) {
+      return Math.round(Math.min(number, ctx.config.maxWinX) * 100) / 100;
     }
-    const firstLine = Math.min(...Object.keys(this.lines).map(Number));
-    if (firstLine !== 1) {
+    this.currentWin = process2(this.currentWin);
+    this.cumulativeWins += this.currentWin;
+    let spinTypeWins = 0;
+    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
+      const st = spinType;
+      const spinTypeWin = process2(this.currentWinPerSpinType[st]);
+      this.cumulativeWinsPerSpinType[st] += spinTypeWin;
+      spinTypeWins += spinTypeWin;
+    }
+    if (process2(spinTypeWins) !== this.currentWin) {
       throw new Error(
-        `Lines must start from 1. Found line ${firstLine} as the first line.`
+        `Inconsistent wallet state: currentWin (${this.currentWin}) does not equal spinTypeWins (${spinTypeWins}).`
       );
     }
+    this.resetCurrentWin();
   }
-  isWild(symbol) {
-    return !!this.wildSymbol && symbol.compare(this.wildSymbol);
+  /**
+   * Intended for internal use only.
+   *
+   * Transfers the win data from the given wallet to the calling book.
+   */
+  writePayoutToBook(ctx) {
+    function process2(number) {
+      return Math.round(Math.min(number, ctx.config.maxWinX) * 100) / 100;
+    }
+    const wallet = ctx.services.wallet._getWallet();
+    const book = ctx.services.data._getBook();
+    book.payout = Math.round(process2(wallet.getCurrentWin()) * 100);
+    book.basegameWins = process2(
+      wallet.getCurrentWinPerSpinType()[SPIN_TYPE.BASE_GAME] || 0
+    );
+    book.freespinsWins = process2(
+      wallet.getCurrentWinPerSpinType()[SPIN_TYPE.FREE_SPINS] || 0
+    );
   }
-  evaluateWins() {
-    this.ensureContext();
-    this.validateConfig();
-    const lineWins = [];
-    let payout = 0;
-    const reels = this.ctx.board.reels;
-    const reelsAmount = this.ctx.getCurrentGameMode().reelsAmount;
-    for (const [lineNumStr, lineDef] of Object.entries(this.lines)) {
-      const lineNum = Number(lineNumStr);
-      let baseSymbol = null;
-      let leadingWilds = 0;
-      const chain = [];
-      const details = [];
-      for (let ridx = 0; ridx < reelsAmount; ridx++) {
-        const rowIdx = lineDef[ridx];
-        const sym = reels[ridx][rowIdx];
-        if (!sym) throw new Error("Encountered an invalid symbol while evaluating wins.");
-        const wild = this.isWild(sym);
-        if (ridx === 0) {
-          chain.push(sym);
-          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: wild });
-          if (wild) leadingWilds++;
-          else baseSymbol = sym;
-          continue;
-        }
-        if (wild) {
-          chain.push(sym);
-          details.push({
-            reelIndex: ridx,
-            posIndex: rowIdx,
-            symbol: sym,
-            isWild: true,
-            substitutedFor: baseSymbol || void 0
-          });
-          continue;
-        }
-        if (!baseSymbol) {
-          baseSymbol = sym;
-          chain.push(sym);
-          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: false });
-          continue;
-        }
-        if (sym.id === baseSymbol.id) {
-          chain.push(sym);
-          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: false });
-          continue;
-        }
-        break;
-      }
-      if (chain.length === 0) continue;
-      const allWild = chain.every((s) => this.isWild(s));
-      const wildRepresentative = this.wildSymbol instanceof GameSymbol ? this.wildSymbol : null;
-      const len = chain.length;
-      let bestPayout = 0;
-      let bestType = null;
-      let payingSymbol = null;
-      if (baseSymbol?.pays && baseSymbol.pays[len]) {
-        bestPayout = baseSymbol.pays[len];
-        bestType = "substituted";
-        payingSymbol = baseSymbol;
-      }
-      if (allWild && wildRepresentative?.pays && wildRepresentative.pays[len]) {
-        const wildPay = wildRepresentative.pays[len];
-        if (wildPay > bestPayout) {
-          bestPayout = wildPay;
-          bestType = "pure-wild";
-          payingSymbol = wildRepresentative;
-        }
-      }
-      if (!bestPayout || !bestType || !payingSymbol) continue;
-      const minLen = payingSymbol.pays ? Math.min(...Object.keys(payingSymbol.pays).map(Number)) : Infinity;
-      if (len < minLen) continue;
-      const wildCount = details.filter((d) => d.isWild).length;
-      const nonWildCount = len - wildCount;
-      lineWins.push({
-        lineNumber: lineNum,
-        kind: len,
-        payout: bestPayout,
-        symbol: payingSymbol,
-        winType: bestType,
-        substitutedBaseSymbol: bestType === "pure-wild" ? null : baseSymbol,
-        symbols: details,
-        stats: { wildCount, nonWildCount, leadingWilds }
-      });
-      payout += bestPayout;
+  /**
+   * Intended for internal use only.
+   */
+  serialize() {
+    return {
+      cumulativeWins: this.cumulativeWins,
+      cumulativeWinsPerSpinType: this.cumulativeWinsPerSpinType,
+      currentWin: this.currentWin,
+      currentWinPerSpinType: this.currentWinPerSpinType,
+      currentSpinWin: this.currentSpinWin,
+      currentTumbleWin: this.currentTumbleWin
+    };
+  }
+  /**
+   * Intended for internal use only.
+   */
+  merge(wallet) {
+    this.cumulativeWins += wallet.getCumulativeWins();
+    const otherWinsPerSpinType = wallet.getCumulativeWinsPerSpinType();
+    for (const spinType of Object.keys(this.cumulativeWinsPerSpinType)) {
+      this.cumulativeWinsPerSpinType[spinType] += otherWinsPerSpinType[spinType] || 0;
     }
-    for (const win of lineWins) {
-      this.ctx.recordSymbolOccurrence({
-        kind: win.kind,
-        symbolId: win.symbol.id,
-        spinType: this.ctx.state.currentSpinType
-      });
+  }
+  /**
+   * Intended for internal use only.
+   */
+  mergeSerialized(data) {
+    this.cumulativeWins += data.cumulativeWins;
+    for (const spinType of Object.keys(this.cumulativeWinsPerSpinType)) {
+      this.cumulativeWinsPerSpinType[spinType] += data.cumulativeWinsPerSpinType[spinType] || 0;
+    }
+    this.currentWin += data.currentWin;
+    this.currentSpinWin += data.currentSpinWin;
+    this.currentTumbleWin += data.currentTumbleWin;
+    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
+      this.currentWinPerSpinType[spinType] += data.currentWinPerSpinType[spinType] || 0;
     }
-    this.payout = payout;
-    this.winCombinations = lineWins;
-    return this;
   }
 };
 
-// src/winTypes/ClusterWinType.ts
-var ClusterWinType = class extends WinType {
-};
-
-// src/winTypes/ManywaysWinType.ts
-var ManywaysWinType = class extends WinType {
-};
-
-// src/optimizer/OptimizationConditions.ts
-var import_assert4 = __toESM(require("assert"));
-var OptimizationConditions = class {
-  rtp;
-  avgWin;
-  hitRate;
-  searchRange;
-  forceSearch;
-  priority;
-  constructor(opts) {
-    let { rtp, avgWin, hitRate, searchConditions, priority } = opts;
-    if (rtp == void 0 || rtp === "x") {
-      (0, import_assert4.default)(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;
+// src/simulation/index.ts
+var completedSimulations = 0;
+var TEMP_FILENAME = "__temp_compiled_src_IGNORE.js";
+var Simulation = class {
+  gameConfigOpts;
+  gameConfig;
+  simRunsAmount;
+  concurrency;
+  debug = false;
+  actualSims = 0;
+  library;
+  recorder;
+  wallet;
+  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)(
+      Object.values(this.gameConfig.gameModes).map((m) => gameModeKeys.includes(m.name)).every((v) => v === true),
+      "Game mode name must match its key in the gameModes object."
+    );
+    if (import_worker_threads.isMainThread) {
+      this.preprocessFiles();
     }
-    let noneCount = 0;
-    for (const val of [rtp, avgWin, hitRate]) {
-      if (val === void 0) noneCount++;
+  }
+  async runSimulation(opts) {
+    const debug = opts.debug || false;
+    this.debug = debug;
+    const gameModesToSimulate = Object.keys(this.simRunsAmount);
+    const configuredGameModes = Object.keys(this.gameConfig.gameModes);
+    if (gameModesToSimulate.length === 0) {
+      throw new Error("No game modes configured for simulation.");
     }
-    (0, import_assert4.default)(noneCount <= 1, "Invalid combination of optimization conditions.");
-    this.searchRange = [-1, -1];
-    this.forceSearch = {};
-    if (typeof searchConditions === "number") {
-      this.searchRange = [searchConditions, searchConditions];
-    }
-    if (Array.isArray(searchConditions)) {
-      if (searchConditions[0] > searchConditions[1] || searchConditions.length !== 2) {
-        throw new Error("Invalid searchConditions range.");
-      }
-      this.searchRange = searchConditions;
-    }
-    if (typeof searchConditions === "object" && !Array.isArray(searchConditions)) {
-      this.searchRange = [-1, -1];
-      this.forceSearch = searchConditions;
-    }
-    this.rtp = rtp;
-    this.avgWin = avgWin;
-    this.hitRate = hitRate;
-    this.priority = priority;
-  }
-  getRtp() {
-    return this.rtp;
-  }
-  getAvgWin() {
-    return this.avgWin;
-  }
-  getHitRate() {
-    return this.hitRate;
-  }
-  getSearchRange() {
-    return this.searchRange;
-  }
-  getForceSearch() {
-    return this.forceSearch;
-  }
-};
-
-// src/optimizer/OptimizationScaling.ts
-var OptimizationScaling = class {
-  config;
-  constructor(opts) {
-    this.config = opts;
-  }
-  getConfig() {
-    return this.config;
-  }
-};
-
-// src/optimizer/OptimizationParameters.ts
-var OptimizationParameters = class _OptimizationParameters {
-  parameters;
-  constructor(opts) {
-    this.parameters = {
-      ..._OptimizationParameters.DEFAULT_PARAMETERS,
-      ...opts
-    };
-  }
-  static DEFAULT_PARAMETERS = {
-    numShowPigs: 5e3,
-    numPigsPerFence: 1e4,
-    threadsFenceConstruction: 16,
-    threadsShowConstruction: 16,
-    testSpins: [50, 100, 200],
-    testSpinsWeights: [0.3, 0.4, 0.3],
-    simulationTrials: 5e3,
-    graphIndexes: [],
-    run1000Batch: false,
-    minMeanToMedian: 4,
-    maxMeanToMedian: 8,
-    pmbRtp: 1,
-    scoreType: "rtp"
-  };
-  getParameters() {
-    return this.parameters;
-  }
-};
-
-// src/Simulation.ts
-var import_fs3 = __toESM(require("fs"));
-var import_path2 = __toESM(require("path"));
-var import_assert5 = __toESM(require("assert"));
-var import_zlib = __toESM(require("zlib"));
-var import_esbuild = require("esbuild");
-var import_worker_threads2 = require("worker_threads");
-var completedSimulations = 0;
-var TEMP_FILENAME = "__temp_compiled_src_IGNORE.js";
-var Simulation = class _Simulation {
-  gameConfigOpts;
-  gameConfig;
-  simRunsAmount;
-  concurrency;
-  wallet;
-  library;
-  records;
-  debug = false;
-  constructor(opts, gameConfigOpts) {
-    this.gameConfig = new GameConfig(gameConfigOpts);
-    this.gameConfigOpts = gameConfigOpts;
-    this.simRunsAmount = opts.simRunsAmount || {};
-    this.concurrency = (opts.concurrency || 6) >= 2 ? opts.concurrency || 6 : 2;
-    this.wallet = new Wallet();
-    this.library = /* @__PURE__ */ new Map();
-    this.records = [];
-    const gameModeKeys = Object.keys(this.gameConfig.config.gameModes);
-    (0, import_assert5.default)(
-      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."
-    );
-    if (import_worker_threads2.isMainThread) {
-      this.preprocessFiles();
-    }
-  }
-  async runSimulation(opts) {
-    const debug = opts.debug || false;
-    this.debug = debug;
-    const gameModesToSimulate = Object.keys(this.simRunsAmount);
-    const configuredGameModes = Object.keys(this.gameConfig.config.gameModes);
-    if (gameModesToSimulate.length === 0) {
-      throw new Error("No game modes configured for simulation.");
-    }
-    this.gameConfig.generateReelsetFiles();
-    if (import_worker_threads2.isMainThread) {
+    this.generateReelsetFiles();
+    if (import_worker_threads.isMainThread) {
       const debugDetails = {};
       for (const mode of gameModesToSimulate) {
         completedSimulations = 0;
         this.wallet = new Wallet();
         this.library = /* @__PURE__ */ new Map();
+        this.recorder = new Recorder();
         debugDetails[mode] = {};
         console.log(`
 Simulating game mode: ${mode}`);
@@ -1971,40 +1448,17 @@ Simulating game mode: ${mode}`);
         const simNumsToCriteria = ResultSet.assignCriteriaToSimulations(this, mode);
         await this.spawnWorkersForGameMode({ mode, simNumsToCriteria });
         createDirIfNotExists(
-          import_path2.default.join(
-            process.cwd(),
-            this.gameConfig.config.outputDir,
-            "optimization_files"
-          )
+          import_path.default.join(process.cwd(), this.gameConfig.outputDir, "optimization_files")
         );
         createDirIfNotExists(
-          import_path2.default.join(process.cwd(), this.gameConfig.config.outputDir, "publish_files")
+          import_path.default.join(process.cwd(), this.gameConfig.outputDir, "publish_files")
         );
-        _Simulation.writeLookupTableCSV({
-          gameMode: mode,
-          library: this.library,
-          gameConfig: this.gameConfig.config
-        });
-        _Simulation.writeLookupTableSegmentedCSV({
-          gameMode: mode,
-          library: this.library,
-          gameConfig: this.gameConfig.config
-        });
-        _Simulation.writeRecords({
-          gameMode: mode,
-          records: this.records,
-          gameConfig: this.gameConfig.config,
-          debug: this.debug
-        });
-        await _Simulation.writeBooksJson({
-          gameMode: mode,
-          library: this.library,
-          gameConfig: this.gameConfig.config
-        });
-        _Simulation.writeIndexJson({
-          gameConfig: this.gameConfig.config
-        });
-        debugDetails[mode].rtp = this.wallet.getCumulativeWins() / (runs * this.gameConfig.config.gameModes[mode].cost);
+        this.writeLookupTableCSV(mode);
+        this.writeLookupTableSegmentedCSV(mode);
+        this.writeRecords(mode);
+        await this.writeBooksJson(mode);
+        this.writeIndexJson();
+        debugDetails[mode].rtp = this.wallet.getCumulativeWins() / (runs * this.gameConfig.gameModes[mode].cost);
         debugDetails[mode].wins = this.wallet.getCumulativeWins();
         debugDetails[mode].winsPerSpinType = this.wallet.getCumulativeWinsPerSpinType();
         console.timeEnd(mode);
@@ -2015,27 +1469,26 @@ Simulating game mode: ${mode}`);
     let desiredSims = 0;
     let actualSims = 0;
     const criteriaToRetries = {};
-    if (!import_worker_threads2.isMainThread) {
-      const { mode, simStart, simEnd, index } = import_worker_threads2.workerData;
+    if (!import_worker_threads.isMainThread) {
+      const { mode, simStart, simEnd, index } = import_worker_threads.workerData;
       const simNumsToCriteria = ResultSet.assignCriteriaToSimulations(this, mode);
       for (let simId = simStart; simId <= simEnd; simId++) {
         if (this.debug) desiredSims++;
         const criteria = simNumsToCriteria[simId] || "N/A";
-        const ctx = new SimulationContext(this.gameConfigOpts);
         if (!criteriaToRetries[criteria]) {
           criteriaToRetries[criteria] = 0;
         }
-        ctx.runSingleSimulation({ simId, mode, criteria, index });
+        this.runSingleSimulation({ simId, mode, criteria, index });
         if (this.debug) {
-          criteriaToRetries[criteria] += ctx.actualSims - 1;
-          actualSims += ctx.actualSims;
+          criteriaToRetries[criteria] += this.actualSims - 1;
+          actualSims += this.actualSims;
         }
       }
       if (this.debug) {
         console.log(`Desired ${desiredSims}, Actual ${actualSims}`);
         console.log(`Retries per criteria:`, criteriaToRetries);
       }
-      import_worker_threads2.parentPort?.postMessage({
+      import_worker_threads.parentPort?.postMessage({
         type: "done",
         workerNum: index
       });
@@ -2051,7 +1504,7 @@ Simulating game mode: ${mode}`);
     await Promise.all(
       simRangesPerChunk.map(([simStart, simEnd], index) => {
         return this.callWorker({
-          basePath: this.gameConfig.config.outputDir,
+          basePath: this.gameConfig.outputDir,
           mode,
           simStart,
           simEnd,
@@ -2074,8 +1527,8 @@ Simulating game mode: ${mode}`);
       }
     }
     return new Promise((resolve, reject) => {
-      const scriptPath = import_path2.default.join(process.cwd(), basePath, TEMP_FILENAME);
-      const worker = new import_worker_threads2.Worker(scriptPath, {
+      const scriptPath = import_path.default.join(process.cwd(), basePath, TEMP_FILENAME);
+      const worker = new import_worker_threads.Worker(scriptPath, {
         workerData: {
           mode,
           simStart,
@@ -2091,7 +1544,7 @@ Simulating game mode: ${mode}`);
             logArrowProgress(completedSimulations, totalSims);
           }
           const book = Book.fromSerialized(msg.book);
-          this.library.set(book.id.toString(), book);
+          this.library.set(book.id, book);
           this.wallet.mergeSerialized(msg.wallet);
           this.mergeRecords(msg.records);
         } else if (msg.type === "done") {
@@ -2109,91 +1562,169 @@ Simulating game mode: ${mode}`);
       });
     });
   }
+  /**
+   * Will run a single simulation until the specified criteria is met.
+   */
+  runSingleSimulation(opts) {
+    const { simId, mode, criteria } = opts;
+    const ctx = createGameContext({
+      config: this.gameConfig
+    });
+    ctx.state.currentGameMode = mode;
+    ctx.state.currentSimulationId = simId;
+    ctx.state.isCriteriaMet = false;
+    const resultSet = ctx.services.game.getResultSetByCriteria(
+      ctx.state.currentGameMode,
+      criteria
+    );
+    while (!ctx.state.isCriteriaMet) {
+      this.actualSims++;
+      this.resetSimulation(ctx);
+      ctx.state.currentResultSet = resultSet;
+      this.handleGameFlow(ctx);
+      if (resultSet.meetsCriteria(ctx)) {
+        ctx.state.isCriteriaMet = true;
+      }
+    }
+    ctx.services.wallet._getWallet().writePayoutToBook(ctx);
+    ctx.services.wallet._getWallet().confirmWins(ctx);
+    if (ctx.services.data._getBook().payout >= ctx.config.maxWinX) {
+      ctx.state.triggeredMaxWin = true;
+    }
+    ctx.services.data.record({
+      criteria: resultSet.criteria
+    });
+    ctx.config.hooks.onSimulationAccepted?.(ctx);
+    this.confirmRecords(ctx);
+    import_worker_threads.parentPort?.postMessage({
+      type: "complete",
+      simId,
+      book: ctx.services.data._getBook().serialize(),
+      wallet: ctx.services.wallet._getWallet().serialize(),
+      records: ctx.services.data._getRecords()
+    });
+  }
+  /**
+   * If a simulation does not meet the required criteria, reset the state to run it again.
+   *
+   * This also runs once before each simulation to ensure a clean state.
+   */
+  resetSimulation(ctx) {
+    this.resetState(ctx);
+    ctx.services.board.resetBoard();
+    ctx.services.data._setRecorder(new Recorder());
+    ctx.services.wallet._setWallet(new Wallet());
+    ctx.services.data._setBook(
+      new Book({
+        id: ctx.state.currentSimulationId,
+        criteria: ctx.state.currentResultSet.criteria
+      })
+    );
+  }
+  resetState(ctx) {
+    ctx.services.rng.setSeedIfDifferent(ctx.state.currentSimulationId);
+    ctx.state.currentSpinType = SPIN_TYPE.BASE_GAME;
+    ctx.state.currentFreespinAmount = 0;
+    ctx.state.totalFreespinAmount = 0;
+    ctx.state.triggeredMaxWin = false;
+    ctx.state.triggeredFreespins = false;
+    ctx.state.userData = ctx.config.userState || {};
+  }
+  /**
+   * Contains and executes the entire game logic:
+   * - Drawing the board
+   * - Evaluating wins
+   * - Updating wallet
+   * - Handling free spins
+   * - Recording events
+   *
+   * You can customize the game flow by implementing the `onHandleGameFlow` hook in the game configuration.
+   */
+  handleGameFlow(ctx) {
+    this.gameConfig.hooks.onHandleGameFlow(ctx);
+  }
   /**
    * Creates a CSV file in the format "simulationId,weight,payout".
    *
    * `weight` defaults to 1.
    */
-  static writeLookupTableCSV(opts) {
-    const { gameMode, library, gameConfig } = opts;
+  writeLookupTableCSV(gameMode) {
     const rows = [];
-    for (const [bookId, book] of library.entries()) {
-      rows.push(`${book.id},1,${Math.round(book.getPayout())}`);
+    for (const [bookId, book] of this.library.entries()) {
+      rows.push(`${book.id},1,${Math.round(book.payout)}`);
     }
     rows.sort((a, b) => Number(a.split(",")[0]) - Number(b.split(",")[0]));
     let outputFileName = `lookUpTable_${gameMode}.csv`;
-    let outputFilePath = import_path2.default.join(gameConfig.outputDir, outputFileName);
+    let outputFilePath = import_path.default.join(this.gameConfig.outputDir, outputFileName);
     writeFile(outputFilePath, rows.join("\n"));
     outputFileName = `lookUpTable_${gameMode}_0.csv`;
-    outputFilePath = import_path2.default.join(gameConfig.outputDir, outputFileName);
+    outputFilePath = import_path.default.join(this.gameConfig.outputDir, "publish_files", outputFileName);
     writeFile(outputFilePath, rows.join("\n"));
     return outputFilePath;
   }
   /**
    * Creates a CSV file in the format "simulationId,criteria,payoutBase,payoutFreespins".
    */
-  static writeLookupTableSegmentedCSV(opts) {
-    const { gameMode, library, gameConfig } = opts;
+  writeLookupTableSegmentedCSV(gameMode) {
     const rows = [];
-    for (const [bookId, book] of library.entries()) {
-      rows.push(
-        `${book.id},${book.criteria},${book.getBasegameWins()},${book.getFreespinsWins()}`
-      );
+    for (const [bookId, book] of this.library.entries()) {
+      rows.push(`${book.id},${book.criteria},${book.basegameWins},${book.freespinsWins}`);
     }
     rows.sort((a, b) => Number(a.split(",")[0]) - Number(b.split(",")[0]));
     const outputFileName = `lookUpTableSegmented_${gameMode}.csv`;
-    const outputFilePath = import_path2.default.join(gameConfig.outputDir, outputFileName);
+    const outputFilePath = import_path.default.join(this.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 = import_path2.default.join(gameConfig.outputDir, outputFileName);
-    writeFile(outputFilePath, JSON.stringify(records, null, 2));
-    if (debug) _Simulation.logSymbolOccurrences(records);
+  writeRecords(gameMode) {
+    const outputFileName = `force_record_${gameMode}.json`;
+    const outputFilePath = import_path.default.join(this.gameConfig.outputDir, outputFileName);
+    writeFile(outputFilePath, JSON.stringify(this.recorder.records, null, 2));
+    if (this.debug) this.logSymbolOccurrences();
     return outputFilePath;
   }
-  static writeIndexJson(opts) {
-    const { gameConfig } = opts;
-    const outputFilePath = import_path2.default.join(
+  writeIndexJson() {
+    const outputFilePath = import_path.default.join(
       process.cwd(),
-      gameConfig.outputDir,
+      this.gameConfig.outputDir,
       "publish_files",
       "index.json"
     );
-    const modes = Object.entries(gameConfig.gameModes).map(([mode, modeConfig]) => ({
-      name: mode,
-      cost: modeConfig.cost,
-      events: `books_${mode}.jsonl.zst`,
-      weights: `lookUpTable_${mode}_0.csv`
-    }));
+    const modes = Object.keys(this.simRunsAmount).map((id) => {
+      const mode = this.gameConfig.gameModes[id];
+      (0, import_assert6.default)(mode, `Game mode "${id}" not found in game config.`);
+      return {
+        name: mode.name,
+        cost: mode.cost,
+        events: `books_${mode.name}.jsonl.zst`,
+        weights: `lookUpTable_${mode.name}_0.csv`
+      };
+    });
     writeFile(outputFilePath, JSON.stringify({ modes }, null, 2));
   }
-  static async writeBooksJson(opts) {
-    const { gameMode, fileNameWithoutExtension, library, gameConfig } = opts;
-    const outputFileName = fileNameWithoutExtension ? `${fileNameWithoutExtension}.jsonl` : `books_${gameMode}.jsonl`;
-    const outputFilePath = import_path2.default.join(gameConfig.outputDir, outputFileName);
-    const books = Array.from(library.values()).map((b) => b.serialize()).map((b) => ({
+  async writeBooksJson(gameMode) {
+    const outputFileName = `books_${gameMode}.jsonl`;
+    const outputFilePath = import_path.default.join(this.gameConfig.outputDir, outputFileName);
+    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 = fileNameWithoutExtension ? `${fileNameWithoutExtension}.jsonl.zst` : `books_${gameMode}.jsonl.zst`;
-    const compressedFilePath = import_path2.default.join(
+    const compressedFileName = `books_${gameMode}.jsonl.zst`;
+    const compressedFilePath = import_path.default.join(
       process.cwd(),
-      gameConfig.outputDir,
+      this.gameConfig.outputDir,
       "publish_files",
       compressedFileName
     );
-    import_fs3.default.rmSync(compressedFilePath, { force: true });
+    import_fs2.default.rmSync(compressedFilePath, { force: true });
     const compressed = import_zlib.default.zstdCompressSync(Buffer.from(contents));
-    import_fs3.default.writeFileSync(compressedFilePath, compressed);
+    import_fs2.default.writeFileSync(compressedFilePath, compressed);
   }
-  static logSymbolOccurrences(records) {
-    const validRecords = records.filter(
+  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) => {
@@ -2221,13 +1752,13 @@ Simulating game mode: ${mode}`);
    * Compiles user configured game to JS for use in different Node processes
    */
   preprocessFiles() {
-    const builtFilePath = import_path2.default.join(this.gameConfig.config.outputDir, TEMP_FILENAME);
-    import_fs3.default.rmSync(builtFilePath, { force: true });
+    const builtFilePath = import_path.default.join(this.gameConfig.outputDir, TEMP_FILENAME);
+    import_fs2.default.rmSync(builtFilePath, { force: true });
     (0, import_esbuild.buildSync)({
       entryPoints: [process.cwd()],
       bundle: true,
       platform: "node",
-      outfile: import_path2.default.join(this.gameConfig.config.outputDir, TEMP_FILENAME),
+      outfile: import_path.default.join(this.gameConfig.outputDir, TEMP_FILENAME),
       external: ["esbuild"]
     });
   }
@@ -2247,7 +1778,7 @@ Simulating game mode: ${mode}`);
   }
   mergeRecords(otherRecords) {
     for (const otherRecord of otherRecords) {
-      let record = this.records.find((r) => {
+      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;
@@ -2261,7 +1792,7 @@ Simulating game mode: ${mode}`);
           timesTriggered: 0,
           bookIds: []
         };
-        this.records.push(record);
+        this.recorder.records.push(record);
       }
       record.timesTriggered += otherRecord.timesTriggered;
       for (const bookId of otherRecord.bookIds) {
@@ -2271,76 +1802,59 @@ Simulating game mode: ${mode}`);
       }
     }
   }
-};
-var SimulationContext = class extends Board {
-  constructor(opts) {
-    super(opts);
-  }
-  actualSims = 0;
   /**
-   * Will run a single simulation until the specified criteria is met.
+   * Generates reelset CSV files for all game modes.
    */
-  runSingleSimulation(opts) {
-    const { simId, mode, criteria, index } = opts;
-    this.state.currentGameMode = mode;
-    this.state.currentSimulationId = simId;
-    this.state.isCriteriaMet = false;
-    const resultSet = this.getResultSetByCriteria(this.state.currentGameMode, criteria);
-    while (!this.state.isCriteriaMet) {
-      this.actualSims++;
-      this.resetSimulation();
-      this.state.currentResultSet = resultSet;
-      this.state.book.criteria = resultSet.criteria;
-      this.handleGameFlow();
-      if (resultSet.meetsCriteria(this)) {
-        this.state.isCriteriaMet = true;
+  generateReelsetFiles() {
+    for (const mode of Object.values(this.gameConfig.gameModes)) {
+      if (mode.reelSets && mode.reelSets.length > 0) {
+        for (const reelSet of Object.values(mode.reelSets)) {
+          reelSet.associatedGameModeName = mode.name;
+          reelSet.generateReels(this);
+        }
+      } else {
+        throw new Error(
+          `Game mode "${mode.name}" has no reel sets defined. Cannot generate reelset files.`
+        );
       }
     }
-    this.wallet.confirmWins(this);
-    if (this.state.book.getPayout() >= this.config.maxWinX) {
-      this.state.triggeredMaxWin = true;
-    }
-    this.record({
-      criteria: resultSet.criteria
-    });
-    this.config.hooks.onSimulationAccepted?.(this);
-    this.confirmRecords();
-    import_worker_threads2.parentPort?.postMessage({
-      type: "complete",
-      simId,
-      book: this.state.book.serialize(),
-      wallet: this.wallet.serialize(),
-      records: this.getRecords()
-    });
-  }
-  /**
-   * If a simulation does not meet the required criteria, reset the state to run it again.
-   *
-   * This also runs once before each simulation to ensure a clean state.
-   */
-  resetSimulation() {
-    this.resetState();
-    this.resetBoard();
   }
   /**
-   * Contains and executes the entire game logic:
-   * - Drawing the board
-   * - Evaluating wins
-   * - Updating wallet
-   * - Handling free spins
-   * - Recording events
-   *
-   * You can customize the game flow by implementing the `onHandleGameFlow` hook in the game configuration.
+   * Confirms all pending records and adds them to the main records list.
    */
-  handleGameFlow() {
-    this.config.hooks.onHandleGameFlow(this);
+  confirmRecords(ctx) {
+    const recorder = ctx.services.data._getRecorder();
+    for (const pendingRecord of recorder.pendingRecords) {
+      const search = Object.entries(pendingRecord.properties).map(([name, value]) => ({ name, value })).sort((a, b) => a.name.localeCompare(b.name));
+      let record = recorder.records.find((r) => {
+        if (r.search.length !== search.length) return false;
+        for (let i = 0; i < r.search.length; i++) {
+          if (r.search[i].name !== search[i].name) return false;
+          if (r.search[i].value !== search[i].value) return false;
+        }
+        return true;
+      });
+      if (!record) {
+        record = {
+          search,
+          timesTriggered: 0,
+          bookIds: []
+        };
+        recorder.records.push(record);
+      }
+      record.timesTriggered++;
+      if (!record.bookIds.includes(pendingRecord.bookId)) {
+        record.bookIds.push(pendingRecord.bookId);
+      }
+    }
+    recorder.pendingRecords = [];
   }
 };
 
 // src/analysis/index.ts
-var import_fs4 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
-var import_assert6 = __toESM(require("assert"));
+var import_fs3 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_assert7 = __toESM(require("assert"));
 
 // src/analysis/utils.ts
 function parseLookupTable(content) {
@@ -2449,7 +1963,7 @@ function getLessBetHitrate(payoutWeights, cost) {
 }
 
 // src/analysis/index.ts
-var import_worker_threads3 = require("worker_threads");
+var import_worker_threads2 = require("worker_threads");
 var Analysis = class {
   gameConfig;
   optimizerConfig;
@@ -2460,7 +1974,7 @@ var Analysis = class {
     this.filePaths = {};
   }
   async runAnalysis(gameModes) {
-    if (!import_worker_threads3.isMainThread) return;
+    if (!import_worker_threads2.isMainThread) return;
     this.filePaths = this.getPathsForModes(gameModes);
     this.getNumberStats(gameModes);
     this.getWinRanges(gameModes);
@@ -2470,28 +1984,28 @@ var Analysis = class {
     const rootPath = process.cwd();
     const paths = {};
     for (const modeStr of gameModes) {
-      const lut = import_path3.default.join(
+      const lut = import_path2.default.join(
         rootPath,
         this.gameConfig.outputDir,
         `lookUpTable_${modeStr}.csv`
       );
-      const lutSegmented = import_path3.default.join(
+      const lutSegmented = import_path2.default.join(
         rootPath,
         this.gameConfig.outputDir,
         `lookUpTableSegmented_${modeStr}.csv`
       );
-      const lutOptimized = import_path3.default.join(
+      const lutOptimized = import_path2.default.join(
         rootPath,
         this.gameConfig.outputDir,
         "publish_files",
         `lookUpTable_${modeStr}_0.csv`
       );
-      const booksJsonl = import_path3.default.join(
+      const booksJsonl = import_path2.default.join(
         rootPath,
         this.gameConfig.outputDir,
         `books_${modeStr}.jsonl`
       );
-      const booksJsonlCompressed = import_path3.default.join(
+      const booksJsonlCompressed = import_path2.default.join(
         rootPath,
         this.gameConfig.outputDir,
         "publish_files",
@@ -2505,8 +2019,8 @@ var Analysis = class {
         booksJsonlCompressed
       };
       for (const p of Object.values(paths[modeStr])) {
-        (0, import_assert6.default)(
-          import_fs4.default.existsSync(p),
+        (0, import_assert7.default)(
+          import_fs3.default.existsSync(p),
           `File "${p}" does not exist. Run optimization to auto-create it.`
         );
       }
@@ -2518,7 +2032,7 @@ var Analysis = class {
     for (const modeStr of gameModes) {
       const mode = this.getGameModeConfig(modeStr);
       const lutOptimized = parseLookupTable(
-        import_fs4.default.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
+        import_fs3.default.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
       );
       const totalWeight = getTotalLutWeight(lutOptimized);
       const payoutWeights = getPayoutWeights(lutOptimized);
@@ -2539,7 +2053,7 @@ var Analysis = class {
       });
     }
     writeJsonFile(
-      import_path3.default.join(process.cwd(), this.gameConfig.outputDir, "stats_summary.json"),
+      import_path2.default.join(process.cwd(), this.gameConfig.outputDir, "stats_summary.json"),
       stats
     );
   }
@@ -2569,7 +2083,7 @@ var Analysis = class {
     for (const modeStr of gameModes) {
       const mode = this.getGameModeConfig(modeStr);
       const lutOptimized = parseLookupTable(
-        import_fs4.default.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
+        import_fs3.default.readFileSync(this.filePaths[modeStr].lutOptimized, "utf-8")
       );
       const totalWeight = getTotalLutWeight(lutOptimized);
       const payoutWeights = getPayoutWeights(lutOptimized);
@@ -2577,13 +2091,19 @@ var Analysis = class {
   }
   getGameModeConfig(mode) {
     const config = this.gameConfig.gameModes[mode];
-    (0, import_assert6.default)(config, `Game mode "${mode}" not found in game config`);
+    (0, import_assert7.default)(config, `Game mode "${mode}" not found in game config`);
     return config;
   }
 };
 
+// src/optimizer/index.ts
+var import_path5 = __toESM(require("path"));
+var import_assert9 = __toESM(require("assert"));
+var import_child_process = require("child_process");
+var import_worker_threads3 = require("worker_threads");
+
 // src/utils/math-config.ts
-var import_path4 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 function makeMathConfig(optimizer, opts = {}) {
   const game = optimizer.getGameConfig();
   const gameModesCfg = optimizer.getOptimizerGameModes();
@@ -2627,14 +2147,14 @@ function makeMathConfig(optimizer, opts = {}) {
     }))
   };
   if (writeToFile) {
-    const outPath = import_path4.default.join(process.cwd(), game.outputDir, "math_config.json");
+    const outPath = import_path3.default.join(process.cwd(), game.outputDir, "math_config.json");
     writeJsonFile(outPath, config);
   }
   return config;
 }
 
 // src/utils/setup-file.ts
-var import_path5 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 function makeSetupFile(optimizer, gameMode) {
   const gameConfig = optimizer.getGameConfig();
   const optimizerGameModes = optimizer.getOptimizerGameModes();
@@ -2670,33 +2190,126 @@ function makeSetupFile(optimizer, gameMode) {
 `;
   content += `simulation_trials;${params.simulationTrials}
 `;
-  content += `user_game_build_path;${import_path5.default.join(process.cwd(), gameConfig.outputDir)}
+  content += `user_game_build_path;${import_path4.default.join(process.cwd(), gameConfig.outputDir)}
 `;
   content += `pmb_rtp;${params.pmbRtp}
 `;
-  const outPath = import_path5.default.join(__dirname, "./optimizer-rust/src", "setup.txt");
+  const outPath = import_path4.default.join(__dirname, "./optimizer-rust/src", "setup.txt");
   writeFile(outPath, content);
 }
 
-// src/optimizer/index.ts
-var import_child_process = require("child_process");
-var import_path6 = __toESM(require("path"));
-var import_assert7 = __toESM(require("assert"));
-var import_worker_threads4 = require("worker_threads");
-var Optimizer = class {
-  gameConfig;
-  gameModes;
+// src/optimizer/OptimizationConditions.ts
+var import_assert8 = __toESM(require("assert"));
+var OptimizationConditions = class {
+  rtp;
+  avgWin;
+  hitRate;
+  searchRange;
+  forceSearch;
+  priority;
   constructor(opts) {
-    this.gameConfig = opts.game.getConfig().config;
-    this.gameModes = opts.gameModes;
-    this.verifyConfig();
-  }
-  /**
-   * Runs the optimization process, and runs analysis after.
-   */
-  async runOptimization({ gameModes }) {
-    if (!import_worker_threads4.isMainThread) return;
-    const mathConfig = makeMathConfig(this, { writeToFile: true });
+    let { rtp, avgWin, hitRate, searchConditions, priority } = opts;
+    if (rtp == void 0 || rtp === "x") {
+      (0, import_assert8.default)(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++;
+    }
+    (0, import_assert8.default)(noneCount <= 1, "Invalid combination of optimization conditions.");
+    this.searchRange = [-1, -1];
+    this.forceSearch = {};
+    if (typeof searchConditions === "number") {
+      this.searchRange = [searchConditions, searchConditions];
+    }
+    if (Array.isArray(searchConditions)) {
+      if (searchConditions[0] > searchConditions[1] || searchConditions.length !== 2) {
+        throw new Error("Invalid searchConditions range.");
+      }
+      this.searchRange = searchConditions;
+    }
+    if (typeof searchConditions === "object" && !Array.isArray(searchConditions)) {
+      this.searchRange = [-1, -1];
+      this.forceSearch = searchConditions;
+    }
+    this.rtp = rtp;
+    this.avgWin = avgWin;
+    this.hitRate = hitRate;
+    this.priority = priority;
+  }
+  getRtp() {
+    return this.rtp;
+  }
+  getAvgWin() {
+    return this.avgWin;
+  }
+  getHitRate() {
+    return this.hitRate;
+  }
+  getSearchRange() {
+    return this.searchRange;
+  }
+  getForceSearch() {
+    return this.forceSearch;
+  }
+};
+
+// src/optimizer/OptimizationScaling.ts
+var OptimizationScaling = class {
+  config;
+  constructor(opts) {
+    this.config = opts;
+  }
+  getConfig() {
+    return this.config;
+  }
+};
+
+// src/optimizer/OptimizationParameters.ts
+var OptimizationParameters = class _OptimizationParameters {
+  parameters;
+  constructor(opts) {
+    this.parameters = {
+      ..._OptimizationParameters.DEFAULT_PARAMETERS,
+      ...opts
+    };
+  }
+  static DEFAULT_PARAMETERS = {
+    numShowPigs: 5e3,
+    numPigsPerFence: 1e4,
+    threadsFenceConstruction: 16,
+    threadsShowConstruction: 16,
+    testSpins: [50, 100, 200],
+    testSpinsWeights: [0.3, 0.4, 0.3],
+    simulationTrials: 5e3,
+    graphIndexes: [],
+    run1000Batch: false,
+    minMeanToMedian: 4,
+    maxMeanToMedian: 8,
+    pmbRtp: 1,
+    scoreType: "rtp"
+  };
+  getParameters() {
+    return this.parameters;
+  }
+};
+
+// src/optimizer/index.ts
+var Optimizer = class {
+  gameConfig;
+  gameModes;
+  constructor(opts) {
+    this.gameConfig = opts.game.getConfig();
+    this.gameModes = opts.gameModes;
+    this.verifyConfig();
+  }
+  /**
+   * Runs the optimization process, and runs analysis after.
+   */
+  async runOptimization({ gameModes }) {
+    if (!import_worker_threads3.isMainThread) return;
+    const mathConfig = makeMathConfig(this, { writeToFile: true });
     for (const mode of gameModes) {
       const setupFile = makeSetupFile(this, mode);
       await this.runSingleOptimization();
@@ -2720,176 +2333,941 @@ var Optimizer = class {
       for (const condition of conditions) {
         if (!configMode.resultSets.find((r) => r.criteria === condition)) {
           throw new Error(
-            `Condition "${condition}" defined in optimizer config for game mode "${k}" does not exist as criteria in any ResultSet of the same game mode.`
+            `Condition "${condition}" defined in optimizer config for game mode "${k}" does not exist as criteria in any ResultSet of the same game mode.`
+          );
+        }
+      }
+      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) {
+        const paramConfig = mode.conditions[cond];
+        paramRtp += Number(paramConfig.getRtp());
+      }
+      gameModeRtp = Math.round(gameModeRtp * 1e3) / 1e3;
+      paramRtp = Math.round(paramRtp * 1e3) / 1e3;
+      (0, import_assert9.default)(
+        gameModeRtp === paramRtp,
+        `Sum of all RTP conditions (${paramRtp}) does not match the game mode RTP (${gameModeRtp}) in game mode "${k}".`
+      );
+    }
+  }
+  getGameConfig() {
+    return this.gameConfig;
+  }
+  getOptimizerGameModes() {
+    return this.gameModes;
+  }
+};
+async function rustProgram(...args) {
+  return new Promise((resolve, reject) => {
+    const task = (0, import_child_process.spawn)("cargo", ["run", "--release", ...args], {
+      shell: true,
+      cwd: import_path5.default.join(__dirname, "./optimizer-rust"),
+      stdio: "pipe"
+    });
+    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/slot-game/index.ts
+var SlotGame = class {
+  configOpts;
+  simulation;
+  optimizer;
+  analyzer;
+  constructor(config) {
+    this.configOpts = config;
+  }
+  /**
+   * Sets up the simulation configuration.\
+   * Must be called before `runTasks()`.
+   */
+  configureSimulation(opts) {
+    this.simulation = new Simulation(opts, this.configOpts);
+  }
+  /**
+   * Sets up the optimization configuration.\
+   * Must be called before `runTasks()`.
+   */
+  configureOptimization(opts) {
+    this.optimizer = new Optimizer({
+      game: this,
+      gameModes: opts.gameModes
+    });
+  }
+  /**
+   * Runs the simulation based on the configured settings.
+   */
+  async runSimulation(opts = {}) {
+    if (!this.simulation) {
+      throw new Error(
+        "Simulation is not configured. Do so by calling configureSimulation() first."
+      );
+    }
+    await this.simulation.runSimulation(opts);
+  }
+  /**
+   * Runs the optimization based on the configured settings.
+   */
+  async runOptimization(opts) {
+    if (!this.optimizer) {
+      throw new Error(
+        "Optimization is not configured. Do so by calling configureOptimization() first."
+      );
+    }
+    await this.optimizer.runOptimization(opts);
+  }
+  /**
+   * Runs the analysis based on the configured settings.
+   */
+  async runAnalysis(opts) {
+    if (!this.optimizer) {
+      throw new Error(
+        "Optimization must be configured to run analysis. Do so by calling configureOptimization() first."
+      );
+    }
+    this.analyzer = new Analysis(this.optimizer);
+    await this.analyzer.runAnalysis(opts.gameModes);
+  }
+  /**
+   * Runs the configured tasks: simulation, optimization, and/or analysis.
+   */
+  async runTasks(opts = {}) {
+    if (!opts.doSimulation && !opts.doOptimization && !opts.doAnalysis) {
+      console.log("No tasks to run. Enable either simulation, optimization or analysis.");
+    }
+    if (opts.doSimulation) {
+      await this.runSimulation(opts.simulationOpts || {});
+    }
+    if (opts.doOptimization) {
+      await this.runOptimization(opts.optimizationOpts || { gameModes: [] });
+    }
+    if (opts.doAnalysis) {
+      await this.runAnalysis(opts.analysisOpts || { gameModes: [] });
+    }
+  }
+  /**
+   * Gets the game configuration.
+   */
+  getConfig() {
+    return createGameConfig(this.configOpts);
+  }
+};
+
+// src/createSlotGame.ts
+function createSlotGame(opts) {
+  return new SlotGame(opts);
+}
+var defineUserState = (data) => data;
+var defineSymbols = (symbols) => symbols;
+var defineGameModes = (gameModes) => gameModes;
+
+// src/game-mode/index.ts
+var import_assert10 = __toESM(require("assert"));
+var GameMode = class {
+  name;
+  reelsAmount;
+  symbolsPerReel;
+  cost;
+  rtp;
+  reelSets;
+  resultSets;
+  isBonusBuy;
+  constructor(opts) {
+    this.name = opts.name;
+    this.reelsAmount = opts.reelsAmount;
+    this.symbolsPerReel = opts.symbolsPerReel;
+    this.cost = opts.cost;
+    this.rtp = opts.rtp;
+    this.reelSets = opts.reelSets;
+    this.resultSets = opts.resultSets;
+    this.isBonusBuy = opts.isBonusBuy;
+    (0, import_assert10.default)(this.rtp >= 0.9 && this.rtp <= 0.99, "RTP must be between 0.9 and 0.99");
+    (0, import_assert10.default)(
+      this.symbolsPerReel.length === this.reelsAmount,
+      "symbolsPerReel length must match reelsAmount."
+    );
+    (0, import_assert10.default)(this.reelSets.length > 0, "GameMode must have at least one ReelSet defined.");
+  }
+};
+
+// src/win-types/index.ts
+var WinType = class {
+  payout;
+  winCombinations;
+  ctx;
+  wildSymbol;
+  constructor(opts) {
+    this.ctx = opts.ctx;
+    this.payout = 0;
+    this.winCombinations = [];
+    this.wildSymbol = opts?.wildSymbol;
+  }
+  /**
+   * Implementation of win evaluation logic. Sets `this.payout` and `this.winCombinations`.
+   */
+  evaluateWins(board) {
+    return this;
+  }
+  /**
+   * Custom post-processing of wins, e.g. for handling multipliers.
+   */
+  postProcess(func) {
+    const result = func(this, this.ctx);
+    this.payout = result.payout;
+    this.winCombinations = result.winCombinations;
+    return this;
+  }
+  /**
+   * Returns the total payout and detailed win combinations.
+   */
+  getWins() {
+    return {
+      payout: this.payout,
+      winCombinations: this.winCombinations
+    };
+  }
+  isWild(symbol) {
+    return !!this.wildSymbol && symbol.compare(this.wildSymbol);
+  }
+};
+
+// src/win-types/LinesWinType.ts
+var LinesWinType = class extends WinType {
+  lines;
+  constructor(opts) {
+    super(opts);
+    this.lines = opts.lines;
+    if (Object.keys(this.lines).length === 0) {
+      throw new Error("LinesWinType must have at least one line defined.");
+    }
+  }
+  validateConfig() {
+    const reelsAmount = this.ctx.services.game.getCurrentGameMode().reelsAmount;
+    const symsPerReel = this.ctx.services.game.getCurrentGameMode().symbolsPerReel;
+    for (const [lineNum, positions] of Object.entries(this.lines)) {
+      if (positions.length !== reelsAmount) {
+        throw new Error(
+          `Line ${lineNum} has ${positions.length} positions, but the current game mode has ${reelsAmount} reels.`
+        );
+      }
+      for (let i = 0; i < positions.length; i++) {
+        if (positions[i] < 0 || positions[i] >= symsPerReel[i]) {
+          throw new Error(
+            `Line ${lineNum} has an invalid position ${positions[i]} on reel ${i}. Valid range is 0 to ${symsPerReel[i] - 1}.`
+          );
+        }
+      }
+    }
+    const firstLine = Math.min(...Object.keys(this.lines).map(Number));
+    if (firstLine !== 1) {
+      throw new Error(
+        `Lines must start from 1. Found line ${firstLine} as the first line.`
+      );
+    }
+  }
+  /**
+   * Calculates wins based on the defined paylines and provided board state.\
+   * Retrieve the results using `getWins()` after.
+   */
+  evaluateWins(board) {
+    this.validateConfig();
+    const lineWins = [];
+    let payout = 0;
+    const reels = board;
+    for (const [lineNumStr, lineDef] of Object.entries(this.lines)) {
+      const lineNum = Number(lineNumStr);
+      let baseSymbol = null;
+      let leadingWilds = 0;
+      const chain = [];
+      const details = [];
+      for (let ridx = 0; ridx < reels.length; ridx++) {
+        const rowIdx = lineDef[ridx];
+        const sym = reels[ridx][rowIdx];
+        if (!sym) throw new Error("Encountered an invalid symbol while evaluating wins.");
+        const wild = this.isWild(sym);
+        if (ridx === 0) {
+          chain.push(sym);
+          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: wild });
+          if (wild) leadingWilds++;
+          else baseSymbol = sym;
+          continue;
+        }
+        if (wild) {
+          chain.push(sym);
+          details.push({
+            reelIndex: ridx,
+            posIndex: rowIdx,
+            symbol: sym,
+            isWild: true,
+            substitutedFor: baseSymbol || void 0
+          });
+          continue;
+        }
+        if (!baseSymbol) {
+          baseSymbol = sym;
+          chain.push(sym);
+          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: false });
+          continue;
+        }
+        if (sym.id === baseSymbol.id) {
+          chain.push(sym);
+          details.push({ reelIndex: ridx, posIndex: rowIdx, symbol: sym, isWild: false });
+          continue;
+        }
+        break;
+      }
+      if (chain.length === 0) continue;
+      const allWild = chain.every((s) => this.isWild(s));
+      const wildRepresentative = this.wildSymbol instanceof GameSymbol ? this.wildSymbol : null;
+      const len = chain.length;
+      let bestPayout = 0;
+      let bestType = null;
+      let payingSymbol = null;
+      if (baseSymbol?.pays && baseSymbol.pays[len]) {
+        bestPayout = baseSymbol.pays[len];
+        bestType = "substituted";
+        payingSymbol = baseSymbol;
+      }
+      if (allWild && wildRepresentative?.pays && wildRepresentative.pays[len]) {
+        const wildPay = wildRepresentative.pays[len];
+        if (wildPay > bestPayout) {
+          bestPayout = wildPay;
+          bestType = "pure-wild";
+          payingSymbol = wildRepresentative;
+        }
+      }
+      if (!bestPayout || !bestType || !payingSymbol) continue;
+      const minLen = payingSymbol.pays ? Math.min(...Object.keys(payingSymbol.pays).map(Number)) : Infinity;
+      if (len < minLen) continue;
+      const wildCount = details.filter((d) => d.isWild).length;
+      const nonWildCount = len - wildCount;
+      lineWins.push({
+        lineNumber: lineNum,
+        kind: len,
+        payout: bestPayout,
+        symbol: payingSymbol,
+        winType: bestType,
+        substitutedBaseSymbol: bestType === "pure-wild" ? null : baseSymbol,
+        symbols: details,
+        stats: { wildCount, nonWildCount, leadingWilds }
+      });
+      payout += bestPayout;
+    }
+    for (const win of lineWins) {
+      this.ctx.services.data.recordSymbolOccurrence({
+        kind: win.kind,
+        symbolId: win.symbol.id,
+        spinType: this.ctx.state.currentSpinType
+      });
+    }
+    this.payout = payout;
+    this.winCombinations = lineWins;
+    return this;
+  }
+};
+
+// src/win-types/ClusterWinType.ts
+var ClusterWinType = class extends WinType {
+};
+
+// src/win-types/ManywaysWinType.ts
+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");
+
+// src/reel-set/index.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+var ReelSet = class {
+  id;
+  associatedGameModeName;
+  reels;
+  rng;
+  constructor(opts) {
+    this.id = opts.id;
+    this.associatedGameModeName = "";
+    this.reels = [];
+    this.rng = new RandomNumberGenerator();
+    this.rng.setSeed(opts.seed ?? 0);
+  }
+  generateReels(simulation) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Reads a reelset CSV file and returns the reels as arrays of GameSymbols.
+   */
+  parseReelsetCSV(reelSetPath, config) {
+    if (!import_fs4.default.existsSync(reelSetPath)) {
+      throw new Error(`Reelset CSV file not found at path: ${reelSetPath}`);
+    }
+    const allowedExtensions = [".csv"];
+    const ext = import_path6.default.extname(reelSetPath).toLowerCase();
+    if (!allowedExtensions.includes(ext)) {
+      throw new Error(
+        `Invalid file extension for reelset CSV: ${ext}. Allowed extensions are: ${allowedExtensions.join(
+          ", "
+        )}`
+      );
+    }
+    const csvData = import_fs4.default.readFileSync(reelSetPath, "utf8");
+    const rows = csvData.split("\n").filter((line) => line.trim() !== "");
+    const reels = Array.from(
+      { length: config.gameModes[this.associatedGameModeName].reelsAmount },
+      () => []
+    );
+    rows.forEach((row) => {
+      const symsInRow = row.split(",").map((symbolId) => {
+        const symbol = config.symbols.get(symbolId.trim());
+        if (!symbol) {
+          throw new Error(`Symbol with id "${symbolId}" not found in game config.`);
+        }
+        return symbol;
+      });
+      symsInRow.forEach((symbol, ridx) => {
+        if (ridx >= reels.length) {
+          throw new Error(
+            `Row in reelset CSV has more symbols than expected reels amount (${reels.length})`
+          );
+        }
+        reels[ridx].push(symbol);
+      });
+    });
+    const reelLengths = reels.map((r) => r.length);
+    const uniqueLengths = new Set(reelLengths);
+    if (uniqueLengths.size > 1) {
+      throw new Error(
+        `Inconsistent reel lengths in reelset CSV at ${reelSetPath}: ${[
+          ...uniqueLengths
+        ].join(", ")}`
+      );
+    }
+    return reels;
+  }
+};
+
+// src/reel-set/GeneratedReelSet.ts
+var GeneratedReelSet = class extends ReelSet {
+  symbolWeights = /* @__PURE__ */ new Map();
+  rowsAmount;
+  limitSymbolsToReels;
+  spaceBetweenSameSymbols;
+  spaceBetweenSymbols;
+  preferStackedSymbols;
+  symbolStacks;
+  symbolQuotas;
+  overrideExisting;
+  constructor(opts) {
+    super(opts);
+    this.id = opts.id;
+    this.symbolWeights = new Map(Object.entries(opts.symbolWeights));
+    this.rowsAmount = opts.rowsAmount || 250;
+    if (opts.limitSymbolsToReels) this.limitSymbolsToReels = opts.limitSymbolsToReels;
+    this.overrideExisting = opts.overrideExisting || false;
+    this.spaceBetweenSameSymbols = opts.spaceBetweenSameSymbols;
+    this.spaceBetweenSymbols = opts.spaceBetweenSymbols;
+    this.preferStackedSymbols = opts.preferStackedSymbols;
+    this.symbolStacks = opts.symbolStacks;
+    this.symbolQuotas = opts.symbolQuotas;
+    if (typeof this.spaceBetweenSameSymbols == "number" && (this.spaceBetweenSameSymbols < 1 || this.spaceBetweenSameSymbols > 8) || typeof this.spaceBetweenSameSymbols == "object" && Object.values(this.spaceBetweenSameSymbols).some((v) => v < 1 || v > 8)) {
+      throw new Error(
+        `spaceBetweenSameSymbols must be between 1 and 8, got ${this.spaceBetweenSameSymbols}.`
+      );
+    }
+    if (Object.values(this.spaceBetweenSymbols || {}).some(
+      (o) => Object.values(o).some((v) => v < 1 || v > 8)
+    )) {
+      throw new Error(
+        `spaceBetweenSymbols must be between 1 and 8, got ${this.spaceBetweenSymbols}.`
+      );
+    }
+    if (this.preferStackedSymbols && (this.preferStackedSymbols < 0 || this.preferStackedSymbols > 100)) {
+      throw new Error(
+        `preferStackedSymbols must be between 0 and 100, got ${this.preferStackedSymbols}.`
+      );
+    }
+  }
+  validateConfig(config) {
+    this.symbolWeights.forEach((_, symbol) => {
+      if (!config.symbols.has(symbol)) {
+        throw new Error(
+          `Symbol "${symbol}" of the reel generator ${this.id} for mode ${this.associatedGameModeName} is not defined in the game config`
+        );
+      }
+    });
+    if (this.limitSymbolsToReels && Object.keys(this.limitSymbolsToReels).length == 0) {
+      this.limitSymbolsToReels = void 0;
+    }
+  }
+  isSymbolAllowedOnReel(symbolId, reelIdx) {
+    if (!this.limitSymbolsToReels) return true;
+    const allowedReels = this.limitSymbolsToReels[symbolId];
+    if (!allowedReels || allowedReels.length === 0) return true;
+    return allowedReels.includes(reelIdx);
+  }
+  resolveStacking(symbolId, reelIdx) {
+    const cfg = this.symbolStacks?.[symbolId];
+    if (!cfg) return null;
+    const STACKING_MIN = 1;
+    const STACKING_MAX = 4;
+    const chance = typeof cfg.chance === "number" ? cfg.chance : cfg.chance?.[reelIdx] ?? 0;
+    if (chance <= 0) return null;
+    let min = typeof cfg.min === "number" ? cfg.min : cfg.min?.[reelIdx] ?? STACKING_MIN;
+    let max = typeof cfg.max === "number" ? cfg.max : cfg.max?.[reelIdx] ?? STACKING_MAX;
+    return { chance, min, max };
+  }
+  tryPlaceStack(reel, config, reelIdx, symbolId, startIndex, maxStack) {
+    if (!this.isSymbolAllowedOnReel(symbolId, reelIdx)) return 0;
+    let canPlace = 0;
+    for (let j = 0; j < maxStack; j++) {
+      const idx = (startIndex + j) % this.rowsAmount;
+      if (reel[idx] !== null) break;
+      canPlace++;
+    }
+    if (canPlace === 0) return 0;
+    const symObj = config.symbols.get(symbolId);
+    if (!symObj) {
+      throw new Error(
+        `Symbol with id "${symbolId}" not found in the game config symbols map.`
+      );
+    }
+    for (let j = 0; j < canPlace; j++) {
+      const idx = (startIndex + j) % reel.length;
+      reel[idx] = symObj;
+    }
+    return canPlace;
+  }
+  /**
+   * Checks if a symbol can be placed at the target index without violating spacing rules.
+   */
+  violatesSpacing(reel, symbolId, targetIndex) {
+    const circDist = (a, b) => {
+      const diff = Math.abs(a - b);
+      return Math.min(diff, this.rowsAmount - diff);
+    };
+    const spacingType = this.spaceBetweenSameSymbols ?? void 0;
+    const sameSpacing = typeof spacingType === "number" ? spacingType : spacingType?.[symbolId] ?? 0;
+    for (let i = 0; i <= reel.length; i++) {
+      const placed = reel[i];
+      if (!placed) continue;
+      const dist = circDist(targetIndex, i);
+      if (sameSpacing >= 1 && placed.id === symbolId) {
+        if (dist <= sameSpacing) return true;
+      }
+      if (this.spaceBetweenSymbols) {
+        const forward = this.spaceBetweenSymbols[symbolId]?.[placed.id] ?? 0;
+        if (forward >= 1 && dist <= forward) return true;
+        const reverse = this.spaceBetweenSymbols[placed.id]?.[symbolId] ?? 0;
+        if (reverse >= 1 && dist <= reverse) return true;
+      }
+    }
+    return false;
+  }
+  generateReels({ gameConfig: config }) {
+    this.validateConfig(config);
+    const gameMode = config.gameModes[this.associatedGameModeName];
+    if (!gameMode) {
+      throw new Error(
+        `Error generating reels for game mode "${this.associatedGameModeName}". It's not defined in the game config.`
+      );
+    }
+    const filePath = import_path7.default.join(
+      config.outputDir,
+      `reels_${this.associatedGameModeName}-${this.id}.csv`
+    );
+    const exists = import_fs5.default.existsSync(filePath);
+    if (exists && !this.overrideExisting) {
+      this.reels = this.parseReelsetCSV(filePath, config);
+      return;
+    }
+    if (!exists && this.symbolWeights.size === 0) {
+      throw new Error(
+        `Cannot generate reels for generator "${this.id}" of mode "${this.associatedGameModeName}" because the symbol weights are empty.`
+      );
+    }
+    const reelsAmount = gameMode.reelsAmount;
+    const weightsObj = Object.fromEntries(this.symbolWeights);
+    for (let ridx = 0; ridx < reelsAmount; ridx++) {
+      const reel = new Array(this.rowsAmount).fill(null);
+      const reelQuotas = {};
+      const quotaCounts = {};
+      let totalReelsQuota = 0;
+      for (const [sym, quotaConf] of Object.entries(this.symbolQuotas || {})) {
+        const q = typeof quotaConf === "number" ? quotaConf : quotaConf[ridx];
+        if (!q) continue;
+        reelQuotas[sym] = q;
+        totalReelsQuota += q;
+      }
+      if (totalReelsQuota > 100) {
+        throw new Error(
+          `Total symbol quotas for reel ${ridx} exceed 100%. Adjust your configuration on reel set "${this.id}".`
+        );
+      }
+      if (totalReelsQuota > 0) {
+        for (const [sym, quota] of Object.entries(reelQuotas)) {
+          const quotaCount = Math.max(1, Math.floor(this.rowsAmount * quota / 100));
+          quotaCounts[sym] = quotaCount;
+        }
+      }
+      for (const [sym, targetCount] of Object.entries(quotaCounts)) {
+        let remaining = targetCount;
+        let attempts = 0;
+        while (remaining > 0) {
+          if (attempts++ > this.rowsAmount * 10) {
+            throw new Error(
+              `Failed to place ${targetCount} of symbol ${sym} on reel ${ridx} (likely spacing/stacking too strict).`
+            );
+          }
+          const pos = Math.round(this.rng.randomFloat(0, this.rowsAmount - 1));
+          const stackCfg = this.resolveStacking(sym, ridx);
+          let placed = 0;
+          if (stackCfg && Math.round(this.rng.randomFloat(1, 100)) <= stackCfg.chance) {
+            const stackSize = Math.max(
+              0,
+              Math.round(this.rng.randomFloat(stackCfg.min, stackCfg.max))
+            );
+            const toPlace = Math.min(stackSize, remaining);
+            placed = this.tryPlaceStack(reel, config, ridx, sym, pos, toPlace);
+          }
+          if (placed === 0 && reel[pos] === null && this.isSymbolAllowedOnReel(sym, ridx) && !this.violatesSpacing(reel, sym, pos)) {
+            reel[pos] = config.symbols.get(sym);
+            placed = 1;
+          }
+          remaining -= placed;
+        }
+      }
+      for (let r = 0; r < this.rowsAmount; r++) {
+        if (reel[r] !== null) continue;
+        let chosenSymbolId = this.rng.weightedRandom(weightsObj);
+        const nextHasStackCfg = !!this.resolveStacking(chosenSymbolId, ridx);
+        if (!nextHasStackCfg && this.preferStackedSymbols && reel.length > 0) {
+          const prevSymbol = r - 1 >= 0 ? reel[r - 1] : reel[reel.length - 1];
+          if (prevSymbol && Math.round(this.rng.randomFloat(1, 100)) <= this.preferStackedSymbols && (!this.spaceBetweenSameSymbols || !this.violatesSpacing(reel, prevSymbol.id, r))) {
+            chosenSymbolId = prevSymbol.id;
+          }
+        }
+        if (this.preferStackedSymbols && reel.length > 0) {
+          const prevSymbol = r - 1 >= 0 ? reel[r - 1] : reel[reel.length - 1];
+          if (Math.round(this.rng.randomFloat(1, 100)) <= this.preferStackedSymbols && (!this.spaceBetweenSameSymbols || !this.violatesSpacing(reel, prevSymbol.id, r))) {
+            chosenSymbolId = prevSymbol.id;
+          }
+        }
+        const stackCfg = this.resolveStacking(chosenSymbolId, ridx);
+        if (stackCfg && this.isSymbolAllowedOnReel(chosenSymbolId, ridx)) {
+          const roll = Math.round(this.rng.randomFloat(1, 100));
+          if (roll <= stackCfg.chance) {
+            const desiredSize = Math.max(
+              1,
+              Math.round(this.rng.randomFloat(stackCfg.min, stackCfg.max))
+            );
+            const placed = this.tryPlaceStack(
+              reel,
+              config,
+              ridx,
+              chosenSymbolId,
+              r,
+              desiredSize
+            );
+            if (placed > 0) {
+              r += placed - 1;
+              continue;
+            }
+          }
+        }
+        let tries = 0;
+        const maxTries = 2500;
+        while (!this.isSymbolAllowedOnReel(chosenSymbolId, ridx) || this.violatesSpacing(reel, chosenSymbolId, r)) {
+          if (++tries > maxTries) {
+            throw new Error(
+              [
+                `Failed to place a symbol on reel ${ridx} at position ${r} after ${maxTries} attempts.
+`,
+                "Try to change the seed or adjust your configuration.\n"
+              ].join(" ")
+            );
+          }
+          chosenSymbolId = this.rng.weightedRandom(weightsObj);
+          const hasStackCfg = !!this.resolveStacking(chosenSymbolId, ridx);
+          if (!hasStackCfg && this.preferStackedSymbols && reel.length > 0) {
+            const prevSymbol = r - 1 >= 0 ? reel[r - 1] : reel[reel.length - 1];
+            if (prevSymbol && Math.round(this.rng.randomFloat(1, 100)) <= this.preferStackedSymbols && (!this.spaceBetweenSameSymbols || !this.violatesSpacing(reel, prevSymbol.id, r))) {
+              chosenSymbolId = prevSymbol.id;
+            }
+          }
+        }
+        const symbol = config.symbols.get(chosenSymbolId);
+        if (!symbol) {
+          throw new Error(
+            `Symbol with id "${chosenSymbolId}" not found in the game config symbols map.`
           );
         }
+        reel[r] = symbol;
       }
-      const criteria = configMode.resultSets.map((r) => r.criteria);
-      (0, import_assert7.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) {
-        const paramConfig = mode.conditions[cond];
-        paramRtp += Number(paramConfig.getRtp());
+      if (reel.some((s) => s === null)) {
+        throw new Error(`Reel ${ridx} has unfilled positions after generation.`);
       }
-      gameModeRtp = Math.round(gameModeRtp * 1e3) / 1e3;
-      paramRtp = Math.round(paramRtp * 1e3) / 1e3;
-      (0, import_assert7.default)(
-        gameModeRtp === paramRtp,
-        `Sum of all RTP conditions (${paramRtp}) does not match the game mode RTP (${gameModeRtp}) in game mode "${k}".`
+      this.reels.push(reel);
+    }
+    const csvRows = Array.from(
+      { length: this.rowsAmount },
+      () => Array.from({ length: reelsAmount }, () => "")
+    );
+    for (let ridx = 0; ridx < reelsAmount; ridx++) {
+      for (let r = 0; r < this.rowsAmount; r++) {
+        csvRows[r][ridx] = this.reels[ridx][r].id;
+      }
+    }
+    const csvString = csvRows.map((row) => row.join(",")).join("\n");
+    if (import_worker_threads4.isMainThread) {
+      import_fs5.default.writeFileSync(filePath, csvString);
+      this.reels = this.parseReelsetCSV(filePath, config);
+      console.log(
+        `Generated reelset ${this.id} for game mode ${this.associatedGameModeName}`
       );
     }
   }
-  getGameConfig() {
-    return this.gameConfig;
+};
+
+// src/reel-set/StaticReelSet.ts
+var import_assert11 = __toESM(require("assert"));
+var StaticReelSet = class extends ReelSet {
+  reels;
+  csvPath;
+  _strReels;
+  constructor(opts) {
+    super(opts);
+    this.reels = [];
+    this._strReels = opts.reels || [];
+    this.csvPath = opts.csvPath || "";
+    (0, import_assert11.default)(
+      opts.reels || opts.csvPath,
+      `Either 'reels' or 'csvPath' must be provided for StaticReelSet ${this.id}`
+    );
   }
-  getOptimizerGameModes() {
-    return this.gameModes;
+  validateConfig(config) {
+    this.reels.forEach((reel) => {
+      reel.forEach((symbol) => {
+        if (!config.symbols.has(symbol.id)) {
+          throw new Error(
+            `Symbol "${symbol}" of the reel set ${this.id} for mode ${this.associatedGameModeName} is not defined in the game config`
+          );
+        }
+      });
+    });
+    if (this.csvPath && this._strReels.length > 0) {
+      throw new Error(
+        `Both 'csvPath' and 'reels' are provided for StaticReelSet ${this.id}. Please provide only one.`
+      );
+    }
+  }
+  generateReels({ gameConfig: config }) {
+    this.validateConfig(config);
+    if (this._strReels.length > 0) {
+      this.reels = this._strReels.map((reel) => {
+        return reel.map((symbolId) => {
+          const symbol = config.symbols.get(symbolId);
+          if (!symbol) {
+            throw new Error(
+              `Symbol "${symbolId}" of the reel set ${this.id} for mode ${this.associatedGameModeName} is not defined in the game config`
+            );
+          }
+          return symbol;
+        });
+      });
+    }
+    if (this.csvPath) {
+      this.reels = this.parseReelsetCSV(this.csvPath, config);
+    }
   }
 };
-async function rustProgram(...args) {
-  return new Promise((resolve, reject) => {
-    const task = (0, import_child_process.spawn)("cargo", ["run", "--release", ...args], {
-      shell: true,
-      cwd: import_path6.default.join(__dirname, "./optimizer-rust"),
-      stdio: "pipe"
-    });
-    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/SlotGame.ts
-var SlotGame = class {
-  gameConfigOpts;
-  simulation;
-  optimizer;
-  analyzer;
-  constructor(config) {
-    this.gameConfigOpts = config;
+// src/board/StandaloneBoard.ts
+var StandaloneBoard = class {
+  board;
+  ctx;
+  reelsAmount;
+  symbolsPerReel;
+  padSymbols;
+  constructor(opts) {
+    this.board = new Board();
+    this.ctx = opts.ctx;
+    this.reelsAmount = opts.reelsAmount;
+    this.symbolsPerReel = opts.symbolsPerReel;
+    this.padSymbols = opts.padSymbols;
   }
   /**
-   * Sets up the simulation configuration.\
-   * Must be called before `runTasks()`.
+   * Resets the board to an empty state.\
+   * This is called before drawing a new board.
    */
-  configureSimulation(opts) {
-    this.simulation = new Simulation(opts, this.gameConfigOpts);
+  resetBoard() {
+    this.resetReels();
+    this.board.lastDrawnReelStops = [];
   }
   /**
-   * Sets up the optimization configuration.\
-   * Must be called before `runTasks()`.
+   * Gets the current reels and symbols on the board.
    */
-  configureOptimization(opts) {
-    this.optimizer = new Optimizer({
-      game: this,
-      gameModes: opts.gameModes
+  getBoardReels() {
+    return this.board.reels;
+  }
+  getPaddingTop() {
+    return this.board.paddingTop;
+  }
+  getPaddingBottom() {
+    return this.board.paddingBottom;
+  }
+  resetReels() {
+    this.board.resetReels({
+      ctx: this.ctx
     });
   }
   /**
-   * Runs the simulation based on the configured settings.
+   * Sets the anticipation value for a specific reel.
    */
-  async runSimulation(opts = {}) {
-    if (!this.simulation) {
-      throw new Error(
-        "Simulation is not configured. Do so by calling configureSimulation() first."
-      );
-    }
-    await this.simulation.runSimulation(opts);
+  setAnticipationForReel(reelIndex, value) {
+    this.board.anticipation[reelIndex] = value;
   }
   /**
-   * Runs the optimization based on the configured settings.
+   * Counts how many symbols matching the criteria are on a specific reel.
    */
-  async runOptimization(opts) {
-    if (!this.optimizer) {
-      throw new Error(
-        "Optimization is not configured. Do so by calling configureOptimization() first."
-      );
-    }
-    await this.optimizer.runOptimization(opts);
+  countSymbolsOnReel(symbolOrProperties, reelIndex) {
+    return this.board.countSymbolsOnReel(symbolOrProperties, reelIndex);
   }
   /**
-   * Runs the analysis based on the configured settings.
+   * Counts how many symbols matching the criteria are on the board.
+   *
+   * Passing a GameSymbol will compare by ID, passing a properties object will compare by properties.
+   *
+   * Returns a tuple where the first element is the total count, and the second element is a record of counts per reel index.
    */
-  async runAnalysis(opts) {
-    if (!this.optimizer) {
-      throw new Error(
-        "Optimization must be configured to run analysis. Do so by calling configureOptimization() first."
-      );
-    }
-    this.analyzer = new Analysis(this.optimizer);
-    await this.analyzer.runAnalysis(opts.gameModes);
+  countSymbolsOnBoard(symbolOrProperties) {
+    return this.board.countSymbolsOnBoard(symbolOrProperties);
   }
-  async runTasks(opts = {}) {
-    if (!opts.doSimulation && !opts.doOptimization && !opts.doAnalysis) {
-      console.log("No tasks to run. Enable either simulation, optimization or analysis.");
-    }
-    if (opts.doSimulation) {
-      await this.runSimulation(opts.simulationOpts || {});
-    }
-    if (opts.doOptimization) {
-      await this.runOptimization(opts.optimizationOpts || { gameModes: [] });
-    }
-    if (opts.doAnalysis) {
-      await this.runAnalysis(opts.analysisOpts || { gameModes: [] });
-    }
+  /**
+   * Checks if a symbol appears more than once on any reel in the current reel set.
+   *
+   * Useful to check for "forbidden" generations, e.g. 2 scatters on one reel.
+   */
+  isSymbolOnAnyReelMultipleTimes(symbol) {
+    return this.board.isSymbolOnAnyReelMultipleTimes(symbol);
   }
   /**
-   * Gets the game configuration.
+   * Gets all reel stops (positions) where the specified symbol appears in the current reel set.\
+   * Returns an array of arrays, where each inner array contains the positions for the corresponding reel.
    */
-  getConfig() {
-    return new GameConfig(this.gameConfigOpts);
+  getReelStopsForSymbol(reels, symbol) {
+    return this.board.getReelStopsForSymbol(reels, symbol);
+  }
+  /**
+   * Combines multiple arrays of reel stops into a single array of reel stops.\
+   */
+  combineReelStops(...reelStops) {
+    return this.board.combineReelStops({
+      ctx: this.ctx,
+      reelStops
+    });
+  }
+  /**
+   * From a list of reel stops on reels, selects a random stop for a speficied number of random symbols.
+   *
+   * Mostly useful for placing scatter symbols on the board.
+   */
+  getRandomReelStops(reels, reelStops, amount) {
+    return this.board.getRandomReelStops({
+      ctx: this.ctx,
+      reels,
+      reelsAmount: this.reelsAmount,
+      reelStops,
+      amount
+    });
+  }
+  /**
+   * Selects a random reel set based on the configured weights of the current result set.\
+   * Returns the reels as arrays of GameSymbols.
+   */
+  getRandomReelset() {
+    return this.board.getRandomReelset(this.ctx);
+  }
+  /**
+   * Draws a board using specified reel stops.
+   */
+  drawBoardWithForcedStops(reels, forcedStops) {
+    this.drawBoardMixed(reels, forcedStops);
+  }
+  /**
+   * Draws a board using random reel stops.
+   */
+  drawBoardWithRandomStops(reels) {
+    this.drawBoardMixed(reels);
+  }
+  drawBoardMixed(reels, forcedStops) {
+    this.board.drawBoardMixed({
+      ctx: this.ctx,
+      reels,
+      forcedStops,
+      reelsAmount: this.reelsAmount,
+      symbolsPerReel: this.symbolsPerReel,
+      padSymbols: this.padSymbols
+    });
+  }
+  /**
+   * Tumbles the board. All given symbols will be deleted and new symbols will fall from the top.
+   */
+  tumbleBoard(symbolsToDelete) {
+    this.board.tumbleBoard({
+      ctx: this.ctx,
+      symbolsToDelete,
+      reelsAmount: this.reelsAmount,
+      symbolsPerReel: this.symbolsPerReel,
+      padSymbols: this.padSymbols
+    });
   }
 };
-
-// index.ts
-function createSlotGame(opts) {
-  return new SlotGame(opts);
-}
-var defineUserState = (data) => data;
-var defineSymbols = (symbols) => symbols;
-var defineGameModes = (gameModes) => gameModes;
-var defineReelSets = (reelSets) => reelSets;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClusterWinType,
-  GameConfig,
   GameMode,
   GameSymbol,
+  GeneratedReelSet,
   LinesWinType,
   ManywaysWinType,
   OptimizationConditions,
   OptimizationParameters,
   OptimizationScaling,
-  ReelGenerator,
   ResultSet,
+  SPIN_TYPE,
   StandaloneBoard,
-  WinType,
+  StaticReelSet,
   createSlotGame,
   defineGameModes,
-  defineReelSets,
   defineSymbols,
-  defineUserState,
-  weightedRandom
+  defineUserState
 });
 //# sourceMappingURL=index.js.map