Struct Board 

pub struct Board { /* private fields */ }

A chessboard with atomic chess rules.

Maintains piece placement, side-to-move, castling rights, en-passant square, and the half-move clock. Supports FEN serialization/deserialization, making and unmaking moves, and legality checking.

Implementations

impl Board

pub fn new() -> Self

Create a board in the standard starting position.

pub fn from_fen(fen: &str) -> Result<Self, FenError>

Parse a board from a FEN string.

Accepts standard FEN with 4–6 space-separated fields. The piece character set includes standard chess pieces plus C/c and K/k for commoners (king-like pseudo-royal pieces).

Examples found in repository

examples/list_moves.rs (line 15)

fn main() {
    atomic_movegen::attacks::init();
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: list_moves <fen>");
        return;
    }
    let fen = &args[1];
    let 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));

    println!("Legal moves ({} total):", moves.len());
    for &m in moves.as_slice() {
        println!("  {}{}", sq_str(m.from_sq()), sq_str(m.to_sq()));
    }
}

examples/perft.rs (line 16)

fn main() {
    atomic_movegen::attacks::init();
    let args: Vec<String> = env::args().collect();
    if args.len() < 3 {
        eprintln!("Usage: perft <fen> <depth>");
        std::process::exit(1);
    }

    let fen = &args[1];
    let depth: u32 = args[2]
        .parse()
        .expect("Depth must be a non-negative integer");

    match atomic_movegen::board::Board::from_fen(fen) {
        Ok(mut board) => {
            let nodes = atomic_movegen::perft(&mut board, depth);
            println!("{}", nodes);
        }
        Err(e) => {
            eprintln!("Error parsing FEN: {}", e);
            std::process::exit(1);
        }
    }
}

examples/perft_divide.rs (line 18)

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 17)

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");
}

examples/debug_moves.rs (line 16)

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

    let mut pseudo = MoveList::new();
    movegen::generate_pseudo_legal(&board, &mut pseudo);

    let mut pseudo_set = HashSet::new();
    for &m in pseudo.as_slice() {
        if !pseudo_set.insert((m.from_sq(), m.to_sq(), m.move_type())) {
            println!(
                "DUPLICATE PSEUDO-LEGAL: {}{}",
                sq_str(m.from_sq()),
                sq_str(m.to_sq())
            );
        }
    }

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

    let mut legal_set = HashSet::new();
    for &m in legal.as_slice() {
        if !legal_set.insert((m.from_sq(), m.to_sq(), m.move_type())) {
            println!(
                "DUPLICATE LEGAL: {}{}",
                sq_str(m.from_sq()),
                sq_str(m.to_sq())
            );
        }
    }

    println!(
        "Pseudo-legal moves: {} (unique: {})",
        pseudo.len(),
        pseudo_set.len()
    );
    println!("Legal moves: {} (unique: {})", legal.len(), legal_set.len());
}

examples/pawn_debug.rs (line 15)

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

    println!("Board side to move: {:?}", board.side_to_move());

    // Manual check: iterate all pawns
    let us = board.side_to_move();
    let _them = us.flip();
    let _occupied = board.occupied();

    let pawns = board.pieces_color_pt(us, PieceType::Pawn);
    println!("Pawns ({:?}): {}", us, pawns.count());
    let mut p = pawns;
    while !p.is_empty() {
        let sq = p.pop_lsb();
        println!(
            "  Pawn at {} (idx={}): file={} rank={}",
            sq_str(sq),
            sq as u8,
            file_of(sq) as u8,
            rank_of(sq) as u8
        );
    }

    // Check what generate_legal produces
    let mut moves = MoveList::new();
    movegen::generate_legal(&board, &mut moves);

    // Find all h3g2 moves
    let h3 = Square::from_index(23);
    let g2 = Square::from_index(14);
    println!("\nAll h3g2 moves:");
    for (i, &m) in moves.as_slice().iter().enumerate() {
        if m.from_sq() == h3 && m.to_sq() == g2 {
            println!(
                "  Move #{}: from={} to={} type={:?}",
                i,
                sq_str(m.from_sq()),
                sq_str(m.to_sq()),
                m.move_type()
            );
        }
    }

    // Also check how many times each move appears
    use std::collections::HashMap;
    let mut counts: HashMap<(u16, u16, u16), usize> = HashMap::new();
    for &m in moves.as_slice() {
        *counts
            .entry((m.from_sq() as u16, m.to_sq() as u16, m.move_type() as u16))
            .or_insert(0) += 1;
    }
    for ((from, to, mt), count) in &counts {
        if *count > 1 {
            println!(
                "DUPLICATE: {}{} type={:?} appears {} times",
                sq_str(Square::from_u8(*from as u8)),
                sq_str(Square::from_u8(*to as u8)),
                match mt {
                    0 => "Normal",
                    1 => "Promo",
                    2 => "EP",
                    3 => "Castle",
                    _ => "?",
                },
                count
            );
        }
    }
}

