Carpathian Treasures: Code Walkthrough

This guide is for developers who are new to the game code. It explains the job of each function in Carpathian Treasures, when it is used, and what it passes along. It also gives a source-structure map of all game packages currently under games/ so the Carpathian implementation can be understood in the context of the repository's shared pattern.

This is a code guide, not a description of unimplemented features. For game rules, payout values, symbol distribution, and math-sheet terms, see the gameplay guide. For the pack/bootstrap, HTTP, game-core, SDK, and RGS call flow, see the shared runtime architecture guide. For certified build artifacts, hash verification, RNG-trace packaging, and request-body Base64 decoding, see certification and request encoding.

1. How Game Packages Are Organized

The inspected game packages share a common set of core files. The names describe typical responsibilities, not a promise that every game's code is identical.

All 13 current game packages contain this core set and implement the SDK's ISlotGamePlugin contract. Some add helper modules for game-specific mechanics. This is an observed repository pattern; follow the target game's existing structure when adding code.

Those extra modules are local to their games. Do not assume a mechanic in one game is part of the shared game contract just because another package has a similarly named helper.

2. Carpathian Treasures Round Flow

The main path for a normal spin is:

flowchart TD
    A[Host calls plugin.spin] --> B[Plugin selects cached R4 math]
    B --> C[Engine executeSpin]
    C --> D[SDK generateReelView]
    D --> E[Logic spin]
    E --> F[Resolve expanding wilds and evaluate paylines]
    F --> G[Calculate scatter and bonus-symbol pays]
    G --> H[Plugin builds SDK spin output]

The startup path is separate: the host calls onLoad, which loads the math JSON into a cache. init later reads the cached paytable. A simulator can also ask for the reel-stop data saved by the most recent spin.

3. Plugin: Host-Facing Adapter

The plugin implements the SDK contract. Its job is to translate host-level inputs into game-engine inputs and package game results into the shared output shapes. It should not own the detailed reel or payout algorithm.

feature exists because the shared plugin interface supports games with feature rounds. Its presence does not mean every game implements a playable feature; check the engine and logic for the actual behavior.

4. Engine: Round Orchestration

The engine is the middle layer between the plugin and game rules. It prepares the board, uses shared SDK helpers where appropriate, and delegates scoring to CarpathianTreasuresLogic.

generateReelView is an SDK function, not a Carpathian function. It draws one stop per reel, then selects consecutive strip entries for visible rows. Keeping this generic work in the SDK avoids duplicating reel construction in each game.

5. Logic: Game Rules and Payouts

CarpathianTreasuresLogic owns this game's score calculation. It uses SDK arithmetic and win-line helpers, while keeping Carpathian-specific choices such as symbol IDs and payout configuration in the math JSON.

The SDK's calculateWinLines function evaluates the configured line paths and returns winning line details and a total. Carpathian passes isColumnMajor: true, its symbol payout table, and payoutMode: 'baseBet'. The SDK arithmetic helpers add, multiply, and divide are used to combine and scale payout values.

Wild-expansion detail

resolveWildExpansion treats any column containing a wild as a candidate expanded column during line evaluation. It uses a Proxy to make cells in that column read as WD without first modifying the original reel view. After line calculation, only candidate columns used by a winning line are represented as fully expanded in expandedReelView and listed in wildExpandedReels. This separates the evaluation view from the original generated board.

6. Interfaces and Exports

These files describe how the pieces fit together without performing a spin themselves.

The SDK's ISlotGamePlugin is the common host-facing contract. ISpinInput, ISpinOutput, IFeatureInput, and related types come from the SDK; the game-specific result remains in this package and is carried as generic gameData.

7. Where to Make a Change

Before editing a rule, check whether the desired behavior is already in the math JSON, this game's logic, or a shared SDK helper. Keep game-specific rules in the game package and only change shared SDK code when the behavior is genuinely common across games.

8. HTTP Request Keys

The HTTP controller receives request DTOs. These are not the same shape as the inputs passed to a game plugin: GameService handles session lookup, RGS calls, and shared fields before it calls the plugin.

POST /games/init

POST /games/spin

POST /games/feature

