rschess

https://docs.rs/rschess/2.0.5
Admin
A Rust chess library designed to be as feature-rich as possible, providing comprehensive chess game...
Tokens:29,087
Snippets:419
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Default Board Initialization

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Constructs a `Board` with the starting position for a chess game.

```rust
impl Default for Board {
    /// Constructs a `Board` with the starting position for a chess game.
    fn default() -> Self {
        Self::from_fen(Fen::try_from("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap())
    }
}
```

--------------------------------

### rschess library overview

Source: https://docs.rs/rschess/2.0.5/src/rschess/lib.rs.html

This snippet provides a high-level overview of the rschess library, including its purpose, examples, and module structure. It also includes functions for converting between square indices and names, and definitions for the Color enum.

```Rust
//! A Rust chess library with the aim to be as feature-rich as possible
//!
//! Examples are available on the [GitHub repository page](https://github.com/Python3-8/rschess).

mod board;
pub mod errors;
mod fen;
mod game_result;
mod helpers;
#[cfg(feature = "img")]
pub mod img;
mod move_;
#[cfg(feature = "pgn")]
pub mod pgn;
mod piece;
mod position;

pub use board::*;
pub(crate) use errors::*;
pub use fen::Fen;
pub use game_result::*;
pub use move_::*;
pub use piece::*;
pub use position::*;
use std::{fmt, ops::Not};

/// Converts a square index (`0..64`) to a square name, returning an error if the square index is invalid.
pub fn idx_to_sq(idx: usize) -> Result<(char, char), InvalidSquareIndexError> {
    if !(0..64).contains(&idx) {
        return Err(InvalidSquareIndexError(idx));
    }
    Ok(helpers::idx_to_sq(idx))
}

/// Converts a square name to a square index, returning an error if the square name is invalid.
pub fn sq_to_idx(file: char, rank: char) -> Result<usize, InvalidSquareNameError> {
    if !(('a'..='h').contains(&file) && ('1'..='8').contains(&rank)) {
        return Err(InvalidSquareNameError(file, rank));
    }
    Ok(helpers::sq_to_idx(file, rank))
}

/// Represents a side/color.
#[derive(Eq, PartialEq, Hash, Copy, Clone, Debug)]
pub enum Color {
    White,
    Black,
}

impl Color {
    /// Checks if the color is white.
    pub fn is_white(&self) -> bool {
        matches!(self, Self::White)
    }

    /// Checks if the color is black.
    pub fn is_black(&self) -> bool {
        matches!(self, Self::Black)
    }
}

impl TryFrom<&str> for Color {
    type Error = InvalidColorCharacterError;

    /// Attempts to convert a color character in a string slice to a `Color` ("w" is white, and "b" is black).
    fn try_from(string: &str) -> Result<Self, Self::Error> {
        match string {
            "w" => Ok(Self::White),
            "b" => Ok(Self::Black),
            _ => Err(InvalidColorCharacterError(string.to_string())),
        }
    }
}

impl From<Color> for char {
    /// Converts a `Color` to a color character (white is 'w', and black is 'b').
    fn from(c: Color) -> char {
        match c {
            Color::White => 'w',
            Color::Black => 'b',
        }
    }
}

impl fmt::Display for Color {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", char::from(*self))
    }
}

impl Not for Color {
    type Output = Self;

    fn not(self) -> Self {
        match self {
            Self::White => Self::Black,
            Self::Black => Self::White,
        }
    }
}

#[cfg(test)]
mod test;

```

--------------------------------

### type_id method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Gets the TypeId of the Move.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Keyboard Shortcuts

Source: https://docs.rs/rschess/2.0.5/help.html

List of keyboard shortcuts for navigating rustdoc.

```text
?
    Show this help dialog

S / /
    Focus the search field

↑
    Move up in search results

↓
    Move down in search results

← / →
    Switch result tab (when results focused)

⏎
    Go to active search result

+ / =
    Expand all sections

-
    Collapse all sections

_
    Collapse all sections, including impl blocks
```

--------------------------------

### Move to SAN Conversion Logic

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

This snippet demonstrates the logic for converting a chess move into its Standard Algebraic Notation (SAN) representation, handling captures, checks, checkmates, castling, en passant, and pawn promotions.

