Carpathian Treasures: Gameplay Guide
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
| Item | Current implementation |
|---|---|
| Game ID | carpathiantreasures |
| Math mode | R4 |
| Visible layout | 5 columns x 3 rows |
| Win model | 10 fixed paylines, plus scatter and bonus-symbol pays |
| Active base-game reel set | BG.ReelSet_1 |
| Base bet used for payout scaling | 10 |
| Free spins / bonus rounds | Not implemented in this milestone |
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
| Term or code | Meaning in this game |
|---|---|
| Reel strip | An ordered, circular list of symbols for one reel/column. |
| Reel stop | The selected starting index on a reel strip for one spin. |
H1-H4 | High-value regular symbols. |
L1-L4 | Low-value regular symbols. |
WD | Wild symbol. It substitutes for regular symbols during line evaluation. |
SC | Scatter symbol. It is excluded from line matching and pays by its count on the board. |
BN | Bonus symbol. It is excluded from line matching and pays by its count on the board. Its Jackpot feature is not implemented here. |
| Paytable value | A multiplier used by the scoring code, not a fixed currency amount. |
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.
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.
| Term | Plain-language meaning |
|---|---|
| RTP (Return to Player) | The expected share of all wagered credits returned as wins over a very large number of plays. It is a long-run statistical measure, not a promise about one spin or one player's session. |
| Hit rate (hit frequency) | The proportion of spins that produce a win under the report's definition of a hit. Check whether the report includes every nonzero win or reports feature triggers and other events separately. |
| Volatility | A description of how wins are distributed: how often wins occur and how large they tend to be. Higher volatility generally means less even results, but the label alone does not specify a precise probability or guarantee a particular pattern. |
| SD (standard deviation) | A statistical measure of how widely outcomes vary around their average. Slot reports often express it relative to the bet; consult the sheet for the exact outcome and units used. SD is related to volatility, but the terms are not interchangeable. |
| Theoretical vs. simulated result | A theoretical value is calculated from the math model. A simulated value is estimated by running many spins, so it can vary with sample size and random outcomes. |
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:
- The plugin loads
carpathian-treasures-R4.jsonduringonLoad. - The spin operation retrieves the math configuration for the requested mode and passes the bet to the game engine.
- The engine asks the SDK reel generator to build a 5-column, 3-row view from
BG.ReelSet_1. - The game logic evaluates paylines, scatter pays, and bonus-symbol pays, then builds the result.
- 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.
| Symbol | Reel 1 (88 positions) | Reel 2 (84 positions) | Reel 3 (80 positions) | Reel 4 (75 positions) | Reel 5 (88 positions) |
|---|---|---|---|---|---|
BN | 3 (3.4%) | 0 (0.0%) | 3 (3.8%) | 0 (0.0%) | 6 (6.8%) |
H1 | 4 (4.5%) | 6 (7.1%) | 6 (7.5%) | 6 (8.0%) | 5 (5.7%) |
H2 | 9 (10.2%) | 3 (3.6%) | 14 (17.5%) | 4 (5.3%) | 7 (8.0%) |
H3 | 3 (3.4%) | 16 (19.0%) | 9 (11.3%) | 7 (9.3%) | 10 (11.4%) |
H4 | 13 (14.8%) | 6 (7.1%) | 9 (11.3%) | 18 (24.0%) | 10 (11.4%) |
L1 | 11 (12.5%) | 9 (10.7%) | 11 (13.8%) | 8 (10.7%) | 12 (13.6%) |
L2 | 13 (14.8%) | 15 (17.9%) | 8 (10.0%) | 9 (12.0%) | 12 (13.6%) |
L3 | 11 (12.5%) | 11 (13.1%) | 10 (12.5%) | 9 (12.0%) | 13 (14.8%) |
L4 | 17 (19.3%) | 13 (15.5%) | 5 (6.3%) | 10 (13.3%) | 11 (12.5%) |
SC | 4 (4.5%) | 4 (4.8%) | 2 (2.5%) | 2 (2.7%) | 2 (2.3%) |
WD | 0 (0.0%) | 1 (1.2%) | 3 (3.8%) | 2 (2.7%) | 0 (0.0%) |
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:
| Symbol | 2 matches | 3 matches | 4 matches | 5 matches |
|---|---|---|---|---|
H1 | 10 | 50 | 250 | 5000 |
H2 | 0 | 40 | 120 | 700 |
H3 | 0 | 40 | 120 | 700 |
H4 | 0 | 20 | 40 | 200 |
L1-L4 | 0 | 10 | 30 | 150 |
SC | 0 | 50 | 200 | 1000 |
BN | 0 | 200 | 0 | 0 |
WD | 0 | 0 | 0 | 0 |
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:
| Field | Meaning |
|---|---|
reelView | Original visible board, stored as [column][row]. |
expandedReelView | Board used for the returned expanded-wild display and scatter/bonus counting. |
winLines | Winning line entries, including line number, symbol, count, amount, and flat winning positions. |
lineWin | Sum of winning paylines. |
scatterWin / scatterPositions | Scatter payout and its [column, row] positions. |
bonusWin / bonusPositions | Bonus-symbol payout and its [column, row] positions. |
wildExpandedReels | Zero-based column indices displayed as expanded wild reels. |
spinWin / totalWin | Total for the spin: line win plus scatter win plus bonus win. |
bet | Total bet used for the spin. |
baseWin | Set to the spin's total win by the current logic. |
nextFeature / featureResults | Feature continuation data; currently null and an empty array. |
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.