The spin DTO converts betAmount to a number, can convert string usePromo to a boolean, normalizes empty buyBonus objects to absent, and parses epoch as a number. The feature DTO also parses epoch. Request validation happens before GameService handles the request.

9. Core-to-Plugin Keys

The SDK interfaces define a shared contract. A game's plugin only receives the values the core chooses to pass; it does not receive the whole HTTP body or raw RGS session.

For a spin, the core gets gameMode, allowCheat, maxWin, and progressData from RGS after debit. It derives devMode from allowCheat. It overwrites extraData.progressData with the RGS value, so client input cannot supply or replace persisted game state. gameId, token, usePromo, and epoch are handled by the core/RGS flow and are not game-plugin input keys.

Plugin output keys

These are the values returned by a game's plugin before GameService builds the HTTP response:

Carpathian currently sets featureTriggered to false, reports zero bonus amount/count, and returns nextFeature: null in gameData. Its feature output is completed immediately because no feature round is implemented.

10. Response Keys and Global Settings

HTTP response envelope

The controller wraps successful endpoint data in ApiResponseDto:

The health endpoint is an exception: it returns { status, games } directly rather than using the standard envelope.

Init data

gameInfo contains gameId, devMode, payTable, and optional gameData. Carpathian provides the paytable; the core sets devMode and may merge RGS progressData into gameData for games that use persisted progression.

playerInfo is built by getPlayerInfo, which renames selected RGS fields for the client:

Other RGS init fields such as platformId, operatorId, brandId, and externalPlayerId are not copied into this playerInfo mapping. RGS progressData is instead carried as game data where applicable.

The raw RGS init response also contains playerName, which this core mapping does not currently expose. Its other fields are used as follows:

When present, promoInfo has its own keys: promoId identifies the award, status indicates its lifecycle state, playCount and remainingPlayCount describe awarded/remaining spins, betAmount is the promo wager, totalWin is the running promo win, and skipCount records skipped spins.

Spin data

Feature data

Inside result: feature state and featureData

The HTTP response's result contains the game's SpinResult. If a game has a feature, the feature state is usually in result.featureResults, an array because a round can contain more than one feature (for example, a queued feature or a feature chain). A typical shape is:

{
    "nextFeature": "freespins",
    "featureResults": [
        {
            "featureType": "freespins",
            "featureSubType": "Green",
            "currentCount": 0,
            "totalCount": 8,
            "currentWin": 0,
            "totalWin": 0,
            "retrigger": false,
            "retriggerCount": 0,
            "closed": false,
            "featureTriggerPositions": [[1, 2]],
            "featureData": { "gameSpecificState": "..." },
            "spinResults": []
        }
    ]
}

This is an illustrative shape only. Keys are optional, and the exact fields and meanings depend on the game and featureType/featureSubType. The SDK deliberately treats gameData and feature data as generic; read the selected game's interfaces.ts and the code that creates/updates featureResults to know its real schema.

Other nearby SpinResult fields have separate jobs:

Common modifier type values include symbolExpansion and lightningStrike (Book of Storms variants), symbolChangeApplied (New Conquest), nudgeFeature and symbolConversionApplied (Frosted Market Bonanza), stoneFired (Mine Dash), bonusWildsAdd and stickyWildCarry (PigStyle), and addWildFeatureTriggered (Royale81). Read that game's modifier interface before consuming its fields. Modifiers explain what changed and often include an initialReelView; the current/settled board and feature state remain in their own fields.

There are several different completion flags. The plugin's featureComplete tells GameService whether to credit and close the feature round. The HTTP response's closed reports whether the RGS round is settled. A nested featureResults[n].closed reports whether that one feature entry is complete. They are related, but they are not interchangeable.

featureData by game

This inventory describes the feature payloads declared/constructed by the game packages in this workspace. It is a reference to help you recognize other games' state; it does not mean Carpathian Treasures has these fields. Optional keys are only present for the relevant branch/stage.

The table is a guide to the current TypeScript contracts, not a frozen cross-game API. A feature response can include additional game-specific fields. When assigned to a different game, start at its SpinResult/FeatureResult types, then follow the plugin's feature() call into the engine/logic code that reads and writes the state.