```rust
        } else if new_content.is_check() {
            "+"
        } else {
            ""
        };
        let piece_type;
        match src_occ {
            Some(Piece(pt, _)) => match pt {
                PieceType::P => {
                    return Ok(format!(
                        "{piece_type_char}{suffix}",
                        piece_type_char = match spec {
                            Some(SpecialMoveType::EnPassant) => format!( "{srcf}x{destf}{destr}"),
                            _ => format!(
                                "{capture_char}{promotion_char}",
                                capture_char = match dest_occ {
                                    Some(_) => format!( "{srcf}x{destf}{destr}",),
                                    None => format!( "{destf}{destr}"),
                                },
                                promotion_char = match spec {
                                    Some(SpecialMoveType::Promotion(piece_type)) => format!( "={}", char::from(piece_type)),
                                    _ => String::new(),
                                }
                            ),
                        },
                    ))
                }
                PieceType::K => {
                    return Ok(format!(
                        "{king_move}{suffix}",
                        king_move = match spec {
                            Some(SpecialMoveType::CastlingKingside) => "O-O".to_owned(),
                            Some(SpecialMoveType::CastlingQueenside) => "O-O-O".to_owned(),
                            _ => format!(
                                "K{capture_char}{destf}{destr}",
                                capture_char = match dest_occ {
                                    Some(_) => "x",
                                    None => "",
                                }
                            ),
                        },
                    ))
                }
                pt => {
                    san.push(char::from(pt));
                    piece_type = pt;
                }
            },
            _ => panic!("the universe is malfunctioning"),
        }
        if legal
            .iter()
            .filter(|m| {
                if m.1 == dest {
                    if let Some(Piece(pt, _)) = content[m.0] {
                        pt == piece_type
                    } else {
                        false
                    }
                } else {
                    false
                }
            })
            .count()
            > 1
        {
            if legal
                .iter()
                .filter(|m| {
                    if m.1 == dest {
                        if let Some(Piece(pt, _)) = content[m.0] {
                            pt == piece_type && helpers::squares_in_file(srcf).contains(&m.0)
                        } else {
                            false
                        }
                    } else {
                        false
                    }
                })
                .count()
                > 1
            {
                if legal
                    .iter()
                    .filter(|m| {
                        if m.1 == dest {
                            if let Some(Piece(pt, _)) = content[m.0] {
                                pt == piece_type && helpers::squares_in_rank(srcr).contains(&m.0)
                            } else {
                                false
                            }
                        } else {
                            false
                        }
                    })
                    .count()
                    > 1
                {
                    san.push(srcf);
                }
                san.push(srcr);
            } else {
                san.push(srcf);
            }
        }
        Ok(format!(
            "{san}{capture_char}{destf}{destr}{suffix}",
            capture_char = match dest_occ {
                Some(_) => "x",
                None => "",
            }
        ))
    }

```

--------------------------------

### Board Initialization from FEN

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Implementation of the `from_fen` associated function to construct a `Board` from a `Fen` object.

```rust
33    /// Constructs a `Board` from a `Fen` object.
34    pub fn from_fen(fen: Fen) -> Self {
35        let (position, halfmove_clock, fullmove_number) = (fen.position().clone(), fen.halfmove_clock(), fen.fullmove_number());
36        let mut board = Self {
37            position,
38            halfmove_clock,
39            fullmove_number,
40            ongoing: halfmove_clock < 150,
41            position_history: Vec::new(),
42            move_history: Vec::new(),
43            halfmove_clock_history: Vec::new(),
44            initial_fen: fen,
45            resigned_side: None,
46            draw_agreed: false,
47        };
48        board.update_status();
49        board
50    }
```

--------------------------------

### Pawn Move Generation (Black)

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

Generates pseudolegal moves for a black pawn, including single/double step, captures, and en passant.

```rust
515                        if content[i - 8].is_none() {
516                            possible_dests.push((i - 8, false));
517                            if (48..56).contains(&i) && content[i - 16].is_none() {
518                                possible_dests.push((i - 16, false))
519                            }
520                        }
521                        if helpers::long_range_can_move(i, -9) {
522                            if let Some(Piece(_, color)) = content[i - 9] {
523                                if color.is_white() {
524                                    possible_dests.push((i - 9, false));
525                                }
526                            } else if ep_target.is_some() && ep_target.unwrap() == i - 9 {
527                                possible_dests.push((i - 9, true));
528                            }
529                        }
530                        if helpers::long_range_can_move(i, -7) {
531                            if let Some(Piece(_, color)) = content[i - 7] {
532                                if color.is_white() {
533                                    possible_dests.push((i - 7, false));
534                                }
535                            } else if ep_target.is_some() && ep_target.unwrap() == i - 7 {
536                                possible_dests.push((i - 7, true));
537                            }
538                        }
539                    }
540                    pseudolegal_moves.extend(
541                        possible_dests
542                            .into_iter()
543                            .filter(|&(dest, is_en_passant)| {
544                                if is_en_passant {
545                                    true
546                                } else {
547                                    match content[dest] {
548                                        Some(Piece(_, color)) => color != *side,
549                                        _ => true,
550                                    }
551                                }
552                            })
553                            .map(|(dest, is_en_passant)| Move(i, dest, if is_en_passant { Some(SpecialMoveType::EnPassant) } else { None })),
554                    );
555                    pseudolegal_moves
556                }
```

--------------------------------

### Pawn Move Generation (White)

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

Generates pseudolegal moves for a white pawn, including single/double step, captures, and en passant.

