Stake Development Kit

https://stakeengine.github.io/
Admin
Stake Development Kit is a comprehensive framework for creating, simulating, and optimizing slot...
Tokens:58,282
Snippets:188
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Clone Repository and Install Dependencies

Source: https://stakeengine.github.io/math-sdk/fe_docs/get_started

Clones the project repository and installs all project dependencies using pnpm. This is a crucial step before running any project commands.

```bash
git clone <REPO_CLONE_URL>
cd web-sdk

pnpm install
```

--------------------------------

### Math SDK Technical Details: Engine Setup and Quickstart

Source: https://stakeengine.github.io/math-sdk/fe_docs/steps

Guides for setting up the Math SDK engine and a quickstart for development.

```English
Math SDK Technical Details:
  Engine Setup
  Quickstart Guide
```

--------------------------------

### Install pnpm

Source: https://stakeengine.github.io/math-sdk/fe_docs/get_started

Installs pnpm version 10.5.0 globally using npm and verifies the installation. This is a package manager for Node.js projects.

```bash
# Install pnpm
npm install pnpm@10.5.0 -g

# Verify the pnpm versions. Should print "v10.5.0"
pnpm -v
```

--------------------------------

### Run Example Game (Stake Development Kits)

Source: https://stakeengine.github.io/math-sdk/math_docs/quickstart

Demonstrates how to run an example game using the 'make run' command or by directly executing the Python script. This process generates necessary files for RGS and math result publication.

```Shell
make run GAME=0_0_lines
```

```Python
python3 games/0_0_lines/run.py
```

--------------------------------

### Install Node.js and nvm

Source: https://stakeengine.github.io/math-sdk/fe_docs/get_started

Installs Node Version Manager (nvm) and Node.js version 18.18.0 using shell commands. It includes verification steps for both nvm and Node.js.

```bash
# Download and install nvm:
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash

# in lieu of restarting the shell
\. "$HOME/.nvm/nvm.sh"

# Download and install Node.js:
nvm install 18.18.0

# Verify the node versions. Should print "v18.18.0".
node -v
```

--------------------------------

### Example: Run 'lines' Module Storybook

Source: https://stakeengine.github.io/math-sdk/fe_docs/get_started

Demonstrates how to run the Storybook for the 'lines' module, identified by its name in the package.json file, using the pnpm command.

```bash
pnpm run storybook --filter=lines
```

--------------------------------

### Simulation Output Example

Source: https://stakeengine.github.io/math-sdk/math_docs/quickstart

Example of the output seen in the terminal during simulation, showing the RTP (Return to Player) for each thread and game mode.

```Shell
Thread 0 finished with 1.632 RTP. [baseGame: 0.043, freeGame: 1.588]

```

--------------------------------

### Setup Math SDK with Makefile

Source: https://stakeengine.github.io/math-sdk/math_docs/general_overview

Sets up the Math SDK using the Makefile. This command handles virtual environment creation, dependency installation, and editable package installation.

```Shell
make setup
```

--------------------------------

### Clone Math SDK Repository

Source: https://stakeengine.github.io/math-sdk/math_docs/general_overview

Clones the Math SDK repository using Git. This is the initial step to get started with the Math SDK.

```Shell
git clone git@github.com:StakeEngine/math-sdk.git
```

--------------------------------

### Example Simulation Output Structure

Source: https://stakeengine.github.io/math-sdk/math_docs/quickstart

Illustrates the JSON structure of a single game simulation output, including simulation ID, payout multiplier, and a detailed list of events.

```JSON
{
    "id": 58,
    "payoutMultiplier": 10,
    "events": [
        {
            "index": 0,
            "type": "reveal",
            "board":[...],
            "paddingPositions": [...],
            "gameType": "basegame",
            "anticipation": [...] 
        },
        {
            "index": 1,
            "type": "winInfo",
            "totalWin": 10,
            "wins": [
                {
                    "symbol": "L5",
                    "kind": 3,
                    "win": 10,
                    "positions": [...],
                    "meta": {}
                }
            ]
        },
        {
            "index": 2,
            "type": "setWin",
            "amount": 10,
            "winLevel": 2
        },
        {
            "index": 3,
            "type": "setTotalWin",
            "amount": 10
        },
        {
            "index": 4,
            "type": "finalWin",
            "amount": 10
        }
    ],
    "criteria": "basegame",
    "baseGameWins": 0.1,
    "freeGameWins": 0.0
}
```

