Implement Display trait for Game to format as FEN

Author: WalterSmuts

src/board.rs

@@ -1084,6 +1084,11 @@ impl Board {
     pub fn checkers(&self) -> &BitBoard {
         &self.checkers
     }
+
+    pub fn get_psuedo_fen(&self) -> String {
+        let board_builder: BoardBuilder = self.into();
+        board_builder.get_psuedo_fen()
+    }
 }
 
 impl fmt::Display for Board {

src/board_builder.rs

@@ -264,83 +264,88 @@ impl BoardBuilder {
         self.en_passant = file;
         self
     }
-}
-
-impl Index<Square> for BoardBuilder {
-    type Output = Option<(Piece, Color)>;
-
-    fn index<'a>(&'a self, index: Square) -> &'a Self::Output {
-        &self.pieces[index.to_index()]
-    }
-}
 
-impl IndexMut<Square> for BoardBuilder {
-    fn index_mut<'a>(&'a mut self, index: Square) -> &'a mut Self::Output {
-        &mut self.pieces[index.to_index()]
-    }
-}
-
-impl fmt::Display for BoardBuilder {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    pub fn get_psuedo_fen(&self) -> String {
+        let mut psuedo_fen = String::new();
         let mut count = 0;
         for rank in ALL_RANKS.iter().rev() {
             for file in ALL_FILES.iter() {
                 let square = Square::make_square(*rank, *file).to_index();
 
                 if self.pieces[square].is_some() && count != 0 {
-                    write!(f, "{}", count)?;
+                    psuedo_fen.push_str(count.to_string().as_str());
                     count = 0;
                 }
 
                 if let Some((piece, color)) = self.pieces[square] {
-                    write!(f, "{}", piece.to_string(color))?;
+                    psuedo_fen.push_str(piece.to_string(color).as_str());
                 } else {
                     count += 1;
                 }
             }
 
             if count != 0 {
-                write!(f, "{}", count)?;
+                psuedo_fen.push_str(count.to_string().as_str());
             }
 
             if *rank != Rank::First {
-                write!(f, "/")?;
+                psuedo_fen.push_str("/");
             }
             count = 0;
         }
 
-        write!(f, " ")?;
+        psuedo_fen.push_str(" ");
 
         if self.side_to_move == Color::White {
-            write!(f, "w ")?;
+            psuedo_fen.push_str("w ");
         } else {
-            write!(f, "b ")?;
+            psuedo_fen.push_str("b ");
         }
 
-        write!(
-            f,
-            "{}",
-            self.castle_rights[Color::White.to_index()].to_string(Color::White)
-        )?;
-        write!(
-            f,
-            "{}",
-            self.castle_rights[Color::Black.to_index()].to_string(Color::Black)
-        )?;
+        psuedo_fen.push_str(
+            self.castle_rights[Color::White.to_index()]
+                .to_string(Color::White)
+                .as_str(),
+        );
+        psuedo_fen.push_str(
+            self.castle_rights[Color::Black.to_index()]
+                .to_string(Color::Black)
+                .as_str(),
+        );
         if self.castle_rights[0] == CastleRights::NoRights
             && self.castle_rights[1] == CastleRights::NoRights
         {
-            write!(f, "-")?;
+            psuedo_fen.push_str("-");
         }
 
-        write!(f, " ")?;
+        psuedo_fen.push_str(" ");
         if let Some(sq) = self.en_passant_target {
-            write!(f, "{}", sq)?;
+            psuedo_fen.push_str(sq.to_string().as_str());
         } else {
-            write!(f, "-")?;
+            psuedo_fen.push_str("-");
         }
 
-        write!(f, " 0 1")
+        psuedo_fen
+    }
+}
+
+impl Index<Square> for BoardBuilder {
+    type Output = Option<(Piece, Color)>;
+
+    fn index<'a>(&'a self, index: Square) -> &'a Self::Output {
+        &self.pieces[index.to_index()]
+    }
+}
+
+impl IndexMut<Square> for BoardBuilder {
+    fn index_mut<'a>(&'a mut self, index: Square) -> &'a mut Self::Output {
+        &mut self.pieces[index.to_index()]
+    }
+}
+
+impl fmt::Display for BoardBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} 0 1", self.get_psuedo_fen())
     }
 }
 

