poker-trainer

A post-flop-focused GTO poker trainer for the command line, written in Rust. You're dealt realistic post-flop spots, you act, and the trainer scores your decision against a solver's equilibrium strategy — reporting EV loss and the full optimal frequency mix.

Status: phases 0–10 are all shipped — precomputed + live solving, resident tree sessions (solve-gen serve), full-hand drills with persistent stats, the formations library, the study browser (lenses, runouts, blockers), aggregate reports, hand-history analysis, and nodelocking. The parity matrix in docs/design/00-overview.md is the status source of truth. Still open: spot filters + curated-library sampling for drill hand, a broad-95 manifest tier, and the P10 deferred trio (saved-lock villain personas, session-wide EV-delta, warm-start re-solve).

Build & run

cargo run -- drill pot-odds   # call/fold vs. break-even pot odds (Monte-Carlo equity)
cargo run -- drill gto        # act vs. a precomputed GTO solution (Phase 1)
cargo run -- drill range      # assign your whole range by bucket; leak stats (Phase 2)
cargo run -- drill hand --board Td9d6h   # play full hands vs. the GTO villain (Phase 5)
cargo run -- drill preflop    # 6-max preflop spots scored on EV loss vs. solved charts (P11)
cargo run -- table            # browse a solved spot's strategy as a 13×13 grid
cargo run -- stats            # leak report over your recorded drill history
cargo run -- report           # aggregate flop report over the library (Phase 8)
cargo run -- analyze hh/*.txt # score your real hands vs. equilibrium (Phase 9)

Web examples

web/ is a browser catalog of the human-facing examples — equity calculator, pot-odds drill (the crate compiled to wasm), a GTO-Wizard-style preflop chart tree browser over the committed data/preflop/ starter tiers, and a GTO strategy grid over the committed starter-8 snapshots. It deploys to GitHub Pages on every push to main; see web/README.md to build and serve it locally.

Preflop charts

drill preflop and the web browser read solved preflop charts from data/preflop/<ruleset>/. Four committed families, each a Fibonacci depth ladder (chip-EV, --ruleset <id>): Cash 6-max cash{5..144} and MTT 6-max mtt{5..144} (six-handed), plus Cash HU cash-hu{3..144} and MTT HU mtt-hu{3..55} (heads-up). Cash tiers take 5% rake capped 3bb; MTT tiers take a 1 BB Big Blind Ante. They're produced by the permissive in-repo MCCFR generator (design 07):

cargo run -p preflop-gen --release -- gen    # re-solve stale rule sets

The gto drill needs solution files; generate them with the (AGPL) solver crate, which walks a manifest of (formation × flop set) entries and skips anything already solved (resumable — pair long runs with scripts/idle-run.sh):

cargo run -p solve-gen        # walks manifests/starter-8.toml into data/solutions/
cargo run -p solve-gen --release -- gen --manifest manifests/texture-25.toml  # first breadth tier

Live solving a custom spot (Phase 3)

Pass --board to drill gto/drill range/drill hand to solve any flop on demand instead of drilling a curated one. It's CPU-saturating and takes tens of seconds to a few minutes (the wide default ranges run ~4 min on an 8-core box) and ~1 GB RAM. The result is cached in data/solutions/, keyed by a hash of the full config, and reused (and so also joins the random pool of plain drill gto/range).

cargo run -- drill gto --board 7c5d2h      # solve this flop, then drill it
cargo run -- drill range --board Td9d6h    # same, range-builder mode

--formation picks the preflop story — seats, default pot/stacks, and the ranges read from data/ranges/<formation>/{oop,ip}.txt (edit those files to taste; they're plain solver range strings). Everything else can be overridden per flag; a changed config gets its own cache entry instead of overwriting the curated one:

cargo run -- drill hand --board Td9d6h --formation 3bp-bb-btn   # 3-bet pot, 18bb
cargo run -- drill gto --board Td9d6h \
  --oop "22+,A2s+,..." --ip "22+,A2s+,..." \
  --sizes "33%, 75%" --turn-sizes "50%" --stack 100 --pot 6 \
  --rake-rate 0.05 --rake-cap 3

Formations: srp-btn-bb, srp-co-bb, srp-sb-bb (single-raised) and 3bp-bb-btn, 3bp-btn-co (3-bet pots).

The trainer never links the solver: --board shells out to the solve-gen binary. In-tree it falls back to cargo run -p solve-gen; set POKER_TRAINER_SOLVE_GEN to a prebuilt solve-gen binary to skip that.

Browse a solution as a strategy table

cargo run -- table opens a GTO-Wizard-style 13×13 grid: every starting hand colored by its equilibrium action mix (red bet, green check/call, blue fold), out-of-range hands left blank. Move the cursor with the arrows or hjkl, cycle through solved nodes with [/], and read the focused hand's exact mix in the side panel; q quits.

Pass --board (and the same --oop/--ip/… knobs) to live-solve a flop and browse the whole game tree instead: the solved game stays resident in a solve-gen serve subprocess (Phase 4), so any line and any runout is one keypress away. Number keys take the numbered actions, u goes one step up, r back to the root, and turn/river cards are picked from a 13×4 card grid; the line so far renders as a breadcrumb.

cargo run -- table                  # browse the curated library (snapshots)
cargo run -- table --board Td9d6h   # live-solve this flop, then walk its tree

Architecture

A two-crate workspace — the AGPL solver lives in crates/solve-gen (see Licensing); the trainer (lib + bin) is organized into modules:

以上为 README 的开头部分。其余内容请阅读原文。 查看完整 README ↗