```rust
487                PieceType::P => {
488                    let mut possible_dests = Vec::new();
489                    if side.is_white() {
490                        if content[i + 8].is_none() {
491                            possible_dests.push((i + 8, false));
492                            if (8..16).contains(&i) && content[i + 16].is_none() {
493                                possible_dests.push((i + 16, false))
494                            }
495                        }
496                        if helpers::long_range_can_move(i, 7) {
497                            if let Some(Piece(_, color)) = content[i + 7] {
498                                if color.is_black() {
499                                    possible_dests.push((i + 7, false));
500                                }
501                            } else if ep_target.is_some() && ep_target.unwrap() == i + 7 {
502                                possible_dests.push((i + 7, true));
503                            }
504                        }
505                        if helpers::long_range_can_move(i, 9) {
506                            if let Some(Piece(_, color)) = content[i + 9] {
507                                if color.is_black() {
508                                    possible_dests.push((i + 9, false));
509                                }
510                            } else if ep_target.is_some() && ep_target.unwrap() == i + 9 {
511                                possible_dests.push((i + 9, true));
512                            }
513                        }
514                    } else {
```

--------------------------------

### Making a Move

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

This code snippet demonstrates the logic for making a legal move within the `Position` struct. It handles piece movement, updates castling rights, determines en passant targets, and returns a new `Position` state.

```rust
let move_ = match helpers::as_legal(move_, &self.gen_non_illegal_moves()) {
            Some(m) => m,
            _ => return Err(IllegalMoveError(move_)),
        };
        let castling_rights_idx_offset = if self.side.is_white() { 0 } else { 2 };
        let Self {
            content,
            mut side,
            mut castling_rights,
            ..
        } = self;
        let mut ep_target = None;
        let Move(move_src, move_dest, ..) = move_;
        let moved_piece = content[move_src];
        match moved_piece {
            Some(Piece(PieceType::K, _)) => (castling_rights[castling_rights_idx_offset], castling_rights[castling_rights_idx_offset + 1]) = (None, None),
            Some(Piece(PieceType::P, _)) => {
                if (std::cmp::max(move_src, move_dest) - std::cmp::min(move_src, move_dest)) == 16 {
                    ep_target = Some(if side.is_white() { move_src + 8 } else { move_src - 8 });
                }
            }
            _ => (),
        }
        for maybe_rook in [move_src, move_dest] {
            let maybe_right = castling_rights.iter().enumerate().find(|(_, right)| right.is_some() && right.unwrap() == maybe_rook);
            if maybe_right.is_some() {
                castling_rights[maybe_right.unwrap().0] = None;
            }
        }
        side = !side;
        let new_content = helpers::change_content(content, &move_, &self.castling_rights);
        Ok(Self {
            content: new_content,
            side,
            castling_rights,
            ep_target,
        })
```

--------------------------------

### Generate Pseudolegal Moves

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

This snippet shows how pseudolegal moves are generated for a given square, handling promotions and en passant captures.

```rust
pseudolegal_moves.extend(possible_dests.into_iter().flat_map(|(dest, ep)| {
                        if (0..8).contains(&dest) || (56..64).contains(&dest) {
                            [PieceType::Q, PieceType::R, PieceType::B, PieceType::N]
                                .into_iter()
                                .map(|p| Move(i, dest, Some(SpecialMoveType::Promotion(p))))
                                .collect()
                        } else {
                            vec![Move(i, dest, if ep { Some(SpecialMoveType::EnPassant) } else { None })]
                        }
                    }));
                    pseudolegal_moves
                }
                long_range_type => {
                    pseudolegal_moves.append(&mut self.gen_long_range_piece_pseudolegal_moves(i, long_range_type));
                    pseudolegal_moves
                }
            }
        } else {
            pseudolegal_moves
        }
    }
```

--------------------------------

### Castling Queenside Logic

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

Handles the logic for generating pseudolegal moves for castling queenside.

```rust
450                            0 => pseudolegal_moves.push(Move(i, ooo_sq, Some(SpecialMoveType::CastlingQueenside))),
451                            1 => {
452                                if helpers::find_all_pieces(ooo_sq..i, content)[0] == r {
453                                    pseudolegal_moves.push(Move(i, ooo_sq, Some(SpecialMoveType::CastlingQueenside)))
454                                }
455                            }
456                            _ => (),
457                        }
458                    }
459                    pseudolegal_moves
```

--------------------------------

### Make Move SAN

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Attempts to interpret the SAN representation of a move and play it on the board, returning an error if it is invalid or illegal.

```rust
    /// Attempts to interpret the SAN representation of a move and play it on the board, returning an error if it is invalid or illegal.
    pub fn make_move_san(&mut self, san: &str) -> Result<(), InvalidSanMoveError> {
        let move_ = self.san_to_move(san)?;
        self.make_move(move_).map_err(|_| InvalidSanMoveError(san.to_owned()))
    }

```