The feature's per-spin entry shape is also game-specific. Common examples include a board (reelView), that step's winLines, spinWin/totalWin, cascade history (cascadeData), modifier data, and the current step number. Book of Storms records free-spin board/wild/expansion wins; cluster games record cascade boards, winning clusters, scatters, and multipliers; House of Cards records dropped board cells and ways wins; PigStyle records the variable-height view and wild multipliers. These entries are history/state for a particular game's feature, not a uniform SDK object.

For the exact compile-time contract, see each package's interface: Book of Storms, Book of Storms Lightning Win, Empire of Gold, New Conquest, Frosted Market Bonanza, House of Cards, Joker Charge, Meow Meow Meow, Mine Dash, PigStyle, Royale81, and Sweet Salon. Carpathian's own result types are in its interfaces.

Global and persisted data in practice

preferences, opCnf, rtp, promoInfo, epoch, and playerInfo are core/RGS-level response fields, not fields inside Carpathian's SpinResult. The game plugin does not currently read these init response fields directly. The core uses RGS session values to select the game mode, enforce the player session and wager flow, decide development mode, preserve round state, and construct the client response. Individual keys inside opCnf and preferences are operator/client-defined; consult their owning contract before assigning a game-specific meaning.

11. How the Repository Runs a Game

The code path crosses several layers. Knowing who owns each step helps you find the right file and avoids putting RGS or HTTP behavior into pure game logic.

1. apps/pack-alpha/src/app.module.ts constructs the pack's game plugin instances and passes them to GameCoreModule.register.
2. GamePluginLoaderService.onModuleInit calls each plugin's onLoad, injects a logger when supported, and indexes it by gameId.
3. GameController validates the endpoint route and delegates to GameService.
4. GameService resolves the plugin, performs session/debit/credit/persistence calls with RGS, and maps the SDK contract to the HTTP response.
5. The game plugin adapts inputs, the game engine orchestrates the round, and game logic computes game-specific outcomes.
6. Shared SDK functions provide common operations such as reel generation, weighted draws, scoring helpers, and win caps.

The game packages import the SDK and Node fs/path; they do not import NestJS. The pack/core layers own HTTP, RGS, and process lifecycle concerns.

Core functions to know

RGS environment configuration

RgsConfigService reads settings registered under the rgs namespace. RGS_URL is required; the remaining values have defaults in libs/rgs-client/src/config/configuration.ts.

These are service deployment settings, not game math values and not opCnf. Do not add game-specific rules to them.

RgsConfigService exposes these as getters (url, poolConnections, poolKeepAliveTimeout, poolPipelining, poolClientTtl, requestTimeout, retryMaxAttempts, and retryBaseDelayMs) so RgsService does not read environment variables throughout request code.

12. Shared SDK Functions Used by Games

These are reusable operations imported by game packages. They do not decide an individual game's complete rules; the game supplies the math and options.

Use the shared helper when its semantics match the game rule. Some games intentionally implement custom logic (for example PigStyle's variable-height reel/payline model or Royale81's wild-multiplied ways); do not replace custom behavior with an SDK helper just because the names look similar.

13. Function Map Across All Game Packages

