Struct Board

pub struct Board { /* private fields */ }

Implementations

impl Board

pub fn horde() -> Self

Create the default board for the Horde variant

pub fn empty() -> Self

pub fn rating_bar(&self, len: usize) -> String

pub fn get_turn_color(&self) -> Color

Get the color of the current player

pub fn get_en_passant(&self) -> Option<Position>

Get the position of the En-Passant square

pub fn remove_all(&self, color: Color) -> Self

Remove all of the pieces for a given player

pub fn queen_all(&self, color: Color) -> Self

Convert all of a given players pieces to queens

pub fn set_turn(&self, color: Color) -> Self

Make the game a certain player’s turn

pub fn get_material_advantage(&self, color: Color) -> i32

Get the value of the material advantage of a certain player

pub fn get_piece(&self, pos: Position) -> Option<Piece>

Does a square have any piece?

Examples found in repository

examples/terminal.rs (line 27)

fn get_cpu_move(b: &Board, best: bool) -> Move {
    let (m, count, _) = if best {
        b.get_best_next_move(4)
    } else {
        b.get_worst_next_move(4)
    };

    print!("CPU evaluated {} moves before choosing to ", count);
    match m {
        Move::Piece(from, to) => match (b.get_piece(from), b.get_piece(to)) {
            (Some(piece), Some(takes)) => println!(
                "take {}({}) with {}({})",
                takes.get_name(),
                to,
                piece.get_name(),
                from
            ),
            (Some(piece), None) => {
                println!("move {}({}) to {}", piece.get_name(), from, to)
            }
            _ => println!("move {} to {}", from, to),
        },
        Move::KingSideCastle => {
            println!("castle kingside")
        }
        Move::QueenSideCastle => {
            println!("castle queenside")
        }
        Move::Resign => println!("resign"),
    }

    m
}

pub fn has_ally_piece(&self, pos: Position, ally_color: Color) -> bool

Does a square have an ally piece?

pub fn has_enemy_piece(&self, pos: Position, ally_color: Color) -> bool

If a square at a given position has an enemy piece from a given ally color, return true. Otherwise, return false.

For example, if a square has a black piece, and this method is called upon it with an ally_color of Color::White, then it will return true. If called with Color::Black upon the same square, however, it will return false.

pub fn has_piece(&self, pos: Position) -> bool

If a square at a given position has any piece, return true. Otherwise, return false.

pub fn has_no_piece(&self, pos: Position) -> bool

If a square at a given position has no piece, return true. Otherwise, return false.

pub fn get_king_pos(&self, color: Color) -> Option<Position>

If there is a king on the board, return the position that it sits on.

pub fn is_threatened(&self, pos: Position, ally_color: Color) -> bool

Is a square threatened by an enemy piece?

pub fn is_in_check(&self, color: Color) -> bool

Get whether or not the king of a given color is in check.

pub fn can_kingside_castle(&self, color: Color) -> bool

Can a given player castle kingside?

pub fn can_queenside_castle(&self, color: Color) -> bool

Can a given player castle queenside?

pub fn has_sufficient_material(&self, color: Color) -> bool

Does the respective player have sufficient material?

pub fn has_insufficient_material(&self, color: Color) -> bool

Does the respective player have insufficient material?

pub fn is_stalemate(&self) -> bool

Is the current player in stalemate?

pub fn is_checkmate(&self) -> bool

Is the current player in checkmate?

pub fn change_turn(self) -> Self

Change the current turn to the next player.

Examples found in repository

examples/terminal.rs (line 71)

