Carpathian Treasures: Gameplay Guide

This guide explains how a Carpathian Treasures base-game spin is represented in the checked-in R4 math configuration, turned into a visible reel view, evaluated for wins, and returned by the game plugin. It is intended as a gameplay and math-to-runtime introduction, not a full platform architecture or certification guide. For certification and request-body encoding, see certification and request encoding.

For function-by-function explanations, shared request/response keys, and a map of the other game packages, see the code walkthrough. For the pack/bootstrap and shared runtime flow, see the runtime architecture guide.

1. At a Glance

The game loads its R4 math JSON when the plugin starts. The init operation returns the paytable. A spin uses the requested bet and mode to generate a reel view, calculate wins, and return a game result. The game currently does not start a follow-up feature round.

2. Key Terms and Symbols

The symbolic names are mapped in the math JSON under symbolsMap. The JSON is the game's runtime math input, but a field being present in the JSON does not by itself mean the current engine uses it; see Configured vs Implemented.

From Math Workbook to Runtime JSON

The separate feg_parse-maths CLI has a Carpathian command that reads an Excel workbook and extracts math ranges. It currently reads rawMaths/carpathianTreasures/carpathian_treasures_v1_92.xlsx, extracts a reel strip starting at B19:B106 (and derives the other four reel columns), win lines from G13:K22, and paytable data from B22:G31. It maps workbook symbols such as HV1 and SCATTER to runtime IDs such as H1 and SC.

That command writes feg_parse-maths/output/carpathian-treasures-<variant>.json; the default filename suffix is R7. This is not automatically copied into the game package. Runtime loads the checked-in R4 math JSON.

The parser's current output shape is only a subset of that runtime config: it emits BG.ReelSet_1, paytable, paylines, wild metadata, and symbolsMap, but not the runtime config block or the extra reel sets/selector fields. A carpathian_treasures_v2.xlsx workbook is present too, while the current command still names v1_92 directly. Confirm the authoritative workbook and reconcile parser output with runtime types/rules before replacing the game's math file.

Math sheet metrics

These terms commonly appear in a game's math sheet or simulation report. They describe the overall probability and payout behavior; they are not values calculated by an individual spin.

The checked-in R4 JSON contains the runtime layout, reel data, paytable, and paylines, but no RTP, hit-rate, volatility, or SD summary values. For a reported number, use the approved math sheet or simulation report and follow the math team's definitions and units.

3. From Spin Request to Reel View

The high-level game flow is:

1. The plugin loads carpathian-treasures-R4.json during onLoad.
2. The spin operation retrieves the math configuration for the requested mode and passes the bet to the game engine.
3. The engine asks the SDK reel generator to build a 5-column, 3-row view from BG.ReelSet_1.
4. The game logic evaluates paylines, scatter pays, and bonus-symbol pays, then builds the result.
5. The plugin returns the result and summary amounts to its caller.

The reel generator selects one stop independently for each column. Starting at that index, it takes three consecutive symbols from that column's strip. If the strip ends before all visible rows are filled, indexing wraps to the beginning of the same strip. Thus, each stop determines one column's visible symbols; it does not select a multi-row block shared across all reels.

The SDK requests each stop through its RNG service. The exact RNG service and certification integration are platform concerns and are outside this guide. In development mode only, extraData.combination can supply stop indices instead; it may be an array or a comma-separated string. This is a test hook, not normal spin behavior.

The board is stored column-major: reelView[column][row]. For example, reelView[0] is the first reel and contains its three visible symbols.

Active reel-strip symbol distribution

The table below counts each symbol in the active BG.ReelSet_1 strips. Each cell shows count (share of strip positions). Strip lengths differ by reel. This describes the stored symbol mix; it is not the probability of seeing a symbol anywhere in the three visible rows or the probability of a win.

4. How Wins Are Evaluated

Fixed paylines

The R4 math JSON defines 10 paylines as sequences of flat cell positions. The board has five columns, so a flat position p maps to:

• Column: p % 5
• Row: floor(p / 5)

The positions in a line are evaluated from left to right. A regular-symbol win starts at the first reel and continues through consecutive matching symbols; WD can substitute for a regular symbol. A mismatch, SC, or BN ends the match. Each line pays at most its best qualifying result. This is a paylines game, not a ways evaluation.

The line definitions are stored in winLines in the math JSON. Their order determines the 1-based lineNumber reported in each win result.

Paytable and bet scaling

For regular line symbols, the paytable array index corresponds to the number of matching positions minus one. For example, the third value is the payout for three matching positions. The game uses a base bet of 10 and scales each paytable value by the total bet:

win amount = paytable value x (total bet / base bet)

The same base-bet scaling is used for scatter and bonus-symbol payouts. The current R4 values are:

The values above are the paytable multipliers before bet scaling. SC and BN are counted across the visible board rather than evaluated as paylines. WD has no standalone payout in this paytable; it participates as a substitute in line evaluation.

Expanding wilds

The runtime treats every reel containing at least one WD as a candidate expanding reel for line evaluation: all row positions on that reel are evaluated as wild. The returned expandedReelView shows a candidate reel filled with WD only when a winning line uses a position on that reel. Otherwise that reel is returned with its original symbols. wildExpandedReels contains the zero-based column indices of reels shown as expanded.

Scatter and bonus positions and counts are calculated from expandedReelView. Consequently, a reel that contributes as an expanded wild is represented as wild symbols in those result calculations too.

5. Reading the Spin Result

The plugin's gameData is the game-specific spin result. The main fields are:

At the plugin output level, featureTriggered is derived from whether nextFeature is non-null. For the current game implementation it is false. The plugin also reports bonusWinAmount and bonusRoundCount as zero.

6. Configured vs Implemented

The math JSON contains ReelSet_2, ReelSet_3, and Reel_Selection_Weight, but the current spin engine always supplies BG.ReelSet_1 to the reel generator. The other reel sets and selector weights do not affect spins in this implementation.

The JSON's wild metadata lists reels and says expansion is enabled. Runtime expansion behavior is determined by logic.ts; it does not read the metadata's reel list. Do not infer a reel restriction from that list without confirming a separate intended rule.

The bonus symbol has a base-game paytable entry, but the code does not trigger or run its Jackpot feature. executeFeature returns the previous spin result unchanged. There is no free-spin or bonus-round logic in this game package for this milestone.

The checked-in R4 JSON does not include summary values for RTP, volatility, or hit rate. This guide does not infer those values; use the approved math/PAR source for them.

7. Scope of This Guide

This document covers gameplay, math configuration, reel generation, scoring, and the game-specific spin result. It intentionally does not document certification workflows, hash generation, encryption/decryption, shared platform request/response architecture, or client-side animations. Those topics belong in follow-up architecture and integration documents.

8. Source Files

• Game plugin
• Spin engine
• Scoring logic
• Game interfaces
• R4 math configuration
• SDK reel generator
• SDK win-line calculator