Struct State 

pub struct State {
    pub bb: Bitboard,
}

Serialisable game state wrapping a Bitboard.

Fields

bb: Bitboard

Implementations

impl State

pub fn new(bb: Bitboard) -> Self

Examples found in repository

examples/selfplay_export.rs (line 121)

fn play_game(seed: u64, iterations: u32) -> (Vec<PendingRow>, WinStatus) {
    let mut bb = Bitboard::EMPTY;
    let mut rows = Vec::new();
    let mut ply = 0u32;

    loop {
        if has_winning_line(&bb) {
            return (rows, check_winner(&bb));
        }
        let legal = generate_legal_moves(&bb);
        if legal.is_empty() {
            // No legal moves: the side to move loses (see Global
            // Constraints — this is a decisive result, never a draw).
            let loser = current_player(&bb).unwrap();
            let winner = if loser == 0 {
                WinStatus::Player1Wins
            } else {
                WinStatus::Player0Wins
            };
            return (rows, winner);
        }

        let side_to_move = current_player(&bb).unwrap();
        // use_transposition_table MUST be false here: with it on (the
        // engine's actual default), root moves that canonicalize to the
        // same child are merged onto one shared node and reported under a
        // single arbitrary move, silently dropping every other legal move
        // that led there — worst exactly at shallow plies (the empty
        // board's 64 legal moves collapse to 3), which every self-play
        // game passes through. Verified in mcts.rs's
        // root_move_visits_default_config_collapses_symmetric_root_moves
        // test — this is not a hypothetical concern, it was caught by
        // Opus review of the PR that added root_move_visits and is
        // exactly what this exporter must avoid to produce a faithful
        // per-legal-move policy target.
        let mut engine = MCTSEngine::new(MCTSConfig {
            max_iterations: iterations,
            seed: Some(seed.wrapping_add(ply as u64)),
            use_transposition_table: false,
            ..Default::default()
        });
        let (best_move, _) = engine.search(&bb).expect("legal moves exist");
        let policy: Vec<(u8, u8, u32)> = engine
            .root_move_visits()
            .into_iter()
            .map(|(mv, visits)| (mv.shape, mv.position, visits))
            .collect();

        rows.push(PendingRow {
            ply,
            qfen: State::new(bb).to_qfen(),
            side_to_move,
            policy,
        });

        bb = apply_move(&bb, &best_move);
        ply += 1;
    }
}

examples/depth4_survey.rs (line 146)

