A doubles battle simulator built to be branched.

git clone https://github.com/colefoster/vgc-engine.git
cd vgc-engine

# @pkmn/dex JSON for build.rs (localdex 0.1.1, as in CI)
mkdir -p .dex
curl -fsSL https://registry.npmjs.org/localdex/-/localdex-0.1.1.tgz | tar xz -C .dex
export VGC_DEX_DIR="$PWD/.dex/package/data"

# Build and install the Python module (vgc_engine 0.5.0).
# ps-rng enables ps_seed and Showdown sessions; without it they raise.
python3 -m venv .venv
.venv/bin/pip install maturin
.venv/bin/maturin build --release -m crates/vgc-engine-py/Cargo.toml \
    --features ps-rng -i .venv/bin/python -o dist
.venv/bin/pip install dist/vgc_engine-0.5.0-*.whl
.venv/bin/python -c "import vgc_engine; print('ok')"

# Optional: the vgc CLI
cargo build --release -p vgc-engine-cli --bin vgc
./target/release/vgc calc chomp rillaboom eq

# After the Install tab, inside .venv. Choices are still plain tuples.
import json, vgc_engine

team = json.dumps([
    {"species": "rillaboom", "moves": ["protect"]},
] * 2)

b = vgc_engine.Battle.from_teams(team, team,
        format="gen9doublescustomgame", seed=7)

# Choices are (kind, actor_slot, move_or_team_idx, target_side, target_slot)
p1 = [b.legal_choices(0, s)[0] for s in (0, 1)]
p2 = [b.legal_choices(1, s)[0] for s in (0, 1)]

branch = b.clone()                  # independent copy, no shared state
result = branch.step_move(p1, p2)   # "continue" | "p1_win" | "p2_win" | "tie"

snapshot = branch.to_bytes()        # compact; to_json() for inspection
again = vgc_engine.Battle.from_bytes(snapshot)

import vgc_engine

# Anytime endgame solve under a hard 1.5 s budget; returns mixed policies.
sol = vgc_engine.solve_endgame_anytime(b, time_budget_ms=1500)
sol["value"], sol["provenance"], sol["depth_completed"]
sol["truncated"], sol["truncation_reason"]   # best-so-far if over budget
row_action = sol["row_joint_policy"][0][0]   # an executable joint choice

# One budget across K sampled opponent sets; own action by EV
w = vgc_engine.solve_endgame_worlds([b, b.clone()], side="p1", time_budget_ms=1500)
w["chosen"], w["chosen_ev_own"], w["robust"]

# Exact search with depth and node limits (also deadline-bounded)
sol = vgc_engine.solve_endgame_exact(b, max_depth=1, node_budget=1_000)

# Or plug in your own batched leaf evaluator (a model, a heuristic…)
sol = vgc_engine.solve_endgame(b, lambda obs: [0.0] * len(obs))

# Champions team legality from a Showdown export ([] means legal)
problems = vgc_engine.parse_and_verify(paste_text, format="regmc")

# Quick damage range
r = vgc_engine.calc("chomp", "rillaboom", "eq")
r["min"], r["max"]

# Test the default workspace, as CI does (needs VGC_DEX_DIR)
cargo test --workspace --exclude vgc-engine-py

# The `vgc` fast-calc front end: terse specs and aliases
cargo run --release -p vgc-engine-cli --bin vgc -- calc chomp rillaboom eq
cargo run --release -p vgc-engine-cli --bin vgc -- survives chomp lando eq
cargo run --release -p vgc-engine-cli --bin vgc -- outspeeds chomp lando

# Rebuild a position from a real replay, or run a local Showdown-protocol sim
cargo run --release -p vgc-engine-cli --bin vgc -- recon --log replay.json --turn 5
cargo run --release -p vgc-engine-cli --bin vgc -- sim

# Opt-in instrumentation lives behind Cargo features
cargo test -p vgc-engine-core --features chance
cargo test -p vgc-engine-core --features ps-rng