Slot Features

Slot Features are the nodes that close the gaps in the September slot mechanics review: cluster pays, meters and multiplier ladders, coin values and jackpots, bonus buy and RTP variants, sticky, expanding and locked symbols, hold-and-win, wheels, picks, and the player-side pieces around them (autoplay, audio mixing, rollups, responsible-gaming timers, jurisdiction rules, accessibility, telemetry).

They come in three groups. The group decides where a node runs and how it reaches the RGS.

Group	Where it runs	Where to find it
Slot Features (21 maths nodes)	In the editor preview and on the RGS. Deploy them inside a Maths Component like any other maths node.	Node picker → Math → Slot Features
Slot Player UX (17 nodes)	In the browser only. They drive the screen, sounds and player limits; the RGS never sees them.	Logic & Utilities → Slot Player UX
Pixi (2 nodes)	In the browser, inside your Pixi stage.	Pixi → Core Game Nodes

Same maths in the preview and on the server

Every maths node in the group calls one shared library of pure functions. The editor node runs it in the browser; when you deploy the component, the compiler embeds the same functions in the generated evaluate(ctx) script and calls them there. What you see in the preview is what the server pays, for the same inputs and seeds.

Three rules follow from that:

1. Seeds are required. Wire ISAAC Random Number Array Generator → array into every Seeds port. Unseeded, a node refuses to run (it logs the reason, empties its outputs and still fires Done), exactly like Weighted Reels.
2. Signals are booleans on the server. A signal input such as reset, step or start is read as "did this fire this round". Wire it from a gateway signal or from another node's boolean output. Outputs that are booleans in the editor (hasWin, filled, roundOver) stay booleans; use Condition or If to branch on them.
3. State is server-owned. The eight stateful nodes (Progressive Meter, Multiplier Ladder, Sticky Symbols, Locked Reels, Hold And Win Grid, Symbol Upgrade, Pick Bonus, Chapter Branch) keep their state across rounds through the same channel Counter uses. On the platform that state persists for identified players; a guest session starts fresh every round.

Grid conventions

Every grid node uses the conventions of the existing slot nodes:

• reels is an array of columns, each an array of rows: reels[col][row], 1-based symbol ids, 0 = blank.
• Positions are [row, col] pairs — the order Cascade The Reels, Check Jackpot and winningLinesDetails already use. (Check Wins' customPaylines are [col, row]; do not mix the two.)
• winningLinesDetails entries are { line, symbols, positions, payout }, the Calculate Winnings shape, so Cluster Pays can feed Cascade The Reels or Directional Cascade directly.
• Paytables are { symbol: { count: multiplier } }, the Get Paytable shape.
• Money is in integer minor units.

Recipes

Cluster pays with tumbles. Weighted Reels → Cluster Pays (reels, paytable, betAmount) → Directional Cascade (winningLinesDetails, symbolWeights, Seeds). Hold the grid in a Variable2, write Directional Cascade's reels back to it, and fire Do again while hadRemoval is true. Step a Multiplier Ladder from hadRemoval to raise the multiplier per tumble and scale the total with the Multiplication node.

Hold and win. Symbol Value Grid marks the coins in the base grid. Hold And Win Grid start locks them; each respin redraws the free cells from symbolWeights and Seeds, locks any new coin and keeps its value. Wire lockedCells into pixi.CellOverlay cells for the frame around held coins, freeColumns from Locked Reels into Column Spin Router when you spin only the free columns, and arm a Reel Stop Watcher on the same columns to know when they have all stopped. isComplete ends the round; totalValue is the win.

Sticky wilds during free spins. Sticky Symbols with captureOnDo on: every spin, wilds that land are remembered for duration spins and written back into the next grid. stickyPositions → pixi.CellOverlay cells highlights them. The renderer re-lands the sticky symbol on every spin rather than freezing the cell.

Expanding and oversized symbols. Expand Symbols rewrites the grid (column, row, cross, 2×2 or 3×3 block) and emits spans; wire them into pixi.CellOverlay spans with the symbol's image in spriteImages so one sprite covers the block. Evaluate wins on the expanded grid.

Bonus buy and RTP variants. In the UI, Bet Mode in base-to-cost mode turns the base bet and the chosen mode into the cost to charge; send that cost as the bet. Inside the maths, Bet Mode in cost-to-base mode recovers the base stake for the paytable and sets forceFeature for a bonus buy. Variant Selector picks the reel strips, weights and paytable scale for the mode or RTP key. Each mode still needs its own certified RTP run.

Progressive pots. Progressive Meter for a per-player meter (identified players persist across rounds). For platform pools, RGS Jackpot Pools: on the server it reads the live pools and, when your maths decides a scatter pool has hit, put its claims output on a Component Outputs port named jackpotClaims; the platform pays the pot with the round. In the browser the same node shows the current pool values.

Wheel and pick bonuses. Wheel Spin picks the segment from the weights and Seeds first; pixi.Wheel animates to segmentIndex. Pick Bonus shuffles the prizes and end-cards from Seeds on start, reveals on pick with pickIndex, and keeps the hidden pool on the server, never in the response.

Autoplay that respects the market. Jurisdiction Rules (fetch with the game slug) exposes what the operator's jurisdiction allows; wire autoplayAllowed into Autoplay allowed, turboAllowed into your turbo toggle, and realityCheckIntervalMin into Reality Check.

What the platform reads for you

Three read-only routes on the component endpoint need no credentials and are what the browser-side nodes call:

Route	Used by	Returns
GET /rgs-fn/{game}/__client-rules	Jurisdiction Rules	The operator's jurisdiction flags: autoplay, turbo, slam-stop, feature-buy, stake cap, pacing, reality-check interval
GET /rgs-fn/{game}/__jackpots	RGS Jackpot Pools	The game's active pools: id, name, type, current value, claimable
GET /rgs-fn/{game}/__leaderboard	RGS Leaderboard	The active tournament and a masked leaderboard

RGS Translations reads GET /game-translations?lang=…&game_slug=… for the platform's string catalogue and its language list.

Limits worth knowing

• The renderer animates cascades downward only. Directional Cascade computes up, left and right correctly; use the fade cascade style for those directions.
• Cells are 1×1 in the renderer. Sticky and oversized symbols are drawn by pixi.CellOverlay on top of the reel columns, which still land whole columns.
• Every stateful mechanic on the platform needs an identified player. Guest sessions replay stateless.
• A maths component that still uses Cascade The Reels cannot be deployed: it has no server-side implementation, and Deploy refuses it. Move the logic to Directional Cascade or a JavaScript Function.