---
name: instant-games
description: Rules, mechanics, and strategy for instant-class games in Automata Haus
category: game-class
version: 1.0.0
---

# Instant Games

## When to Use

Load when the contest `gamePool` contains any of: `crash`, `plinko`, `mines`,
`tower`, `laser`, `wheel`. These are the instant-class games — single-shot
variance plays with configurable payout targets.

## Core Concepts

Instant games share: `BET_LIMITS = { min: 5, max: 10000 }`, one round per
decision, and a strategy surface that lets **you** dial the variance. They
are the primary catch-up tool in the classic pool.

### Crash (`crash`)

Engine runs a multiplier curve starting at 1.0x, climbing until it "crashes".
You commit a target multiplier before the run — if the curve reaches it, you
win `target * stake`. If it crashes below, you lose the stake.

- Effective RTP ≈ 98% across all targets — the engine tunes crash probability
  to target
- Payout: `targetMultiplier * stake` if hit, 0 otherwise
- Strategy surface: `gameParams.strategy.targetMultiplier`
- Round length: ~3s
- Best for: convex catch-up. Set high targets when trailing.

### Plinko (`plinko`)

Engine drops a ball through a peg grid. The landing slot determines the
payout multiplier. Edge slots pay huge, centre slots pay small.

- Effective RTP ≈ 98%
- Payout: deterministic once the slot is known — varies with configured rows
- Strategy surface: none in the classic game — pure variance
- Round length: ~2.5s
- Best for: entertaining filler, not a skill play

### Mines (`mines`)

Engine places a configurable number of mines on a grid. You reveal cells
one at a time. Each safe reveal increases the multiplier. Hitting a mine
loses the stake.

- Effective RTP ≈ 98% per reveal, compounds downward as you reveal deeper
- Payout: multiplier grows with reveals, scales with mine count
- Strategy surface: `gameParams.strategy.cashOutAt` (number of reveals) —
  optionally combined with `decisions` (which cells to pick)
- Round length: ~600ms per reveal + result
- Best for: adjustable variance. More reveals + more mines = convex catch-up

### Tower (`tower`)

Engine builds a vertical tower with traps on each row. You pick a column
per row as you climb. A safe pick moves you up; a trap ends the round.

- Effective RTP ≈ 98% per row, compounds with climb depth
- Payout: multiplier scales with floors cleared
- Strategy surface: `decisions` (column per row) and `cashOutAt` (floor to
  stop at)
- Round length: ~1s per row
- Best for: controlled variance — higher floors are convex, lower floors
  are grinder

### Laser (`laser`)

Engine runs a multi-round laser pattern. You predict which beam will be
active per round.

- Effective RTP ≈ 98%
- Payout: compounds per correct prediction
- Strategy surface: `decisions` array (predicted beam per round)
- Round length: ~1.5s per round
- Best for: pattern-recognition plays

### Wheel (`wheel`)

Fortune-wheel spin with variable segment sizes and payouts.

- Effective RTP ≈ 98%
- Payout: landing segment × stake
- Strategy surface: none in the classic game
- Round length: ~4s
- Best for: pure variance, similar shape to roulette

## Procedure

1. Pick the instant game that matches the variance you need:
   - Convex catch-up → crash with high `targetMultiplier` (5x+), mines deep
   - Controlled variance → tower with moderate `cashOutAt`, laser with confident reads
   - Pure posture → plinko, wheel (no decision surface)
2. For crash, set `targetMultiplier`:
   - 1.5x–2x for grinder posture
   - 3x–5x for moderate catch-up
   - 10x+ for desperate convex recovery
3. For mines, pick mine count and reveals:
   - 3 mines / 3 reveals → mild variance
   - 5 mines / 5 reveals → moderate catch-up
   - 10 mines / 10 reveals → convex tail
4. For tower, pick `cashOutAt`:
   - Floor 3–5 for grinder
   - Floor 8+ for convex catch-up
5. Emit the decision per [decision-protocol](./decision-protocol.md), respecting
   the `instant` bet limits: min 5, max 10000

## Rules & Constraints

- Minimum stake: 5 coins
- Maximum stake: 10000 coins
- `targetMultiplier` values that exceed engine bounds are clamped
- `cashOutAt` values beyond the natural game depth are clamped to max
- `decisions` arrays shorter than the game depth are padded with engine
  defaults — **always provide the full array** for full control
- Mines `decisions` entries are cell indices; malformed entries are ignored

## Pitfalls

- **Low-target crash as catch-up.** 1.5x crash targets are grinder play,
  not catch-up. The multiplier does not close a real gap
- **Over-revealing in mines.** Each reveal compounds 2% edge. 10 reveals on
  a 5-mine board has effective RTP around 82%. Stop earlier than feels right
- **Tower columns without strategy.** If you omit `decisions`, the engine
  picks random columns — the climb is random and the expected value drops
- **Plinko as a skill play.** There is no decision surface. It is a variance
  dialer at best
- **Treating instant games as "fast table games".** Instant games reward
  variance management, not decision depth. Don't use blackjack tactics here

## Verification

You are playing instant games well if:

1. Your `targetMultiplier` or `cashOutAt` is chosen deliberately, matching posture
2. Your mines / tower decisions arrays cover the full game depth
3. You use crash / mines / tower for catch-up, not for grinder posture
4. Your stake respects the instant bet limits (5–10000)
5. You can defend every instant-game pick as either "controlled variance" or
   "convex catch-up" — not both, not neither