Merge pull request #29 from htamas1210/UI/event

UI/event

engine/src/boardsquare.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BoardSquare {
     pub x: usize,
     pub y: usize,
@@ -28,10 +28,10 @@ impl BoardSquare {
         return Self { x: x, y: y };
     }
 
-    pub(in super) fn from_index(idx: u8) -> Self {
+    pub(super) fn from_index(idx: u8) -> Self {
         let file = idx % 8;
         let rank = idx / 8;
-        
+
         #[cfg(debug_assertions)]
         {
             if !(0..8).contains(&rank) {
@@ -39,10 +39,12 @@ impl BoardSquare {
             }
         }
 
-        return Self {x: file as usize, y: rank as usize};
+        return Self {
+            x: file as usize,
+            y: rank as usize,
+        };
     }
-    pub(in super) fn to_index(&self) -> u8 {
+    pub(super) fn to_index(&self) -> u8 {
         return (8 * self.y + self.x) as u8;
     }
 }
-

engine/src/chessmove.rs

@@ -1,10 +1,13 @@
-use crate::{bitboard::{bitmove::{BitMove, BitMoveType}, board::Board}};
+use crate::bitboard::{
+    bitmove::{BitMove, BitMoveType},
+    board::Board,
+};
 
 use super::boardsquare::BoardSquare;
 use super::piecetype::PieceType;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 /*pub struct ChessMove {
     pub move_type: MoveType,
     pub piece_type: PieceType,
@@ -19,14 +22,14 @@ pub enum ChessMove {
         piece_type: PieceType,
         from_square: BoardSquare,
         to_square: BoardSquare,
-        promotion_piece: Option<PieceType>
+        promotion_piece: Option<PieceType>,
     },
     Capture {
         piece_type: PieceType,
         from_square: BoardSquare,
         to_square: BoardSquare,
         captured_piece: PieceType,
-        promotion_piece: Option<PieceType>
+        promotion_piece: Option<PieceType>,
     },
     Castle {
         king_type: PieceType,
@@ -34,15 +37,15 @@ pub enum ChessMove {
         king_to: BoardSquare,
         rook_type: PieceType,
         rook_from: BoardSquare,
-        rook_to: BoardSquare
+        rook_to: BoardSquare,
     },
     EnPassant {
         pawn_type: PieceType,
         from_square: BoardSquare,
         to_square: BoardSquare,
         captured_piece: PieceType,
-        captured_from: BoardSquare
+        captured_from: BoardSquare,
-    }
+    },
 }
 
 impl ChessMove {
@@ -56,7 +59,7 @@ impl ChessMove {
             piece_type,
             from_square,
             to_square,
-            promotion_piece
+            promotion_piece,
         };
     }
 
@@ -72,7 +75,7 @@ impl ChessMove {
             from_square,
             to_square,
             captured_piece,
-            promotion_piece
+            promotion_piece,
         };
     }
 
@@ -90,11 +93,11 @@ impl ChessMove {
             king_to,
             rook_type,
             rook_from,
-            rook_to
+            rook_to,
         };
     }
 
-    pub(in super) fn from_bitmove(bitmove: &BitMove, board: &Board) -> Self {
+    pub(super) fn from_bitmove(bitmove: &BitMove, board: &Board) -> Self {
         match bitmove.move_type() {
             BitMoveType::Quiet => {
                 let from_square_index = bitmove.from_square();
@@ -103,11 +106,16 @@ impl ChessMove {
                 let to_square = BoardSquare::from_index(bitmove.to_square());
                 let promotion_piece = match bitmove.promotion_piece() {
                     Some(piece) => Some(PieceType::from_index(piece)),
-                    None => None
+                    None => None,
                 };
 
-                return ChessMove::Quiet { piece_type, from_square, to_square, promotion_piece }
+                return ChessMove::Quiet {
-            },
+                    piece_type,
+                    from_square,
+                    to_square,
+                    promotion_piece,
+                };
+            }
             BitMoveType::Capture => {
                 let from_square_index = bitmove.from_square();
                 let to_square_index = bitmove.to_square();
@@ -117,18 +125,28 @@ impl ChessMove {
                 let captured_piece = PieceType::from_index(board.piece_board(to_square_index));
                 let promotion_piece = match bitmove.promotion_piece() {
                     Some(piece) => Some(PieceType::from_index(piece)),
-                    None => None
+                    None => None,
                 };
 
-                return ChessMove::Capture { piece_type, from_square, to_square, captured_piece, promotion_piece }
+                return ChessMove::Capture {
-            },
+                    piece_type,
+                    from_square,
+                    to_square,
+                    captured_piece,
+                    promotion_piece,
+                };
+            }
             BitMoveType::Castle => {
                 let from_square_index = bitmove.from_square();
                 let to_square_index = bitmove.to_square();
                 let king_type = PieceType::from_index(board.piece_board(from_square_index));
                 let king_from = BoardSquare::from_index(from_square_index);
                 let king_to = BoardSquare::from_index(to_square_index);
-                let rook_type = if bitmove.from_square() < 32 { PieceType::WhiteRook } else { PieceType::BlackRook };
+                let rook_type = if bitmove.from_square() < 32 {
+                    PieceType::WhiteRook
+                } else {
+                    PieceType::BlackRook
+                };
                 let rook_from_index = if bitmove.to_square() > bitmove.from_square() {
                     bitmove.from_square() + 3
                 } else {
@@ -142,47 +160,79 @@ impl ChessMove {
                 };
                 let rook_to = BoardSquare::from_index(rook_to_index);
 
-                return ChessMove::Castle { king_type, king_from, king_to, rook_type, rook_from, rook_to }
+                return ChessMove::Castle {
-            },
+                    king_type,
+                    king_from,
+                    king_to,
+                    rook_type,
+                    rook_from,
+                    rook_to,
+                };
+            }
             BitMoveType::EnPassant => {
                 panic!("ChessMove::from_bitmove was left unimplemented");
             }
         }
     }
-    pub(in super) fn to_bitmove(&self) -> BitMove {
+    pub(super) fn to_bitmove(&self) -> BitMove {
         let bitmove = match self {
-            ChessMove::Quiet { piece_type, from_square, to_square, promotion_piece } => {
+            ChessMove::Quiet {
+                piece_type,
+                from_square,
+                to_square,
+                promotion_piece,
+            } => {
                 let promotion_piece = match promotion_piece {
                     Some(piece) => Some(piece.to_index()),
-                    None => None
+                    None => None,
                 };
                 return BitMove::quiet(
                     from_square.to_index(),
                     to_square.to_index(),
-                    promotion_piece
+                    promotion_piece,
                 );
-            },
+            }
-            ChessMove::Capture { piece_type, from_square, to_square, captured_piece, promotion_piece } => {
+            ChessMove::Capture {
+                piece_type,
+                from_square,
+                to_square,
+                captured_piece,
+                promotion_piece,
+            } => {
                 let promotion_piece = match promotion_piece {
                     Some(piece) => Some(piece.to_index()),
-                    None => None
+                    None => None,
                 };
                 return BitMove::capture(
                     from_square.to_index(),
                     to_square.to_index(),
-                    promotion_piece
+                    promotion_piece,
                 );
-            },
+            }
-            ChessMove::Castle { king_type, king_from, king_to, rook_type, rook_from, rook_to } => {
+            ChessMove::Castle {
-                return BitMove::castle(
+                king_type,
-                    king_from.to_index(),
+                king_from,
-                    king_to.to_index()
+                king_to,
-                );
+                rook_type,
-            },
+                rook_from,
-            ChessMove::EnPassant { pawn_type, from_square, to_square, captured_piece, captured_from } => {
+                rook_to,
+            } => {
+                return BitMove::castle(king_from.to_index(), king_to.to_index());
+            }
+            ChessMove::EnPassant {
+                pawn_type,
+                from_square,
+                to_square,
+                captured_piece,
+                captured_from,
+            } => {
                 panic!("ChessMove::to_bitmove was left unimplemented");
             }
         };
         return bitmove;
     }
+
+    pub fn notation(&self) -> String {
+        return self.to_bitmove().uci_notation();
+    }
 }

engine/src/gameend.rs

@@ -1,9 +1,8 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
 pub enum GameEnd {
     WhiteWon(String),
     BlackWon(String),
     Draw(String),
 }
-

engine/src/lib.rs

@@ -1,215 +1,538 @@
 mod bitboard;
-pub mod chessmove;
-pub mod piecetype;
 pub mod boardsquare;
-pub mod movetype;
+pub mod chessmove;
 pub mod gameend;
+pub mod movetype;
+pub mod piecetype;
 
-use chessmove::ChessMove;
-use gameend::GameEnd;
 use bitboard::board::Board;
 use bitboard::movebuffer::MoveBuffer;
+use chessmove::ChessMove;
+use gameend::GameEnd;
 
 pub fn get_available_moves(fen: &str) -> Vec<ChessMove> {
-  let mut board = Board::build(fen);
+    let mut board = Board::build(fen);
-  let mut buffer = MoveBuffer::new();
+    let mut buffer = MoveBuffer::new();
-  let mut temp_buffer = MoveBuffer::new();
+    let mut temp_buffer = MoveBuffer::new();
-  let mut generated_moves: Vec<ChessMove> = vec![];
+    let mut generated_moves: Vec<ChessMove> = vec![];
 
-  board.collect_moves(&mut buffer, &mut temp_buffer);
+    board.collect_moves(&mut buffer, &mut temp_buffer);
 
-  for idx in 0..buffer.count() {
+    for idx in 0..buffer.count() {
-    generated_moves.push(ChessMove::from_bitmove(buffer.get(idx), &board));
+        generated_moves.push(ChessMove::from_bitmove(buffer.get(idx), &board));
-  }
+    }
 
-  println!("get_available_moves resulted in {} moves", generated_moves.len());
+    println!(
-  return generated_moves;
+        "get_available_moves resulted in {} moves",
+        generated_moves.len()
+    );
+    return generated_moves;
 }
 
 pub fn is_game_over(fen: &str) -> Option<GameEnd> {
-  let mut board = Board::build(fen);
+    let mut board = Board::build(fen);
-  let mut buffer = MoveBuffer::new();
+    let mut buffer = MoveBuffer::new();
-  let mut temp_buffer = MoveBuffer::new();
+    let mut temp_buffer = MoveBuffer::new();
-  let in_check = board.collect_moves(&mut buffer, &mut temp_buffer);
+    let in_check = board.collect_moves(&mut buffer, &mut temp_buffer);
 
-  println!("is_game_over answered");
+    println!("is_game_over answered");
-  if buffer.count() > 0 {
+    if buffer.count() > 0 {
-    return None;
+        return None;
-  }
+    }
-  if !in_check {
+    if !in_check {
-    return Some(GameEnd::Draw("".to_string()));
+        return Some(GameEnd::Draw("".to_string()));
-  }
+    }
-  return if board.side_to_move() == 0 { Some(GameEnd::BlackWon("".to_string())) } else { Some(GameEnd::WhiteWon("".to_string())) };
+    return if board.side_to_move() == 0 {
+        Some(GameEnd::BlackWon("".to_string()))
+    } else {
+        Some(GameEnd::WhiteWon("".to_string()))
+    };
 }
 
 pub fn get_board_after_move(fen: &str, chess_move: &ChessMove) -> String {
-  let mut board = Board::build(fen);
+    let mut board = Board::build(fen);
-  let played_move = chess_move.to_bitmove();
+    let played_move = chess_move.to_bitmove();
 
-  println!("get_board_after_move answered");
+    println!("get_board_after_move answered");
-  board.make_move(&played_move);
+    board.make_move(&played_move);
 
-  return board.fen();
+    return board.fen();
 }
 
 #[cfg(test)]
 mod tests {
-  use crate::boardsquare::BoardSquare;
+    use crate::boardsquare::BoardSquare;
-  use crate::piecetype::PieceType::*;
+    use crate::gameend::GameEnd;
-  use crate::gameend::GameEnd;
+    use crate::piecetype::PieceType::*;
 
-  use super::*;
+    use super::*;
 
-  impl PartialEq for ChessMove {
+    impl PartialEq for ChessMove {
-    fn eq(&self, other: &Self) -> bool {
+        fn eq(&self, other: &Self) -> bool {
-      canonical(self) == canonical(other)
+            canonical(self) == canonical(other)
+        }
+    }
+    impl Eq for ChessMove {}
+    impl Ord for ChessMove {
+        fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+            let lhs = canonical(self);
+            let rhs = canonical(other);
+            lhs.cmp(&rhs)
+        }
+    }
+    impl PartialOrd for ChessMove {
+        fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+            Some(self.cmp(other))
+        }
     }
-  }
-  impl Eq for ChessMove {
 
-  }
+    fn canonical(m: &ChessMove) -> (u8, u8, u8) {
-  impl Ord for ChessMove {
+        match m {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+            ChessMove::Quiet {
-      let lhs = canonical(self);
+                piece_type,
-      let rhs = canonical(other);
+                from_square,
-      lhs.cmp(&rhs)
+                to_square,
+                promotion_piece,
+            } => (0, from_square.to_index(), to_square.to_index()),
+            ChessMove::Capture {
+                piece_type,
+                from_square,
+                to_square,
+                captured_piece,
+                promotion_piece,
+            } => (1, from_square.to_index(), to_square.to_index()),
+            ChessMove::Castle {
+                king_type,
+                king_from,
+                king_to,
+                rook_type,
+                rook_from,
+                rook_to,
+            } => (2, king_from.to_index(), king_to.to_index()),
+            ChessMove::EnPassant {
+                pawn_type,
+                from_square,
+                to_square,
+                captured_piece,
+                captured_from,
+            } => (3, from_square.to_index(), to_square.to_index()),
+        }
     }
-  }
-  impl PartialOrd for ChessMove {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-      Some(self.cmp(other))
-    }
-  }
 
-  impl PartialEq for GameEnd {
+    #[test]
-    fn eq(&self, other: &Self) -> bool {
+    fn get_available_moves_test() {
-    match (self, other) {
+        let boards: [&str; 2] = [
-      (GameEnd::WhiteWon(a), GameEnd::WhiteWon(b)) => a == b,
+            "rnbqkbnr/pppppppp/8/1B6/4P3/5P1N/PPPP2PP/RNBQK2R w KQkq e6 0 1",
-      (GameEnd::BlackWon(a), GameEnd::BlackWon(b)) => a == b,
+            "6Bn/B2Pk3/8/p1r3NK/3p4/b6P/3p2n1/2R5 w - - 0 1",
-      (GameEnd::Draw(a),     GameEnd::Draw(b))     => a == b,
+        ];
-      _ => false,
+        let mut expected_moves: Vec<Vec<ChessMove>> = vec![
+            vec![
+                ChessMove::capture(
+                    WhiteBishop,
+                    BoardSquare::from_coord(1, 4),
+                    BoardSquare::from_coord(3, 6),
+                    BlackPawn,
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(0, 1),
+                    BoardSquare::from_coord(0, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(0, 1),
+                    BoardSquare::from_coord(0, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(1, 1),
+                    BoardSquare::from_coord(1, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(1, 1),
+                    BoardSquare::from_coord(1, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(2, 1),
+                    BoardSquare::from_coord(2, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(2, 1),
+                    BoardSquare::from_coord(2, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(3, 1),
+                    BoardSquare::from_coord(3, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(3, 1),
+                    BoardSquare::from_coord(3, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(4, 3),
+                    BoardSquare::from_coord(4, 4),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(5, 2),
+                    BoardSquare::from_coord(5, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(6, 1),
+                    BoardSquare::from_coord(6, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(6, 1),
+                    BoardSquare::from_coord(6, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKnight,
+                    BoardSquare::from_coord(1, 0),
+                    BoardSquare::from_coord(0, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKnight,
+                    BoardSquare::from_coord(1, 0),
+                    BoardSquare::from_coord(2, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKnight,
+                    BoardSquare::from_coord(7, 2),
+                    BoardSquare::from_coord(6, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKnight,
+                    BoardSquare::from_coord(7, 2),
+                    BoardSquare::from_coord(5, 1),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKnight,
+                    BoardSquare::from_coord(7, 2),
+                    BoardSquare::from_coord(5, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKnight,
+                    BoardSquare::from_coord(7, 2),
+                    BoardSquare::from_coord(6, 4),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(1, 4),
+                    BoardSquare::from_coord(5, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(1, 4),
+                    BoardSquare::from_coord(4, 1),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(1, 4),
+                    BoardSquare::from_coord(3, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(1, 4),
+                    BoardSquare::from_coord(2, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(1, 4),
+                    BoardSquare::from_coord(0, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(1, 4),
+                    BoardSquare::from_coord(0, 5),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(1, 4),
+                    BoardSquare::from_coord(2, 5),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(7, 0),
+                    BoardSquare::from_coord(6, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(7, 0),
+                    BoardSquare::from_coord(5, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteQueen,
+                    BoardSquare::from_coord(3, 0),
+                    BoardSquare::from_coord(4, 1),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKing,
+                    BoardSquare::from_coord(4, 0),
+                    BoardSquare::from_coord(4, 1),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKing,
+                    BoardSquare::from_coord(4, 0),
+                    BoardSquare::from_coord(5, 1),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKing,
+                    BoardSquare::from_coord(4, 0),
+                    BoardSquare::from_coord(5, 0),
+                    None,
+                ),
+                ChessMove::castle(
+                    WhiteKing,
+                    BoardSquare::from_coord(4, 0),
+                    BoardSquare::from_coord(6, 0),
+                    WhiteRook,
+                    BoardSquare::from_coord(7, 0),
+                    BoardSquare::from_coord(5, 0),
+                ),
+            ],
+            vec![
+                ChessMove::capture(
+                    WhiteBishop,
+                    BoardSquare::from_coord(0, 6),
+                    BoardSquare::from_coord(2, 4),
+                    BlackRook,
+                    None,
+                ),
+                ChessMove::capture(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(2, 4),
+                    BlackRook,
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(7, 2),
+                    BoardSquare::from_coord(7, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(3, 6),
+                    BoardSquare::from_coord(3, 7),
+                    Some(WhiteQueen),
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(3, 6),
+                    BoardSquare::from_coord(3, 7),
+                    Some(WhiteRook),
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(3, 6),
+                    BoardSquare::from_coord(3, 7),
+                    Some(WhiteBishop),
+                ),
+                ChessMove::quiet(
+                    WhitePawn,
+                    BoardSquare::from_coord(3, 6),
+                    BoardSquare::from_coord(3, 7),
+                    Some(WhiteKnight),
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(0, 6),
+                    BoardSquare::from_coord(1, 5),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(0, 6),
+                    BoardSquare::from_coord(1, 7),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(6, 7),
+                    BoardSquare::from_coord(7, 6),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(6, 7),
+                    BoardSquare::from_coord(5, 6),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(6, 7),
+                    BoardSquare::from_coord(4, 5),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(6, 7),
+                    BoardSquare::from_coord(3, 4),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(6, 7),
+                    BoardSquare::from_coord(2, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(6, 7),
+                    BoardSquare::from_coord(1, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteBishop,
+                    BoardSquare::from_coord(6, 7),
+                    BoardSquare::from_coord(0, 1),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(0, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(1, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(3, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(4, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(5, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(6, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(7, 0),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(2, 1),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(2, 2),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteRook,
+                    BoardSquare::from_coord(2, 0),
+                    BoardSquare::from_coord(2, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKing,
+                    BoardSquare::from_coord(7, 4),
+                    BoardSquare::from_coord(6, 3),
+                    None,
+                ),
+                ChessMove::quiet(
+                    WhiteKing,
+                    BoardSquare::from_coord(7, 4),
+                    BoardSquare::from_coord(7, 5),
+                    None,
+                ),
+            ],
+        ];
+
+        for case in 0..2 {
+            let mut generated_moves = get_available_moves(boards[case]);
+
+            generated_moves.sort();
+            expected_moves[case].sort();
+            assert_eq!(generated_moves.len(), expected_moves[case].len());
+            assert_eq!(generated_moves, expected_moves[case]);
+        }
+    }
+
+    #[test]
+    fn is_game_over_test() {
+        let boards: [&str; 4] = [
+            "2k5/3pn3/2pP4/1R1P3B/1Np5/3RPp2/1B6/6Kb w - - 0 1",
+            "2K3B1/4P3/8/7p/4pPn1/1N1P1p1p/4bp2/2Rk4 b - - 0 1",
+            "6N1/B2PP3/pR1b4/3P2nb/6P1/3P1k2/2p5/4r1K1 w - - 0 1",
+            "3n1K2/p2k1p2/5P2/b1p2P2/P7/8/3p2r1/8 w - - 0 1",
+        ];
+        let expected_results: [Option<GameEnd>; 4] = [
+            None,
+            Some(GameEnd::WhiteWon("".to_string())),
+            Some(GameEnd::BlackWon("".to_string())),
+            Some(GameEnd::Draw("".to_string())),
+        ];
+
+        for case in 0..4 {
+            let fen = boards[case];
+            let actual = is_game_over(fen);
+            assert_eq!(actual, expected_results[case]);
+        }
     }
-  }
 }
 
-  fn canonical(m: &ChessMove) -> (u8, u8, u8) {
-    match m {
-      ChessMove::Quiet { piece_type, from_square, to_square, promotion_piece } =>
-      (0, from_square.to_index(), to_square.to_index()),
-      ChessMove::Capture { piece_type, from_square, to_square, captured_piece, promotion_piece } =>
-      (1, from_square.to_index(), to_square.to_index()),
-      ChessMove::Castle { king_type, king_from, king_to, rook_type, rook_from, rook_to } =>
-      (2, king_from.to_index(), king_to.to_index()),
-      ChessMove::EnPassant { pawn_type, from_square, to_square, captured_piece, captured_from } =>
-      (3, from_square.to_index(), to_square.to_index()),
-    }
-  }
-
-  #[test]
-  fn get_available_moves_test() {
-    let boards: [&str; 2] = [
-      "rnbqkbnr/pppppppp/8/1B6/4P3/5P1N/PPPP2PP/RNBQK2R w KQkq e6 0 1",
-      "6Bn/B2Pk3/8/p1r3NK/3p4/b6P/3p2n1/2R5 w - - 0 1"
-    ];
-    let mut expected_moves: Vec<Vec<ChessMove>> = vec![
-      vec![
-        ChessMove::capture(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(3, 6), BlackPawn, None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(0, 1), BoardSquare::from_coord(0, 2), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(0, 1), BoardSquare::from_coord(0, 3), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(1, 1), BoardSquare::from_coord(1, 2), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(1, 1), BoardSquare::from_coord(1, 3), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(2, 1), BoardSquare::from_coord(2, 2), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(2, 1), BoardSquare::from_coord(2, 3), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 1), BoardSquare::from_coord(3, 2), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 1), BoardSquare::from_coord(3, 3), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(4, 3), BoardSquare::from_coord(4, 4), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(5, 2), BoardSquare::from_coord(5, 3), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(6, 1), BoardSquare::from_coord(6, 2), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(6, 1), BoardSquare::from_coord(6, 3), None),
-        ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(1, 0), BoardSquare::from_coord(0, 2), None),
-        ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(1, 0), BoardSquare::from_coord(2, 2), None),
-        ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(6, 0), None),
-        ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(5, 1), None),
-        ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(5, 3), None),
-        ChessMove::quiet(WhiteKnight, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(6, 4), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(5, 0), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(4, 1), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(3, 2), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(2, 3), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(0, 3), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(0, 5), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(1, 4), BoardSquare::from_coord(2, 5), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(7, 0), BoardSquare::from_coord(6, 0), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(7, 0), BoardSquare::from_coord(5, 0), None),
-        ChessMove::quiet(WhiteQueen, BoardSquare::from_coord(3, 0), BoardSquare::from_coord(4, 1), None),
-        ChessMove::quiet(WhiteKing, BoardSquare::from_coord(4, 0), BoardSquare::from_coord(4, 1), None),
-        ChessMove::quiet(WhiteKing, BoardSquare::from_coord(4, 0), BoardSquare::from_coord(5, 1), None),
-        ChessMove::quiet(WhiteKing, BoardSquare::from_coord(4, 0), BoardSquare::from_coord(5, 0), None),
-        ChessMove::castle(WhiteKing, BoardSquare::from_coord(4, 0), BoardSquare::from_coord(6, 0), WhiteRook, BoardSquare::from_coord(7, 0), BoardSquare::from_coord(5, 0))
-      ],
-      vec![
-        ChessMove::capture(WhiteBishop, BoardSquare::from_coord(0, 6), BoardSquare::from_coord(2, 4), BlackRook, None),
-        ChessMove::capture(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(2, 4), BlackRook, None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(7, 2), BoardSquare::from_coord(7, 3), None),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 6), BoardSquare::from_coord(3, 7), Some(WhiteQueen)),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 6), BoardSquare::from_coord(3, 7), Some(WhiteRook)),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 6), BoardSquare::from_coord(3, 7), Some(WhiteBishop)),
-        ChessMove::quiet(WhitePawn, BoardSquare::from_coord(3, 6), BoardSquare::from_coord(3, 7), Some(WhiteKnight)),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(0, 6), BoardSquare::from_coord(1, 5), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(0, 6), BoardSquare::from_coord(1, 7), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(7, 6), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(5, 6), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(4, 5), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(3, 4), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(2, 3), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(1, 2), None),
-        ChessMove::quiet(WhiteBishop, BoardSquare::from_coord(6, 7), BoardSquare::from_coord(0, 1), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(0, 0), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(1, 0), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(3, 0), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(4, 0), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(5, 0), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(6, 0), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(7, 0), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(2, 1), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(2, 2), None),
-        ChessMove::quiet(WhiteRook, BoardSquare::from_coord(2, 0), BoardSquare::from_coord(2, 3), None),
-        ChessMove::quiet(WhiteKing, BoardSquare::from_coord(7, 4), BoardSquare::from_coord(6, 3), None),
-        ChessMove::quiet(WhiteKing, BoardSquare::from_coord(7, 4), BoardSquare::from_coord(7, 5), None)
-      ]
-    ];
-
-    for case in 0..2 {
-
-      let mut generated_moves = get_available_moves(boards[case]);
-      
-      generated_moves.sort();
-      expected_moves[case].sort();
-      assert_eq!(generated_moves.len(), expected_moves[case].len());
-      assert_eq!(generated_moves, expected_moves[case]);
-    }
-  }
-
-  #[test]
-  fn is_game_over_test() {
-
-    let boards: [&str; 4] = [
-      "2k5/3pn3/2pP4/1R1P3B/1Np5/3RPp2/1B6/6Kb w - - 0 1",
-      "2K3B1/4P3/8/7p/4pPn1/1N1P1p1p/4bp2/2Rk4 b - - 0 1",
-      "6N1/B2PP3/pR1b4/3P2nb/6P1/3P1k2/2p5/4r1K1 w - - 0 1",
-      "3n1K2/p2k1p2/5P2/b1p2P2/P7/8/3p2r1/8 w - - 0 1"
-    ];
-    let expected_results: [Option<GameEnd>; 4] = [
-      None,
-      Some(GameEnd::WhiteWon("".to_string())),
-      Some(GameEnd::BlackWon("".to_string())),
-      Some(GameEnd::Draw("".to_string()))
-    ];
-
-    for case in 0..4 {
-      let fen = boards[case];
-      let actual = is_game_over(fen);
-      assert_eq!(actual, expected_results[case]);
-    }
-  }
-}

engine/src/piecetype.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Clone, Serialize, Deserialize, Debug)]
 pub enum PieceType {
     WhitePawn,
     WhiteKnight,
@@ -17,8 +17,7 @@ pub enum PieceType {
 }
 
 impl PieceType {
-
+    pub(super) fn from_index(idx: u8) -> Self {
-    pub(in super) fn from_index(idx: u8) -> Self {
         return match idx {
             0 => PieceType::WhitePawn,
             1 => PieceType::WhiteKnight,
@@ -32,10 +31,10 @@ impl PieceType {
             9 => PieceType::BlackRook,
             10 => PieceType::BlackQueen,
             11 => PieceType::BlackKing,
-            _ => panic!("invalid piece index! should NEVER appear")
+            _ => panic!("invalid piece index! should NEVER appear"),
-        }
+        };
     }
-    pub(in super) fn to_index(&self) -> u8 {
+    pub(super) fn to_index(&self) -> u8 {
         return match self {
             &PieceType::WhitePawn => 0,
             &PieceType::WhiteKnight => 1,
@@ -48,7 +47,8 @@ impl PieceType {
             &PieceType::BlackBishop => 8,
             &PieceType::BlackRook => 9,
             &PieceType::BlackQueen => 10,
-            &PieceType::BlackKing => 11
+            &PieceType::BlackKing => 11,
-        }
+        };
     }
-}
+}
+

server/src/connection.rs

@@ -39,12 +39,6 @@ pub fn new_waiting_queue() -> WaitingQueue {
     Arc::new(Mutex::new(VecDeque::new()))
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Step {
-    pub from: String,
-    pub to: String,
-}
-
 #[derive(Serialize, Deserialize)]
 pub enum ServerMessage2 {
     GameEnd {
@@ -52,12 +46,17 @@ pub enum ServerMessage2 {
     },
     UIUpdate {
         fen: String,
+        turn_player: String,
+        move_history: Vec<String>,
     },
     MatchFound {
         match_id: Uuid,
         color: String,
         opponent_name: String,
     },
+    LegalMoves {
+        moves: Vec<ChessMove>,
+    },
     Ok {
         response: Result<(), String>,
     },
@@ -66,12 +65,22 @@ pub enum ServerMessage2 {
 #[derive(Serialize, Deserialize)]
 #[serde(tag = "type")]
 enum ClientEvent {
-    Join { username: String },
+    Join {
+        username: String,
+    },
     FindMatch,
-    Move { step: ChessMove },
+    Move {
+        step: ChessMove,
+        turn_player: String,
+    },
     Resign,
-    Chat { text: String },
+    Chat {
-    RequestLegalMoves { fen: String },
+        text: String,
+    },
+    RequestLegalMoves {
+        fen: String,
+    },
+    CloseConnection,
 }
 
 #[derive(Debug)]
@@ -88,7 +97,7 @@ pub struct GameMatch {
     pub player_white: Uuid,
     pub player_black: Uuid,
     pub board_state: String,
-    pub move_history: Vec<Step>,
+    pub move_history: Vec<String>,
 }
 
 // Message sending utilities
@@ -179,6 +188,13 @@ pub async fn handle_connection(
 
     info!("id: {}", &player_id);
 
+    println!("\n\n\n");
+    println!(
+        "{:?}",
+        engine::get_available_moves("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
+    );
+    println!("\n\n\n");
+
     // Message processing loop
     while let Some(Ok(message)) = read.next().await {
         if message.is_text() {
@@ -213,7 +229,7 @@ pub async fn handle_connection(
                     info!("Appended {} to the waiting queue", player_id);
                     info!("queue {:?}", wait_queue);
                 }
-                Move { step } => {
+                Move { step, turn_player } => {
                     let match_id = connections
                         .lock()
                         .await
@@ -222,6 +238,8 @@ pub async fn handle_connection(
                         .current_match
                         .unwrap();
 
+                    println!("\n\nstep: {:?}\n", step);
+
                     {
                         info!("updating board state in match: {}", &match_id);
                         let mut matches = matches.lock().await;
@@ -230,15 +248,29 @@ pub async fn handle_connection(
                                 &matches.get(&match_id).unwrap().board_state,
                                 &step,
                             );
-                    }
+
-                    let message = ServerMessage2::UIUpdate {
+                        info!(
-                        fen: matches
+                            "board after engine fn: {}",
-                            .lock()
+                            matches.get_mut(&match_id).unwrap().board_state.clone()
-                            .await
+                        );
-                            .get(&match_id)
+
+                        matches
+                            .get_mut(&match_id)
                             .unwrap()
-                            .board_state
+                            .move_history
-                            .clone(),
+                            .push(step.clone().notation());
+                    }
+
+                    let message = ServerMessage2::UIUpdate {
+                        fen: {
+                            let mut matches = matches.lock().await;
+                            matches.get(&match_id).unwrap().board_state.clone()
+                        },
+                        turn_player: turn_player,
+                        move_history: {
+                            let mut matches = matches.lock().await;
+                            matches.get(&match_id).unwrap().move_history.clone()
+                        },
                     };
 
                     let _ = broadcast_to_match(
@@ -265,7 +297,7 @@ pub async fn handle_connection(
                                     &serde_json::to_string(&message).unwrap(),
                                 )
                                 .await;
-                                clean_up_match(&matches, &match_id);
+                                clean_up_match(&matches, &match_id).await;
                             }
                             None => {
                                 info!("No winner match continues. Id: {}", &match_id);
@@ -276,9 +308,10 @@ pub async fn handle_connection(
                 RequestLegalMoves { fen } => {
                     info!("Requesting legal moves player: {}", &player_id);
                     let moves = get_available_moves(&fen);
+                    let message = ServerMessage2::LegalMoves { moves };
                     let _ = send_message_to_player_connection(
                         connections.lock().await.get_mut(&player_id),
-                        &serde_json::to_string(&moves).unwrap(),
+                        &serde_json::to_string(&message).unwrap(),
                     )
                     .await;
                     info!("Sent moves to player: {}", player_id);
@@ -329,20 +362,18 @@ pub async fn handle_connection(
                         }
                     };
 
-                    broadcast_to_match(
+                    let _ = broadcast_to_match(
                         &connections,
                         &matches,
-                        connections
+                        fuck_id.clone(),
-                            .lock()
-                            .await
-                            .get(&player_id)
-                            .unwrap()
-                            .current_match
-                            .unwrap(),
                         &serde_json::to_string(&fuck).unwrap(),
                     )
                     .await;
-                    clean_up_match(&matches, fuck_id);
+                    clean_up_match(&matches, fuck_id).await;
+                }
+                CloseConnection => {
+                    warn!("Closing connection for: {}", &player_id);
+                    break;
                 }
                 _ => {
                     warn!("Not known client event");