--------------------------------

### Make Move

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Implementation of the `make_move` method to play a move on the board, updating the game state and returning an error if the move is illegal.

```rust
103    /// Plays on the board the given move, returning an error if the move is illegal.
104    pub fn make_move(&mut self, move_: Move) -> Result<(), IllegalMoveError> {
105        let move_ = match helpers::as_legal(move_, &self.gen_legal_moves()) {
106            Some(m) => m,
107            _ => return Err(IllegalMoveError(move_)),
108        };
109        let mut halfmove_clock = self.halfmove_clock;
110        let fullmove_number = self.fullmove_number + if self.position.side.is_black() { 1 } else { 0 };
111        let Move(move_src, move_dest, ..) = move_;
112        let (moved_piece, dest_occ) = (self.position.content[move_src], self.position.content[move_dest]);
113        if matches!(moved_piece, Some(Piece(PieceType::P, _))) || dest_occ.is_some() {
114            halfmove_clock = 0;
115        } else {
116            halfmove_clock += 1;
117        }
118        self.position_history.push(self.position.clone());
119        self.position = self.position.with_move_made(move_).unwrap();
120        self.move_history.push(move_);
121        self.halfmove_clock_history.push(self.halfmove_clock);

```

--------------------------------

### SAN to Move Conversion

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

This snippet shows how to convert a Standard Algebraic Notation (SAN) string back into a `Move` struct, searching through generated legal moves.

```rust
    /// Constructs a `Move` from a SAN representation, returning an error if it is invalid or illegal.
    pub fn san_to_move(&self, san: &str) -> Result<Move, InvalidSanMoveError> {
        let san = san.trim().replace('0', "O").replace(['+', '#'], "");
        self.gen_non_illegal_moves()
            .into_iter()
            .find(|&m| self.move_to_san(m).unwrap().replace(['+', '#'], "") == san)
            .ok_or(InvalidSanMoveError(san.to_owned()))
    }

```

--------------------------------

### Struct Board

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Board.html

The structure for a chessboard/game

```rust
pub struct Board { /* private fields */ }
```

--------------------------------

### Knight Move Generation

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

Generates pseudolegal moves for a knight, considering its L-shaped movement and board boundaries.

```rust
461                PieceType::N => {
462                    let b_r_axes = [(7, [-1, 8]), (9, [8, 1]), (-7, [1, -8]), (-9, [-8, -1])];
463                    let mut dest_squares = Vec::new();
464                    for (b_axis, r_axes) in b_r_axes {
465                        if !helpers::long_range_can_move(i, b_axis) {
466                            continue;
467                        }
468                        let b_dest = i as isize + b_axis;
469                        for r_axis in r_axes {
470                            if !helpers::long_range_can_move(b_dest as usize, r_axis) {
471                                continue;
472                            }
473                            dest_squares.push((b_dest + r_axis) as usize);
474                        }
475                    }
476                    pseudolegal_moves.extend(
477                        dest_squares
478                            .into_iter()
479                            .filter(|&dest| match content[dest] {
480                                Some(Piece(_, color)) => color != *side,
481                                _ => true,
482                            })
483                            .map(|dest| Move(i, dest, None)),
484                    );
485                    pseudolegal_moves
486                }
```

--------------------------------

### Sufficient Material Check

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Checks whether there is sufficient checkmating material on the board.

```Rust
pub fn is_sufficient_material(&self) -> bool {
        !self.is_insufficient_material()
    }
```

--------------------------------

### Make Moves SAN

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Attempts to play the given line of SAN moves (separated by spaces, **excluding move numbers**) on the board, returning an error if any move is illegal. If an error is returned, the board is left unchanged, i.e. no moves are played on the board.

```rust
    /// Attempts to play the given line of SAN moves (separated by spaces, **excluding move numbers**) on the board,
    /// returning an error if any move is illegal. If an error is returned, the board is left unchanged, i.e. no moves
    /// are played on the board.
    pub fn make_moves_san(&mut self, line: &str) -> Result<(), InvalidSanMoveError> {
        let mut board = self.clone();
        for san in line.split_ascii_whitespace() {
            board.make_move_san(san)?;
        }
        *self = board;
        Ok(())
    }

```

--------------------------------

### from method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Returns the argument unchanged.

```rust
fn from(t: T) -> T
```

--------------------------------

### Generate Legal Moves

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Implementation of the `gen_legal_moves` method to generate all legal moves in the current position.

```rust
81    /// Generates the legal moves in the position.
82    pub fn gen_legal_moves(&self) -> Vec<Move> {
83        if self.ongoing {
84            self.position.gen_non_illegal_moves()
85        } else {
86            Vec::new()
87        }
88    }
```

--------------------------------

### Pretty Printing the Board

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

This function generates a string representation of the chessboard. It can display pieces using Unicode characters or ASCII characters, and the board orientation can be set from either white's or black's perspective.

