Struct StateInfo 

pub struct StateInfo {
    pub checkers: Bitboard,
    pub pinned: Bitboard,
    pub commoners_count: u32,
    pub them_commoners_count: u32,
    pub castling_rights: u8,
    pub ep_square: Option<Square>,
    pub rule50: u8,
    pub captured_count: u8,
    pub captured: [(Square, Piece); 9],
    pub cap_sq: Option<Square>,
    pub cap_piece: Piece,
}

Cached state for a position, used during move generation and legality checks.

Fields are populated by Board::populate_state and consumed by Board::legal and generate_legal.

Fields

checkers: Bitboard

pinned: Bitboard

commoners_count: u32

them_commoners_count: u32

castling_rights: u8

ep_square: Option<Square>

rule50: u8

captured_count: u8

captured: [(Square, Piece); 9]

cap_sq: Option<Square>

cap_piece: Piece

Implementations

impl StateInfo

pub fn new() -> Self

Create a new StateInfo with all fields zeroed/empty.

Examples found in repository

examples/perft_divide.rs (line 28)

fn main() {
    atomic_movegen::attacks::init();
    let args: Vec<String> = env::args().collect();
    if args.len() < 3 {
        eprintln!("Usage: perft_divide <fen> <depth>");
        return;
    }
    let fen = &args[1];
    let depth: u32 = args[2].parse().unwrap_or(1);

    let mut board = Board::from_fen(fen).expect("Invalid FEN");

    let mut moves = MoveList::new();
    movegen::generate_legal(&board, &mut moves);
    moves
        .as_mut_slice()
        .sort_by_key(|m| (m.from_sq() as u16, m.to_sq() as u16));

    let mut total = 0u64;
    for &m in moves.as_slice() {
        let mut state = atomic_movegen::board::StateInfo::new();
        board.do_move(m, &mut state);
        let cnt = if depth <= 1 {
            1
        } else {
            perft(&mut board, depth - 1)
        };
        board.undo_move(m, &state);
        total += cnt;
        println!("{}{}: {}", sq_str(m.from_sq()), sq_str(m.to_sq()), cnt);
    }
    println!("\nNodes searched: {}", total);
}

examples/fen_after.rs (line 27)

fn main() {
    atomic_movegen::attacks::init();
    let args: Vec<String> = env::args().collect();
    if args.len() < 3 {
        eprintln!("Usage: fen_after <fen> <move>");
        return;
    }
    let fen = &args[1];
    let movestr = &args[2];
    let mut board = Board::from_fen(fen).expect("Invalid FEN");

    let from_sq = parse_sq(&movestr[0..2]);
    let to_sq = parse_sq(&movestr[2..4]);

    let mut moves = MoveList::new();
    movegen::generate_legal(&board, &mut moves);

    for &m in moves.as_slice() {
        if m.from_sq() == from_sq && m.to_sq() == to_sq {
            let mut state = atomic_movegen::board::StateInfo::new();
            board.do_move(m, &mut state);
            println!("{}", board.fen());

            let mut moves2 = MoveList::new();
            movegen::generate_legal(&board, &mut moves2);
            moves2
                .as_mut_slice()
                .sort_by_key(|m| (m.from_sq() as u16, m.to_sq() as u16));
            println!("Legal moves ({} total):", moves2.len());
            for &m2 in moves2.as_slice() {
                println!("  {}{}", sq_str(m2.from_sq()), sq_str(m2.to_sq()));
            }
            return;
        }
    }
    println!("Move not found");
}

Trait Implementations

impl Clone for StateInfo

fn clone(&self) -> StateInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StateInfo

impl Debug for StateInfo

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

Formats the value using the given formatter.

impl Default for StateInfo

fn default() -> Self

Returns the “default value” for a type.