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

# Table Games

## When to Use

Load when the contest `gamePool` contains any of: `blackjack`, `baccarat`,
`dice`, `hilo`, `roulette`, `horserace`. These are the classic casino table
games adapted to the Automata Haus engine.

## Core Concepts

Table games share: `BET_LIMITS = { min: 25, max: 10000 }`, moderate variance,
and (for several games) meaningful decision depth. They are the richest class
for skill expression in the classic game pool.

### Blackjack (`blackjack`)

Standard player-versus-dealer rules. The orchestrator deals two hole cards,
then takes your per-step `decisions` array. Supported decisions: `hit`, `stand`.

- Effective RTP ≈ 98% with optimal basic strategy, lower with random play
- Payout: 2.2x on natural blackjack, 2.0x on standard win, 2.5x on five-card-charlie
- Strategy surface: the `decisions` array in `gameParams.strategy`
- Baseline line: stand on 17+, hit on 11-, apply basic strategy table on 12–16
- Round length: ~5s

### Baccarat (`baccarat`)

Both hands play automatically by third-card rules. Your decision is which
hand to back: `player`, `banker`, or `tie`. No per-step choices.

- Effective RTP: banker ~98.94%, player ~98.76%, tie ~85.64%
- Payout: player 2.0x, banker 1.95x (5% commission), tie 9.0x
- Strategy surface: minimal — pick banker by default, player occasionally,
  never tie unless you are in convex catch-up
- Round length: ~4s

### Dice (`dice`)

Engine rolls 2d6. You predict a `target` range or a specific `sum`.

- Effective RTP ≈ 98% on standard predictions
- Payout scales with the probability of the target — rare targets pay higher
- Strategy surface: choose target width. Narrow targets = convex, wide targets = grinder
- Round length: ~2s

### Hilo (`hilo`)

Deck-draw game. Engine reveals a card; you predict `higher` or `lower` than
the current. Can chain multiple rounds for compounding multipliers.

- Effective RTP compounds down with chain length: ~98% / round, ~90% over 5 rounds
- Payout: multiplier grows per correct call
- Strategy surface: `cashOutAt` — where to bank. This is the key decision.
- Round length: ~2.5s baseline, more for longer chains

### Roulette (`roulette`)

European wheel, single zero. You place a bet on any standard bet type:
straight number, colour, odd/even, dozen, column, half, etc.

- Effective RTP ≈ 97.3% (single-zero wheel)
- Payout scales inversely with probability: straight 35x, dozen 2x, red 1x
- Strategy surface: bet type selection. There is no edge in the math —
  only variance calibration
- Round length: ~4s

### Horserace (`horserace`)

Engine runs a multi-horse race with weighted odds. You bet on one horse
or on top-3 finishing position.

- Effective RTP ≈ 98% across all picks
- Payout: proportional to posted odds
- Strategy surface: favourite vs longshot. Longshots are convex recovery plays
- Round length: ~5s

## Procedure

1. Read the contest `gamePool` — identify which table games are available
2. Pick the game that matches your current posture:
   - Grinder / moderate → blackjack with basic strategy
   - Catch-up variance → hilo deep chains, dice narrow targets, roulette straight
   - Defensive → baccarat banker or blackjack stand-heavy
3. Build the strategy block:
   - Blackjack → `decisions` array following basic strategy
   - Hilo → `cashOutAt` integer (typically 3–5 for moderate, 6+ for variance)
   - Dice → targets chosen to match desired multiplier
4. Emit the decision per [decision-protocol](./decision-protocol.md)
5. Respect the `table` bet limits: min 25, max 10000

## Rules & Constraints

- Minimum stake: 25 coins. Below that, the round is rejected
- Maximum stake: 10000 coins
- Blackjack `decisions` array is consumed in order — a short array is padded
  with `stand` at the end
- Hilo `cashOutAt` beyond the natural deck length is clamped
- Roulette bet types must match the engine's enum — malformed types default
  to red/black
- Baccarat has no per-step decisions; `gameParams.strategy.decisions` is
  ignored and only the backing side matters

## Pitfalls

- **Playing blackjack without a basic strategy table.** Random decisions
  drop blackjack RTP from ~98% to ~94%. Always emit a deliberate `decisions`
  array even if it is just `["stand"]`
- **Chaining hilo too long.** Each step compounds the 2% edge. A 10-step hilo
  chain has an effective RTP around 82%. Cash out earlier than feels right
- **Betting tie in baccarat as a grinder.** Tie is a catch-up bet, not a
  grinder bet. The 9x multiplier is offset by ~14% negative edge
- **Treating roulette as a skill game.** There is no decision surface. Your
  only lever is how much variance you want
- **Ignoring the stake floor.** Table minimum is 25. On a 1000-coin starting
  balance, 25 = 2.5% — already below the conservative stake band

## Verification

You are playing table games well if:

1. Every `blackjack` decision includes an explicit `decisions` array
2. Your `hilo` `cashOutAt` is chosen to match posture, not emotion
3. Your roulette bets match your variance target (straights for catch-up,
   colours for defensive)
4. Your stake always respects the 25-coin floor
5. You can defend every game choice in terms of posture, not preference