src/game.rs

@@ -4,6 +4,7 @@ use crate::color::Color;
 use crate::error::Error;
 use crate::movegen::MoveGen;
 use crate::piece::Piece;
+use std::fmt;
 use std::str::FromStr;
 
 /// Contains all actions supported within the game
@@ -170,6 +171,48 @@ impl Game {
         copy
     }
 
+    fn get_full_move_counter(&self) -> usize {
+        let mut half_moves = 2;
+        for x in self.moves.iter() {
+            match *x {
+                Action::MakeMove(_) => {
+                    half_moves += 1;
+                }
+                _ => (),
+            }
+        }
+        half_moves / 2
+    }
+
+    fn get_half_move_clock(&self) -> usize {
+        let mut reversible_moves = 0;
+        let mut board = self.start_pos;
+        for x in self.moves.iter() {
+            match *x {
+                Action::MakeMove(m) => {
+                    let white_castle_rights = board.castle_rights(Color::White);
+                    let black_castle_rights = board.castle_rights(Color::Black);
+                    if board.piece_on(m.get_source()) == Some(Piece::Pawn) {
+                        reversible_moves = 0;
+                    } else if board.piece_on(m.get_dest()).is_some() {
+                        reversible_moves = 0;
+                    } else {
+                        reversible_moves += 1;
+                    }
+                    board = board.make_move_new(m);
+
+                    if board.castle_rights(Color::White) != white_castle_rights
+                        || board.castle_rights(Color::Black) != black_castle_rights
+                    {
+                        reversible_moves = 0;
+                    }
+                }
+                _ => {}
+            }
+        }
+        reversible_moves
+    }
+
     /// Determine if a player can legally declare a draw by 3-fold repetition or 50-move rule.
     ///
     /// ```
@@ -205,7 +248,6 @@ impl Game {
         let mut legal_moves_per_turn: Vec<(u64, Vec<ChessMove>)> = vec![];
 
         let mut board = self.start_pos;
-        let mut reversible_moves = 0;
 
         // Loop over each move, counting the reversible_moves for draw by 50 move rule,
         // and filling a list of legal_moves_per_turn list for 3-fold repitition
@@ -216,20 +258,16 @@ impl Game {
                     let white_castle_rights = board.castle_rights(Color::White);
                     let black_castle_rights = board.castle_rights(Color::Black);
                     if board.piece_on(m.get_source()) == Some(Piece::Pawn) {
-                        reversible_moves = 0;
                         legal_moves_per_turn.clear();
                     } else if board.piece_on(m.get_dest()).is_some() {
-                        reversible_moves = 0;
                         legal_moves_per_turn.clear();
                     } else {
-                        reversible_moves += 1;
                     }
                     board = board.make_move_new(m);
 
                     if board.castle_rights(Color::White) != white_castle_rights
                         || board.castle_rights(Color::Black) != black_castle_rights
                     {
-                        reversible_moves = 0;
                         legal_moves_per_turn.clear();
                     }
                     legal_moves_per_turn
@@ -239,7 +277,7 @@ impl Game {
             }
         }
 
-        if reversible_moves >= 100 {
+        if self.get_half_move_clock() >= 100 {
             return true;
         }
 
@@ -427,6 +465,18 @@ impl FromStr for Game {
     }
 }
 
+impl fmt::Display for Game {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{} {} {}",
+            self.current_position().get_psuedo_fen(),
+            self.get_half_move_clock(),
+            self.get_full_move_counter()
+        )
+    }
+}
+
 #[cfg(test)]
 pub fn fake_pgn_parser(moves: &str) -> Game {
     moves