chessframe 0.3.0

# chessframe

chessframe is a Rust library for working with chess positions, generating psudo-legal moves, and interacting with the UCI protocol. It provides efficient tools for move generation and board manipulation.

## Features

- Load positions from FEN strings.
- Generate psudo-legal moves efficiently.

## Examples

### Loading a position from a FEN string

Creating a `Board` from a FEN string is easy with the `Board::from_fen()` constructor. The `Board::default()` method constructs the starting position using the standard starting FEN.

```rust
use chessframe::board::Board;

let fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
let board = Board::from_fen(fen);
```

### Making a Move

This example demonstrates how to make a move on the chessboard. Since `Board` does not maintain move history, you need to use `board.make_move_new()` to create a new board instead of modifying the current one. However, in this example, we use `board.make_move()`, which updates the board state but does not allow undoing the move.

```rust
use chessframe::{board::Board, chess_move::ChessMove, square::Square};

let mut board = Board::default();

let mv = ChessMove::new(Square::E2, Square::E4);

assert_eq!(board.make_move(&mv), Ok(()));
```

### Making and undoing a Move using `Game`

This example demonstrates how to make and undo a move using the `Game` struct.

```rust
use chessframe::{chess_move::ChessMove, game::Game, piece::Piece, square::Square};

let mut game = Game::new();

let mv = ChessMove::new(Square::E2, Square::E4);
assert_eq!(game.board.get_piece(Square::E2), Some(Piece::Pawn));
assert_eq!(game.board.get_piece(Square::E4), None);

game.make_move(mv);
assert_eq!(game.board.get_piece(Square::E2), None);
assert_eq!(game.board.get_piece(Square::E4), Some(Piece::Pawn));

game.undo_move();
assert_eq!(game.board.get_piece(Square::E2), Some(Piece::Pawn));
assert_eq!(game.board.get_piece(Square::E4), None);
```

### Using `make_move_new` for Perft Tests

The following example implements a Perft test, which counts all possible positions after a given number of moves.

```rust
use chessframe::{board::Board, bitboard::EMPTY};

fn perft(board: &Board, depth: usize) -> usize {
    let mut count = 0;

    for mv in board.generate_moves_vec(!EMPTY) {
        if let Ok(ref board) = board.make_move_new(&mv) {
            let perft_results = if depth == 1 {
                1
            } else {
                perft(board, depth - 1)
            };
            count += perft_results;
        }
    }

    count
}

fn main() {
    let fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
    let board = Board::from_fen(fen);

    let depth = 5;
    println!("The number of nodes after {} moves is: {}", depth, perft(&board, depth));
}
```