fn main() {
    let args = parse_args();

    let started = Instant::now();
    let mut states = enumerate_depth4();
    println!(
        "enumerated {} canonical nonterminal depth-4 states in {:.2}s",
        states.len(),
        started.elapsed().as_secs_f64()
    );
    if args.sample > 0 && args.sample < states.len() {
        use rand::prelude::*;
        let mut rng = StdRng::seed_from_u64(args.seed);
        states.shuffle(&mut rng);
        states.truncate(args.sample);
        states.sort_by_key(|(bb, _)| bb.to_le_bytes());
        println!(
            "sampled {} of {} states (seed={})",
            states.len(),
            10946,
            args.seed
        );
    } else if args.limit > 0 {
        states.truncate(args.limit);
        println!("limited to {} states for this run", states.len());
    }

    let book = OpeningBookDatabase::open(&OpeningBookConfig {
        database_path: args.db.clone(),
        ..Default::default()
    })
    .expect("open book");

    let mut rows: Vec<serde_json::Value> = Vec::with_capacity(states.len());
    let mut solved = 0usize;
    let mut cutoff = 0usize;
    let solve_started = Instant::now();

    for (i, (bb, mult)) in states.iter().enumerate() {
        let t0 = Instant::now();
        let reference = solve_position_with_book(bb, args.budget_s, Some(&book));
        let elapsed = t0.elapsed().as_secs_f64();
        println!(
            "  [{}/{}] {} solved={} elapsed={:.3}s",
            i + 1,
            states.len(),
            State::new(*bb).to_qfen(),
            reference.is_some(),
            elapsed
        );

        match &reference {
            Some(r) => {
                solved += 1;
                rows.push(serde_json::json!({
                    "qfen": State::new(*bb).to_qfen(),
                    "multiplicity": mult,
                    "value": r["value"],
                    "nodes": r["nodes"],
                    "solve_time_s": elapsed,
                    "solver": r["solver"],
                }));
            }
            None => {
                cutoff += 1;
                rows.push(serde_json::json!({
                    "qfen": State::new(*bb).to_qfen(),
                    "multiplicity": mult,
                    "value": null,
                    "nodes": null,
                    "solve_time_s": elapsed,
                    "solver": null,
                }));
            }
        }

        if (i + 1) % 25 == 0 || i + 1 == states.len() {
            println!(
                "progress: {}/{} solved={} cutoff={} elapsed_total={:.1}s",
                i + 1,
                states.len(),
                solved,
                cutoff,
                solve_started.elapsed().as_secs_f64()
            );
            // Flush partial results after every progress line so a killed
            // run still leaves a readable, if incomplete, artifact — the
            // SQLite book itself is already durable per-row regardless.
            let partial = serde_json::json!({
                "budget_s": args.budget_s,
                "total_canonical_depth4_states": states.len(),
                "processed": i + 1,
                "solved": solved,
                "cutoff": cutoff,
                "positions": rows,
            });
            std::fs::write(&args.out, serde_json::to_string_pretty(&partial).unwrap())
                .expect("write partial output");
        }
    }

    println!(
        "done: {} solved, {} cutoff, total solve wall time {:.1}s -> {}",
        solved,
        cutoff,
        solve_started.elapsed().as_secs_f64(),
        args.out
    );
}

pub fn empty() -> Self

pub fn pack(&self, flags: u8) -> [u8; 18]

pub fn unpack(data: &[u8]) -> Result<Self, String>

pub fn to_qfen(&self) -> String

Examples found in repository

examples/selfplay_export.rs (line 121)

fn play_game(seed: u64, iterations: u32) -> (Vec<PendingRow>, WinStatus) {
    let mut bb = Bitboard::EMPTY;
    let mut rows = Vec::new();
    let mut ply = 0u32;

    loop {
        if has_winning_line(&bb) {
            return (rows, check_winner(&bb));
        }
        let legal = generate_legal_moves(&bb);
        if legal.is_empty() {
            // No legal moves: the side to move loses (see Global
            // Constraints — this is a decisive result, never a draw).
            let loser = current_player(&bb).unwrap();
            let winner = if loser == 0 {
                WinStatus::Player1Wins
            } else {
                WinStatus::Player0Wins
            };
            return (rows, winner);
        }

        let side_to_move = current_player(&bb).unwrap();
        // use_transposition_table MUST be false here: with it on (the
        // engine's actual default), root moves that canonicalize to the
        // same child are merged onto one shared node and reported under a
        // single arbitrary move, silently dropping every other legal move
        // that led there — worst exactly at shallow plies (the empty
        // board's 64 legal moves collapse to 3), which every self-play
        // game passes through. Verified in mcts.rs's
        // root_move_visits_default_config_collapses_symmetric_root_moves
        // test — this is not a hypothetical concern, it was caught by
        // Opus review of the PR that added root_move_visits and is
        // exactly what this exporter must avoid to produce a faithful
        // per-legal-move policy target.
        let mut engine = MCTSEngine::new(MCTSConfig {
            max_iterations: iterations,
            seed: Some(seed.wrapping_add(ply as u64)),
            use_transposition_table: false,
            ..Default::default()
        });
        let (best_move, _) = engine.search(&bb).expect("legal moves exist");
        let policy: Vec<(u8, u8, u32)> = engine
            .root_move_visits()
            .into_iter()
            .map(|(mv, visits)| (mv.shape, mv.position, visits))
            .collect();

        rows.push(PendingRow {
            ply,
            qfen: State::new(bb).to_qfen(),
            side_to_move,
            policy,
        });

        bb = apply_move(&bb, &best_move);
        ply += 1;
    }
}