```rust
pub fn pretty_print(&self, perspective: Color, ascii: bool) -> String {
        let mut string = String::new();
        let mut content = self.content;
        let ranks: Vec<_> = if perspective.is_white() {
            content.chunks(8).rev().enumerate().collect()
        } else {
            content.reverse();
            content.chunks(8).rev().enumerate().collect()
        };
        let mut file_names = ["a", "b", "c", "d", "e", "f", "g", "h"];
        if perspective.is_black() {
            file_names.reverse();
        }
        string += &("  ".to_owned() + "┌" + &"───┬".repeat(7) + "───┐\n");
        for (ranki, rank) in ranks {
            if ranki != 0 {
                string += &("  ".to_owned() + "├" + &"───┼".repeat(7) + "───┤\n");
            }
            string += &format!("{} │", if perspective.is_white() { 8 - ranki } else { ranki + 1 },);
            for occupant in rank.iter() {
                string += &format!(
                    " {} │",
                    if let Some(p) = occupant {
                        if ascii {
                            (*p).into()
                        } else {
                            p.to_string().chars().next().unwrap()
                        }
                    } else {
                        ' '
                    }
                );
            }
            string.push('\n');
        }
        string += &("  ".to_owned() + "└" + &"───┴".repeat(7) + "───┘\n");
        let mut files = vec![" "];
        files.extend(file_names);
        string += &(files.join("   ") + "  ");
        string
    }
```

--------------------------------

### ne method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Tests for inequality between two Move values.

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

--------------------------------

### Move to SAN Conversion

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Implementation of the `move_to_san` method to convert a `Move` into its Standard Algebraic Notation (SAN) representation, returning an error if the move is illegal.

```rust
61    /// Represents a `Move` in SAN, returning an error if the move is illegal.
62    pub fn move_to_san(&self, move_: Move) -> Result<String, IllegalMoveError> {
63        let move_ = helpers::as_legal(move_, &self.gen_legal_moves()).ok_or(IllegalMoveError(move_))?;
64        self.position.move_to_san(move_)
65    }
```

--------------------------------

### clone_from method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Performs copy-assignment from another Move.

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

--------------------------------

### Struct Position

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Position.html

The structure for a chess position

```rust
pub struct Position { /* private fields */ }
```

--------------------------------

### fmt method (Debug)

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Formats the Move value using the given formatter.

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

--------------------------------

### SAN to Move Conversion

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Implementation of the `san_to_move` method to construct a `Move` from a SAN string, returning an error if the move is invalid or illegal.

```rust
67    /// Constructs a `Move` from a SAN representation, returning an error if it is invalid or illegal.
68    pub fn san_to_move(&self, san: &str) -> Result<Move, InvalidSanMoveError> {
69        match self.position.san_to_move(san) {
70            Ok(m) => {
71                if self.is_legal(m) {
72                    Ok(m)
73                } else {
74                    Err(InvalidSanMoveError(san.to_owned()))
75                }
76            }
77            e => e,
78        }
79    }
```

--------------------------------

### Is Ongoing

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Checks whether the game is still ongoing.

```rust
    /// Checks whether the game is still ongoing.
    pub fn is_ongoing(&self) -> bool {
        self.ongoing
    }

```

--------------------------------

### try_from method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Performs the conversion from U to T.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Change Board Content

Source: https://docs.rs/rschess/2.0.5/src/rschess/helpers.rs.html

Updates the board content based on a given move, including special moves like castling, en passant, and promotion.

```Rust
pub fn change_content(content: &[Option<Piece>; 64], move_: &Move, castling_rights: &[Option<usize>]) -> [Option<Piece>; 64] {
    let mut content = *content;
    let Move(src, dest, spec) = move_;
    (content[*src], content[*dest]) = (None, content[*src]);
    match spec {
        Some(SpecialMoveType::CastlingKingside | SpecialMoveType::CastlingQueenside) => match *dest {
            6 => {
                let krook = castling_rights[0].unwrap();
                (content[krook], content[5]) = (None, content[krook]);
            }
            2 => {
                let qrook = castling_rights[1].unwrap();
                (content[qrook], content[3]) = (None, content[qrook]);
            }
            62 => {
                let krook = castling_rights[2].unwrap();
                (content[krook], content[61]) = (None, content[krook]);
            }
            58 => {
                let qrook = castling_rights[3].unwrap();
                (content[qrook], content[59]) = (None, content[qrook]);
            }
            _ => panic!("the universe is malfunctioning"),
        },
        Some(SpecialMoveType::EnPassant) => match dest {
            16..=23 => content[dest + 8] = None,
            40..=47 => content[dest - 8] = None,
            _ => panic!("the universe is malfunctioning"),
        },
        Some(SpecialMoveType::Promotion(piece_type)) => {
            if let Some(Piece(_, color)) = content[*dest] {
                content[*dest] = Some(Piece(*piece_type, color));
            }
        }
        _ => (),
    }
}
```

