@slot-engine/core 0.0.1 → 0.0.2

package/src/SlotGame.ts

@@ -1,117 +0,0 @@
-import { AnyGameModes, AnySymbols, AnyUserData, CommonGameOptions } from "../index"
-import { GameConfig } from "./GameConfig"
-import { Simulation, SimulationConfigOpts, SimulationOpts } from "./Simulation"
-import { Analysis, AnalysisOpts } from "./analysis"
-import { OptimizationOpts, Optimizer, OptimizerOpts } from "./optimizer"
-
-/**
- * SlotGame class that encapsulates the game configuration and state.\
- * Main entry point for the slot game.
- */
-export class SlotGame<
-  TGameModes extends AnyGameModes = AnyGameModes,
-  TSymbols extends AnySymbols = AnySymbols,
-  TUserState extends AnyUserData = AnyUserData,
-> {
-  private readonly gameConfigOpts: CommonGameOptions<TGameModes, TSymbols, TUserState>
-  private simulation?: Simulation
-  private optimizer?: Optimizer
-  private analyzer?: Analysis
-
-  constructor(config: CommonGameOptions<TGameModes, TSymbols, TUserState>) {
-    this.gameConfigOpts = config
-  }
-
-  /**
-   * Sets up the simulation configuration.\
-   * Must be called before `runTasks()`.
-   */
-  configureSimulation(opts: SimulationConfigOpts) {
-    this.simulation = new Simulation(opts, this.gameConfigOpts as any)
-  }
-
-  /**
-   * Sets up the optimization configuration.\
-   * Must be called before `runTasks()`.
-   */
-  configureOptimization(opts: Pick<OptimizerOpts, "gameModes">) {
-    this.optimizer = new Optimizer({
-      game: this,
-      gameModes: opts.gameModes,
-    })
-  }
-
-  /**
-   * Runs the simulation based on the configured settings.
-   */
-  private async runSimulation(opts: SimulationOpts = {}) {
-    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.
-   */
-  private async runOptimization(opts: OptimizationOpts) {
-    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.
-   */
-  private async runAnalysis(opts: AnalysisOpts) {
-    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)
-  }
-
-  async runTasks(
-    opts: {
-      debug?: boolean
-      doSimulation?: boolean
-      doOptimization?: boolean
-      doAnalysis?: boolean
-      simulationOpts?: SimulationOpts
-      optimizationOpts?: OptimizationOpts
-      analysisOpts?: AnalysisOpts
-    } = {},
-  ) {
-    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({ debug: opts.debug })
-    }
-
-    if (opts.doOptimization) {
-      await this.runOptimization(opts.optimizationOpts || { gameModes: [] })
-    }
-
-    if (opts.doAnalysis) {
-      await this.runAnalysis(opts.analysisOpts || { gameModes: [] })
-    }
-  }
-
-  /**
-   * Gets the game configuration.
-   */
-  getConfig() {
-    return new GameConfig(this.gameConfigOpts)
-  }
-}

package/src/Wallet.ts