examples/depth4_survey.rs (line 146)

fn main() {
    let args = parse_args();

    let started = Instant::now();
    let mut states = enumerate_depth4();
    println!(
        "enumerated {} canonical nonterminal depth-4 states in {:.2}s",
        states.len(),
        started.elapsed().as_secs_f64()
    );
    if args.sample > 0 && args.sample < states.len() {
        use rand::prelude::*;
        let mut rng = StdRng::seed_from_u64(args.seed);
        states.shuffle(&mut rng);
        states.truncate(args.sample);
        states.sort_by_key(|(bb, _)| bb.to_le_bytes());
        println!(
            "sampled {} of {} states (seed={})",
            states.len(),
            10946,
            args.seed
        );
    } else if args.limit > 0 {
        states.truncate(args.limit);
        println!("limited to {} states for this run", states.len());
    }

    let book = OpeningBookDatabase::open(&OpeningBookConfig {
        database_path: args.db.clone(),
        ..Default::default()
    })
    .expect("open book");

    let mut rows: Vec<serde_json::Value> = Vec::with_capacity(states.len());
    let mut solved = 0usize;
    let mut cutoff = 0usize;
    let solve_started = Instant::now();

    for (i, (bb, mult)) in states.iter().enumerate() {
        let t0 = Instant::now();
        let reference = solve_position_with_book(bb, args.budget_s, Some(&book));
        let elapsed = t0.elapsed().as_secs_f64();
        println!(
            "  [{}/{}] {} solved={} elapsed={:.3}s",
            i + 1,
            states.len(),
            State::new(*bb).to_qfen(),
            reference.is_some(),
            elapsed
        );

        match &reference {
            Some(r) => {
                solved += 1;
                rows.push(serde_json::json!({
                    "qfen": State::new(*bb).to_qfen(),
                    "multiplicity": mult,
                    "value": r["value"],
                    "nodes": r["nodes"],
                    "solve_time_s": elapsed,
                    "solver": r["solver"],
                }));
            }
            None => {
                cutoff += 1;
                rows.push(serde_json::json!({
                    "qfen": State::new(*bb).to_qfen(),
                    "multiplicity": mult,
                    "value": null,
                    "nodes": null,
                    "solve_time_s": elapsed,
                    "solver": null,
                }));
            }
        }

        if (i + 1) % 25 == 0 || i + 1 == states.len() {
            println!(
                "progress: {}/{} solved={} cutoff={} elapsed_total={:.1}s",
                i + 1,
                states.len(),
                solved,
                cutoff,
                solve_started.elapsed().as_secs_f64()
            );
            // Flush partial results after every progress line so a killed
            // run still leaves a readable, if incomplete, artifact — the
            // SQLite book itself is already durable per-row regardless.
            let partial = serde_json::json!({
                "budget_s": args.budget_s,
                "total_canonical_depth4_states": states.len(),
                "processed": i + 1,
                "solved": solved,
                "cutoff": cutoff,
                "positions": rows,
            });
            std::fs::write(&args.out, serde_json::to_string_pretty(&partial).unwrap())
                .expect("write partial output");
        }
    }

    println!(
        "done: {} solved, {} cutoff, total solve wall time {:.1}s -> {}",
        solved,
        cutoff,
        solve_started.elapsed().as_secs_f64(),
        args.out
    );
}

pub fn from_qfen(qfen: &str) -> Result<Self, String>

pub fn canonical_payload(&self) -> [u8; 16]

pub fn canonical_key(&self) -> [u8; 18]

pub fn symmetry_count(&self) -> usize

Trait Implementations

impl Clone for State

fn clone(&self) -> State

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for State

impl Debug for State

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for State

fn default() -> Self

Returns the “default value” for a type.

impl Eq for State

impl Hash for State

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for State

fn eq(&self, other: &State) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for State