--------------------------------

### Run Sample Game Storybook

Source: https://stakeengine.github.io/math-sdk/fe_docs/get_started

Executes the Storybook for a specific module within a TurboRepo project using pnpm. This allows developers to view and interact with sample games.

```bash
pnpm run storybook --filter=<MODULE_NAME>
```

--------------------------------

### Verify Math SDK Installation

Source: https://stakeengine.github.io/math-sdk/math_docs/general_overview

Verifies the installation of the Math SDK package by listing installed packages or importing the package in Python.

```Shell
python3 -m pip list
```

```Python
>>> import your_package_name
```

--------------------------------

### Getting Started with Math SDK

Source: https://stakeengine.github.io/math-sdk/math_home

Encourages developers to explore the technical details and resources available for the Math SDK to begin creating engaging and mathematically sound games.

```English
Get Started Today
Dive into the technical details and explore how the Carrot Math SDK can transform your game development process. With powerful tools, sample games, and detailed documentation, you'll have everything you need to create engaging and mathematically sound games.
See Math SDK Technical Details for more details.
```

--------------------------------

### Install Math SDK Package in Editable Mode

Source: https://stakeengine.github.io/math-sdk/math_docs/general_overview

Installs the Math SDK package in editable mode using the setup.py file. This allows for live code modifications without reinstallation.

```Shell
python3 -m pip install -e .
```

--------------------------------

### RGS Connection Example: Getting Started with RGS Responses

Source: https://stakeengine.github.io/math-sdk/simple_example/simple_example

This section provides a tutorial for using the RGS with a simple 'fifty-fifty' game. It explains the game rules, API requests for playing and ending rounds, and how to view game responses and balances.

```APIDOC
API Endpoints:

/play
  - Description: Requests a game response from the RGS.
  - Request Body: (Implicitly contains bet information)
  - Response Body: Contains the game round structure, including outcome and win amount.

/end-round
  - Description: Finalizes a bet when a win is greater than 0.
  - Purpose: Updates the player's balance and closes the bet.
  - Condition: Must be called manually if win > 0.
```

--------------------------------

### Install Python Dependencies

Source: https://stakeengine.github.io/math-sdk/math_docs/general_overview

Installs all necessary Python packages listed in the 'requirements.txt' file using pip.

```Shell
python3 -m pip install -r requirements.txt
```

--------------------------------

### Install Rust and Cargo

Source: https://stakeengine.github.io/math-sdk/math_docs/general_overview

Installs Rust and Cargo using the official installation script. This is required for the optimization algorithm.

```Shell
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

--------------------------------

### Configure Simulation Parameters

Source: https://stakeengine.github.io/math-sdk/math_docs/quickstart

Sets the number of simulations to run for different game modes and configures simulation execution parameters. This includes enabling simulation runs, optimization, and analysis.

```Python
num_sim_args = {
    "base": int(1e4),
    "bonus": int(1e4),
}

run_conditions = {
    "run_sims": True,
    "run_optimization": True,
    "run_analysis": True,
    "upload_data": False,
}

```

--------------------------------

### RGS Connection Example

Source: https://stakeengine.github.io/math-sdk/fe_docs/steps

An example demonstrating how to establish an RGS connection.

```English
RGS Connection Example
```

--------------------------------

### Configure Simulation Parameters in run.py

Source: https://stakeengine.github.io/math-sdk/math_docs/quickstart

Sets simulation parameters to generate human-readable JSON output without compression. Allows inspection of game results by simulating a specified number of outcomes.

```Python
num_threads = 1
compression = False

num_sim_args = {
    "base": 100,
    "bonus": 100,
}