Additional examples can be found in:

• examples/verify_perft.rs

pub fn fen(&self) -> String

Serialize the board to a FEN string.

Examples found in repository

examples/fen_after.rs (line 29)

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");
}

pub fn piece_on(&self, sq: Square) -> Piece

Return the piece on a square (or NO_PIECE if empty).

pub fn empty(&self, sq: Square) -> bool

Return true if the given square is empty.

pub fn occupied(&self) -> Bitboard

Return the bitboard of all occupied squares.

Examples found in repository

examples/pawn_debug.rs (line 22)

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

    println!("Board side to move: {:?}", board.side_to_move());

    // Manual check: iterate all pawns
    let us = board.side_to_move();
    let _them = us.flip();
    let _occupied = board.occupied();

    let pawns = board.pieces_color_pt(us, PieceType::Pawn);
    println!("Pawns ({:?}): {}", us, pawns.count());
    let mut p = pawns;
    while !p.is_empty() {
        let sq = p.pop_lsb();
        println!(
            "  Pawn at {} (idx={}): file={} rank={}",
            sq_str(sq),
            sq as u8,
            file_of(sq) as u8,
            rank_of(sq) as u8
        );
    }

    // Check what generate_legal produces
    let mut moves = MoveList::new();
    movegen::generate_legal(&board, &mut moves);

    // Find all h3g2 moves
    let h3 = Square::from_index(23);
    let g2 = Square::from_index(14);
    println!("\nAll h3g2 moves:");
    for (i, &m) in moves.as_slice().iter().enumerate() {
        if m.from_sq() == h3 && m.to_sq() == g2 {
            println!(
                "  Move #{}: from={} to={} type={:?}",
                i,
                sq_str(m.from_sq()),
                sq_str(m.to_sq()),
                m.move_type()
            );
        }
    }

    // Also check how many times each move appears
    use std::collections::HashMap;
    let mut counts: HashMap<(u16, u16, u16), usize> = HashMap::new();
    for &m in moves.as_slice() {
        *counts
            .entry((m.from_sq() as u16, m.to_sq() as u16, m.move_type() as u16))
            .or_insert(0) += 1;
    }
    for ((from, to, mt), count) in &counts {
        if *count > 1 {
            println!(
                "DUPLICATE: {}{} type={:?} appears {} times",
                sq_str(Square::from_u8(*from as u8)),
                sq_str(Square::from_u8(*to as u8)),
                match mt {
                    0 => "Normal",
                    1 => "Promo",
                    2 => "EP",
                    3 => "Castle",
                    _ => "?",
                },
                count
            );
        }
    }
}

pub fn pieces_color(&self, c: Color) -> Bitboard

Return all pieces of a given color.

pub fn pieces_pt(&self, pt: PieceType) -> Bitboard

Return all pieces of a given type.

pub fn pieces_color_pt(&self, c: Color, pt: PieceType) -> Bitboard

Return all pieces of a given color and type.

Examples found in repository

examples/pawn_debug.rs (line 24)

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

    println!("Board side to move: {:?}", board.side_to_move());

    // Manual check: iterate all pawns
    let us = board.side_to_move();
    let _them = us.flip();
    let _occupied = board.occupied();

    let pawns = board.pieces_color_pt(us, PieceType::Pawn);
    println!("Pawns ({:?}): {}", us, pawns.count());
    let mut p = pawns;
    while !p.is_empty() {
        let sq = p.pop_lsb();
        println!(
            "  Pawn at {} (idx={}): file={} rank={}",
            sq_str(sq),
            sq as u8,
            file_of(sq) as u8,
            rank_of(sq) as u8
        );
    }

    // Check what generate_legal produces
    let mut moves = MoveList::new();
    movegen::generate_legal(&board, &mut moves);

    // Find all h3g2 moves
    let h3 = Square::from_index(23);
    let g2 = Square::from_index(14);
    println!("\nAll h3g2 moves:");
    for (i, &m) in moves.as_slice().iter().enumerate() {
        if m.from_sq() == h3 && m.to_sq() == g2 {
            println!(
                "  Move #{}: from={} to={} type={:?}",
                i,
                sq_str(m.from_sq()),
                sq_str(m.to_sq()),
                m.move_type()
            );
        }
    }

    // Also check how many times each move appears
    use std::collections::HashMap;
    let mut counts: HashMap<(u16, u16, u16), usize> = HashMap::new();
    for &m in moves.as_slice() {
        *counts
            .entry((m.from_sq() as u16, m.to_sq() as u16, m.move_type() as u16))
            .or_insert(0) += 1;
    }
    for ((from, to, mt), count) in &counts {
        if *count > 1 {
            println!(
                "DUPLICATE: {}{} type={:?} appears {} times",
                sq_str(Square::from_u8(*from as u8)),
                sq_str(Square::from_u8(*to as u8)),
                match mt {
                    0 => "Normal",
                    1 => "Promo",
                    2 => "EP",
                    3 => "Castle",
                    _ => "?",
                },
                count
            );
        }
    }
}