fn main() -> Result<(), String> {
    let mut b = Board::default();

    println!("{}", b);
    let mut history = vec![];

    loop {
        let mut s = input(">>> ");
        s = s.trim().to_string();

        let m = if s.is_empty() {
            println!("Waiting for CPU to choose best move...");
            get_cpu_move(&b, true)
        } else if s == "worst" {
            println!("Waiting for CPU to choose worst move...");
            get_cpu_move(&b, false)
        } else if s == "rate" {
            continue;
        } else if s == "pass" {
            b = b.change_turn();
            continue;
        } else if s == "history" {
            for i in 0..history.len() {
                if i < history.len() - 1 {
                    println!("{} {}", history[i], history[i + 1]);
                } else {
                    println!("{}", history[i]);
                }
            }
            continue;
        } else {
            match Move::try_from(s) {
                Ok(m) => m,
                Err(e) => {
                    eprintln!("{}", e);
                    continue;
                }
            }
        };

        match b.play_move(m) {
            GameResult::Continuing(next_board) => {
                b = next_board;
                println!("{}", b);
                history.push(m);
            }

            GameResult::Victory(winner) => {
                println!("{}", b);
                println!("{} loses. {} is victorious.", !winner, winner);
                break;
            }

            GameResult::IllegalMove(x) => {
                eprintln!("{} is an illegal move.", x);
            }

            GameResult::Stalemate => {
                println!("Drawn game.");
                break;
            }
        }
    }

    for m in history {
        println!("{}", m);
    }
    Ok(())
}

pub fn play_move(&self, m: Move) -> GameResult

Play a move and confirm it is legal.

Examples found in repository

examples/terminal.rs (line 92)

fn main() -> Result<(), String> {
    let mut b = Board::default();

    println!("{}", b);
    let mut history = vec![];

    loop {
        let mut s = input(">>> ");
        s = s.trim().to_string();

        let m = if s.is_empty() {
            println!("Waiting for CPU to choose best move...");
            get_cpu_move(&b, true)
        } else if s == "worst" {
            println!("Waiting for CPU to choose worst move...");
            get_cpu_move(&b, false)
        } else if s == "rate" {
            continue;
        } else if s == "pass" {
            b = b.change_turn();
            continue;
        } else if s == "history" {
            for i in 0..history.len() {
                if i < history.len() - 1 {
                    println!("{} {}", history[i], history[i + 1]);
                } else {
                    println!("{}", history[i]);
                }
            }
            continue;
        } else {
            match Move::try_from(s) {
                Ok(m) => m,
                Err(e) => {
                    eprintln!("{}", e);
                    continue;
                }
            }
        };

        match b.play_move(m) {
            GameResult::Continuing(next_board) => {
                b = next_board;
                println!("{}", b);
                history.push(m);
            }

            GameResult::Victory(winner) => {
                println!("{}", b);
                println!("{} loses. {} is victorious.", !winner, winner);
                break;
            }

            GameResult::IllegalMove(x) => {
                eprintln!("{} is an illegal move.", x);
            }

            GameResult::Stalemate => {
                println!("Drawn game.");
                break;
            }
        }
    }

    for m in history {
        println!("{}", m);
    }
    Ok(())
}

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<(), Error>

Formats the value using the given formatter.

impl Evaluate for Board

fn value_for(&self, ally_color: Color) -> f64

Get the value of the board for a given color. This subtracts the opponents value, and accounts for piece positions and material value.

fn get_current_player_color(&self) -> Color

Get the current player’s color.

fn apply_eval_move(&self, m: Move) -> Self

Apply a move to the board for evaluation.

fn get_legal_moves(&self) -> Vec<Move>

Get the legal moves for the current player.

fn get_best_next_move(&self, depth: i32) -> (Move, u64, f64)

Get the best move for the current player with depth number of moves of lookahead.

fn get_worst_next_move(&self, depth: i32) -> (Move, u64, f64)

Get the best move for the current player with depth number of moves of lookahead.

fn minimax( &self, depth: i32, alpha: f64, beta: f64, is_maximizing: bool, getting_move_for: Color, board_count: &mut u64, ) -> f64

Perform minimax on a certain position, and get the minimum or maximum value for a board. To get the best move, you minimize the values of the possible outcomes from your own position, and maximize the values of the replies made by the other player.

impl From<Board> for BoardBuilder

fn from(board: Board) -> Self

Converts to this type from the input type.

impl Ord for Board

fn cmp(&self, other: &Board) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Board

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Board

fn partial_cmp(&self, other: &Board) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Board

impl Eq for Board

impl StructuralPartialEq for Board