run_conditions = {
    "run_sims": True,
    "run_optimization": False,
    "run_analysis": False
}
```

--------------------------------

### Create and Activate Python Virtual Environment

Source: https://stakeengine.github.io/math-sdk/math_docs/general_overview

Creates a Python virtual environment named 'env' and activates it. This is a recommended step for managing dependencies.

```Shell
python3 -m venv env
```

```Shell
source env/bin/activate
```

```Shell
env\Scripts\activate.bat
```

--------------------------------

### BetMode Configuration Example

Source: https://stakeengine.github.io/math-sdk/math_docs/gamestate_section/configuration_section/betmode_overview

An example of the BetMode class configuration for a bonus/buy feature game, demonstrating settings for cost, RTP, max win, auto-close behavior, feature flags, and distribution conditions.

```Python
BetMode(
        name="bonus",
        cost=100.0,
        rtp=self.rtp,
        max_win=self.wincap,
        auto_close_disabled=False,
        is_feature=False,
        is_buybonus=True,
        distributions=[
            Distribution(
                criteria="wincap",
                quota=0.001,
                win_criteria=self.wincap,
                conditions={
                    "reel_weights": {
                        self.basegame_type: {"BR0": 1},
                        self.freegame_type: {"FR0": 1, "WCAP": 5},
                    },
                    "mult_values": {
                        self.basegame_type: {1: 1},
                        self.freegame_type: {2: 10, 3: 20, 4: 50, 5: 60, 10: 100, 20: 90, 50: 50},
                    },
                    "scatter_triggers": {4: 1, 5: 2},
                    "force_wincap": True,
                    "force_freegame": True,
                },
            ),
            Distribution(
                criteria="freegame",
                quota=0.999,
                conditions={
                    "reel_weights": {
                        self.basegame_type: {"BR0": 1},
                        self.freegame_type: {"FR0": 1},
                    },
                    "scatter_triggers": {3: 20, 4: 10, 5: 2},
                    "mult_values": {
                        self.basegame_type: {1: 1},
                        self.freegame_type: {2: 100, 3: 80, 4: 50, 5: 20, 10: 10, 20: 5, 50: 1},
                    },
                    "force_wincap": False,
                    "force_freegame": True,
                },
            ),
        ],
    )
```

--------------------------------

### Run Math SDK Game with Makefile

Source: https://stakeengine.github.io/math-sdk/math_docs/general_overview

Executes a specific game within the Math SDK using the Makefile. Requires the game ID to be specified.

```Shell
make run GAME=<game_id>
```

--------------------------------

### Svelte Context Setup Example

Source: https://stakeengine.github.io/math-sdk/fe_docs/context

Demonstrates how to set up shared contexts in a Svelte application using the `setContext` function. It shows the initialization of EventEmitters, XState machines, Layout states, and App states.

```typescript
import { setContextEventEmitter } from 'packages/utils-event-emitter/src/createEventEmitter';
import { setContextXstate } from 'packages/utils-xstate/src/createXstate';
import { setContextLayout } from 'packages/utils-layout/src/createLayout.svelte';
import { setContextApp } from 'apps/context/src/createAppContext';

export const setContext = () => {
  setContextEventEmitter<EmitterEvent>({ eventEmitter });
  setContextXstate({ stateXstate, stateXstateDerived });
  setContextLayout({ stateLayout, stateLayoutDerived });
  setContextApp({ stateApp });
};
```

--------------------------------

### BookEvent Examples (Reveal and SetTotalWin)

Source: https://stakeengine.github.io/math-sdk/fe_docs/flowchart

Examples of different bookEvent types within a game book. The 'reveal' event shows the game board, while 'setTotalWin' updates the total win amount.

```typescript
// base_books.ts - Example of a "reveal" bookEvent

{
  index: 0,
  type: 'reveal',
  board: [
    [{ name: 'L2' }, { name: 'L1' }, { name: 'L4' }, { name: 'H2' }, { name: 'L1' }],
    [{ name: 'H1' }, { name: 'L5' }, { name: 'L2' }, { name: 'H3' }, { name: 'L4' }],
    [{ name: 'L3' }, { name: 'L5' }, { name: 'L3' }, { name: 'H4' }, { name: 'L4' }],
    [{ name: 'H4' }, { name: 'H3' }, { name: 'L4' }, { name: 'L5' }, { name: 'L1' }],
    [{ name: 'H3' }, { name: 'L3' }, { name: 'L3' }, { name: 'H1' }, { name: 'H1' }],
  ],
  paddingPositions: [216, 205, 195, 16, 65],
  gameType: 'basegame',
  anticipation: [0, 0, 0, 0, 0],
}

// base_books.ts - Example of a setTotalWin bookEvent