pub fn side_to_move(&self) -> Color

Return the side to move.

Examples found in repository

examples/pawn_debug.rs (line 17)

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

    println!("Board side to move: {:?}", board.side_to_move());

    // Manual check: iterate all pawns
    let us = board.side_to_move();
    let _them = us.flip();
    let _occupied = board.occupied();

    let pawns = board.pieces_color_pt(us, PieceType::Pawn);
    println!("Pawns ({:?}): {}", us, pawns.count());
    let mut p = pawns;
    while !p.is_empty() {
        let sq = p.pop_lsb();
        println!(
            "  Pawn at {} (idx={}): file={} rank={}",
            sq_str(sq),
            sq as u8,
            file_of(sq) as u8,
            rank_of(sq) as u8
        );
    }

    // Check what generate_legal produces
    let mut moves = MoveList::new();
    movegen::generate_legal(&board, &mut moves);

    // Find all h3g2 moves
    let h3 = Square::from_index(23);
    let g2 = Square::from_index(14);
    println!("\nAll h3g2 moves:");
    for (i, &m) in moves.as_slice().iter().enumerate() {
        if m.from_sq() == h3 && m.to_sq() == g2 {
            println!(
                "  Move #{}: from={} to={} type={:?}",
                i,
                sq_str(m.from_sq()),
                sq_str(m.to_sq()),
                m.move_type()
            );
        }
    }

    // Also check how many times each move appears
    use std::collections::HashMap;
    let mut counts: HashMap<(u16, u16, u16), usize> = HashMap::new();
    for &m in moves.as_slice() {
        *counts
            .entry((m.from_sq() as u16, m.to_sq() as u16, m.move_type() as u16))
            .or_insert(0) += 1;
    }
    for ((from, to, mt), count) in &counts {
        if *count > 1 {
            println!(
                "DUPLICATE: {}{} type={:?} appears {} times",
                sq_str(Square::from_u8(*from as u8)),
                sq_str(Square::from_u8(*to as u8)),
                match mt {
                    0 => "Normal",
                    1 => "Promo",
                    2 => "EP",
                    3 => "Castle",
                    _ => "?",
                },
                count
            );
        }
    }
}

pub fn castling_rights(&self) -> u8

Return the castling rights bitmask.

pub fn ep_square(&self) -> Option<Square>

Return the en-passant target square, if any.

pub fn commoners(&self, c: Color) -> Bitboard

Return the bitboard of commoners (king-like pseudo-royal pieces) for a color.

pub fn attackers_to(&self, sq: Square, occupied: Bitboard) -> Bitboard

Return all pieces that attack sq on the given occupancy.

Includes pawns, knights, bishops, rooks, queens, and commoners of either color that attack sq.

pub fn checkers(&self) -> Bitboard

Return the bitboard of enemy pieces checking the side to move.

pub fn pinned(&self, c: Color) -> Bitboard

Return the bitboard of pieces of the given color that are pinned (cannot move without exposing a commoner to capture).

pub fn populate_state(&self, state: &mut StateInfo)

Fill cached state fields (checkers, pinned, commoner counts) for the current position so that legal() can read them instead of recomputing.

pub fn do_move(&mut self, m: Move, state: &mut StateInfo)

Make m on the board, storing undo information in state.

Handles all move types (normal, promotion, en-passant, castling) as well as atomic-blast removal on captures.

Examples found in repository

examples/perft_divide.rs (line 29)

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 28)

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");
}

pub fn undo_move(&mut self, m: Move, state: &StateInfo)

Unmake m, restoring the board to its state before do_move.

state must be the same StateInfo that was passed to do_move.

Examples found in repository

examples/perft_divide.rs (line 35)

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);
}

pub fn legal(&self, m: Move, state: &StateInfo) -> bool

Check whether m is legal under atomic chess rules.

Considers blast-zone effects (self-explosion), castling pass-through safety, pseudo-royal adjacency, and commoner extinction.

state must contain up-to-date cached fields for the current position.

Trait Implementations

impl Clone for Board

fn clone(&self) -> Board

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Board

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

Formats the value using the given formatter.

impl Default for Board

fn default() -> Self

Returns the “default value” for a type.

impl Display for Board

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

Formats the value using the given formatter.