[board] A ton of API refinements

board/src/fen.rs

@@ -1,6 +1,6 @@
 // Eryn Wells <eryn@erynwells.me>
 
-use crate::{Board, Builder, Castle, EnPassant};
+use crate::{piece_sets::PlacePieceStrategy, Board, Castle, EnPassant};
 use chessfriend_core::{
     coordinates::ParseSquareError, piece, Color, File, Piece, PlacedPiece, Rank, Square,
 };
@@ -103,10 +103,7 @@ impl ToFenStr for Board {
             (Color::Black, Castle::QueenSide),
         ]
         .map(|(color, castle)| {
-            if !self
-                .castling_rights
-                .player_has_right_to_castle(color, castle)
-            {
+            if !self.castling_rights.is_set(color, castle) {
                 return "";
             }
 
@@ -129,14 +126,14 @@ impl ToFenStr for Board {
         write!(
             fen_string,
             " {}",
-            self.en_passant()
-                .map_or("-".to_string(), |ep| ep.target_square().to_string())
+            self.en_passant_target
+                .map_or("-".to_string(), |square| square.to_string())
         )
         .map_err(ToFenStrError::FmtError)?;
 
-        write!(fen_string, " {}", self.move_counter.halfmove_number)
+        write!(fen_string, " {}", self.clock.half_move_number())
             .map_err(ToFenStrError::FmtError)?;
-        write!(fen_string, " {}", self.move_counter.fullmove_number)
+        write!(fen_string, " {}", self.clock.full_move_number())
             .map_err(ToFenStrError::FmtError)?;
 
         Ok(fen_string)
@@ -178,7 +175,7 @@ impl FromFenStr for Board {
     type Error = FromFenStrError;
 
     fn from_fen_str(string: &str) -> Result<Self, Self::Error> {
-        let mut builder = Builder::default();
+        let mut board = Board::empty();
 
         let mut fields = string.split(' ');
 
@@ -202,34 +199,35 @@ impl FromFenStr for Board {
                 let file = files.next().ok_or(FromFenStrError::MissingPlacement)?;
                 let piece = Piece::from_fen_str(&ch.to_string())?;
 
-                builder.place_piece(PlacedPiece::new(
+                let _ = board.pieces.place(
                     piece,
                     Square::from_file_rank(*file, *rank),
-                ));
+                    PlacePieceStrategy::default(),
+                );
             }
 
             debug_assert_eq!(files.next(), None);
         }
 
-        let player_to_move = Color::from_fen_str(
+        let active_color = Color::from_fen_str(
             fields
                 .next()
                 .ok_or(FromFenStrError::MissingField(Field::PlayerToMove))?,
         )?;
-        builder.to_move(player_to_move);
+        board.clock.active_color = active_color;
 
         let castling_rights = fields
             .next()
             .ok_or(FromFenStrError::MissingField(Field::CastlingRights))?;
         if castling_rights == "-" {
-            builder.no_castling_rights();
+            board.castling_rights.clear_all();
         } else {
             for ch in castling_rights.chars() {
                 match ch {
-                    'K' => builder.player_can_castle(Color::White, Castle::KingSide),
-                    'Q' => builder.player_can_castle(Color::White, Castle::QueenSide),
-                    'k' => builder.player_can_castle(Color::Black, Castle::KingSide),
-                    'q' => builder.player_can_castle(Color::Black, Castle::QueenSide),
+                    'K' => board.castling_rights.set(Color::White, Castle::KingSide),
+                    'Q' => board.castling_rights.set(Color::White, Castle::QueenSide),
+                    'k' => board.castling_rights.set(Color::Black, Castle::KingSide),
+                    'q' => board.castling_rights.set(Color::Black, Castle::QueenSide),
                     _ => return Err(FromFenStrError::InvalidValue),
                 };
             }
@@ -241,7 +239,7 @@ impl FromFenStr for Board {
         if en_passant_square != "-" {
             let square = Square::from_algebraic_str(en_passant_square)
                 .map_err(FromFenStrError::ParseSquareError)?;
-            builder.en_passant(Some(EnPassant::from_target_square(square).unwrap()));
+            board.en_passant_target = Some(square);
         }
 
         let half_move_clock = fields
@@ -250,7 +248,7 @@ impl FromFenStr for Board {
         let half_move_clock: u16 = half_move_clock
             .parse()
             .map_err(FromFenStrError::ParseIntError)?;
-        builder.halfmove_number(half_move_clock);
+        board.clock.half_move_number = half_move_clock;
 
         let full_move_counter = fields
             .next()
@@ -258,11 +256,11 @@ impl FromFenStr for Board {
         let full_move_counter: u16 = full_move_counter
             .parse()
             .map_err(FromFenStrError::ParseIntError)?;
-        builder.fullmove_number(full_move_counter);
+        board.clock.full_move_number = full_move_counter;
 
         debug_assert_eq!(fields.next(), None);
 
-        Ok(builder.build())
+        Ok(board)
     }
 }
 
@@ -318,16 +316,14 @@ mod tests {
         let pos = test_board!(starting);
 
         assert_eq!(
-            pos.to_fen_str(),
-            Ok(String::from(
-                "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
-            ))
+            pos.to_fen_str().unwrap(),
+            "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 0"
         );
     }
 
     #[test]
     fn from_starting_fen() {
-        let board = fen!("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
+        let board = fen!("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 0").unwrap();
         let expected = Board::starting();
         assert_eq!(board, expected, "{board:#?}\n{expected:#?}");
     }