--------------------------------

### Pseudolegal Move Generation

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

Functions to generate all pseudolegal moves for the current position or from a specific square.

```Rust
    /// Generates the pseudolegal moves in the position.
    pub fn gen_pseudolegal_moves(&self) -> Vec<Move> {
        let mut pseudolegal_moves = Vec::new();
        for i in 0..64 {
            pseudolegal_moves.append(&mut self.gen_pseudolegal_moves_sq(i));
        }
        pseudolegal_moves
    }

    /// Generates the pseudolegal moves **from** a specific square.
    /// The square index `i` can be converted from a square name using the [`sq_to_idx`](super::sq_to_idx) function.
    pub fn gen_pseudolegal_moves_sq(&self, i: usize) -> Vec<Move> {
        let Self {
            content,
            castling_rights,
            ep_target,
            side,
        } = self;
        let mut pseudolegal_moves = Vec::new();
        if let Some(piece) = self.content[i] {
            if piece.1 != *side {
                return pseudolegal_moves;
            }
            match piece.0 {
                PieceType::K => {
                    let mut possible_dests = Vec::new();
                    for axis in [1, 8, 7, 9] {
                        if helpers::long_range_can_move(i, axis as isize) {
                            possible_dests.push(i + axis);
                        }
                        if helpers::long_range_can_move(i, -(axis as isize)) {
                            possible_dests.push(i - axis);
                        }
                    }
                    possible_dests.retain(|&dest| match content[dest] {
                        Some(Piece(_, color)) => color != *side,
                        _ => true,
                    });
                    pseudolegal_moves.extend(possible_dests.into_iter().map(|d| Move(i, d, None)));
                    let castling_rights_idx_offset = if side.is_white() { 0 } else { 2 };
                    let (oo_sq, ooo_sq) = if side.is_white() { (6, 2) } else { (62, 58) };
                    let (kingside, queenside) = (castling_rights[castling_rights_idx_offset], castling_rights[castling_rights_idx_offset + 1]);
                    if let Some(r) = kingside {
                        match helpers::count_pieces(i + 1..=oo_sq, content) {
                            0 => pseudolegal_moves.push(Move(i, oo_sq, Some(SpecialMoveType::CastlingKingside))),
                            1 => {
                                if helpers::find_all_pieces(i + 1..=oo_sq, content)[0] == r {
                                    pseudolegal_moves.push(Move(i, oo_sq, Some(SpecialMoveType::CastlingKingside)))
                                }
                            }
                            _ => (),
                        }
                    }
                    if let Some(r) = queenside {
                        match helpers::count_pieces(ooo_sq..i, content) {

```

--------------------------------

### Generate Movetext

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Generates the SAN movetext of the game thus far (excluding the game result).

```rust
pub fn gen_movetext(&self) -> String {
        let mut movetext = String::new();
        let initial_side = self.initial_fen.position().side;
        let initial_fullmove_number: usize = self.initial_fen.fullmove_number();
        let mut current_side = initial_side;
        let mut current_fullmove_number = initial_fullmove_number;
        for (movei, &move_) in self.move_history.iter().enumerate() {
            let pos = &self.position_history[movei];
            let san = pos.move_to_san(move_).unwrap();
            if current_side.is_black() {
                movetext.push_str(&format!("{}{san} ", if movei == 0 { format!("{current_fullmove_number}... ") } else { String::new() }));
                current_fullmove_number += 1;
            } else {
                movetext.push_str(&format!("{current_fullmove_number}. {san} "))
            }
            current_side = !current_side;
        }
        movetext.trim().to_owned()
    }
```

--------------------------------

### Count Material

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

Counts the material on the board, categorizing pieces into Knights, Bishops (with color complexity), and others.

```rust
pub(crate) fn count_material(&self) -> Vec<Material> {
        let mut material = Vec::new();
        for sq in 0..64 {
            if let Some(Piece(piece_type, _)) = self.content[sq] {
                match piece_type {
                    PieceType::K => (),
                    PieceType::N => material.push(Material::Knight),
                    PieceType::B => material.push(Material::Bishop(helpers::color_complex_of(sq))),
                    _ => material.push(Material::Other),
                }
            }
        }
        material
    }
```

--------------------------------

### eq method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Tests for equality between two Move values.

```rust
fn eq(&self, other: &Move) -> bool
```

--------------------------------

### Insufficient Material Check

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Checks whether the game is drawn by insufficient material.

```Rust
pub fn is_insufficient_material(&self) -> bool {
        self.position.is_insufficient_material()
    }
```

--------------------------------

### Invalid position image properties

Source: https://docs.rs/rschess/2.0.5/src/rschess/errors.rs.html

The piece set does not contain all the necessary pieces.

