implemented library function get_board_after_move

Server/logging

engine/src/bitboard.rs

@@ -3,8 +3,9 @@ mod utils;
 mod legality;
 mod checkinfo;
 mod attacks;
-mod bitmove;
-mod movebuffer;
 mod movegen;
 
-pub mod board;
+pub mod board;
+pub(in super) mod bitmove;
+pub(in super) mod movebuffer;
+pub(in super) mod makemove;

engine/src/bitboard/board.rs

@@ -1,3 +1,5 @@
+use crate::bitboard::utils::notation_from_square_number;
+
 use super::utils::try_get_square_number_from_notation;
 
 pub struct Board {
@@ -12,6 +14,7 @@ pub struct Board {
 }
 
 impl Board {
+  pub const EMPTY_SQUARE: u8 = 12;
 
   pub fn new_clear() -> Self {
     let mut bit_board: Self = Self {
@@ -159,6 +162,57 @@ impl Board {
     return if self.side_to_move == 0 { self.bitboards[5].trailing_zeros() } else { self.bitboards[11].trailing_zeros() };
   }
 
+  pub fn fen(&self) -> String {
+    let mut fen = String::new();
+
+    for row in (0..8).rev() {
+      let mut empty = 0;
+      for col in 0..8 {
+        let sq = row * 8 + col;
+        if let Some(piece) = self.get_piece_character(sq) {
+          if empty > 0 {
+            fen.push_str(&empty.to_string());
+            empty = 0;
+          }
+          fen.push(piece);
+        } else {
+          empty += 1;
+          if col == 7 {
+            fen.push_str(&empty.to_string());
+          }
+        }
+      }
+      if row > 0 {
+        fen.push('/');
+      }
+    }
+
+    fen.push(' ');
+    if self.side_to_move() == 0 { fen.push('w'); } else { fen.push('b'); }
+
+    fen.push(' ');
+    if self.castling_rights() == 0 {
+      fen.push('-');
+    } else {
+      if self.castling_rights() & (1 << 3) != 0 { fen.push('K'); }
+      if self.castling_rights() & (1 << 2) != 0 { fen.push('Q'); }
+      if self.castling_rights() & (1 << 1) != 0 { fen.push('k'); }
+      if self.castling_rights() & (1 << 0) != 0 { fen.push('q'); }
+    }
+
+    fen.push(' ');
+    if self.en_passant_square() == 0 {
+      fen.push('-');
+    } else {
+      let sq = self.en_passant_square().trailing_zeros();
+      fen.push_str(&notation_from_square_number(sq as u8));
+    }
+
+    fen.push_str(" 0 1");
+
+    return fen;
+  }
+
   fn calc_occupancy(&mut self) {
     self.occupancy = [0u64; 3];
     for b in 0..6 {
@@ -196,4 +250,46 @@ impl Board {
        _  => ()
     }
   }
+  pub fn get_piece_character(&self, index: i32) -> Option<char> {
+    let sq = 1 << index;
+
+    if (self.bitboards[0] & sq) != 0 {
+      return Some('P');
+    }
+    if (self.bitboards[1] & sq) != 0 {
+      return Some('N');
+    }
+    if (self.bitboards[2] & sq) != 0 {
+      return Some('B');
+    }
+    if (self.bitboards[3] & sq) != 0 {
+      return Some('R');
+    }
+    if (self.bitboards[4] & sq) != 0 {
+      return Some('Q');
+    }
+    if (self.bitboards[5] & sq) != 0 {
+      return Some('K');
+    }
+    if (self.bitboards[6] & sq) != 0 {
+      return Some('p');
+    }
+    if (self.bitboards[7] & sq) != 0 {
+      return Some('n');
+    }
+    if (self.bitboards[8] & sq) != 0 {
+      return Some('b');
+    }
+    if (self.bitboards[9] & sq) != 0 {
+      return Some('r');
+    }
+    if (self.bitboards[10] & sq) != 0 {
+      return Some('q');
+    }
+    if (self.bitboards[11] & sq) != 0 {
+      return Some('k');
+    }
+
+    return None;
+  }
 }

engine/src/bitboard/makemove.rs

@@ -0,0 +1,38 @@
+mod quiets;
+mod captures;
+mod castles;
+
+use super::bitmove::BitMoveType;
+use super::bitmove::BitMove;
+use super::board::Board;
+
+impl Board {
+
+  #[inline]
+  pub fn make_move(&mut self, played_move: &BitMove) {
+    let move_type = played_move.move_type();
+
+    match move_type {
+      BitMoveType::Quiet => {
+        self.make_quiet(played_move);
+      }
+      BitMoveType::Capture => {
+        self.make_capture(played_move);
+      }
+      BitMoveType::Castle => {
+        self.make_castle(played_move);
+      }
+      BitMoveType::EnPassant => {
+        
+      }
+    }
+
+    self.occupancy[2] = self.occupancy[0] | self.occupancy[1];
+
+    if self.en_passant_square != 0 {
+      self.en_passant_square = 0u64;
+    }
+
+    self.side_to_move = 1 - self.side_to_move;
+  }
+}

engine/src/bitboard/makemove/captures.rs

@@ -0,0 +1,82 @@
+use super::*;
+
+impl Board {
+  pub fn make_capture(&mut self, played_move: &BitMove) {
+    let main_from: usize = played_move.from_square() as usize;
+    let main_to: usize = played_move.to_square() as usize;
+    let main_piece: usize = self.piece_board(main_from as u8) as usize;
+    let friendly_occupancy = main_piece/6;
+
+    let color_offset = self.side_to_move * 6;
+    let castling_offset = 2 - 2 * self.side_to_move as usize;
+    let castling_rights = self.castling_rights >> castling_offset;
+
+    let mut taken_piece = 0u8;
+
+    taken_piece = self.piece_board(main_to as u8);
+    let secondary_piece = taken_piece as usize;
+    let secondary_from = main_to;
+
+    let opponent_castling_offset = 2 * self.side_to_move as usize;
+    let opponent_castling_rights = self.castling_rights >> opponent_castling_offset;
+
+    let opponent_occupancy = 1 - self.side_to_move as usize;
+        
+    self.bitboards[main_piece] &= !(1 << main_from);
+    self.occupancy[friendly_occupancy] &= !(1 << main_from);
+    self.piece_board[main_from] = Self::EMPTY_SQUARE;
+
+    self.bitboards[secondary_piece] &= !(1 << secondary_from);
+    self.occupancy[opponent_occupancy] &= !(1 << secondary_from);
+    self.piece_board[secondary_from] = Self::EMPTY_SQUARE;
+
+    if opponent_castling_rights != 0
+      && secondary_piece == 9 - color_offset as usize{
+
+      let back_rank_offset = 56 - 56 * self.side_to_move as usize;
+      if opponent_castling_rights & 0b01 != 0
+        && secondary_from == back_rank_offset {
+          self.castling_rights &= !(1 << opponent_castling_offset);
+      }
+      else if opponent_castling_rights & 0b10 != 0
+        && secondary_from == 7 + back_rank_offset {
+          self.castling_rights &= !(2 << opponent_castling_offset);
+      }
+    }
+
+    if let Some(promotion_piece) = played_move.promotion_piece() {
+      let promotion_piece = (color_offset + promotion_piece) as usize;
+      self.bitboards[promotion_piece] |= 1 << main_to;
+      self.occupancy[friendly_occupancy] |= 1 << main_to;
+      self.piece_board[main_to] = promotion_piece as u8;
+    }
+    else {
+      self.bitboards[main_piece] |= 1 << main_to;
+      self.occupancy[friendly_occupancy] |= 1 << main_to;
+      self.piece_board[main_to] = main_piece as u8;
+
+      if main_piece == 5 + color_offset as usize 
+            && castling_rights != 0 {
+        if castling_rights & 0b1 != 0 {
+          self.castling_rights &= !(1 << castling_offset);
+        }
+        if castling_rights & 0b10 != 0 {
+          self.castling_rights &= !(2 << castling_offset);
+        }
+      }
+      else if main_piece == 3 + color_offset as usize
+            && castling_rights != 0 {
+        let back_rank_offset = 56 * self.side_to_move as usize;
+
+        if castling_rights & 0b10 != 0
+              && main_from == 7 + back_rank_offset {
+          self.castling_rights &= !(2 << castling_offset);
+        }
+        else if castling_rights & 0b1 != 0
+              && main_from == back_rank_offset {
+          self.castling_rights &= !(1 << castling_offset);
+        }
+      }
+    }
+  }
+}

engine/src/bitboard/makemove/castles.rs

@@ -0,0 +1,35 @@
+use super::*;
+
+impl Board {
+  pub fn make_castle(&mut self, played_move: &BitMove) {
+    let main_from: usize = played_move.from_square() as usize;
+    let main_to: usize = played_move.to_square() as usize;
+    let main_piece: usize = self.piece_board(main_from as u8) as usize;
+    let friendly_occupancy = main_piece/6;
+
+    let castling_offset = 2 - 2 * self.side_to_move as usize;
+
+    let secondary_piece: usize = main_piece - 2;
+    let is_kingside = main_to%8 > 4;
+    let secondary_from: usize = if is_kingside { main_to + 1 } else { main_to - 2 };
+    let secondary_to: usize = if is_kingside { main_to - 1 } else { main_to + 1 };
+
+    self.bitboards[main_piece] |= 1 << main_to;
+    self.occupancy[friendly_occupancy] |= 1 << main_to;
+    self.piece_board[main_to] = main_piece as u8;
+
+    self.bitboards[main_piece] &= !(1 << main_from);
+    self.occupancy[friendly_occupancy] &= !(1 << main_from);
+    self.piece_board[main_from] = Self::EMPTY_SQUARE;
+
+    self.bitboards[secondary_piece] |= 1 << secondary_to;
+    self.occupancy[friendly_occupancy] |= 1 << secondary_to;
+    self.piece_board[secondary_to] = secondary_piece as u8;
+
+    self.bitboards[secondary_piece] &= !(1 << secondary_from);
+    self.occupancy[friendly_occupancy] &= !(1 << secondary_from);
+    self.piece_board[secondary_from] = Self::EMPTY_SQUARE;
+
+    self.castling_rights &= !(3 << castling_offset);
+  }
+}

engine/src/bitboard/makemove/quiets.rs

@@ -0,0 +1,61 @@
+use super::*;
+
+impl Board {
+  pub fn make_quiet(&mut self, played_move: &BitMove) {
+    let main_from: usize = played_move.from_square() as usize;
+    let main_to: usize = played_move.to_square() as usize;
+    let main_piece: usize = self.piece_board(main_from as u8) as usize;
+    let friendly_occupancy = main_piece/6;
+
+    let color_offset = self.side_to_move * 6;
+    let castling_offset = 2 - 2 * self.side_to_move as usize;
+    let castling_rights = self.castling_rights >> castling_offset;
+
+    self.bitboards[main_piece] &= !(1 << main_from);
+    self.occupancy[friendly_occupancy] &= !(1 << main_from);
+    self.piece_board[main_from] = Self::EMPTY_SQUARE;
+
+    if let Some(promotion_piece) = played_move.promotion_piece() {
+      let promotion_piece = (color_offset + promotion_piece) as usize;
+      self.bitboards[promotion_piece] |= 1 << main_to;
+      self.occupancy[friendly_occupancy] |= 1 << main_to;
+      self.piece_board[main_to] = promotion_piece as u8;
+    }
+    else {
+      self.bitboards[main_piece] |= 1 << main_to;
+      self.occupancy[friendly_occupancy] |= 1 << main_to;
+      self.piece_board[main_to] = main_piece as u8;
+
+      if main_piece == 0 && (main_to - main_from) == 16 {
+        let new_en_passant = main_to - 8;
+        self.en_passant_square = 1 << new_en_passant;
+      }
+      else if main_piece == 6 && (main_from - main_to) == 16 {
+        let new_en_passant = main_to + 8;
+        self.en_passant_square = 1 << new_en_passant;
+      }
+      else if main_piece == 5 + color_offset as usize 
+            && castling_rights != 0 {
+        if castling_rights & 0b1 != 0 {
+          self.castling_rights &= !(1 << castling_offset);
+        }
+        if castling_rights & 0b10 != 0 {
+          self.castling_rights &= !(2 << castling_offset);
+        }
+      }
+      else if main_piece == 3 + color_offset as usize
+            && castling_rights != 0 {
+        let back_rank_offset = 56 * self.side_to_move as usize;
+            
+        if castling_rights & 0b10 != 0
+              && main_from == 7 + back_rank_offset {
+          self.castling_rights &= !(2 << castling_offset);
+        }
+        else if castling_rights & 0b1 != 0
+              && main_from == back_rank_offset {
+          self.castling_rights &= !(1 << castling_offset);
+        }
+      }
+    }
+  }
+}

engine/src/boardsquare.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct BoardSquare {
     pub x: usize,
     pub y: usize,
@@ -27,5 +27,22 @@ impl BoardSquare {
         }
         return Self { x: x, y: y };
     }
+
+    pub(in super) fn from_index(idx: u8) -> Self {
+        let file = idx % 8;
+        let rank = idx / 8;
+        
+        #[cfg(debug_assertions)]
+        {
+            if !(0..8).contains(&rank) {
+                println!("Warning: internal engine issue, given index is not on the board!");
+            }
+        }
+
+        return Self {x: file as usize, y: rank as usize};
+    }
+    pub(in super) fn to_index(&self) -> u8 {
+        return (8 * self.y + self.x) as u8;
+    }
 }
 

engine/src/chessmove.rs

@@ -1,12 +1,11 @@
-use crate::piecetype;
+use crate::{bitboard::{bitmove::{BitMove, BitMoveType}, board::Board}};
 
 use super::boardsquare::BoardSquare;
-use super::movetype::MoveType;
 use super::piecetype::PieceType;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
-pub struct ChessMove {
+#[derive(Serialize, Deserialize, Debug)]
+/*pub struct ChessMove {
     pub move_type: MoveType,
     pub piece_type: PieceType,
     pub from_square: BoardSquare,
@@ -14,6 +13,36 @@ pub struct ChessMove {
     pub rook_from: BoardSquare,
     pub rook_to: BoardSquare,
     pub promotion_piece: Option<PieceType>,
+}*/
+pub enum ChessMove {
+    Quiet {
+        piece_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        promotion_piece: Option<PieceType>
+    },
+    Capture {
+        piece_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        captured_piece: PieceType,
+        promotion_piece: Option<PieceType>
+    },
+    Castle {
+        king_type: PieceType,
+        king_from: BoardSquare,
+        king_to: BoardSquare,
+        rook_type: PieceType,
+        rook_from: BoardSquare,
+        rook_to: BoardSquare
+    },
+    EnPassant {
+        pawn_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        captured_piece: PieceType,
+        captured_from: BoardSquare
+    }
 }
 
 impl ChessMove {
@@ -23,14 +52,11 @@ impl ChessMove {
         to_square: BoardSquare,
         promotion_piece: Option<PieceType>,
     ) -> Self {
-        return Self {
-            move_type: MoveType::Quiet,
-            piece_type: piece_type,
-            from_square: from_square,
-            to_square: to_square,
-            rook_from: BoardSquare::new(),
-            rook_to: BoardSquare::new(),
-            promotion_piece: promotion_piece,
+        return Self::Quiet {
+            piece_type,
+            from_square,
+            to_square,
+            promotion_piece
         };
     }
 
@@ -38,34 +64,125 @@ impl ChessMove {
         piece_type: PieceType,
         from_square: BoardSquare,
         to_square: BoardSquare,
+        captured_piece: PieceType,
         promotion_piece: Option<PieceType>,
     ) -> Self {
-        return Self {
-            move_type: MoveType::Capture,
-            piece_type: piece_type,
-            from_square: from_square,
-            to_square: to_square,
-            rook_from: BoardSquare::new(),
-            rook_to: BoardSquare::new(),
-            promotion_piece: promotion_piece,
+        return Self::Capture {
+            piece_type,
+            from_square,
+            to_square,
+            captured_piece,
+            promotion_piece
         };
     }
 
     pub fn castle(
-        piece_type: PieceType,
-        from_square: BoardSquare,
-        to_square: BoardSquare,
+        king_type: PieceType,
+        king_from: BoardSquare,
+        king_to: BoardSquare,
+        rook_type: PieceType,
         rook_from: BoardSquare,
         rook_to: BoardSquare,
     ) -> Self {
-        return Self {
-            move_type: MoveType::Quiet,
-            piece_type: piece_type,
-            from_square: from_square,
-            to_square: to_square,
-            rook_from: rook_from,
-            rook_to: rook_to,
-            promotion_piece: None,
+        return Self::Castle {
+            king_type,
+            king_from,
+            king_to,
+            rook_type,
+            rook_from,
+            rook_to
         };
     }
+
+    pub(in super) fn from_bitmove(bitmove: &BitMove, board: &Board) -> Self {
+        match bitmove.move_type() {
+            BitMoveType::Quiet => {
+                let from_square_index = bitmove.from_square();
+                let piece_type = PieceType::from_index(board.piece_board(from_square_index));
+                let from_square = BoardSquare::from_index(from_square_index);
+                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
+                };
+
+                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();
+                let piece_type = PieceType::from_index(board.piece_board(from_square_index));
+                let from_square = BoardSquare::from_index(from_square_index);
+                let to_square = BoardSquare::from_index(to_square_index);
+                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
+                };
+
+                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_from_index = if bitmove.to_square() > bitmove.from_square() {
+                    bitmove.from_square() + 3
+                } else {
+                    bitmove.from_square() - 4
+                };
+                let rook_from = BoardSquare::from_index(rook_from_index);
+                let rook_to_index = if bitmove.to_square() > bitmove.from_square() {
+                    bitmove.from_square() + 1
+                } else {
+                    bitmove.from_square() - 1
+                };
+                let rook_to = BoardSquare::from_index(rook_to_index);
+
+                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 {
+        let bitmove = match self {
+            ChessMove::Quiet { piece_type, from_square, to_square, promotion_piece } => {
+                let promotion_piece = match promotion_piece {
+                    Some(piece) => Some(piece.to_index()),
+                    None => None
+                };
+                return BitMove::quiet(
+                    from_square.to_index(),
+                    to_square.to_index(),
+                    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
+                };
+                return BitMove::capture(
+                    from_square.to_index(),
+                    to_square.to_index(),
+                    promotion_piece
+                );
+            },
+            ChessMove::Castle { king_type, king_from, king_to, rook_type, rook_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;
+    }
 }

engine/src/gameend.rs

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

engine/src/lib.rs

@@ -7,18 +7,209 @@ pub mod gameend;
 
 use chessmove::ChessMove;
 use gameend::GameEnd;
+use bitboard::board::Board;
+use bitboard::movebuffer::MoveBuffer;
 
 pub fn get_available_moves(fen: &str) -> Vec<ChessMove> {
-  println!("get_available_moves answered");
-  return vec![];
+  let mut board = Board::build(fen);
+  let mut buffer = MoveBuffer::new();
+  let mut temp_buffer = MoveBuffer::new();
+  let mut generated_moves: Vec<ChessMove> = vec![];
+
+  board.collect_moves(&mut buffer, &mut temp_buffer);
+
+  for idx in 0..buffer.count() {
+    generated_moves.push(ChessMove::from_bitmove(buffer.get(idx), &board));
+  }
+
+  println!("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 buffer = MoveBuffer::new();
+  let mut temp_buffer = MoveBuffer::new();
+  let in_check = board.collect_moves(&mut buffer, &mut temp_buffer);
+
   println!("is_game_over answered");
-  return None;
+  if buffer.count() > 0 {
+    return None;
+  }
+  if !in_check {
+    return Some(GameEnd::Draw("".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 played_move = chess_move.to_bitmove();
+
   println!("get_board_after_move answered");
-  return String::from("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
+  board.make_move(&played_move);
+
+  return board.fen();
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::boardsquare::BoardSquare;
+  use crate::piecetype::PieceType::*;
+  use crate::gameend::GameEnd;
+
+  use super::*;
+
+  impl PartialEq for ChessMove {
+    fn eq(&self, other: &Self) -> bool {
+      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 PartialEq for GameEnd {
+    fn eq(&self, other: &Self) -> bool {
+    match (self, other) {
+      (GameEnd::WhiteWon(a), GameEnd::WhiteWon(b)) => a == b,
+      (GameEnd::BlackWon(a), GameEnd::BlackWon(b)) => a == b,
+      (GameEnd::Draw(a),     GameEnd::Draw(b))     => a == b,
+      _ => false,
+    }
+  }
+}
+
+  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/movetype.rs

@@ -1,5 +1,6 @@
 use serde::Deserialize;
 use serde::Serialize;
+use super::bitboard::bitmove::BitMoveType;
 
 #[derive(Serialize, Deserialize)]
 pub enum MoveType {
@@ -9,3 +10,22 @@ pub enum MoveType {
     EnPassant,
 }
 
+impl MoveType {
+    pub(in super) fn from_bitmovetype(move_type: BitMoveType) -> Self {
+        return match move_type {
+            BitMoveType::Quiet => Self::Quiet,
+            BitMoveType::Capture => Self::Capture,
+            BitMoveType::Castle => Self::Castle,
+            BitMoveType::EnPassant => Self::EnPassant,
+            _ => panic!("invalid move_type index! should NEVER appear")
+        }
+    }
+    pub(in super) fn to_bitmoveType(&self) -> BitMoveType {
+        return match self {
+            &MoveType::Quiet => BitMoveType::Quiet,
+            &MoveType::Capture => BitMoveType::Capture,
+            &MoveType::Castle => BitMoveType::Castle,
+            &MoveType::EnPassant => BitMoveType::EnPassant
+        };
+    }
+}

engine/src/piecetype.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub enum PieceType {
     WhitePawn,
     WhiteKnight,
@@ -16,3 +16,39 @@ pub enum PieceType {
     BlackKing,
 }
 
+impl PieceType {
+
+    pub(in super) fn from_index(idx: u8) -> Self {
+        return match idx {
+            0 => PieceType::WhitePawn,
+            1 => PieceType::WhiteKnight,
+            2 => PieceType::WhiteBishop,
+            3 => PieceType::WhiteRook,
+            4 => PieceType::WhiteQueen,
+            5 => PieceType::WhiteKing,
+            6 => PieceType::BlackPawn,
+            7 => PieceType::BlackKnight,
+            8 => PieceType::BlackBishop,
+            9 => PieceType::BlackRook,
+            10 => PieceType::BlackQueen,
+            11 => PieceType::BlackKing,
+            _ => panic!("invalid piece index! should NEVER appear")
+        }
+    }
+    pub(in super) fn to_index(&self) -> u8 {
+        return match self {
+            &PieceType::WhitePawn => 0,
+            &PieceType::WhiteKnight => 1,
+            &PieceType::WhiteBishop => 2,
+            &PieceType::WhiteRook => 3,
+            &PieceType::WhiteQueen => 4,
+            &PieceType::WhiteKing => 5,
+            &PieceType::BlackPawn => 6,
+            &PieceType::BlackKnight => 7,
+            &PieceType::BlackBishop => 8,
+            &PieceType::BlackRook => 9,
+            &PieceType::BlackQueen => 10,
+            &PieceType::BlackKing => 11
+        }
+    }
+}

server/Cargo.toml

@@ -15,6 +15,8 @@ uuid = {version = "1.18.1", features = ["v4", "serde"] }
 anyhow = "1.0.100"
 rand = "0.9.2"
 engine = {path = "../engine/"}
+log = {version = "0.4.28"}
+env_logger = "0.11.8"
 
 
 [[bin]]

server/src/bin/client.rs

@@ -1,17 +1,27 @@
+use engine::gameend::GameEnd;
+use engine::{boardsquare::BoardSquare, chessmove::ChessMove, piecetype::PieceType};
 use futures_util::{SinkExt, StreamExt};
 use serde::{Deserialize, Serialize};
 use std::io::{self, Write};
 use tokio_tungstenite::{connect_async, tungstenite::Message};
 use url::Url;
+use uuid::Uuid;
 
 #[derive(Serialize, Deserialize, Debug)]
+struct Step {
+    from: String,
+    to: String,
+}
+
+#[derive(Serialize, Deserialize)]
 #[serde(tag = "type")]
 enum ClientMessage {
     Join { username: String },
     FindMatch,
-    Move { from: String, to: String },
+    Move { step: ChessMove, fen: String },
     Resign,
     Chat { text: String },
+    RequestLegalMoves { fen: String },
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -25,6 +35,21 @@ struct ServerMessage {
     reason: Option<String>,
 }
 
+#[derive(Serialize, Deserialize)]
+pub enum ServerMessage2 {
+    GameEnd {
+        winner: GameEnd,
+    },
+    UIUpdate {
+        fen: String,
+    },
+    MatchFound {
+        match_id: Uuid,
+        color: String,
+        opponent_name: String,
+    },
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Knightly Chess Client");
@@ -60,15 +85,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                         println!("\nServer: {}", text);
 
                         // Try to parse as structured message
-                        if let Ok(parsed) = serde_json::from_str::<ServerMessage>(text) {
-                            match parsed.message_type.as_str() {
-                                "welcome" => {
-                                    if let Some(player_id) = parsed.player_id {
-                                        println!("Welcome! Your player ID: {}", player_id);
-                                    }
+                        if let Ok(parsed) = serde_json::from_str::<ServerMessage2>(text) {
+                            match parsed {
+                                ServerMessage2::MatchFound {
+                                    match_id,
+                                    color,
+                                    opponent_name,
+                                } => {
+                                    println!(
+                                        "opponent: {}, match_id: {}, color: {}",
+                                        opponent_name, match_id, color
+                                    );
                                 }
                                 _ => {
-                                    println!("cucc: {:?}", parsed);
+                                    println!("cucc");
                                 }
                             }
                         }
@@ -128,11 +158,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             }
             "move" => {
                 if parts.len() >= 3 {
-                    let from = parts[1].to_string();
-                    let to = parts[2].to_string();
-                    let message = ClientMessage::Move { from, to };
+                    //let from = parts[1].to_string();
+                    //let to = parts[2].to_string();
+                    let fen = parts[1].to_string();
+
+                    let step = ChessMove::quiet(
+                        engine::piecetype::PieceType::WhiteBishop,
+                        BoardSquare::new(),
+                        BoardSquare { x: 1, y: 1 },
+                        None,
+                    );
+
+                    let message = ClientMessage::Move { step, fen };
                     send_message(&mut write, &message).await?;
-                    println!("♟️  Sent move: {} -> {}", parts[1], parts[2]);
+                    //println!("♟️  Sent move: {} -> {}", parts[1], parts[2]);
                 } else {
                     println!("Usage: move <from> <to> (e.g., move e2 e4)");
                 }
@@ -154,6 +193,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "help" => {
                 print_help();
             }
+            "requestmoves" => {
+                if parts.len() >= 2 {
+                    let fen = parts[1..].join(" ");
+                    let message = ClientMessage::RequestLegalMoves { fen };
+                    send_message(&mut write, &message).await?;
+                }
+            }
             _ => {
                 println!(
                     "Unknown command: {}. Type 'help' for available commands.",
@@ -191,5 +237,6 @@ fn print_help() {
     println!("  resign             - Resign from current game");
     println!("  help               - Show this help");
     println!("  quit               - Exit the client");
+    println!("  requestmoves       - Request the legal moves");
     println!();
 }

server/src/connection.rs

@@ -1,7 +1,12 @@
 use crate::connection::ClientEvent::*;
-use engine::get_available_moves;
+use crate::matchmaking;
+use engine::chessmove::ChessMove;
+use engine::gameend::GameEnd::{self, *};
+use engine::{get_available_moves, is_game_over};
 use futures_util::{SinkExt, StreamExt};
+use log::{error, info, warn};
 use serde::{Deserialize, Serialize};
+use std::char::from_u32_unchecked;
 use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
 use tokio::net::TcpStream;
@@ -15,41 +20,73 @@ pub type ConnectionMap = Arc<Mutex<HashMap<Uuid, PlayerConnection>>>;
 pub type MatchMap = Arc<Mutex<HashMap<Uuid, GameMatch>>>;
 pub type WaitingQueue = Arc<Mutex<VecDeque<Uuid>>>;
 
+pub async fn clean_up_match(matches: &MatchMap, match_id: &Uuid) {
+    matches.lock().await.remove(&match_id);
+}
+
 // Helper functions to create new instances
 pub fn new_connection_map() -> ConnectionMap {
+    warn!("Created new connection map");
     Arc::new(Mutex::new(HashMap::new()))
 }
 
 pub fn new_match_map() -> MatchMap {
+    warn!("Created new match map");
     Arc::new(Mutex::new(HashMap::new()))
 }
 
 pub fn new_waiting_queue() -> WaitingQueue {
+    warn!("Created new waiting queue");
     Arc::new(Mutex::new(VecDeque::new()))
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Step {
     pub from: String,
     pub to: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+/*#[derive(Serialize, Deserialize, Debug)]
+struct ServerMessage {
+    #[serde(rename = "type")]
+    message_type: String,
+    player_id: Option<Uuid>,
+    match_id: Option<Uuid>,
+    opponent: Option<Uuid>,
+    color: Option<String>,
+    reason: Option<String>,
+    response: Option<String>,
+}*/
+
+#[derive(Serialize, Deserialize)]
+pub enum ServerMessage2 {
+    GameEnd {
+        winner: GameEnd,
+    },
+    UIUpdate {
+        fen: String,
+    },
+    MatchFound {
+        match_id: Uuid,
+        color: String,
+        opponent_name: String,
+    },
+    Ok {
+        response: Result<(), String>,
+    },
+}
+
+#[derive(Serialize, Deserialize)]
 #[serde(tag = "type")]
 enum ClientEvent {
     Join { username: String },
     FindMatch,
-    Move { from: String, to: String },
+    Move { step: ChessMove },
     Resign,
     Chat { text: String },
     RequestLegalMoves { fen: String },
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct EventResponse {
-    pub response: Result<(), String>,
-}
-
 #[derive(Debug)]
 pub struct PlayerConnection {
     pub id: Uuid,
@@ -64,23 +101,24 @@ pub struct GameMatch {
     pub player_white: Uuid,
     pub player_black: Uuid,
     pub board_state: String,
-    pub move_history: Vec<String>,
+    pub move_history: Vec<Step>,
 }
 
 // Message sending utilities
-pub async fn send_message_to_player(
-    connections: &ConnectionMap,
-    player_id: Uuid,
+pub async fn send_message_to_player_connection(
+    connection: Option<&mut PlayerConnection>,
     message: &str,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let mut connections_lock = connections.lock().await;
-    if let Some(connection) = connections_lock.get_mut(&player_id) {
-        connection
-            .tx
-            .send(Message::Text(message.to_string()))
-            .await?;
+) -> Result<(), tokio_tungstenite::tungstenite::Error> {
+    match connection {
+        Some(connection) => {
+            info!("sending message to: {}", connection.id);
+            connection.tx.send(Message::Text(message.to_string())).await
+        }
+        None => {
+            error!("No connection provided");
+            Err(tokio_tungstenite::tungstenite::Error::ConnectionClosed)
+        }
     }
-    Ok(())
 }
 
 pub async fn broadcast_to_all(connections: &ConnectionMap, message: &str) {
@@ -89,7 +127,7 @@ pub async fn broadcast_to_all(connections: &ConnectionMap, message: &str) {
 
     for (id, connection) in connections_lock.iter_mut() {
         if let Err(e) = connection.tx.send(Message::Text(message.to_string())).await {
-            eprintln!("Failed to send to {}: {}", id, e);
+            error!("Failed to send to {}: {}", id, e);
             dead_connections.push(*id);
         }
     }
@@ -106,10 +144,19 @@ pub async fn broadcast_to_match(
     match_id: Uuid,
     message: &str,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    info!("Broadcasting data to match: {}", &match_id);
     let matches_lock = matches.lock().await;
     if let Some(game_match) = matches_lock.get(&match_id) {
-        send_message_to_player(connections, game_match.player_white, message).await?;
-        send_message_to_player(connections, game_match.player_black, message).await?;
+        send_message_to_player_connection(
+            connections.lock().await.get_mut(&game_match.player_white),
+            message,
+        )
+        .await?;
+        send_message_to_player_connection(
+            connections.lock().await.get_mut(&game_match.player_black),
+            message,
+        )
+        .await?;
     }
     Ok(())
 }
@@ -125,6 +172,7 @@ pub async fn handle_connection(
 
     let ws_stream = accept_async(stream).await?;
     let (write, mut read) = ws_stream.split();
+    warn!("Accepted new connection");
 
     let player_id = Uuid::new_v4();
 
@@ -142,45 +190,32 @@ pub async fn handle_connection(
         );
     }
 
-    println!("New connection: {}", player_id);
-
-    // Send welcome message
-    let _ = send_message_to_player(
-        &connections,
-        player_id,
-        &format!(r#"{{"type": "welcome", "player_id": "{}"}}"#, player_id),
-    )
-    .await;
+    info!("id: {}", &player_id);
 
     // Message processing loop
     while let Some(Ok(message)) = read.next().await {
         if message.is_text() {
             let text = message.to_text()?;
-            println!("Received from {}: {}", player_id, text);
+            info!("Received from {}: {}", player_id, text);
 
             let client_data: ClientEvent = serde_json::from_str(text)
                 .expect("Failed to convert data into json at handle_connection");
 
-            println!("client: {:?}", client_data);
-
             match client_data {
                 Join { username } => {
                     {
                         let mut conn_map = connections.lock().await;
                         let player = conn_map.get_mut(&player_id).unwrap();
-                        player.username = Some(username);
+                        player.username = Some(username.clone());
+                        info!("player: {}, set username: {}", &player_id, username);
                     }
 
                     //respone to client
-                    let response: EventResponse = EventResponse {
-                        response: core::result::Result::Ok(()),
-                    };
+                    let response = ServerMessage2::Ok { response: Ok(()) };
 
-                    println!("response: {:?}", response);
-
-                    let _ = send_message_to_player(
-                        &connections,
-                        player_id,
+                    let mut conn_map = connections.lock().await;
+                    let _ = send_message_to_player_connection(
+                        conn_map.get_mut(&player_id),
                         &serde_json::to_string(&response).unwrap(),
                     )
                     .await;
@@ -188,28 +223,150 @@ pub async fn handle_connection(
                 FindMatch => {
                     let mut wait_queue = waiting_queue.lock().await;
                     wait_queue.push_back(player_id.clone());
-                    println!("Appended {} to the waiting queue", player_id);
-                    println!("queue {:?}", wait_queue);
+                    info!("Appended {} to the waiting queue", player_id);
+                    info!("queue {:?}", wait_queue);
                 }
-                Move { from, to } => {}
-                RequestLegalMoves { fen } => {
-                    let moves = get_available_moves(&fen);
-                    let _ = send_message_to_player(
+                Move { step } => {
+                    let match_id = connections
+                        .lock()
+                        .await
+                        .get(&player_id)
+                        .unwrap()
+                        .current_match
+                        .unwrap();
+
+                    {
+                        info!("updating board state in match: {}", &match_id);
+                        let mut matches = matches.lock().await;
+                        matches.get_mut(&match_id).unwrap().board_state =
+                            engine::get_board_after_move(
+                                &matches.get(&match_id).unwrap().board_state,
+                                &step,
+                            );
+                    }
+                    let message = ServerMessage2::UIUpdate {
+                        fen: matches
+                            .lock()
+                            .await
+                            .get(&match_id)
+                            .unwrap()
+                            .board_state
+                            .clone(),
+                    };
+
+                    let _ = broadcast_to_match(
                         &connections,
-                        player_id,
+                        &matches,
+                        match_id,
+                        &serde_json::to_string(&message).unwrap(),
+                    )
+                    .await;
+
+                    {
+                        let is_game_end = engine::is_game_over(
+                            &matches.lock().await.get(&match_id).unwrap().board_state,
+                        );
+
+                        match is_game_end {
+                            Some(res) => {
+                                warn!("A player won the match: {}", &match_id);
+                                let message = ServerMessage2::GameEnd { winner: res };
+                                let _ = broadcast_to_match(
+                                    &connections,
+                                    &matches,
+                                    match_id,
+                                    &serde_json::to_string(&message).unwrap(),
+                                )
+                                .await;
+                                clean_up_match(&matches, &match_id);
+                            }
+                            None => {
+                                info!("No winner match continues. Id: {}", &match_id);
+                            }
+                        }
+                    }
+                }
+                RequestLegalMoves { fen } => {
+                    info!("Requesting legal moves player: {}", &player_id);
+                    let moves = get_available_moves(&fen);
+                    let _ = send_message_to_player_connection(
+                        connections.lock().await.get_mut(&player_id),
                         &serde_json::to_string(&moves).unwrap(),
                     )
                     .await;
-                    println!("Sent moves to player: {}", player_id);
+                    info!("Sent moves to player: {}", player_id);
+                }
+                Resign => {
+                    warn!("Resigned!");
+                    let (fuck, fuck_id): (ServerMessage2, &Uuid) = {
+                        let matches = matches.lock().await;
+
+                        let curr_match = matches
+                            .get(
+                                &connections
+                                    .lock()
+                                    .await
+                                    .get(&player_id)
+                                    .unwrap()
+                                    .current_match
+                                    .unwrap(),
+                            )
+                            .unwrap();
+
+                        if player_id == curr_match.player_white {
+                            (
+                                ServerMessage2::GameEnd {
+                                    winner: GameEnd::BlackWon("Resigned".to_string()),
+                                },
+                                &connections
+                                    .lock()
+                                    .await
+                                    .get(&player_id)
+                                    .unwrap()
+                                    .current_match
+                                    .unwrap(),
+                            )
+                        } else {
+                            (
+                                ServerMessage2::GameEnd {
+                                    winner: GameEnd::WhiteWon("Resigned".to_string()),
+                                },
+                                &connections
+                                    .lock()
+                                    .await
+                                    .get(&player_id)
+                                    .unwrap()
+                                    .current_match
+                                    .unwrap(),
+                            )
+                        }
+                    };
+
+                    broadcast_to_match(
+                        &connections,
+                        &matches,
+                        connections
+                            .lock()
+                            .await
+                            .get(&player_id)
+                            .unwrap()
+                            .current_match
+                            .unwrap(),
+                        &serde_json::to_string(&fuck).unwrap(),
+                    )
+                    .await;
+                    clean_up_match(&matches, fuck_id);
+                }
+                _ => {
+                    warn!("Not known client event");
                 }
-                _ => {}
             }
         }
     }
 
     // Cleanup on disconnect
     cleanup_player(player_id, &connections, &matches, &waiting_queue).await;
-    println!("Connection {} closed", player_id);
+    warn!("Connection {} closed", player_id);
 
     Ok(())
 }
@@ -226,7 +383,7 @@ async fn cleanup_player(
     // Remove from connections
     connections.lock().await.remove(&player_id);
 
-    println!("Cleaned up player {}", player_id);
+    warn!("Cleaned up player {}", player_id);
 }
 
 #[cfg(test)]
@@ -239,8 +396,24 @@ mod tests {
         let connections = new_connection_map();
         let player_id = Uuid::new_v4();
 
-        let result = send_message_to_player(&connections, player_id, "test message").await;
-        assert!(result.is_ok(), "Should handle missing player gracefully");
+        // Test 1: Pass None directly (non-existent player)
+        let result = send_message_to_player_connection(None, "test message").await;
+
+        assert!(result.is_err(), "Should return error for None connection");
+        println!("Test passed: Handles None connection correctly");
+
+        // Test 2: Try to get non-existent player from map
+        let mut conn = connections.lock().await;
+        let non_existent_connection = conn.get_mut(&player_id); // This will be None
+
+        let result2 =
+            send_message_to_player_connection(non_existent_connection, "test message").await;
+
+        assert!(
+            result2.is_err(),
+            "Should return error for non-existent player"
+        );
+        println!("Test passed: Handles non-existent player in map correctly");
     }
 
     #[tokio::test]

server/src/main.rs

@@ -1,13 +1,18 @@
 mod connection;
 mod matchmaking;
-mod messages;
+use env_logger::{Env, Logger};
+use log::{error, info, warn};
+use std::env;
 use tokio::net::TcpListener;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
+    let env = Env::default().filter_or("MY_LOG_LEVEL", "INFO");
+    env_logger::init_from_env(env);
+
     let address = "0.0.0.0:9001";
     let listener = TcpListener::bind(address).await?;
-    println!("Server running on ws://{}", address);
+    info!("Server running on ws://{}", address);
 
     // Shared state initialization using the new helper functions
     let connections = connection::new_connection_map();
@@ -34,7 +39,7 @@ async fn main() -> anyhow::Result<()> {
             if let Err(e) =
                 connection::handle_connection(stream, connections, matches, waiting_queue).await
             {
-                eprintln!("Connection error: {}", e);
+                error!("Connection error: {}", e);
             }
         });
     }

server/src/matchmaking.rs

@@ -1,4 +1,6 @@
-use crate::connection::{ConnectionMap, GameMatch, MatchMap, WaitingQueue};
+use crate::connection::ServerMessage2;
+use crate::connection::{ConnectionMap, GameMatch, MatchMap, WaitingQueue, broadcast_to_match};
+use log::{error, info, warn};
 use rand::random;
 use uuid::Uuid;
 
@@ -20,21 +22,30 @@ impl MatchmakingSystem {
     pub async fn run(&self) {
         loop {
             self.try_create_match().await;
-            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+            tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
         }
     }
 
+    pub async fn clean_up(&self, match_id: Uuid) {
+        self.matches.lock().await.remove(&match_id);
+    }
+
     async fn try_create_match(&self) {
+        info!("Checking for new matches!");
         let mut queue = self.waiting_queue.lock().await;
 
         while queue.len() >= 2 {
             let player1 = queue.pop_front().unwrap();
             let player2 = queue.pop_front().unwrap();
 
+            info!("Creating new match. Players: {}, {}", &player1, &player2);
+
             let match_id = Uuid::new_v4();
             let (white_player, black_player) = if random::<bool>() {
+                info!("player1 is white, player2 is black");
                 (player1, player2)
             } else {
+                info!("player2 is white, player1 is black");
                 (player2, player1)
             };
 
@@ -46,6 +57,8 @@ impl MatchmakingSystem {
                 move_history: Vec::new(),
             };
 
+            info!("Match id: {}", &game_match.id);
+
             // Store the match
             self.matches.lock().await.insert(match_id, game_match);
 
@@ -54,52 +67,68 @@ impl MatchmakingSystem {
                 let mut conn_map = self.connections.lock().await;
                 if let Some(player) = conn_map.get_mut(&white_player) {
                     player.current_match = Some(match_id);
+                } else {
+                    error!("Could not store match id for white player");
                 }
                 if let Some(player) = conn_map.get_mut(&black_player) {
                     player.current_match = Some(match_id);
+                } else {
+                    error!("Could not store match id for black player");
                 }
             }
 
             // Notify players
+            info!(
+                "Notifying player for a match: {:?} | {:?}",
+                white_player, black_player
+            );
             self.notify_players(white_player, black_player, match_id)
                 .await;
         }
     }
 
     async fn notify_players(&self, white: Uuid, black: Uuid, match_id: Uuid) {
-        let conn_map = self.connections.lock().await;
-
-        // Get opponent names
-        let white_name = conn_map
-            .get(&black)
-            .and_then(|c| c.username.as_deref())
-            .unwrap_or("Opponent");
-        let black_name = conn_map
-            .get(&white)
-            .and_then(|c| c.username.as_deref())
-            .unwrap_or("Opponent");
+        let mut conn_map = self.connections.lock().await;
 
         // Notify white player
         if let Some(_) = conn_map.get(&white) {
-            let message = format!(
-                r#"{{"type": "match_found", "match_id": "{}", "opponent": "{}", "color": "white"}}"#,
-                match_id, black_name
-            );
-            let _ =
-                crate::connection::send_message_to_player(&self.connections, white, &message).await;
+            let message = ServerMessage2::MatchFound {
+                match_id: match_id.clone(),
+                color: String::from("white"),
+                opponent_name: conn_map
+                    .get(&white)
+                    .and_then(|c| c.username.as_deref())
+                    .unwrap_or("Opponent")
+                    .to_string(),
+            };
+
+            let _ = crate::connection::send_message_to_player_connection(
+                conn_map.get_mut(&white),
+                &serde_json::to_string(&message).unwrap(),
+            )
+            .await;
         }
 
         // Notify black player
         if let Some(_) = conn_map.get(&black) {
-            let message = format!(
-                r#"{{"type": "match_found", "match_id": "{}", "opponent": "{}", "color": "black"}}"#,
-                match_id, white_name
-            );
-            let _ =
-                crate::connection::send_message_to_player(&self.connections, black, &message).await;
+            let message = ServerMessage2::MatchFound {
+                match_id: match_id.clone(),
+                color: String::from("black"),
+                opponent_name: conn_map
+                    .get(&black)
+                    .and_then(|c| c.username.as_deref())
+                    .unwrap_or("Opponent")
+                    .to_string(),
+            };
+
+            let _ = crate::connection::send_message_to_player_connection(
+                conn_map.get_mut(&white),
+                &serde_json::to_string(&message).unwrap(),
+            )
+            .await;
         }
 
-        println!("Match created: {} (white) vs {} (black)", white, black);
+        info!("Match created: {} (white) vs {} (black)", white, black);
     }
 }
 

server/src/messages.rs

@@ -1,36 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(tag = "type")]
-pub enum ServerMessage {
-    Welcome {
-        player_id: String,
-    },
-    MatchFound {
-        match_id: String,
-        opponent: String,
-        color: String,
-    },
-    GameStart {
-        fen: String,
-        white_time: u32,
-        black_time: u32,
-    },
-    MoveResult {
-        valid: bool,
-        from: String,
-        to: String,
-        new_fen: String,
-    },
-    OpponentMove {
-        from: String,
-        to: String,
-    },
-    GameEnd {
-        result: String,
-        reason: String,
-    },
-    Error {
-        reason: String,
-    },
-}