{ index: 1, type: 'setTotalWin', amount: 0 }
```

--------------------------------

### Detailed Subdirectory Breakdown - games/

Source: https://stakeengine.github.io/math-sdk/math_docs/directory

Lists the example slot games found in the 'games/' directory, categorizing them by mechanics such as cluster wins, line wins, ways wins, scatter pays, and expanding wilds.

```Markdown
#### `games/`
  * **`0_0_cluster/`**: Sample cascading cluster-wins game.
  * **`0_0_lines/`**: Basic win-lines example game.
  * **`0_0_ways/`**: Basic ways-wins example game.
  * **`0_0_scatter/`**: Pay-anywhere cascading example game.
  * **`0_0_expwilds/`**: Expanding Wild-reel game with an additional prize-collection feature.
```

--------------------------------

### UI Component Integration (PixiJS)

Source: https://stakeengine.github.io/math-sdk/fe_docs/ui

Demonstrates how to integrate and use UI components from the 'components-ui-pixi' package. It shows the setup for a game name and a custom logo with specific styling.

```typescript
import { UI, UiGameName } from 'components-ui-pixi';
import { GameVersion, Modals } from 'components-ui-html';

<App>
  <UI>
    {#snippet gameName()}
      <UiGameName name="LINES GAME" />
    {/snippet}
    {#snippet logo()}
      <Text
        anchor={{ x: 1, y: 0 }}
        text="ADD YOUR LOGO"
        style={{
          fontFamily: 'proxima-nova',
          fontSize: REM * 1.5,
          fontWeight: '600',
          lineHeight: REM * 2,
          fill: 0xffffff,
        }}
      />
    {/snippet}
  </UI>
</App>

<Modals>
    {#snippet version()}
        <GameVersion version="0.0.0" />
    {/snippet}
</Modals>
```

--------------------------------

### StakeEngine EventEmitter: Broadcast and Subscribe Examples

Source: https://stakeengine.github.io/math-sdk/fe_docs/flowchart

Demonstrates how to broadcast emitterEvents synchronously and asynchronously using StakeEngine's EventEmitter, and how to subscribe to these events in Svelte components.

```typescript
// bookEventHandlerMap.ts - Example of an emitterEvent

{
  type: 'freeSpinCounterUpdate',
  current: undefined,
  total: bookEvent.totalFs,
}
```

```typescript
// bookEventHandlerMap.ts - Example of broadcast

eventEmitter.broadcast({
  type: 'freeSpinCounterUpdate',
  current: undefined,
  total: bookEvent.totalFs,
});
```

```typescript
// FreeSpinCounter.svelte - Example of receiving

context.eventEmitter.subscribeOnMount({
  ...,
  freeSpinCounterUpdate: (emitterEvent) => {
    if (emitterEvent.current !== undefined) current = emitterEvent.current;
    if (emitterEvent.total !== undefined) total = emitterEvent.total;
  },
  ...,
});
```

```typescript
// bookEventHandlerMap.ts - Example of broadcastAsync

await eventEmitter.broadcastAsync({
  type: 'freeSpinIntroUpdate',
  totalFreeSpins: bookEvent.totalFs,
});
```

```typescript
// FreeSpinIntro.svelte - Example of receiving

context.eventEmitter.subscribeOnMount({
  ...,
  freeSpinIntroUpdate: async (emitterEvent) => {
    freeSpinsFromEvent = emitterEvent.totalFreeSpins;
    await waitForResolve((resolve) => (oncomplete = resolve));
  },
  ...,
});
```

--------------------------------

### Scatter-Pays Game Mechanics

Source: https://stakeengine.github.io/math-sdk/math_docs/sample_section/sample_games

Provides an overview of Scatter-Pays Game mechanics, including basegame and freegame rules, notes on event descriptions, and potential notes for the game type.

```English
#### Summary: 
#### Basegame:
#### Freegame rules
#### Notes 
#### Event descriptions
```

--------------------------------

### PixiJS Application Context Setup

Source: https://stakeengine.github.io/math-sdk/fe_docs/context

Initializes the application context for PixiJS, including state management for assets, loading progress, and the PixiJS application instance. `loadedAssets` can be directly used by PixiJS components.

```typescript
// createApp.svelte.ts

const stateApp = $state({
  reset,
  assets,
  loaded: false,
  loadingProgress: 0,
  loadedAssets: {} as LoadedAssets,
  pixiApplication: undefined as PIXI.Application | undefined,
});

```

--------------------------------

### Frontend Implementation with Vite and Svelte

Source: https://stakeengine.github.io/math-sdk/simple_example/simple_example

This section details the steps to set up a static frontend using Svelte 5 and Vite, bundled with NPM. It covers project creation, configuration, replacing default files, building the project, and deploying the output to the Stake Engine.

```Shell
1. Create the Vite project: `npm create vite@latest`
2. Navigate into the project directory: `cd <your-project-name>`
3. Install dependencies: `npm install` (or `yarn install` if using Yarn)
4. Build the project: `yarn build` (or `npm run build`)
```

```TypeScript
2. Edit the `vite.config.ts` file:
   Ensure the `defineConfig` function includes `base: "./"` within the `plugins` array or as a top-level option depending on Vite version.

   Example:
   import { defineConfig } from 'vite'
   import svelte from '@sveltejs/vite-plugin-svelte'

   export default defineConfig({
     plugins: [
       svelte(),
       // Other plugins...
     ],
     base: "./", // Ensure this is correctly placed
   })

```

```JavaScript
3. Replace styles and main component:
   - Copy the contents of `css.txt` into your generated `src/app.css` file.
   - Replace the contents of `src/App.svelte` with the content from `app_svelte.txt`.
```

```Shell
5. Deploy:
   Upload the contents of the `dist/` folder to the Stake Engine under the 'frontend files' section.
```

--------------------------------

### Distribution Conditions Usage Example

Source: https://stakeengine.github.io/math-sdk/math_docs/gamestate_section/configuration_section/betmode_dist

Demonstrates how to retrieve distribution conditions and use them to get a random outcome or check for forced free games.

```Python
multiplier = get_random_outcome(betmode.get_distribution_conditions()['mult_values'])

if get_distribution_conditions()['force_freegame']:
    ... # Logic for forcing freegame
```

--------------------------------

### Setup Optimization Parameters in Python

Source: https://stakeengine.github.io/math-sdk/math_docs/optimization_section/optimization_algorithm

Demonstrates how to set up optimization algorithm parameters within a Python script using the OptimizationSetup class. It outlines the structure for defining conditions, scaling, and other parameters for different bet modes.

```Python
opt_params = <mode_name> : {
    "conditions": ...
    "scaling": ...
    "parameters: 
}
```

--------------------------------

### Force Files

Source: https://stakeengine.github.io/math-sdk/math_docs/source_section/file_info

Describes the `force_mode.json` and `force.json` files used for tracking event instances and identifying max-win/freegame books via description keys. Explains how the `.record()` function appends keys and handles existing entries.

```English
Each bet mode will output a file of the format `force_mode.json`. Every time the `.record()` function is called, the description keys used as input are appended to the file. If the key already exists, the `book-id` is appended to the array. This file is used to count instances of particular events. The optimization algorithm also makes use of these keys to identify max-win and freegame books. Once all bet mode simulations are finished, a `force.json` file is output which contains all the unique fields and keys.
```

--------------------------------

### Build Optimization Binary

Source: https://stakeengine.github.io/math-sdk/math_docs/optimization_section/optimization_algorithm

Instructions on how to rebuild the optimization binary using Cargo, typically done after modifications to the main.rs file.

```Rust
cargo build --release
```

--------------------------------

### Bet Level Configuration Example

Source: https://stakeengine.github.io/math-sdk/rgs_docs/RGS

Provides an example JSON structure for bet level configuration, including minimum bet, maximum bet, step bet, and a list of predefined bet levels.

```APIDOC
{
  "minBet": 100000,
  "maxBet": 1000000000,
  "stepBet": 10000,
  "betLevels": [
    100000, // $0.10
    200000,
    400000,
    600000,
    ...
    1000000000 // $1000
  ]
}
```

--------------------------------

### XState Game Actor Setup

Source: https://stakeengine.github.io/math-sdk/fe_docs/context

Defines a finite state machine for managing complex game logic and states, including betting mechanics like auto-betting and resuming bets. Uses XState's `setup` and `createActor` for actor creation and machine definition.

```typescript
// createGameActor.svelte.ts

import { setup, createActor } from 'xstate';

...

const gameMachine = setup({
  actors: {
    bet: intermediateMachines.bet,
    autoBet: intermediateMachines.autoBet,
    resumeBet: intermediateMachines.resumeBet,
    forceResult: intermediateMachines.forceResult,
  },
}).createMachine({
  initial: 'rendering',
  states: {
    [STATE_RENDERING]: stateRendering,
    [STATE_IDLE]: stateIdle,
    [STATE_BET]: stateBet,
    [STATE_AUTOBET]: stateAutoBet,
    [STATE_RESUME_BET]: stateResumeBet,
    [STATE_FORCE_RESULT]: stateForceResult,
  },
});

const gameActor = createActor(gameMachine);

```

--------------------------------

### run.py Simulation Execution

Source: https://stakeengine.github.io/math-sdk/math_docs/overview_section/game_format

The main script for generating simulations and configuration files. It sets up simulation parameters, initializes the GameState and GameConfig, and calls functions to create simulation data and configuration files.

```Python
if __name__ == "__main__":

    num_threads = 1
    rust_threaeds = 20
    batching_size = 50000
    compression = False
    profiling = False

    num_sim_args = {
        "base": int(10),
        "bonus": int(10),
    }

    config = GameConfig()
    gamestate = GameState(config)

    create_books(
        gamestate,
        config,
        num_sim_args,
        batching_size,
        num_threads,
        compression,
        profiling,
    )
    generate_configs(gamestate)

```

--------------------------------

### Deactivate Python Virtual Environment

Source: https://stakeengine.github.io/math-sdk/math_docs/general_overview

Deactivates the currently active Python virtual environment.

```Shell
deactivate
```

--------------------------------

### EventEmitter Usage Examples

Source: https://stakeengine.github.io/math-sdk/fe_docs/flowchart

Demonstrates the primary functions of the eventEmitter: broadcasting events synchronously and asynchronously, and subscribing to events when a component mounts.

```javascript
eventEmitter.broadcast()
eventEmitter.broadcastAsync()
eventEmitter.subscribeOnMount()
```

--------------------------------

### Detailed Subdirectory Breakdown - src/

Source: https://stakeengine.github.io/math-sdk/math_docs/directory

Details the subdirectories within the 'src/' directory, explaining their roles in game development, including calculations, configuration, events, executables, state management, wins, and data writing.

```Markdown
#### `src/`
  * **`calculations/`**: Handles board and symbol setup, along with various win-type game logic.
  * **`config/`**: Creates configuration files required by the RGS, frontend, and optimization algorithm.
  * **`events/`**: Defines data structures passed between the math engine and frontend engine.
  * **`executables/`**: Groups commonly used game logic and events for reuse.
  * **`state/`**: Tracks the game state during simulations.
  * **`wins/`**: Manages wallet functionality and various win criteria.
  * **`write_data/`**: Writes simulation data, handles compression, and generates force files.
```

--------------------------------

### GameStateOverride Example

Source: https://stakeengine.github.io/math-sdk/math_docs/overview_section/state_overview

Demonstrates how to override the reset_book function in GameStateOverride to include game-specific parameters like resetting grid multipliers and tumble wins.

```Python
def reset_book(self):
    super().reset_book()
    self.reset_grid_mults()
    self.reset_grid_bool()
    self.tumble_win = 0

```

--------------------------------

### Repository Directory Overview

Source: https://stakeengine.github.io/math-sdk/math_docs/directory

Provides a breakdown of the main directories within the Stake Development Kits repository and their specific purposes in the game creation process.

```Markdown
### **Main Directories**
  * **`games/`**
  * Contains sample slot games showcasing widely used mechanics and modes:
    * `0_0_cluster`: Cascading cluster-wins game.
    * `0_0_lines`: Basic win-lines example game.
    * `0_0_ways`: Basic ways-wins example game.
    * `0_0_scatter`: Pay-anywhere cascading example game.
    * `0_0_expwilds`: Expanding Wild-reel game with an additional prize-collection feature.
  * **`src/`**
  * Core game setup functions, game mechanics, frontend event structures, wallet management, and simulation output control. This directory contains reusable code shared across games. **Edit with caution.**
  * Subdirectories:
    * `calculations/`: Board and symbol setup, various win-type game logic.
    * `config/`: Generates configuration files required by the RGS, frontend, and optimization algorithm.
    * `events/`: Data structures passed between the math engine and frontend engine.
    * `executables/`: Commonly used groupings of game logic and events.
    * `state/`: Tracks the game state during simulations.
    * `wins/`: Wallet manager handling various win criteria.
    * `write_data/`: Handles writing simulation data, compression, and force files.
  * **`utils/`**
  * Contains helpful functions for simulation and win-distribution analysis:
    * `analysis/`: Constructs and analyzes basic properties of win distributions.
    * `game_analytics/`: Uses recorded events, paytables, and lookup tables to generate hit-rate and simulation properties.
  * **`tests/`**
  * Includes basic PyTest functions for verifying win calculations:
    * `win_calculations/`: Tests various win-mechanic functionality.
  * **`uploads/`**
  * Handles the data upload process for connecting and uploading game files to an AWS S3 bucket for testing.
  * **`optimization_program/`**
  * Contains an experimental genetic algorithm (written in Rust) for balancing discrete-outcome games.
  * **`docs/`**
  * Documentation files written in Markdown.
```

--------------------------------

### SvelteKit App Entry File

Source: https://stakeengine.github.io/math-sdk/fe_docs/file_struct

Illustrates the structure of a SvelteKit app's entry file ('+page.svelte'), including setting context and rendering the main game component.

```svelte
// +page.svelte

<script lang="ts">
  import Game from '../components/Game.svelte';
  import { setContext } from '../game/context';

  setContext();
</script>

<Game />

```

--------------------------------

### Output Files Overview

Source: https://stakeengine.github.io/math-sdk/math_docs/source_section/file_info

Details the automatically generated output files within the game/library directories, including the creation of necessary sub-directories.

```English
All relevant output files are automatically generated within the `game/library/` directories. If the required sub-directories do not exist, the will be automatically generated.
```

--------------------------------

### Monetary Value Representation

Source: https://stakeengine.github.io/math-sdk/rgs_docs/RGS

Explains how monetary values are represented in the Stake Engine, using integers with six decimal places of precision. Provides examples of conversion.

```APIDOC
Value | Actual Amount  
---|---
100,000 | 0.1  
1,000,000 | 1  
10,000,000 | 10  
100,000,000 | 100  
For example, to place a $1 bet, pass "1000000" as the amount.
```

--------------------------------

### BookEventHandler for Free Spin Update

Source: https://stakeengine.github.io/math-sdk/fe_docs/flowchart

An example of a bookEventHandler that updates the free spin counter in the UI. It broadcasts events to show and update the counter based on the bookEvent data.

```typescript
// bookEventHandlerMap.ts - Example of "updateFreeSpin" bookEventHandler

export const bookEventHandlerMap: BookEventHandlerMap<BookEvent, BookEventContext> = {
  ...,
  updateFreeSpin: async (bookEvent: BookEventOfType<'updateFreeSpin'>) => {
    eventEmitter.broadcast({ type: 'freeSpinCounterShow' });
    eventEmitter.broadcast({
      type: 'freeSpinCounterUpdate',
      current: bookEvent.amount,
      total: bookEvent.total,
    });
  },
  ...,
}
```

--------------------------------

### Generate Math SDK Simulation Results

Source: https://stakeengine.github.io/math-sdk/simple_example/simple_example

This snippet describes the process of generating simulation results using the Math SDK. It involves running a Python script that produces compressed simulation data, a lookup table, and an index file required for publishing to the Stake Engine.

```Shell
Navigate to the `math-sdk/games/fifty_fifty/` directory and execute the `run.py` script.
```

```Python
import os

# Assuming run.py is in the current directory or accessible via path
# This is a conceptual representation of executing the script
# In a real scenario, you would use subprocess or similar

# Example of the script's expected output:
# os.system("python run.py") 

# The script is expected to generate:
# - A Zstandard-compressed set of simulation results
# - A lookup table matching each result to its simulation
# - The required `index.json` file
# All necessary files to publish the game to the Stake Engine will be placed in `library/publish_files/`
```

--------------------------------

### Config Files

Source: https://stakeengine.github.io/math-sdk/math_docs/source_section/file_info

Explains the three generated config files: `config_math.json` for optimization, `config_fe.json` for frontend display, and `config.json` for RGS verification and bet mode information.

```English
There are three config files generated after all simulations and optimizations are run. `config_math.json` is used by the optimization algorithm and contains all relevant bet mode details, RTP splits and optimization parameters. `config_fe.json` is used by the front-end frame work and contains symbol information, padding reels and bet mode details which need to be displayed to players. `config.json` contains bet mode information and file hash information and used used by the RGS to determine and verify changes to files being uploaded to the ACP.
```
Tokens:
Raw