```rust
#[error("Invalid position image properties: the piece set \'{0:?}\' does not contain all the necessary pieces")]
InvalidCustomPieceSet(super::img::PieceSet),
```

--------------------------------

### As Legal Move

Source: https://docs.rs/rschess/2.0.5/src/rschess/helpers.rs.html

Checks if a given move is legal, returning the legal move if found, or a similar move if the special move type is 'Unclear'.

```rust
pub fn as_legal(move_: Move, legal: &[Move]) -> Option<Move> {
    if legal.contains(&move_) {
        Some(move_)
    } else if move_.2 == Some(SpecialMoveType::Unclear) {
        match legal.iter().find(|m| (m.0, m.1) == (move_.0, move_.1) && !matches!(m.2, Some(SpecialMoveType::Promotion(_)))) {
            Some(&m) => Some(m),
            _ => None,
        }
    } else {
        None
    }
}

```

--------------------------------

### Is Game Over

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Checks whether the game is over.

```rust
    /// Checks whether the game is over.
    pub fn is_game_over(&self) -> bool {
        !self.ongoing
    }

```

--------------------------------

### try_into method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Performs the conversion from T to U.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### clone_to_uninit method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Performs copy-assignment from Move to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### into method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Calls U::from(self).

```rust
fn into(self) -> U
```

--------------------------------

### from_uci method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Creates a Move object from its UCI representation.

```rust
pub fn from_uci(uci: &str) -> Result<Self, InvalidUciError>
```

--------------------------------

### Applying a Move to the Position

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

This snippet defines a method to return a new `Position` after a given `Move` is made, returning an error if the move is illegal.

```rust
    /// Returns the position which would occur if the given move were played, returning an error if the move is illegal.
    pub fn with_move_made(&self, move_: Move) -> Result<Self, IllegalMoveError> {

```

--------------------------------

### Position struct and FEN conversion

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

Defines the `Position` struct for a chess board and implements the `to_fen` method to convert it to a Forsyth-Edwards Notation (FEN) string.

```rust
1use super::{helpers, Color, IllegalMoveError, InvalidSanMoveError, Move, Piece, PieceType, SpecialMoveType};
use std::{
    collections::HashMap,
    fmt,
    sync::{Mutex, OnceLock},
};

/// Returns the cached positions and their legal moves.
fn legal_move_cache() -> &'static Mutex<HashMap<Position, Vec<Move>>> {
    static LEGAL_MOVE_CACHE: OnceLock<Mutex<HashMap<Position, Vec<Move>>>> = OnceLock::new();
    LEGAL_MOVE_CACHE.get_or_init(|| Mutex::new(HashMap::new()))
}

/// The structure for a chess position
#[derive(Eq, PartialEq, Hash, Clone, Debug)]
pub struct Position {
    /// The board content; each square is represented by a number 0..64 where a1 is 0, h1 is 7, and h8 is 63
    pub(crate) content: [Option<Piece>; 64],
    /// The side to move; white is `true` and black is `false`
    pub(crate) side: Color,
    /// The indices of rook locations representing castling rights for both sides in the format [K, Q, k, q]
    pub(crate) castling_rights: [Option<usize>; 4],
    /// The index of the en passant target square, 0..64
    pub(crate) ep_target: Option<usize>,
}

impl Position {
    /// Generates an FEN string representing the board data, active color, castling rights, and en passant target in the position.
    pub fn to_fen(&self) -> String {
        let Self { content, side, castling_rights, ep_target } = self;
        let mut rankstrs = Vec::new();
        for rank in content.chunks(8).rev() {
            let mut rankstr = String::new();
            let mut empty = 0;
            for sq in rank {
                match sq {
                    Some(p) => {
                        if empty > 0 {
                            rankstr.push(char::from_digit(empty, 10).unwrap());
                            empty = 0;
                        }
                        rankstr.push((*p).into());
                    }
                    None => {
                        empty += 1;
                    }
                }
            }
            if empty > 0 {
                rankstr.push(char::from_digit(empty, 10).unwrap());
            }
            rankstrs.push(rankstr);
        }
        let board_data = rankstrs.join("/");
        let active_color = char::from(*side).to_string();
        let mut castling_availability = String::new();
        let count_rooks = |rng, color| helpers::count_piece(rng, Piece(PieceType::R, color), content);
        let (wk, bk) = (helpers::find_king(Color::White, content), helpers::find_king(Color::Black, content));
        if let Some(idx) = castling_rights[0] {
            castling_availability.push(if count_rooks(wk + 1..8, Color::White) == 1 {
                'K'
            } else {
                helpers::idx_to_sq(idx).0.to_ascii_uppercase()
            });
        }
        if let Some(idx) = castling_rights[1] {
            castling_availability.push(if count_rooks(0..wk, Color::White) == 1 {
                'Q'
            } else {
                helpers::idx_to_sq(idx).0.to_ascii_uppercase()
            });
        }
        if let Some(idx) = castling_rights[2] {
            castling_availability.push(if count_rooks(bk + 1..64, Color::Black) == 1 { 'k' } else { helpers::idx_to_sq(idx).0 });
        }
        if let Some(idx) = castling_rights[3] {
            castling_availability.push(if count_rooks(56..bk, Color::Black) == 1 { 'q' } else { helpers::idx_to_sq(idx).0 });
        }
        if castling_availability.is_empty() {
            castling_availability.push('-');
        }
        let en_passant_target_square;
        if let Some(target) = ep_target {
            let (f, r) = helpers::idx_to_sq(*target);
            en_passant_target_square = [f.to_string(), r.to_string()].join("");
        } else {
            en_passant_target_square = "-".to_owned();
        }
        [board_data, active_color, castling_availability, en_passant_target_square].join(" ")
    }

    /// Converts a `Move` to SAN, returning an error if the move is illegal.
    pub fn move_to_san(&self, move_: Move) -> Result<String, IllegalMoveError> {
        let legal = self.gen_non_illegal_moves();
        let move_ = match helpers::as_legal(move_, &legal) {
            Some(m) => m,
            _ => return Err(IllegalMoveError(move_)),
        };
        let mut san = String::new();
        let Move(src, dest, spec) = move_;
        let Self { content, .. } = self;
        let (src_occ, dest_occ) = (content[src], content[dest]);
        let ((srcf, srcr), (destf, destr)) = (helpers::idx_to_sq(src), helpers::idx_to_sq(dest));
        let new_content = self.with_move_made(move_).unwrap();
        let suffix = if new_content.is_checkmate() {

```

