Scatter pays and free spins retriggers: simple math modeling of bonus rounds

To model scatter pays, free spins, and retriggers, treat each bonus trigger as a probability event, assign each outcome an average payout, then combine them into an expected value (EV) and variance estimate for the whole bonus. This simple slot bonus round math model lets you forecast RTP impact and volatility, and safely test changes before deployment.

Core concepts behind scatters, free spins and retriggers

• Scatter pays are separate from paylines: model them as a distribution of outcomes (e.g., 3/4/5 scatters) with their own payouts.
• Free spins are a conditional game state: EV is "trigger probability × expected payout during the feature".
• Retriggers create feedback: the feature length becomes a random variable; caps strongly shape risk.
• RTP vs volatility: two designs can share the same EV but have very different variance and tail risk.
• Use math first, simulation second: closed-form estimates catch obvious errors; Monte Carlo validates edge cases.

Probabilistic model of scatter pays: rates, clusters and payouts

This approach fits designers/analysts who need a fast, auditable way to reason about scatter pays slot bonuses and their RTP contribution without building a full reel-strip simulator. It also helps when you have only aggregate trigger rates and average payouts from playtests.

Don't rely on it when:

• Scatter outcomes are highly dependent on complex reel/ways rules you can't summarize as stable probabilities.
• Payouts depend heavily on player choices or multi-stage branching (you'll need a state model).
• You are tuning very tight RTP targets where small modeling bias is unacceptable (use a full engine sim).

Minimal math: let outcomes be k ∈ {0,3,4,5}. If P(k) is the probability of landing k scatters and Pay(k) is the scatter payout (in bet units), then:

EV_scatter = Σ P(k)·Pay(k)

Numeric mini-example (scatter pays): suppose P(3)=0.010, P(4)=0.001, P(5)=0.0001; Pay(3)=2, Pay(4)=20, Pay(5)=200 (all in bet units). Then:

EV_scatter = 0.010·2 + 0.001·20 + 0.0001·200 = 0.02 + 0.02 + 0.02 = 0.06 bet per base spin from scatters alone.

Free spins mechanics: expected value, variance and hold calculation

To model free spins bonus round mechanics, you need a few measurable inputs (from prototype logs, math sheets, or controlled simulation):

• Trigger probability p_trig per base spin (or per paid spin).
• Initial free spins grant N (e.g., 10 spins), plus any multipliers/conditions.
• Average payout per free spin μ_fs in bet units (can differ from base due to multipliers/reels).
• Variance per free spin σ²_fs (or at least a rough estimate).
• Retrigger rule (probability, extra spins, caps), since it changes the effective feature length.

Baseline EV without retriggers: if each free spin has mean μ_fs and you always get N spins, then:

EV_feature = N·μ_fs

EV_contribution to base spin = p_trig · EV_feature

Variance sketch (without retriggers): if free spins are treated as i.i.d. with variance σ²_fs, then feature variance is:

Var_feature ≈ N·σ²_fs

This approximation breaks when spins are correlated (e.g., progressive multipliers), but it's useful for risk triage.

Hold note (operator lens): if you're estimating hold, keep units consistent. Player expected return ≈ (base game EV + bonus EV) in "bet per paid spin". Hold is driven by (1 − RTP). When you later calculate RTP from free spins and retriggers, the bonus EV is usually the easiest place to over/under-shoot.

Numeric mini-example (free spins): p_trig=0.005 (0.5%), N=10, μ_fs=0.8 bet. Then EV_feature=8 bets, and EV contribution per base spin = 0.005·8 = 0.04 bet.

Retrigger behavior: geometric series, state transitions and caps

Risks and limits to state clearly before you model:

• Tail risk: small changes to retrigger rate can create very long features and extreme payouts.
• Cap sensitivity: max retriggers / max spins often dominates volatility more than the mean does.
• Non-independence: retrigger chance may vary by remaining spins, multipliers, or reel-set.
• Accounting mistakes: mixing "per paid spin" and "per free spin" probabilities is a common silent error.

1. Define the retrigger event and units. Decide whether your retrigger is measured per free spin (most common) or per feature, and keep it consistent. Write: with probability r, a free spin awards +A extra spins.
   • Use r for the retrigger free spins probability per free spin.
   • Use A for the number of spins added per retrigger (e.g., +5).
2. Compute the expected total number of free spins (uncapped). Treat "spins remaining" as a branching process. If each spin can add A new spins with probability r, then expected total spins is:
   • E[T] = N / (1 − r·A) provided r·A < 1.
   • If r·A ≥ 1, the expectation diverges (practically: the design is unstable without a hard cap).
3. Translate total spins into expected payout. If each free spin has mean μ_fs, then:
   • EV_feature = E[T] · μ_fs
   • EV per paid spin = p_trig · EV_feature

   This is the fastest way to connect retriggers to "what happens to RTP".

4. Add a cap as a controlled safety valve. Real games cap retriggers (R_max), total spins (T_max), or feature win (W_max). Model caps explicitly because they reduce EV slightly but can reduce variance drastically.
   • Simple approximation: compute uncapped EV, then run a Monte Carlo with the cap to measure EV drop and variance change.
   • If you must do closed-form: treat capped total spins as min(T, T_max) and estimate E[min(T, T_max)] via simulation tables.
5. Use a small state model when rules depend on feature state. If retrigger rate changes with multipliers or remaining spins, use a Markov-style transition:
   • State = (spins_remaining, multiplier_level, reelset_id).
   • Transition updates spins_remaining with retrigger outcomes, and tracks payout distribution per state.

   This is still a "simple" model if you keep states coarse and measurable.

Numeric mini-example (retriggers): N=10, μ_fs=0.8, r=0.08 per free spin, A=5. Then r·A=0.4, so:

E[T] = 10 / (1−0.4) = 16.666... spins, EV_feature ≈ 16.666...·0.8 = 13.33 bets.

Practical simulation: simple Monte Carlo and convergence checks

Use simulation to validate your assumptions and quantify variance. Minimal pseudo-code for one feature:

spins = N
win = 0
while spins > 0 and spins < T_max:
  spins -= 1
  win += sample_free_spin_payout()
  if rand() < r and spins + A <= T_max:
    spins += A
return win

• Verify your RNG seed control (repeatable runs) and then run with multiple seeds (stability).
• Run separate simulations for: base game only, feature only, and combined "paid spin → maybe trigger feature".
• Track mean, standard deviation, and at least a few quantiles (e.g., median, high percentile) to see tail behavior.
• Check convergence by plotting running mean of EV_feature versus number of simulated features.
• Confirm the simulated average feature length matches E[T] from your math when caps are removed.
• Test sensitivity: bump r slightly up/down and observe EV and tail growth (retriggers are nonlinear).
• Validate cap behavior: ensure the cap triggers at the intended frequency and doesn't bias results via implementation bugs.
• Log a small sample of full feature traces (spins, retriggers, payouts) to spot rule misreads.

Risk-aware tuning: volatility, RTP targets and bankroll stress tests

• Overfitting to EV: hitting your target RTP while doubling variance can break bankroll and player experience.
• Ignoring r·A stability: designs close to r·A=1 become extremely sensitive; small tweaks create huge tail growth.
• Cap only on wins, not on spins: a win cap can still allow very long low-paying features; consider a spin cap too.
• Mixing conditioning: using μ_fs measured under one reel-set while retrigger r comes from another biases EV.
• Assuming independence: multipliers that increase during the feature typically correlate wins and inflate variance.
• Not separating "trigger rate" from "scatter pay rate": scatters can both pay and trigger; model both pathways explicitly.
• Failing to stress test tails: a rare long retrigger chain can dominate max exposure even if mean looks fine.
• Stopping simulation too early: rare events converge slowly; use more runs when retriggers exist.

Worked example: step-by-step math, table of scenarios and interpretation

Below is one consistent setup that connects scatter pays slot bonuses, free spins bonus round mechanics, and retrigger free spins probability into a single, simple forecast. This is a pragmatic slot bonus round math model you can audit and then validate with simulation.

1. Scatter pays EV per base spin: from the earlier mini-example, EV_scatter = 0.06 bet.
2. Trigger probability for free spins: assume p_trig = 0.005 per paid spin.
3. Free spin payout mean: assume μ_fs = 0.8 bet per free spin.
4. Compute EV_feature under each retrigger scenario: use E[T] = N/(1−r·A) when uncapped and stable.
5. Compute total bonus EV per base spin: EV_bonus_total = EV_scatter + p_trig·EV_feature.

Scenario	Inputs (N, r, A, μ_fs)	Expected total spins E[T]	EV_feature (bets)	EV from FS per paid spin = p_trig·EV_feature	Total bonus EV per paid spin (scatter + FS)	Volatility note (qualitative)
No retrigger	N=10, r=0, A=5, μ_fs=0.8	10	8.0	0.005·8.0 = 0.04	0.06 + 0.04 = 0.10	Lower tail risk; variance dominated by per-spin payout
Moderate retrigger	N=10, r=0.05, A=5, μ_fs=0.8	10/(1−0.25)=13.33...	10.67	0.005·10.67 ≈ 0.053	0.06 + 0.053 ≈ 0.113	Noticeably higher variance; longer features appear occasionally
Aggressive retrigger	N=10, r=0.08, A=5, μ_fs=0.8	10/(1−0.4)=16.67...	13.33	0.005·13.33 ≈ 0.0667	0.06 + 0.0667 ≈ 0.1267	High tail sensitivity; caps become important for exposure control

Interpretation: even when scatter pays EV is unchanged, retrigger parameters can materially shift expected bonus contribution. To calculate RTP from free spins and retriggers reliably, you must also account for cap effects and the fact that variance (not just EV) grows faster as retriggers strengthen.

Alternatives you should choose when appropriate:

• Full reel-strip simulation: when trigger probabilities and payouts can't be treated as stable inputs.
• Markov/state model: when multipliers, reel-sets, or "spin remaining" materially change r or μ_fs.
• Hybrid approach (math + Monte Carlo): use closed-form E[T] for quick tuning, then simulate to measure cap bias and tail quantiles.

Practical clarifications and concise answers

How do I separate scatter pays from scatter-triggered features?

Model two branches: a direct scatter payout EV, and a feature-trigger probability p_trig leading to EV_feature. If a single scatter outcome both pays and triggers, include both contributions for that outcome.

What is the fastest sanity check for retriggers?

Compute r·A. If r·A is close to 1, your expected feature length becomes extremely sensitive and you should add or tighten caps and run longer simulations.

Can I use base-game payout per spin as μ_fs for free spins?

Only if free spins use the same reels, paytable, and multipliers. If free spins have enhanced symbols or multipliers, measure μ_fs specifically for the feature.

How do caps affect EV and why can't I ignore them?

Caps usually reduce EV slightly but can massively reduce variance and tail exposure. Ignoring caps tends to overestimate both RTP contribution and maximum liability.

What's a common mistake when I calculate RTP from free spins and retriggers?

Mixing "per paid spin" trigger rates with "per free spin" retrigger rates in the same formula. Keep p_trig for paid spins, and r for free spins.

Do I need variance if I only care about RTP?

Yes for risk management: two configurations can match RTP but differ in bankroll stress and maximum win frequency. Variance/tail checks prevent "RTP-correct but unsafe" designs.