@@ -1,203 +0,0 @@
-import { GameConfig, SpinType } from "./GameConfig"
-import { AnySimulationContext } from "./Simulation"
-
-/**
- * Stores win amounts for simulations.
- */
-export class Wallet {
-  /**
-   * Total win amount (as the bet multiplier) from all simulations.
-   */
-  protected cumulativeWins = 0
-  /**
-   * Total win amount (as the bet multiplier) per spin type.
-   *
-   * @example
-   * ```ts
-   * {
-   *   basegame: 50,
-   *   freespins: 100,
-   *   superfreespins: 200,
-   * }
-   * ```
-   */
-  protected cumulativeWinsPerSpinType = {
-    [GameConfig.SPIN_TYPE.BASE_GAME]: 0,
-    [GameConfig.SPIN_TYPE.FREE_SPINS]: 0,
-  }
-  /**
-   * Current win amount (as the bet multiplier) for the ongoing simulation.
-   */
-  protected currentWin = 0
-  /**
-   * Current win amount (as the bet multiplier) for the ongoing simulation per spin type.
-   *
-   * @example
-   * ```ts
-   * {
-   *   basegame: 50,
-   *   freespins: 100,
-   *   superfreespins: 200,
-   * }
-   * ```
-   */
-  protected currentWinPerSpinType = {
-    [GameConfig.SPIN_TYPE.BASE_GAME]: 0,
-    [GameConfig.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.
-   */
-  protected currentSpinWin = 0
-  /**
-   * Current win amount (as the bet multiplier) for the ongoing tumble sequence.
-   */
-  protected currentTumbleWin = 0
-
-  constructor() {}
-
-  /**
-   * Updates the win for the current spin.
-   *
-   * 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()`
-   */
-  addSpinWin(amount: number) {
-    this.currentSpinWin += amount
-  }
-
-  /**
-   * Assigns a win amount to the given spin type.
-   *
-   * 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.
-   */
-  confirmSpinWin(spinType: 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
-  }
-
-  /**
-   * Returns the accumulated win amount (as the bet multiplier) from all simulations.
-   */
-  getCumulativeWins() {
-    return this.cumulativeWins
-  }
-
-  /**
-   * Returns the accumulated win amount (as the bet multiplier) per spin type from all simulations.
-   */
-  getCumulativeWinsPerSpinType() {
-    return this.cumulativeWinsPerSpinType
-  }
-
-  /**
-   * Returns the current win amount (as the bet multiplier) for the ongoing simulation.
-   */
-  getCurrentWin() {
-    return this.currentWin
-  }
-
-  /**
-   * Returns the current win amount (as the bet multiplier) per spin type for the ongoing simulation.
-   */
-  getCurrentWinPerSpinType() {
-    return this.currentWinPerSpinType
-  }
-
-  /**
-   * Adds a win to `currentSpinWin` and `currentTumbleWin`.
-   *
-   * After each (free) spin, this amount should be added to `currentWinPerSpinType` via `confirmSpinWin()`
-   */
-  addTumbleWin(amount: number) {
-    this.currentTumbleWin += amount
-    this.addSpinWin(amount)
-  }
-
-  /**
-   * 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 as SpinType] = 0
-    }
-  }
-
-  /**
-   * Adds current wins to cumulative wins and resets current wins to zero.
-   */
-  confirmWins(ctx: AnySimulationContext) {
-    function process(number: number) {
-      return Math.round(Math.min(number, ctx.config.maxWinX) * 100) / 100
-    }
-
-    ctx.state.book.writePayout(ctx)
-
-    this.currentWin = process(this.currentWin)
-    this.cumulativeWins += this.currentWin
-    let spinTypeWins = 0
-
-    for (const spinType of Object.keys(this.currentWinPerSpinType)) {
-      const st = spinType as SpinType
-      const spinTypeWin = process(this.currentWinPerSpinType[st])
-      this.cumulativeWinsPerSpinType[st]! += spinTypeWin
-      spinTypeWins += spinTypeWin
-    }
-
-    if (process(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: Wallet) {
-    this.cumulativeWins += wallet.getCumulativeWins()
-    const otherWinsPerSpinType = wallet.getCumulativeWinsPerSpinType()
-
-    for (const spinType of Object.keys(this.cumulativeWinsPerSpinType)) {
-      this.cumulativeWinsPerSpinType[spinType as SpinType]! +=
-        otherWinsPerSpinType[spinType as SpinType] || 0
-    }
-  }
-
-  mergeSerialized(data: ReturnType<Wallet["serialize"]>) {
-    this.cumulativeWins += data.cumulativeWins
-    for (const spinType of Object.keys(this.cumulativeWinsPerSpinType)) {
-      this.cumulativeWinsPerSpinType[spinType as SpinType]! +=
-        data.cumulativeWinsPerSpinType[spinType as 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 as SpinType]! +=
-        data.currentWinPerSpinType[spinType as SpinType] || 0
-    }
-  }
-}

package/src/WinType.ts

@@ -1,102 +0,0 @@
-import { GameSymbol } from "./GameSymbol"
-import { AnySimulationContext } from "./Simulation"
-
-export class WinType {
-  protected payout: number
-  protected winCombinations: WinCombination[]
-  protected ctx!: AnySimulationContext
-  protected readonly wildSymbol?: WildSymbol
-
-  constructor(opts?: WinTypeOpts) {
-    this.payout = 0
-    this.winCombinations = []
-    this.wildSymbol = opts?.wildSymbol
-  }
-
-  /**
-   * Sets the simulation context for this WinType instance.
-   * 
-   * This gives the WinType access to the current board.
-   */
-  context(ctx: AnySimulationContext): WinType {
-    this.ctx = ctx
-    return this
-  }
-
-  protected ensureContext() {
-    if (!this.ctx) {
-      throw new Error("WinType context is not set. Call context(ctx) first.")
-    }
-  }
-
-  /**
-   * Implementation of win evaluation logic. Sets `this.payout` and `this.winCombinations`.
-   */
-  evaluateWins() {
-    this.ensureContext()
-    return this
-  }
-
-  /**
-   * Custom post-processing of wins, e.g. for handling multipliers.
-   */
-  postProcess(func: PostProcessFn<typeof this.winCombinations>) {
-    this.ensureContext()
-    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,
-    }
-  }
-}
-
-export interface WinTypeOpts {
-  /**
-   * Configuration used to identify wild symbols on the board.\
-   * You can either provide a specific `GameSymbol` instance or a set of properties to match against symbols on the board.
-   *
-   * @example
-   * If you have different wild symbols, each with a property `isWild: true`, you can define:
-   * ```ts
-   * wildSymbol: { isWild: true }
-   * ```
-   *
-   * @example
-   * If you have a single wild symbol instance, you can define:
-   * ```ts
-   * wildSymbol: myWildSymbol
-   * ```
-   */
-  wildSymbol?: WildSymbol
-}
-
-export type WinCombination = {
-  payout: number
-  kind: number
-  symbols: Array<{
-    symbol: GameSymbol
-    isWild: boolean
-    substitutedFor?: GameSymbol
-    reelIndex: number
-    posIndex: number
-  }>
-}
-
-type PostProcessFn<TWinCombs extends WinCombination[]> = (
-  winType: WinType,
-  ctx: AnySimulationContext,
-) => {
-  payout: number
-  winCombinations: TWinCombs
-}
-
-type WildSymbol = GameSymbol | Record<string, any>

package/src/analysis/index.ts

@@ -1,198 +0,0 @@
-import fs from "fs"
-import path from "path"
-import { GameConfig } from "../GameConfig"
-import { Optimizer, OptimzierGameModeConfig } from "../optimizer"
-import assert from "assert"
-import {
-  getAvgWin,
-  getLessBetHitrate,
-  getMaxWin,
-  getMaxwinHitrate,
-  getMinWin,
-  getNonZeroHitrate,
-  getNullHitrate,
-  getPayoutWeights,
-  getRtp,
-  getStandardDeviation,
-  getTotalLutWeight,
-  getUniquePayouts,
-  getVariance,
-  parseLookupTable,
-} from "./utils"
-import { writeJsonFile } from "../../utils"
-
-export class Analysis {
-  protected readonly gameConfig: GameConfig["config"]
-  protected readonly optimizerConfig: OptimzierGameModeConfig
-  protected filePaths: Record<string, FilePaths>
-
-  constructor(optimizer: Optimizer) {
-    this.gameConfig = optimizer.getGameConfig()
-    this.optimizerConfig = optimizer.getOptimizerGameModes()
-    this.filePaths = {}
-  }
-
-  async runAnalysis(gameModes: string[]) {
-    this.filePaths = this.getPathsForModes(gameModes)
-    this.getNumberStats(gameModes)
-    this.getWinRanges(gameModes)
-    //this.getSymbolStats(gameModes)
-    console.log("Analysis complete. Files written to build directory.")
-  }
-
-  private getPathsForModes(gameModes: string[]) {
-    const rootPath = process.cwd()
-    const paths: Record<string, FilePaths> = {}
-
-    for (const modeStr of gameModes) {
-      const lut = path.join(
-        rootPath,
-        this.gameConfig.outputDir,
-        `lookUpTable_${modeStr}.csv`,
-      )
-      const lutSegmented = path.join(
-        rootPath,
-        this.gameConfig.outputDir,
-        `lookUpTableSegmented_${modeStr}.csv`,
-      )
-      const lutOptimized = path.join(
-        rootPath,
-        this.gameConfig.outputDir,
-        "publish_files",
-        `lookUpTable_${modeStr}_0.csv`,
-      )
-      const booksJsonl = path.join(
-        rootPath,
-        this.gameConfig.outputDir,
-        `books_${modeStr}.jsonl`,
-      )
-      const booksJsonlCompressed = path.join(
-        rootPath,
-        this.gameConfig.outputDir,
-        "publish_files",
-        `books_${modeStr}.jsonl.zst`,
-      )
-
-      paths[modeStr] = {
-        lut,
-        lutSegmented,
-        lutOptimized,
-        booksJsonl,
-        booksJsonlCompressed,
-      }
-
-      for (const p of Object.values(paths[modeStr])) {
-        assert(
-          fs.existsSync(p),
-          `File "${p}" does not exist. Run optimization to auto-create it.`,
-        )
-      }
-    }
-
-    return paths
-  }
-
-  private getNumberStats(gameModes: string[]) {
-    const stats: Statistics[] = []
-
-    for (const modeStr of gameModes) {
-      const mode = this.getGameModeConfig(modeStr)
-
-      const lutOptimized = parseLookupTable(
-        fs.readFileSync(this.filePaths[modeStr]!.lutOptimized, "utf-8"),
-      )
-      const totalWeight = getTotalLutWeight(lutOptimized)
-      const payoutWeights = getPayoutWeights(lutOptimized)
-
-      stats.push({
-        gameMode: mode.name,
-        totalWeight,
-        avgWin: getAvgWin(payoutWeights),
-        rtp: getRtp(payoutWeights, mode.cost),
-        minWin: getMinWin(payoutWeights),
-        maxWin: getMaxWin(payoutWeights),
-        stdDev: getStandardDeviation(payoutWeights),
-        variance: getVariance(payoutWeights),
-        nonZeroHitRate: getNonZeroHitrate(payoutWeights),
-        nullHitRate: getNullHitrate(payoutWeights),
-        maxwinHitRate: getMaxwinHitrate(payoutWeights),
-        lessBetHitRate: getLessBetHitrate(payoutWeights, mode.cost),
-        uniquePayouts: getUniquePayouts(payoutWeights),
-      })
-    }
-
-    writeJsonFile(
-      path.join(process.cwd(), this.gameConfig.outputDir, "stats_summary.json"),
-      stats,
-    )
-  }
-
-  private getWinRanges(gameModes: string[]) {
-    const winRanges: [number, number][] = [
-      [0, 0.1],
-      [0, 0.99],
-      [1, 1.99],
-      [2, 2.99],
-      [3, 4.99],
-      [5, 9.99],
-      [10, 19.99],
-      [20, 49.99],
-      [50, 99.99],
-      [100, 199.99],
-      [200, 499.99],
-      [500, 999.99],
-      [1000, 1999.99],
-      [2000, 2999.99],
-      [3000, 4999.99],
-      [5000, 7499.99],
-      [7500, 9999.99],
-      [10000, 14999.99],
-      [15000, 19999.99],
-      [20000, 24999.99],
-    ]
-
-    for (const modeStr of gameModes) {
-      const mode = this.getGameModeConfig(modeStr)
-
-      const lutOptimized = parseLookupTable(
-        fs.readFileSync(this.filePaths[modeStr]!.lutOptimized, "utf-8"),
-      )
-      const totalWeight = getTotalLutWeight(lutOptimized)
-      const payoutWeights = getPayoutWeights(lutOptimized)
-    }
-  }
-
-  private getGameModeConfig(mode: string) {
-    const config = this.gameConfig.gameModes[mode]
-    assert(config, `Game mode "${mode}" not found in game config`)
-    return config
-  }
-}
-
-export interface AnalysisOpts {
-  gameModes: string[]
-}
-
-interface FilePaths {
-  lut: string
-  lutSegmented: string
-  lutOptimized: string
-  booksJsonl: string
-  booksJsonlCompressed: string
-}
-
-interface Statistics {
-  gameMode: string
-  totalWeight: number
-  rtp: number
-  avgWin: number
-  minWin: number
-  maxWin: number
-  stdDev: number
-  variance: number
-  maxwinHitRate: number
-  nonZeroHitRate: number
-  nullHitRate: number
-  lessBetHitRate: number
-  uniquePayouts: number
-}