--------------------------------

### Check for Insufficient Material

Source: https://docs.rs/rschess/2.0.5/src/rschess/position.rs.html

Determines if the game is drawn due to insufficient material for checkmate.

```rust
pub fn is_insufficient_material(&self) -> bool {
        let copy1 = self.count_material();
        let (mut copy2, copy3, mut copy4) = (copy1.clone(), copy1.clone(), copy1.clone());
        if copy1.is_empty() {
            return true;
        }
        for (i, m) in copy2.iter().enumerate() {
            if let Material::Knight = m {
                copy2.remove(i);
                break;
            }
        }
        if copy2.is_empty() {
            return true;
        }
        let mut b_complex = None;
        for m in copy3.iter() {
            if let Material::Bishop(complex) = m {
                b_complex = Some(complex);
                break;
            }
        }
        if let Some(complex) = b_complex {
            copy4.retain(|m| m != &Material::Bishop(*complex));
            if copy4.is_empty() {
                return true;
            }
        }
        false
    }
```

--------------------------------

### Make Move UCI

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Attempts to parse the UCI representation of a move and play it on the board, returning an error if the move is invalid or illegal.

```rust
    /// Attempts to parse the UCI representation of a move and play it on the board, returning an error if the move is invalid or illegal.
    pub fn make_move_uci(&mut self, uci: &str) -> Result<(), InvalidUciMoveError> {
        let move_ = Move::from_uci(uci).map_err(|_| InvalidUciMoveError::InvalidUci(uci.to_owned()))?;
        self.make_move(move_).map_err(|_| InvalidUciMoveError::IllegalMove(uci.to_owned()))
    }

```

--------------------------------

### clone_into method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Uses borrowed data to replace owned data, usually by cloning.

```rust
fn clone_into(&self, target: &mut T)
```

--------------------------------

### Function idx_to_sq

Source: https://docs.rs/rschess/2.0.5/rschess/fn.idx_to_sq.html

Converts a square index (0..64) to a square name, returning an error if the square index is invalid.

```rust
pub fn idx_to_sq(idx: usize) -> Result<(char, char), InvalidSquareIndexError>
```

--------------------------------

### Pretty Print

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Pretty-prints the position to a string, from the perspective of the side `perspective`. If `ascii` is `true`, this function uses piece characters like 'K' and 'p' instead of characters like '♔' and '♟'.

```Rust
pub fn pretty_print(&self, perspective: Color, ascii: bool) -> String {
        self.position.pretty_print(perspective, ascii)
    }
```

--------------------------------

### Board to FEN Conversion

Source: https://docs.rs/rschess/2.0.5/src/rschess/board.rs.html

Implementation of the `to_fen` method to return a `Fen` object representing the current `Board` state.

```rust
52    /// Returns a `Fen` object representing the `Board`.
53    pub fn to_fen(&self) -> Fen {
54        Fen {
55            position: self.position.clone(),
56            halfmove_clock: self.halfmove_clock,
57            fullmove_number: self.fullmove_number,
58        }
59    }
```

--------------------------------

### from_square method

Source: https://docs.rs/rschess/2.0.5/rschess/struct.Move.html

Returns the source square of the move.

```rust
pub fn from_square(&self) -> (char, char)
```
Tokens:
Raw