The following map was checked against every TypeScript source file under the 13 registered games/*/src/ packages. It lists each game-specific runtime function and its purpose. Functions with the same name in different games are separate implementations unless explicitly described as sharing a role. interfaces.ts and index.ts primarily declare types and exports rather than round-processing functions.

Shared plugin methods

Each package implements the shared plugin lifecycle described in Plugin: Host-Facing Adapter: onLoad, init, spin, feature, and getMath. The common purpose is the same, but the details vary: onLoad may pre-parse math; init may return extra gameData; spin/feature normalize game-specific values and compute feature reporting; and getMath returns the selected cache entry. Optional or game-specific plugin methods are listed under their game below. Joker Charge has no simulator hook because its engine does not use reel stops.

Book of Storms

Sources: engine, logic, plugin.

• executeSpin: chooses BG or buy-bonus trigger math, makes the board, adds buy-bonus wilds when needed, calculates the trigger result, and chooses/persists the free-spin book symbol.
• executeFeature: uses the stored book symbol and trigger state to choose the correct free-game reel set, generates the feature board, and calls runFeature.
• getLastSpinSimData: exposes the last reel stops to the simulator.
• parseWinLineDefs: converts math-file comma-separated line positions to number arrays.
• countWilds: counts WD symbols and records their coordinates.
• mapWinLines: converts SDK wins to the game's result shape and applies its minimum match-count rule for high/low symbols.
• countSymbol: counts one symbol and identifies which columns contain it.
• buildExpandedReelView: fills each selected column with the expanding symbol for feature presentation/evaluation.
• buildLineWin: constructs a line result with amount, symbol, count, and both flat/matrix coordinates.
• evaluateLineWin: compares a wild-only H1 payout with a wild-substituted symbol payout and returns the better valid win.
• spin: scores paylines, wild scatter pay, book-symbol expansion in free spins, feature triggers/retriggers, totals, and win caps.
• runFeature: executes one free spin and updates the persisted feature count, retriggers, cumulative wins, and cap/closed state.
• selectBookSymbol: weighted selection of the book symbol that defines the free-game reel set.
• addWildsForBuyBonus: copies the board and adds the requested wild count to distinct columns.

Book of Storms Lightning Win

Sources: engine, logic, feature-trigger-check, cheat-logic, plugin.

• executeSpin: chooses the base/buy-bonus trigger strips; applies buy-bonus wilds or the normal/lightning trigger-check branch; passes the board to scoring and attaches animation modifiers/book symbol.
• executeFeature: resumes free spins using the persisted trigger variant/book symbol and its corresponding reel strips.
• getLastSpinSimData: reports the last stops.
• parseWinLineDefs, countWilds, mapWinLines, countSymbol, buildExpandedReelView, buildLineWin, evaluateLineWin, spin, runFeature, selectBookSymbol, addWildsForBuyBonus: serve the same responsibilities as the same-named Book of Storms logic functions, with this game's Lightning feature variant and modifiers included in scoring/state.
• injectWilds: places a requested number of wilds in different unused columns and reports positions.
• performFeatureTriggerCheck: decides no-trigger, normal-trigger, or lightning-trigger behavior from feature math; injects natural/lightning wilds and captures the pre-strike board for the visual modifier.
• BookOfStormsLightningWinCheatLogic.selectBookSymbol: uses a development-forced book symbol when set; otherwise delegates to weighted production selection.
• buildDevModeOverrides: creates the feature/wild/book forcing object only when devMode is true.

Empire of Gold

Sources: engine, logic, plugin.

• executeSpin: chooses BG, ANTE, or buy-bonus trigger math; validates optional forced stops; applies buy-bonus scatter placement or ante stack replacement; then calls cascade scoring.
• executeFeature: selects FG or buy-bonus free-game math and delegates one free-spin state update to runFeature.
• getLastSpinSimData: returns base-spin reel stops.
• spin: finds paying symbol clusters, awards bonus-symbol multipliers, repeatedly removes/refills winning clusters, counts scatter triggers, updates totals/multipliers, and applies win caps.
• runFeature: generates and scores one free spin, handles retriggers and accumulated free-spin multipliers, updates the persisted feature state, and closes/caps the feature.

Empire of Gold: New Conquest

Sources: engine, logic, symbol-change, plugin.

• setLogger (engine/plugin): passes the shared monitoring service into the engine and its feature helper.
• executeSpin: chooses BG/ANTE/buy-bonus math, generates and modifies the board, applies the passive symbol-change hook for BG/ANTE, then invokes cascade scoring.
• executeFeature: chooses FG/BB math and resumes the accumulated free-spin round.
• getLastSpinSimData: returns base-spin stops.
• spin / runFeature: use the Empire of Gold cascade, bonus multiplier, trigger, retrigger, and cap flow, with optional forced bonus multiplier and logger messages.
• applySymbolChange: selects low/high symbols, checks the combined-count gate and trigger weight, replaces matching low cells with the high symbol, and returns both the changed board and result metadata.

Frosted Market Bonanza

Sources: engine, logic, symbol-conversion, plugin.

• executeSpin: selects BG/ANTE/buy-bonus strips, runs the scoring pipeline, and may re-run scoring on a converted board after a non-winning BG/ANTE spin without a nudge.
• executeFeature: delegates persisted free-spin state to runFeature.
• getLastSpinSimData: returns reel stops.
• spin: applies buy-bonus scatter placement and stack-symbol resolution; evaluates cluster cascades; assigns free-spin bomb multipliers; handles scatters, nudge, totals, caps, and result cleanup.
• runFeature: selects the free-spin math/reel set, calls spinFreeGame, updates retriggers and accumulated wins, and applies cumulative caps.
• spinFreeGame: generates a feature board from already selected strips and scores it as a free spin.
• applySymbolConversion: selects low/high symbols, applies its count/trigger gates, replaces low symbols, and returns the changed positions/initial board for the modifier.

House of Cards

Sources: engine, logic, house-board, plugin.

• executeSpin: draws the feature branch, chooses/records its reel set, generates a board, and delegates scoring.
• getLastSpinSimData: returns reel stops and selected reel set.
• executeFeature: delegates the persisted pick/House state machine.
• findPositions: lists coordinates for a requested symbol.
• injectSymbols: randomly fills eligible cells without overwriting excluded positions.
• forceSymbolCount: normalizes a dev-forced symbol count by removing or injecting symbols.
• mapToWinLines: converts SDK ways results into this game's win-line representation.
• requireTriggerPositions: rejects corrupt feature state without trigger positions instead of silently building an empty board.
• evaluateWays: invokes the SDK ways calculator with this game's layout, wild, and paytable.
• capWin: applies configured and RGS win caps.
• nextFeatureFields: builds the result's feature type/subtype fields consistently.
• spin: injects Buzz Saws/Hard Hats, scores ways, selects triggered features, and queues simultaneous features when needed.
• runFeature: dispatches to House free spins or resolves the Buzz Saw pick wheel based on persisted feature state.
• executeBSFeature: resolves the wheel outcome as a jackpot or seeds a Buzz Saw, Mega Hat, or Mansion feature board.
• executeHouseFeature: upgrades the persisted board, plays/scorers a House spin, checks retrigger/cap/closure, and activates queued features.
• resolveHouseReelSelection: prepares weighted reel sets, with separate selection for Mansion.
• buildBSFeatureResult / buildHouseFeatureResult: create the initial persisted result structures for the pick wheel or House free spins.
• emptyBoard: allocates the flattened house-board state.
• indicesWithState: finds board cells at a requested level.
• indexToPosition: converts a flattened index to [column, row].
• toValueWeight: converts [value, weight] entries into the SDK's parallel-array weight format.
• requireCountTable: validates the count-specific board-weight table.
• drawDropCount: draws a count and caps placed cells to available positions.
• fillCells: draws and writes a tier's selected board cells while preserving both requested and placed counts.
• cascadeUpgrade: promotes an existing board cell when repeat drops occur, or awards the full-board multiplier.
• upgradeTier (local helper in applyBoardUpgrade): applies a forced count of tier promotions in the game's priority order while tracking unplaced drops.
• applyBoardUpgrade: applies weighted or dev-forced Hard Hat tier upgrades and reports placed/landed counts and board awards.
• seedBuzzSaw: moves Buzz Saw positions across board cells, upgrading each touched tier.
• seedMansion: seeds Buzz Saw positions directly as max-tier board cells.
• seedMegaHat: selects/forces hat placement, updates eligible board cells, and overlays hats onto the generated reel view.
• resolveFrameValue: converts a numeric or jackpot-tier frame entry into a bet-scaled award.
• revealHouse: draws and sums values for every occupied cell when the House board reveals.
• buildDevModeOverrides: packages development-only trigger/outcome/board controls for the engine.

Joker Charge

Sources: engine, logic, cheat-logic, config, plugin.

Joker Charge is table-driven and has no reel strips or reel-stop simulator path; its board is built from decision weights.

• setLogger: attaches monitoring to the engine.
• executeSpin: validates active paylines, carries sticky state only when bet/paylines are unchanged, decides base vs. bonus entry, and returns either a base board or a new respin feature state.
• renderHoldField: turns stored hold cells into the display grid.
• executeFeature: adds a hold-spin result, runs modifier-row effects, reveals mysteries at close, totals cell/jackpot values, and applies the cap.
• ACTIVE_LINE_ROWS: maps the active-payline choice to the rows considered active.
• symbolNames: gets the allowed symbol names from weight tables for validating cheats.
• forcedGrid: validates a development-forced grid against the layout and allowed symbols.
• resolveBaseTrigger: selects base game vs. bonus game from the active-payline weight table.
• fillBaseGameBoard: preserves sticky symbols and fills active/inactive rows from their distinct weights.
• collectStickyCells: extracts persistent sticky symbols to store in progress data.
• resolveMetamorphicTrigger: rolls the metamorphic display decision and optional added count; it does not change base-game payout.
• resolveBonusEntry: creates active/inactive/sticky hold cells and applies the initial modifier row.
• buildMetamorphicSymbolPosition: determines which newly added active cells the metamorphic animation highlights.
• runHoldSpin: fills unlocked cells, resets or decrements respins, and closes on full board or exhausted respins.
• resolveModifierRow: applies per-column or whole-field multiplier/tier modifiers.
• revealMysteries: resolves Mystery/Mystery Jackpot cells only when the bonus closes.
• resolveValue: looks up a symbol's bet-scaled value.
• resolveBoostValue: snapshots the value of symbols a Boost collects.
• buildHoldFieldCell: normalizes sticky/mystery symbols and calculates the cell's stored value.
• Cheat overrides resolveBaseTrigger, resolveMetamorphicTrigger, fillBaseGameBoard, resolveBonusEntry, runHoldSpin, resolveModifierRow, and revealMysteries: use validated development overrides, otherwise call the production implementation.
• inScope: local cheat/logic predicate that selects one column or the whole hold field for modifier application.
• buildDevModeOverrides: parses only development-authorized forced values from extraData.
• JokerChargeConfig: supplies the fixed layout, respin count, and maximum/base-bet constants used by the game.

Meow Meow Meow

Sources: engine, logic, feature-helpers, cheat-logic, plugin.

• executeSpin: selects BG/ANTE math and weighted reel set, optionally forces ReelSet_1 in dev mode, then delegates board modifiers/scoring.
• getLastSpinSimData: returns stop indices and selected reel set.
• executeFeature: dispatches the persisted RED, BLUE, or GREEN feature to logic.
• spin: adds weighted wilds and symbol overlays, calculates ways and scatter payouts, caps the win, and initializes the triggered feature state.
• runFeature: resumes GREEN when it is open; otherwise dispatches RED pick, BLUE wheel, or GREEN free spin.
• executeRedFeature: resolves one coin pick per call, checks category-of-three wins, accumulates/caps the award, and closes the pick feature when resolved.
• executeBlueFeature: resolves a wheel prize, closes BLUE, and signals a subsequent RED/GREEN feature when awarded.
• buildInitialFeatureResult: creates the persisted initial state for RED, BLUE, or GREEN.
• resolveSymbolOverlay: rolls feature trigger/type/color and places scatters/coins, or places ambient non-trigger symbols.
• nextFeatureFields: maps RED/BLUE/GREEN colors to the shared feature type/subtype fields.
• placeSymbols: chooses eligible cells and places symbols, respecting exclusions and optional unique-reel rules.
• addWilds: draws and places the round's weighted wild count.
• mapToWinLines: converts SDK ways wins into this game's display/result shape.
• executeGreenSpin: performs one green free spin: wilds/coins, ways scoring, and cap delta.
• executeGreenFeature: initializes/resumes GREEN, chooses its board dimensions/reel set, accounts for retriggers, wins, and closure.
• Cheat resolveSymbolOverlay: forces a trigger/type/color/count only in dev mode.
• Cheat executeRedFeature: forces a valid jackpot category while preserving normal pick-state/cap handling.
• Cheat executeBlueFeature: forces a wheel prize while preserving the normal result/state shape.
• categoryOf: removes a numeric tier suffix to group RED picks by jackpot category.
• parseCombination: accepts array or comma-separated reel stops only in dev mode.
• buildDevModeOverrides: gathers game-specific forced trigger, symbol, and feature values only in dev mode.

Mine Dash

Sources: engine, logic, stone-meter, cheat-logic, plugin.

• setLogger: passes monitoring into the engine.
• executeSpin: selects a weighted BG reel set, uses ReelSet_2 for valid forced stops, then executes stone and line logic.
• getLastSpinSimData: returns reel stops and selected reel set.
• executeFeature: generates a free-game view and resumes the saved free-spin state; stone collection advances only on base spins.
• resolveStoneOutcome: advances the persisted stone meters and returns a fired stone/position when a meter triggers.
• spin: applies a fired stone's board effect, places ambient wilds, calculates line wins, awards mystery/free spins, saves stone state, and caps the result.
• runFeature: applies stack replacement/wilds and line scoring to one free spin, then updates the saved counter and total.
• placeWilds: places wilds on shuffled eligible cells, protecting feature cells when requested.
• parsePositions: converts a comma-delimited math position string to indices.
• stoneSymbolFor / megawinStoneSymbol: render the current stone or banked MEGAWIN symbol name.
• stampPositions: writes a selected symbol at flattened positions.
• calculateLineWin / mapWinLines: call the SDK line calculator and map wins to game results.
• executeMultiFeature: builds the guaranteed-win board for a MULTI stone.
• executeWildsFeature: builds the tier-specific WILDS board and records its before/after modifier.
• executeMegawinFeature: creates the selected OAK combination and collects it into the winning row.
• executeMysteryFeature: draws and returns the flat mystery award and modifier.
• freshMeter / initialStoneState: create an empty meter or a new player's complete stone state.
• advanceStones: makes the stone selection, trigger, value, and pip updates on a copied state; a hit on pip five fires and resets that stone.
• validForcedValues: finds values that the real stone math tables can draw, for safe dev forcing.
• forceStoneFire / forceStoneLand: dev-only helpers to force a stone to fire now or land without firing.
• maxTier: keeps the best banked tier (numeric max, or symbol rank by five-of-a-kind pay).
• STONE_SELECTION_TO_KEY, STONE_MATH_KEY, STONE_RESERVED_REEL, STONE_KEYS: map sheet names, game keys, and reserved reels consistently.
• Cheat resolveStoneOutcome: delegates normally or uses the validated force-fire/force-land helper.
• parseCombination / buildDevModeOverrides: validate dev stop inputs and package stone overrides.

PigStyle

Sources: engine, logic, pigstyle-helpers, cheat-logic, plugin.

PigStyle uses variable-height reels. Its custom helper owns generation and path expansion; its intermediate board is padded row-major for scoring and converted to jagged column-major output for the client.

• executeSpin / executeFeature: choose production or cheat logic, invoke base/feature logic, and preserve simulator detail.
• getLastSpinSimData / getLastReelGenDetails: return stops, reel type, and selected row pattern.
• spin / runFeature: initialize a result and dispatch base-game scoring or feature continuation.
• runBaseGame: builds variable-height reels, derives symbols/wild multipliers, scores paths, caps wins, and records scatter triggers.
• selectReelSet: chooses the weighted base reel or the buy-bonus precomputed stop record; free games select their section's reel.
• selectRowPattern: chooses a row-height pattern, or uses the saved buy-bonus pattern.
• selectReelStopPosition: draws a stop or reuses the precomputed buy-bonus stop.
• selectRowLength: draws each reel height from the selected pattern or uses the buy-bonus record.
• addFGWilds: selects eligible middle-reel cells for feature wilds and returns display/flat positions.
• findWildMultipliers: draws a multiplier for each wild and records values greater than one.
• checkFeatureTrigger: creates the initial feature-selection state after 3+ scatters.
• continueFeature: processes the selection step or one FG1/FG2 free spin, updating state and caps.
• mathSection: maps platform feature names such as BuyBonusFG1 to math JSON sections BB1/BB2.
• getAllSymbols: reads a requested count of consecutive strip symbols with wraparound.
• convertMatrixToObj: creates flat-index, symbol, column, wild, and scatter lookups for scoring.
• createMatrixFromColumns: pads column data into a row-major matrix.
• getBetAmounts: converts total bet using the configured base-bet divisor.
• findMiddlePositions: lists nonblank, nonwild cells eligible for feature wild placement.
• buildPigStyleReelView: runs the decision points in fixed order to select reel, pattern, stop, and height; returns the board and simulator metadata.
• toJaggedReelView: removes padding and returns variable-height columns for the client.
• convertNumber: parses flattened path positions.
• populatePaylinesLeftToRight: recursively forms all left-to-right cell paths from the eligible cells on each reel.
• calculatePigStyleWinLines: finds matching paths, deduplicates identical paths, applies wild multipliers, and sums wins.
• playFG2: generates an FG2 board, carries/repositions prior sticky wilds when heights change, then adds new wilds and multipliers.
• Cheat overrides selectReelSet, selectRowPattern, selectReelStopPosition, selectRowLength, addFGWilds, and findWildMultipliers: replace only those decision points when valid dev cheats are supplied.
• buildSpinDevModeCheat / buildSharedCheat: parse spin-only or spin-and-feature dev controls; maxRowCount finds the tallest valid forced board.

Royale81

Sources: engine, logic, plugin.

• executeSpin: selects weighted BG strips, uses ReelSet_1 for dev overrides, and passes the selected set/forced wild options into logic.
• getLastSpinSimData: returns the selected set and stops.
• executeFeature: currently returns the prior result unchanged; there is no feature round in this implementation.
• spin: adds regular/feature wilds, calculates ways payouts, builds the feature modifier, and applies the maximum win cap.
• addWilds: draws normal wilds and optional triggered feature wilds, snapshots the display board between placements, and tracks added positions.
• getWildPositions: lists all wild cells on the final board.
• calculateWaysWins: enumerates left-to-right symbol/wild matches and applies the game's 2x multiplier for each wild in a path.
• cartesianProduct: expands per-reel match choices into all possible ways paths.
• buildDevModeOverrides (plugin): parses only explicit dev-mode wild controls.

Sweet Salon

Sources: engine, logic, plugin.

• executeSpin: chooses BG/ANTE/buy-bonus strips, generates the board, and delegates base-game scoring.
• getLastSpinSimData: returns reel stops.
• executeFeature: passes saved round state and dev-only feature choices to runFeature.
• spin: applies buy-bonus scatter placement and stack replacement; scores cluster cascades, free-spin bomb multipliers/retriggers, scatter pay, totals, and caps.
• runFeature: chooses the free-game type/reel set, scores one free spin, adds its multiplier/win to saved state, and closes when pending spins or caps are exhausted.
• spinFreeGame: generates one free-spin board from the selected strips and invokes spin in free-game mode.
• buildDevModeOverrides is not separate in this plugin; it parses the optional forced multiplier and reel combination inline in spin/feature.

14. Shared Runtime Settings vs. Game Math

Use these boundaries when deciding where a new value belongs:

• Math JSON: game-mode data such as layout, symbols, reel strips, weights, paytable, lines, and feature rules.
• Plugin input/output: the SDK contract values passed by the core, plus this game's gameData result.
• RGS/player response: session, bet limits, balance, promo state, rtp, opCnf, and epoch values.
• Environment configuration: service-level connection/retry settings such as RGS_URL and the RGS pool/timeouts.
• SDK helpers: algorithms shared across games; use only when their behavior matches the game's rule.
• Pack/core/RGS layers: plugin registration, HTTP, persistence, debit/credit, logging, and response envelopes.

This distinction matters because identically named data can have different owners. For example, RGS rtp response data is not the same thing as the plugin's gameMode, and neither one substitutes for the game's paytable or reel weights.

15. Related Sources

• Gameplay guide
• Plugin
• Engine
• Logic
• Interfaces
• Package exports
• SDK plugin contract
• SDK spin input/output types
• Game request DTOs
• Game service orchestration
• Game controller and HTTP envelope
• Response contracts
• RGS player and session contract
• Player-info mapping
• HTTP response wrapper
• Plugin registry and lifecycle
• Core module registration
• Pack game registration
• RGS service configuration
• SDK arithmetic helpers
• SDK weighted-draw helpers
• SDK reel-set selector
• SDK ways calculator
• SDK cascade refill
• SDK cluster helpers
• SDK stack-symbol replacement
• SDK win-cap helper
• SDK exports
• SDK reel generator
• SDK win-line calculator