removed unused imports from chessmove.rs

Engine/movebuffer

.github/workflows/upload_data.yml

@@ -20,7 +20,7 @@ jobs:
           echo "$GOOGLE_SERVICE_ACCOUNT_JSON" > service_account.json
           
           python <<'PYCODE'
-          import gspread, json, subprocess
+          import gspread, json, subprocess, time
 
           creds = json.load(open("service_account.json"))
           gc = gspread.service_account_from_dict(creds)
@@ -38,6 +38,7 @@ jobs:
 
               for i, row in enumerate(rows_to_append):
                   worksheet.insert_row(row, start_row + i)
+                  time.sleep(1)
 
 
           with open(f"{v}/test_data.log", "r") as f:

engine/Cargo.toml

@@ -5,3 +5,5 @@ edition = "2024"
 
 [dependencies]
 once_cell = "1.19"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"

engine/src/bitboard.rs

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

engine/src/bitboard/attackmaps.rs

@@ -94,6 +94,64 @@ pub static RAY_TABLE: Lazy<[[u64; 8]; 64]> = Lazy::new(|| {
   return table;
 });
 
+// ROOK_MOVE_MASK[<square_index>]
+pub static ROOK_MOVE_MASK: Lazy<[u64; 64]> = Lazy::new(|| {
+  let mut table = [0u64; 64];
+
+  for sq in 0..64 {
+    for dir in [0, 2, 4, 6] {
+      table[sq] |= RAY_TABLE[sq][dir];
+    }
+  }
+  table
+});
+
+// BISHOP_MOVE_MASK[<square_index>]
+pub static BISHOP_MOVE_MASK: Lazy<[u64; 64]> = Lazy::new(|| {
+  let mut table = [0u64; 64];
+
+  for sq in 0..64 {
+    for dir in [1, 3, 5, 7] {
+      table[sq] |= RAY_TABLE[sq][dir];
+    }
+  }
+  table
+});
+
+// KING_SAFETY_ROOK_MASK[<square_index>]
+pub static KING_SAFETY_ROOK_MASK: Lazy<[u64; 64]> = Lazy::new(|| {
+  let mut table = [0u64; 64];
+
+  for sq in 0..64 {
+    let mut mask = KING_ATTACK_MAP[sq];
+
+    while mask != 0 {
+      let next_sq = mask.trailing_zeros();
+      table[sq] |= ROOK_MOVE_MASK[next_sq as usize];
+      mask &= !(1 << next_sq);
+    }
+  }
+
+  table
+});
+
+// KING_SAFETY_BISHOP_MASK[<square_index>]
+pub static KING_SAFETY_BISHOP_MASK: Lazy<[u64; 64]> = Lazy::new(|| {
+  let mut table = [0u64; 64];
+
+  for sq in 0..64 {
+    let mut mask = KING_ATTACK_MAP[sq];
+
+    while mask != 0 {
+      let next_sq = mask.trailing_zeros();
+      table[sq] |= BISHOP_MOVE_MASK[next_sq as usize];
+      mask &= !(1 << next_sq);
+    }
+  }
+
+  table
+});
+
 
 
 // <----- TESTS ----->

engine/src/bitboard/attacks.rs

@@ -5,6 +5,8 @@ impl Board {
 
   const RANK_2: u64 = 0x0000_0000_0000_FF00;
   const RANK_7: u64 = 0x00FF_0000_0000_0000;
+  const A_FILE: u64 = 0x0101_0101_0101_0101;
+  const H_FILE: u64 = 0x8080_8080_8080_8080;
 
   pub fn get_pseudo_pawn_moves(&self, sq: u32) -> u64 {
     let pawn: u64 = 1 << sq;
@@ -71,6 +73,111 @@ impl Board {
   pub fn get_pseudo_queen_moves(&self, sq: u32) -> u64 {
     return self.get_pseudo_bishop_moves(sq) | self.get_pseudo_rook_moves(sq);
   }
+
+  #[inline]
+  pub fn get_pseudo_bishop_moves_ignore_king(&self, sq: u32) -> u64 {
+    let mut  moves = 0u64;
+    let sq  = sq as usize;
+    let king = self.bitboards[5 + 6*self.side_to_move as usize];
+    let occupancy = self.occupancy[2] & !king;
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 1);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 3);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 5);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 7);
+
+    return moves;
+  }
+  #[inline]
+  pub fn get_pseudo_rook_moves_ignore_king(&self, sq: u32) -> u64 {
+    let mut moves: u64 = 0u64;
+    let sq = sq as usize;
+    let king = self.bitboards[5 + 6*self.side_to_move as usize];
+    let occupancy = self.occupancy[2] & !king;
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 0);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 2);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 4);
+    moves |= get_raycast_from_square_in_direction(occupancy, sq, 6);
+
+    return moves;
+  }
+
+  #[inline]
+  pub fn is_square_attacked(&self, king_sq: u32) -> bool {
+    let offset: usize = 6 * self.side_to_move as usize;
+
+    // rook-queen checks (+)
+    let mut threat_mask: u64 = self.get_pseudo_rook_moves(king_sq);
+    let mut attacker_mask: u64 = self.bitboards[10 - offset] | self.bitboards[9 - offset];
+    if threat_mask & attacker_mask != 0 { return true; }
+
+    // bishop-queen checks (x)
+    threat_mask = self.get_pseudo_bishop_moves(king_sq);
+    attacker_mask = self.bitboards[10 - offset] | self.bitboards[8 - offset];
+    if threat_mask & attacker_mask != 0 { return true; }
+
+    // knight checks (L)
+    threat_mask = KNIGHT_ATTACK_MAP[king_sq as usize];
+    attacker_mask = self.bitboards[7 - offset];
+    if threat_mask & attacker_mask != 0 { return true; }
+
+    // pawn checks (v)
+    threat_mask = PAWN_ATTACK_MAP[king_sq as usize][self.side_to_move as usize];
+    attacker_mask = self.bitboards[6 - offset];
+    return threat_mask & attacker_mask != 0;
+  }
+  pub fn get_safe_king_squares(&self) -> u64 {
+    let offset: usize = 6 * (1 - self.side_to_move as usize);
+    let king_sq = self.bitboards[11 - offset].trailing_zeros() as usize;
+    let bishop_mask = KING_SAFETY_BISHOP_MASK[king_sq];
+    let rook_mask = KING_SAFETY_ROOK_MASK[king_sq];
+    let mut attack_map: u64 = 0u64;
+
+    let mut board: u64 = self.bitboards[offset];
+    if self.side_to_move() == 0 {
+      attack_map |= (board >> 9 & !Self::H_FILE) | (board >> 7 & !Self::A_FILE);
+    }
+    else {
+      attack_map |= (board << 9 & !Self::A_FILE) | (board << 7 & !Self::H_FILE);
+    }
+
+    board = self.bitboards[offset + 1];
+    while board != 0 {
+      let piece_sq: u32 = board.trailing_zeros();
+      board &= !(1 << piece_sq);
+
+      attack_map |= self.get_pseudo_knight_moves(piece_sq);
+    }
+
+    board = self.bitboards[offset + 2] & bishop_mask;
+    while board != 0 {
+      let piece_sq: u32 = board.trailing_zeros();
+      board &= !(1 << piece_sq);
+
+      attack_map |= self.get_pseudo_bishop_moves_ignore_king(piece_sq);
+    }
+
+    board = self.bitboards[offset + 3] & rook_mask;
+    while board != 0 {
+      let piece_sq: u32 = board.trailing_zeros();
+      board &= !(1 << piece_sq);
+
+      attack_map |= self.get_pseudo_rook_moves_ignore_king(piece_sq);
+    }
+
+    board = self.bitboards[offset + 4] & (bishop_mask | rook_mask);
+    while board != 0 {
+      let piece_sq: u32 = board.trailing_zeros();
+      board &= !(1 << piece_sq);
+
+      attack_map |= self.get_pseudo_rook_moves_ignore_king(piece_sq) | self.get_pseudo_bishop_moves_ignore_king(piece_sq);
+    }
+
+    board = self.bitboards[offset + 5];
+    let piece_sq: u32 = board.trailing_zeros();
+    attack_map |= self.get_pseudo_king_moves(piece_sq);
+
+    return !attack_map;
+  }
 }
 
 #[inline(always)]

engine/src/bitboard/bitmove.rs

@@ -0,0 +1,77 @@
+use super::utils::*;
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct BitMove {
+
+  move_type: BitMoveType,
+  from_square: u8,
+  to_square: u8,
+  promotion_piece: Option<u8>
+}
+
+impl BitMove {
+
+  #[inline]
+  pub fn quiet(from: u8, to: u8, promotion_piece: Option<u8>) -> Self {
+    return Self {
+      move_type: BitMoveType::Quiet,
+      from_square: from,
+      to_square: to,
+      promotion_piece: promotion_piece
+    };
+  }
+  #[inline]
+  pub fn capture(from: u8, to: u8, promotion_piece: Option<u8>) -> Self {
+    return Self {
+      move_type: BitMoveType::Capture,
+      from_square: from,
+      to_square: to,
+      promotion_piece: promotion_piece
+    };
+  }
+  #[inline]
+  pub fn castle(from: u8, to: u8) -> Self {
+    return Self {
+      move_type: BitMoveType::Castle,
+      from_square: from,
+      to_square: to,
+      promotion_piece: None
+    };
+  }
+
+  #[inline(always)]
+  pub fn move_type(&self) -> BitMoveType {
+    return self.move_type;
+  }
+  #[inline(always)]
+  pub fn from_square(&self) -> u8 {
+    return self.from_square;
+  }
+  #[inline(always)]
+  pub fn to_square(&self) -> u8 {
+    return self.to_square;
+  }
+  #[inline(always)]
+  pub fn promotion_piece(&self) -> Option<u8> {
+    return self.promotion_piece;
+  }
+
+  pub fn uci_notation(&self) -> String {
+    let mut notation = notation_from_square_number(self.from_square());
+    notation.push_str(&notation_from_square_number(self.to_square()));
+
+    if let Some(promotion_piece) = self.promotion_piece {
+      notation.push(get_character_by_piece_id(promotion_piece).to_ascii_lowercase());
+    }
+
+    return notation;
+  }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum BitMoveType {
+  Quiet,
+  Capture,
+  Castle,
+  EnPassant
+}

engine/src/bitboard/legality.rs

@@ -93,6 +93,13 @@ impl Board {
     }
   }
 
+  #[inline]
+  pub(in super) fn get_pin_masked_moves(&self, moves: u64, sq: u32) -> u64 {
+    let sq: usize = sq as usize;
+    if self.pinned_squares[sq] == 4 { return moves; }
+    let dir: u8 = self.pinned_squares[sq];
+    return moves & (RAY_TABLE[sq][dir as usize] | RAY_TABLE[sq][4 + dir as usize]);
+  }
 }
 
 // <----- TESTS ----->

engine/src/bitboard/movebuffer.rs

@@ -0,0 +1,44 @@
+use super::bitmove::BitMove;
+
+pub struct MoveBuffer {
+
+  buffer: [BitMove; 256],
+  count: usize
+}
+
+impl MoveBuffer {
+
+  pub fn new() -> Self {
+    return Self {
+      buffer: [BitMove::quiet(0, 0, None); 256],
+      count: 0
+    };
+  }
+
+  #[inline]
+  pub fn add(&mut self, bitmove: BitMove) {
+    self.buffer[self.count] = bitmove;
+    self.count += 1;
+  }
+  #[inline]
+  pub fn append(&mut self, other: &MoveBuffer) {
+    self.buffer[self.count..self.count + other.count()].copy_from_slice(other.contents());
+    self.count += other.count();
+  }
+  #[inline(always)]
+  pub fn clear(&mut self) {
+    self.count = 0;
+  }
+  #[inline(always)]
+  pub fn count(&self) -> usize{
+    return self.count;
+  }
+  #[inline(always)]
+  pub fn get(&self, idx: usize) -> &BitMove {
+    return &self.buffer[idx];
+  }
+  #[inline(always)]
+  pub fn contents(&self) -> &[BitMove] {
+    return &self.buffer[0..self.count];
+  } 
+}

engine/src/bitboard/movegen.rs

@@ -0,0 +1,67 @@
+mod pawns;
+mod knights;
+mod bishops;
+mod rooks;
+mod queens;
+mod kings;
+
+use super::board::Board;
+use super::movebuffer::MoveBuffer;
+use super::bitmove::BitMove;
+use super::checkinfo::CheckInfo;
+use super::utils::*;
+
+impl Board {
+
+  const NO_FILTER: u64 = 0xFFFF_FFFF_FFFF_FFFF;
+
+  pub fn collect_moves(&mut self, buffer: &mut MoveBuffer, temp_buffer: &mut MoveBuffer) -> bool {
+    buffer.clear();
+    self.calc_pinned_squares();
+    let check_info = self.check_test();
+
+    match check_info.check_count {
+      0 => self.collect_all_moves(buffer, temp_buffer),
+      1 => self.collect_moves_single_check(buffer, temp_buffer, &check_info),
+      2 => self.collect_king_evasion(buffer, temp_buffer),
+      _ => panic!("More than 2 checking pieces found as the same time!")
+    }
+    return check_info.check_count > 0;
+  }
+
+  pub(in super) fn collect_all_moves(&self, buffer: &mut MoveBuffer, temp_buffer: &mut MoveBuffer) {
+    let safe_squares = self.get_safe_king_squares();
+
+    self.add_pawn_moves(buffer, temp_buffer, Self::NO_FILTER);
+    self.add_knight_moves(buffer, temp_buffer, Self::NO_FILTER);
+    self.add_bishop_moves(buffer, temp_buffer, Self::NO_FILTER);
+    self.add_rook_moves(buffer, temp_buffer, Self::NO_FILTER);
+    self.add_queen_moves(buffer, temp_buffer, Self::NO_FILTER);
+    self.add_king_moves(buffer, temp_buffer, safe_squares);
+    self.add_king_castles(buffer, safe_squares);
+
+    buffer.append(temp_buffer);
+    temp_buffer.clear();
+  }
+  pub(in super) fn collect_moves_single_check(&self, buffer: &mut MoveBuffer, temp_buffer: &mut MoveBuffer, check_info: &CheckInfo) {
+    let safe_squares = self.get_safe_king_squares();
+
+    self.add_pawn_moves(buffer, temp_buffer, check_info.move_mask);
+    self.add_knight_moves(buffer, temp_buffer, check_info.move_mask);
+    self.add_bishop_moves(buffer, temp_buffer, check_info.move_mask);
+    self.add_rook_moves(buffer, temp_buffer, check_info.move_mask);
+    self.add_queen_moves(buffer, temp_buffer, check_info.move_mask);
+    self.add_king_moves(buffer, temp_buffer, safe_squares);
+
+    buffer.append(temp_buffer);
+    temp_buffer.clear();
+  }
+  pub(in super) fn collect_king_evasion(&self, buffer: &mut MoveBuffer, temp_buffer: &mut MoveBuffer) {
+    let safe_squares = self.get_safe_king_squares();
+
+    self.add_king_moves(buffer, temp_buffer, safe_squares);
+
+    buffer.append(&temp_buffer);
+    temp_buffer.clear();
+  }
+}

engine/src/bitboard/movegen/bishops.rs

@@ -0,0 +1,55 @@
+use super::*;
+
+impl Board {
+
+  pub fn add_bishop_moves(&self, capture_buffer: &mut MoveBuffer, quiet_buffer: &mut MoveBuffer, move_mask: u64) {
+    let piece_index = 2 + self.side_to_move * 6;
+    let mut bishops = self.bitboards[piece_index as usize];
+    let empty = !self.occupancy[2];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while bishops != 0 {
+      let from_sq = pop_lsb(&mut bishops);
+      let raw_move_map = self.get_pseudo_bishop_moves(from_sq) & move_mask;
+      let move_map = self.get_pin_masked_moves(raw_move_map, from_sq);
+
+      let mut quiet_map = move_map & empty;
+      let mut capture_map = move_map & opponents;
+
+      while quiet_map != 0 {
+        let to_sq = pop_lsb(&mut quiet_map);
+        quiet_buffer.add(BitMove::quiet(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+      while capture_map != 0 {
+        let to_sq = pop_lsb(&mut capture_map);
+        capture_buffer.add(BitMove::capture(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+  pub fn add_bishop_captures(&self, buffer: &mut MoveBuffer, move_mask: u64) {
+    let offset = 6 * self.side_to_move as usize;
+    let mut bishops: u64 = self.bitboards[2 + offset];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while bishops != 0 {
+      let next_sq: u32 = pop_lsb(&mut bishops);
+      let mut attacks: u64 = self.get_pseudo_bishop_moves(next_sq) & opponents & move_mask;
+      attacks = self.get_pin_masked_moves(attacks, next_sq);
+
+      while attacks != 0 {
+        let to_sq = pop_lsb(&mut attacks);
+        buffer.add(BitMove::capture(
+          next_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+}

engine/src/bitboard/movegen/kings.rs

@@ -0,0 +1,88 @@
+use super::*;
+
+impl Board {
+
+  pub fn add_king_moves(&self, capture_buffer: &mut MoveBuffer, quiet_buffer: &mut MoveBuffer, move_mask: u64) {
+    let piece_index = 5 + self.side_to_move * 6;
+    let mut kings = self.bitboards[piece_index as usize];
+    let empty = !self.occupancy[2];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while kings != 0 {
+      let from_sq = pop_lsb(&mut kings);
+      let move_map = self.get_pseudo_king_moves(from_sq) & move_mask;
+
+      let mut quiet_map = move_map & empty;
+      let mut capture_map = move_map & opponents;
+
+      while quiet_map != 0 {
+        let to_sq = pop_lsb(&mut quiet_map);
+        quiet_buffer.add(BitMove::quiet(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+      while capture_map != 0 {
+        let to_sq = pop_lsb(&mut capture_map);
+        capture_buffer.add(BitMove::capture(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+  pub fn add_king_captures(&self, buffer: &mut MoveBuffer, move_mask: u64) {
+    let offset = 6 * self.side_to_move as usize;
+    let mut kings: u64 = self.bitboards[5 + offset];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while kings != 0 {
+      let next_sq: u32 = pop_lsb(&mut kings);
+      let mut attacks: u64 = self.get_pseudo_king_moves(next_sq) & opponents & move_mask;
+      attacks = self.get_pin_masked_moves(attacks, next_sq);
+
+      while attacks != 0 {
+        let to_sq = pop_lsb(&mut attacks);
+        buffer.add(BitMove::capture(
+          next_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+  pub fn add_king_castles(&self, buffer: &mut MoveBuffer, move_mask: u64) {
+    if self.castling_rights & (0b11 << (2 - 2 * self.side_to_move)) == 0 {
+      return;
+    }
+    
+    let offset = 5 + 6 * self.side_to_move as u8;
+    let castle_offset = 2 - 2 * self.side_to_move as u8;
+    let castling_rights = self.castling_rights & 3 << castle_offset;
+    let occupied = self.occupancy[2];
+    let king_sq = self.bitboards[offset as usize].trailing_zeros();
+      
+    let queenside_mask = 0b111 << (king_sq - 3);
+    let kingside_mask = 0b11 << (king_sq + 1);
+
+    if (castling_rights & 1 << castle_offset) != 0
+        && queenside_mask & occupied == 0
+        && !move_mask & 0b11 << (king_sq - 2) == 0
+        && !self.is_square_attacked(king_sq - 2) {
+      buffer.add(BitMove::castle(
+        king_sq as u8,
+        (king_sq - 2) as u8
+      ));
+    }
+    if (castling_rights & 2 << castle_offset) != 0
+        && kingside_mask & occupied == 0
+        && !move_mask & 0b11 << (king_sq + 1) == 0
+        && !self.is_square_attacked(king_sq + 2) {
+      buffer.add(BitMove::castle(
+        king_sq as u8,
+        (king_sq + 2) as u8
+      ));
+    }
+    
+  }
+}

engine/src/bitboard/movegen/knights.rs

@@ -0,0 +1,55 @@
+use super::*;
+
+impl Board {
+
+  pub fn add_knight_moves(&self, capture_buffer: &mut MoveBuffer, quiet_buffer: &mut MoveBuffer, move_mask: u64) {
+    let piece_index = 1 + self.side_to_move * 6;
+    let mut knights = self.bitboards[piece_index as usize];
+    let empty = !self.occupancy[2];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while knights != 0 {
+      let from_sq = pop_lsb(&mut knights);
+      let raw_move_map = self.get_pseudo_knight_moves(from_sq) & move_mask;
+      let move_map = self.get_pin_masked_moves(raw_move_map, from_sq);
+
+      let mut quiet_map = move_map & empty;
+      let mut capture_map = move_map & opponents;
+
+      while quiet_map != 0 {
+        let to_sq = pop_lsb(&mut quiet_map);
+        quiet_buffer.add(BitMove::quiet(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+      while capture_map != 0 {
+        let to_sq = pop_lsb(&mut capture_map);
+        capture_buffer.add(BitMove::capture(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+  pub fn add_knight_captures(&self, buffer: &mut MoveBuffer, move_mask: u64) {
+    let offset = 6 * self.side_to_move as usize;
+    let mut knights: u64 = self.bitboards[1 + offset];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while knights != 0 {
+      let next_sq: u32 = pop_lsb(&mut knights);
+      let mut attacks: u64 = self.get_pseudo_knight_moves(next_sq) & opponents & move_mask;
+      attacks = self.get_pin_masked_moves(attacks, next_sq);
+
+      while attacks != 0 {
+        let to_sq = pop_lsb(&mut attacks);
+        buffer.add(BitMove::capture(
+          next_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+}

engine/src/bitboard/movegen/pawns.rs

@@ -0,0 +1,76 @@
+use super::*;
+
+impl Board {
+
+  pub fn add_pawn_quiets(&self, buffer: &mut MoveBuffer, move_mask: u64) {
+    let offset: u8 = self.side_to_move * 6;
+    let mut pawns: u64 = self.bitboards[offset as usize];
+    while pawns != 0 {
+      let next_sq = pop_lsb(&mut pawns);
+
+      let mut quiets: u64 = self.get_pseudo_pawn_moves(next_sq) & move_mask;
+      quiets = self.get_pin_masked_moves(quiets, next_sq);
+      while quiets != 0 {
+        let to_sq = quiets.trailing_zeros();
+
+        if (self.side_to_move == 0 && quiets.trailing_zeros() / 8 == 7)
+        || (self.side_to_move == 1 && quiets.trailing_zeros() / 8 == 0) {
+          for piece_type in [4, 3, 2, 1] {
+            buffer.add(BitMove::quiet(
+              next_sq as u8,
+              to_sq as u8,
+              Some(piece_type)
+            ));
+          }
+        }
+        else {
+          buffer.add(BitMove::quiet(
+            next_sq as u8,
+            to_sq as u8,
+            None
+          ));
+        }
+        quiets &= !(1 << to_sq);
+      }
+    }
+  }
+  pub fn add_pawn_captures(&self, buffer: &mut MoveBuffer, move_mask: u64) {
+    let offset = 6 * self.side_to_move as usize;
+    let mut pawns: u64 = self.bitboards[offset];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while pawns != 0 {
+      let next_sq = pop_lsb(&mut pawns);
+
+      let mut attacks: u64 = self.get_pseudo_pawn_captures(next_sq) & move_mask;
+      attacks = self.get_pin_masked_moves(attacks, next_sq);
+      attacks &= opponents;
+
+      while attacks != 0 {
+        let to_sq = attacks.trailing_zeros();
+
+        if (self.side_to_move == 0 && attacks.trailing_zeros() / 8 == 7)
+        || (self.side_to_move == 1 && attacks.trailing_zeros() / 8 == 0) {
+          for piece_type in [4, 3, 2, 1] {
+            buffer.add(BitMove::capture(
+              next_sq as u8,
+              to_sq as u8,
+              Some(piece_type)
+            ));
+          }
+        }
+        else {
+          buffer.add(BitMove::capture(
+            next_sq as u8,
+            to_sq as u8,
+            None
+          ));
+        }
+        attacks &= !(1 << to_sq);
+      }
+    }
+  }
+  pub fn add_pawn_moves(&self, capture_buffer: &mut MoveBuffer, quiet_buffer: &mut MoveBuffer, move_mask: u64) {
+    self.add_pawn_captures(capture_buffer, move_mask);
+    self.add_pawn_quiets(quiet_buffer, move_mask);
+  }
+}

engine/src/bitboard/movegen/queens.rs

@@ -0,0 +1,55 @@
+use super::*;
+
+impl Board {
+
+  pub fn add_queen_moves(&self, capture_buffer: &mut MoveBuffer, quiet_buffer: &mut MoveBuffer, move_mask: u64) {
+    let piece_index = 4 + self.side_to_move * 6;
+    let mut queens = self.bitboards[piece_index as usize];
+    let empty = !self.occupancy[2];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while queens != 0 {
+      let from_sq = pop_lsb(&mut queens);
+      let raw_move_map = self.get_pseudo_queen_moves(from_sq) & move_mask;
+      let move_map = self.get_pin_masked_moves(raw_move_map, from_sq);
+
+      let mut quiet_map = move_map & empty;
+      let mut capture_map = move_map & opponents;
+
+      while quiet_map != 0 {
+        let to_sq = pop_lsb(&mut quiet_map);
+        quiet_buffer.add(BitMove::quiet(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+      while capture_map != 0 {
+        let to_sq = pop_lsb(&mut capture_map);
+        capture_buffer.add(BitMove::capture(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+  pub fn add_queen_captures(&self, buffer: &mut MoveBuffer, move_mask: u64) {
+    let offset = 6 * self.side_to_move as usize;
+    let mut queens: u64 = self.bitboards[4 + offset];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while queens != 0 {
+      let next_sq: u32 = pop_lsb(&mut queens);
+      let mut attacks: u64 = self.get_pseudo_queen_moves(next_sq) & opponents & move_mask;
+      attacks = self.get_pin_masked_moves(attacks, next_sq);
+
+      while attacks != 0 {
+        let to_sq = pop_lsb(&mut attacks);
+        buffer.add(BitMove::capture(
+          next_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+}

engine/src/bitboard/movegen/rooks.rs

@@ -0,0 +1,55 @@
+use super::*;
+
+impl Board {
+
+  pub fn add_rook_moves(&self, capture_buffer: &mut MoveBuffer, quiet_buffer: &mut MoveBuffer, move_mask: u64) {
+    let piece_index = 3 + self.side_to_move * 6;
+    let mut rooks = self.bitboards[piece_index as usize];
+    let empty = !self.occupancy[2];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while rooks != 0 {
+      let from_sq = pop_lsb(&mut rooks);
+      let raw_move_map = self.get_pseudo_rook_moves(from_sq) & move_mask;
+      let move_map = self.get_pin_masked_moves(raw_move_map, from_sq);
+
+      let mut quiet_map = move_map & empty;
+      let mut capture_map = move_map & opponents;
+
+      while quiet_map != 0 {
+        let to_sq = pop_lsb(&mut quiet_map);
+        quiet_buffer.add(BitMove::quiet(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+      while capture_map != 0 {
+        let to_sq = pop_lsb(&mut capture_map);
+        capture_buffer.add(BitMove::capture(
+          from_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+  pub fn add_rook_captures(&self, buffer: &mut MoveBuffer, move_mask: u64) {
+    let offset = 6 * self.side_to_move as usize;
+    let mut rooks: u64 = self.bitboards[3 + offset];
+    let opponents = self.occupancy[1 - self.side_to_move as usize];
+    while rooks != 0 {
+      let next_sq: u32 = pop_lsb(&mut rooks);
+      let mut attacks: u64 = self.get_pseudo_rook_moves(next_sq) & opponents & move_mask;
+      attacks = self.get_pin_masked_moves(attacks, next_sq);
+
+      while attacks != 0 {
+        let to_sq = pop_lsb(&mut attacks);
+        buffer.add(BitMove::capture(
+          next_sq as u8,
+          to_sq as u8,
+          None
+        ));
+      }
+    }
+  }
+}

engine/src/bitboard/utils.rs

@@ -1,13 +1,13 @@
 #[inline(always)]
-pub fn pop_lsb(value: &mut u64) -> usize {
-  let idx = value.trailing_zeros() as usize;
+pub fn pop_lsb(value: &mut u64) -> u32 {
+  let idx = value.trailing_zeros();
   *value &= !(1 << idx);
   return idx;
 }
 
 #[inline(always)]
-pub fn pop_msb(value: &mut u64) -> usize {
-  let idx = 63 - value.leading_zeros() as usize;
+pub fn pop_msb(value: &mut u64) -> u32 {
+  let idx = 63 - value.leading_zeros();
   *value &= !(1 << idx);
   return idx;
 }
@@ -48,6 +48,11 @@ pub fn try_get_square_number_from_notation(notation: &str) -> Result<u8, ()> {
   }
 }
 
+const PIECE_CHARACTERS: [char; 12] = ['P', 'N', 'B', 'R', 'Q', 'K', 'p', 'n', 'b', 'r', 'q', 'k'];
+pub fn get_character_by_piece_id(id: u8) -> char {
+  return PIECE_CHARACTERS[id as usize];
+}
+
 
 // <----- TESTS ----->
 
@@ -67,7 +72,7 @@ mod tests {
       0xBEAC_DBE0_903A_AC00,
       0x01E8_C895_A6F0_0000
     ];
-    let expected_values: [usize; 6] = [63, 0, 4, 2, 10, 20];
+    let expected_values: [u32; 6] = [63, 0, 4, 2, 10, 20];
 
     // tests
     for index in 0..6 {
@@ -87,7 +92,7 @@ mod tests {
       0x0000_C1C3_201C_0DB1,
       0x0000_0203_0DE4_E944
     ];
-    let expected_values: [usize; 6] = [63, 0, 61, 57, 47, 41];
+    let expected_values: [u32; 6] = [63, 0, 61, 57, 47, 41];
 
     // tests
     for index in 0..6 {

engine/src/boardsquare.rs

@@ -1,32 +1,48 @@
+use serde::{Deserialize, Serialize};
 
+#[derive(Serialize, Deserialize)]
 pub struct BoardSquare {
-  pub x: usize,
-  pub y: usize
+    pub x: usize,
+    pub y: usize,
 }
 
 impl BoardSquare {
-
-  pub fn new() -> Self {
-    return Self{
-      x: 0,
-      y: 0
-    };
-  }
-
-  pub fn from_coord(x: usize, y: usize) -> Self {
-    
-    #[cfg(debug_assertions)]
-    {
-      if x > 7 {
-        println!("Warning: x coordinate of square is bigger than 7, it might not be on the board!");
-      }
-      if y > 7 {
-        println!("Warning: y coordinate of square is bigger than 7, it might not be on the board!");
-      }
+    pub fn new() -> Self {
+        return Self { x: 0, y: 0 };
+    }
+
+    pub fn from_coord(x: usize, y: usize) -> Self {
+        #[cfg(debug_assertions)]
+        {
+            if x > 7 {
+                println!(
+                    "Warning: x coordinate of square is bigger than 7, it might not be on the board!"
+                );
+            }
+            if y > 7 {
+                println!(
+                    "Warning: y coordinate of square is bigger than 7, it might not be on the board!"
+                );
+            }
+        }
+        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;
     }
-    return Self {
-      x: x,
-      y: y
-    };
-  }
 }
+

engine/src/chessmove.rs

@@ -1,71 +1,192 @@
-use crate::piecetype;
+use crate::{bitboard::{bitmove::{BitMove, BitMoveType}, board::Board}};
 
 use super::boardsquare::BoardSquare;
 use super::piecetype::PieceType;
-use super::movetype::MoveType;
+use serde::{Deserialize, Serialize};
 
-
-pub struct ChessMove {
-  pub move_type: MoveType,
-  pub piece_type: PieceType,
-  pub from_square: BoardSquare,
-  pub to_square: BoardSquare,
-  pub rook_from: BoardSquare,
-  pub rook_to: BoardSquare,
-  pub promotion_piece: Option<PieceType>
+#[derive(Serialize, Deserialize)]
+/*pub struct ChessMove {
+    pub move_type: MoveType,
+    pub piece_type: PieceType,
+    pub from_square: BoardSquare,
+    pub to_square: BoardSquare,
+    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 {
-
-  pub fn quiet(
-    piece_type: PieceType,
-    from_square: BoardSquare,
-    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
+    pub fn quiet(
+        piece_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        promotion_piece: Option<PieceType>,
+    ) -> Self {
+        return Self::Quiet {
+            piece_type,
+            from_square,
+            to_square,
+            promotion_piece
+        };
     }
-  }
 
-  pub fn capture(
-    piece_type: PieceType,
-    from_square: BoardSquare,
-    to_square: BoardSquare,
-    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
+    pub fn capture(
+        piece_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        captured_piece: PieceType,
+        promotion_piece: Option<PieceType>,
+    ) -> Self {
+        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,
-    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
+    pub fn castle(
+        king_type: PieceType,
+        king_from: BoardSquare,
+        king_to: BoardSquare,
+        rook_type: PieceType,
+        rook_from: BoardSquare,
+        rook_to: BoardSquare,
+    ) -> Self {
+        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 promotion_piece = match bitmove.promotion_piece() {
+                    Some(piece) => Some(PieceType::from_index(piece)),
+                    None => None
+                };
+                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/movetype.rs

@@ -1,7 +1,31 @@
+use serde::Deserialize;
+use serde::Serialize;
+use super::bitboard::bitmove::BitMoveType;
 
+#[derive(Serialize, Deserialize)]
 pub enum MoveType {
-  Quiet,
-  Capture,
-  Castle,
-  EnPassant
+    Quiet,
+    Capture,
+    Castle,
+    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,15 +1,54 @@
+use serde::{Deserialize, Serialize};
 
+#[derive(Serialize, Deserialize)]
 pub enum PieceType {
-  WhitePawn,
-  WhiteKnight,
-  WhiteBishop,
-  WhiteRook,
-  WhiteQueen,
-  WhiteKing,
-  BlackPawn,
-  BlackKnight,
-  BlackBishop,
-  BlackRook,
-  BlackQueen,
-  BlackKing
+    WhitePawn,
+    WhiteKnight,
+    WhiteBishop,
+    WhiteRook,
+    WhiteQueen,
+    WhiteKing,
+    BlackPawn,
+    BlackKnight,
+    BlackBishop,
+    BlackRook,
+    BlackQueen,
+    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

@@ -14,3 +14,9 @@ url = "2.5.7"
 uuid = {version = "1.18.1", features = ["v4", "serde"] }
 anyhow = "1.0.100"
 rand = "0.9.2"
+engine = {path = "../engine/"}
+
+
+[[bin]]
+name = "client"
+path = "src/bin/client.rs"

server/src/bin/client.rs

@@ -0,0 +1,195 @@
+use futures_util::{SinkExt, StreamExt};
+use serde::{Deserialize, Serialize};
+use std::io::{self, Write};
+use tokio_tungstenite::{connect_async, tungstenite::Message};
+use url::Url;
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(tag = "type")]
+enum ClientMessage {
+    Join { username: String },
+    FindMatch,
+    Move { from: String, to: String },
+    Resign,
+    Chat { text: String },
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct ServerMessage {
+    #[serde(rename = "type")]
+    message_type: String,
+    player_id: Option<String>,
+    match_id: Option<String>,
+    opponent: Option<String>,
+    color: Option<String>,
+    reason: Option<String>,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Knightly Chess Client");
+    println!("========================");
+
+    // Get server address from user
+    print!("Enter server address [ws://127.0.0.1:9001]: ");
+    io::stdout().flush()?;
+    let mut server_addr = String::new();
+    io::stdin().read_line(&mut server_addr)?;
+    let server_addr = server_addr.trim();
+    let server_addr = if server_addr.is_empty() {
+        "ws://127.0.0.1:9001".to_string()
+    } else {
+        server_addr.to_string()
+    };
+
+    // Connect to server
+    println!("Connecting to {}...", server_addr);
+    let url = Url::parse(&server_addr)?;
+    let (ws_stream, _) = connect_async(url).await?;
+    println!("Connected to server!");
+
+    let (mut write, mut read) = ws_stream.split();
+
+    // Spawn a task to handle incoming messages
+    let read_handle = tokio::spawn(async move {
+        while let Some(message) = read.next().await {
+            match message {
+                Ok(msg) => {
+                    if msg.is_text() {
+                        let text = msg.to_text().unwrap();
+                        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);
+                                    }
+                                }
+                                _ => {
+                                    println!("cucc: {:?}", parsed);
+                                }
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Error receiving message: {}", e);
+                    break;
+                }
+            }
+        }
+    });
+
+    // Main loop for sending messages
+    println!("\nAvailable commands:");
+    println!("  join <username>    - Join the server");
+    println!("  findmatch          - Find a match");
+    println!("  move <from> <to>   - Make a move (e.g., move e2 e4)");
+    println!("  chat <message>     - Send chat message");
+    println!("  resign             - Resign from current game");
+    println!("  quit               - Exit client");
+    println!();
+
+    loop {
+        print!("➡️  Enter command: ");
+        io::stdout().flush()?;
+
+        let mut input = String::new();
+        io::stdin().read_line(&mut input)?;
+        let input = input.trim();
+
+        if input.is_empty() {
+            continue;
+        }
+
+        let parts: Vec<&str> = input.split_whitespace().collect();
+        let command = parts[0].to_lowercase();
+
+        match command.as_str() {
+            "quit" | "exit" => {
+                println!("👋 Goodbye!");
+                break;
+            }
+            "join" => {
+                if parts.len() >= 2 {
+                    let username = parts[1..].join(" ");
+                    let message = ClientMessage::Join { username };
+                    send_message(&mut write, &message).await?;
+                } else {
+                    println!("Usage: join <username>");
+                }
+            }
+            "findmatch" | "find" => {
+                let message = ClientMessage::FindMatch;
+                send_message(&mut write, &message).await?;
+                println!("🔍 Searching for a match...");
+            }
+            "move" => {
+                if parts.len() >= 3 {
+                    let from = parts[1].to_string();
+                    let to = parts[2].to_string();
+                    let message = ClientMessage::Move { from, to };
+                    send_message(&mut write, &message).await?;
+                    println!("♟️  Sent move: {} -> {}", parts[1], parts[2]);
+                } else {
+                    println!("Usage: move <from> <to> (e.g., move e2 e4)");
+                }
+            }
+            "chat" => {
+                if parts.len() >= 2 {
+                    let text = parts[1..].join(" ");
+                    let message = ClientMessage::Chat { text };
+                    send_message(&mut write, &message).await?;
+                } else {
+                    println!("Usage: chat <message>");
+                }
+            }
+            "resign" => {
+                let message = ClientMessage::Resign;
+                send_message(&mut write, &message).await?;
+                println!("Resigned from current game");
+            }
+            "help" => {
+                print_help();
+            }
+            _ => {
+                println!(
+                    "Unknown command: {}. Type 'help' for available commands.",
+                    command
+                );
+            }
+        }
+    }
+
+    // Cleanup
+    read_handle.abort();
+    Ok(())
+}
+
+async fn send_message(
+    write: &mut futures_util::stream::SplitSink<
+        tokio_tungstenite::WebSocketStream<
+            tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
+        >,
+        Message,
+    >,
+    message: &ClientMessage,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let json = serde_json::to_string(message)?;
+    write.send(Message::Text(json)).await?;
+    Ok(())
+}
+
+fn print_help() {
+    println!("\n📖 Available Commands:");
+    println!("  join <username>    - Register with a username");
+    println!("  findmatch          - Enter matchmaking queue");
+    println!("  move <from> <to>   - Make a chess move");
+    println!("  chat <message>     - Send chat to opponent");
+    println!("  resign             - Resign from current game");
+    println!("  help               - Show this help");
+    println!("  quit               - Exit the client");
+    println!();
+}

server/src/connection.rs

@@ -1,3 +1,5 @@
+use crate::connection::ClientEvent::*;
+use engine::get_available_moves;
 use futures_util::{SinkExt, StreamExt};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, VecDeque};
@@ -26,6 +28,28 @@ pub fn new_waiting_queue() -> WaitingQueue {
     Arc::new(Mutex::new(VecDeque::new()))
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Step {
+    pub from: String,
+    pub to: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(tag = "type")]
+enum ClientEvent {
+    Join { username: String },
+    FindMatch,
+    Move { from: String, to: String },
+    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,
@@ -43,12 +67,6 @@ pub struct GameMatch {
     pub move_history: Vec<String>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Step {
-    pub from: String,
-    pub to: String,
-}
-
 // Message sending utilities
 pub async fn send_message_to_player(
     connections: &ConnectionMap,
@@ -102,7 +120,6 @@ pub async fn handle_connection(
     connections: ConnectionMap,
     matches: MatchMap,
     waiting_queue: WaitingQueue,
-    event_system: crate::events::EventSystem,
 ) -> anyhow::Result<()> {
     use tokio_tungstenite::accept_async;
 
@@ -141,8 +158,52 @@ pub async fn handle_connection(
             let text = message.to_text()?;
             println!("Received from {}: {}", player_id, text);
 
-            // TODO: Parse and handle message with event system
-            // This will be implemented when we integrate the event system
+            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);
+                    }
+
+                    //respone to client
+                    let response: EventResponse = EventResponse {
+                        response: core::result::Result::Ok(()),
+                    };
+
+                    println!("response: {:?}", response);
+
+                    let _ = send_message_to_player(
+                        &connections,
+                        player_id,
+                        &serde_json::to_string(&response).unwrap(),
+                    )
+                    .await;
+                }
+                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);
+                }
+                Move { from, to } => {}
+                RequestLegalMoves { fen } => {
+                    let moves = get_available_moves(&fen);
+                    let _ = send_message_to_player(
+                        &connections,
+                        player_id,
+                        &serde_json::to_string(&moves).unwrap(),
+                    )
+                    .await;
+                    println!("Sent moves to player: {}", player_id);
+                }
+                _ => {}
+            }
         }
     }
 

server/src/events.rs

@@ -1,126 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use tokio::sync::Mutex;
-use tokio::sync::mpsc;
-use uuid::Uuid;
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Step {
-    pub from: String,
-    pub to: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(tag = "type")]
-pub enum ClientEvent {
-    Join { username: String },
-    FindMatch,
-    Move { from: String, to: String },
-    Resign,
-    Chat { text: String },
-    RequestLegalMoves { fen: String },
-}
-
-#[derive(Debug)]
-pub enum ServerEvent {
-    PlayerJoined(Uuid, String),
-    PlayerLeft(Uuid),
-    PlayerJoinedQueue(Uuid),
-    PlayerJoinedMatch(Uuid, Uuid), // player_id, match_id
-    PlayerMove(Uuid, Step),
-    PlayerResigned(Uuid),
-    MatchCreated(Uuid, Uuid, Uuid), // match_id, white_id, black_id
-}
-
-pub struct EventSystem {
-    sender: mpsc::UnboundedSender<(Uuid, ClientEvent)>,
-    receiver: Arc<Mutex<mpsc::UnboundedReceiver<(Uuid, ClientEvent)>>>,
-}
-
-impl Clone for EventSystem {
-    fn clone(&self) -> Self {
-        Self {
-            sender: self.sender.clone(),
-            receiver: Arc::clone(&self.receiver),
-        }
-    }
-}
-
-impl EventSystem {
-    pub fn new() -> Self {
-        let (sender, receiver) = mpsc::unbounded_channel();
-        Self {
-            sender,
-            receiver: Arc::new(Mutex::new(receiver)),
-        }
-    }
-
-    pub async fn send_event(
-        &self,
-        player_id: Uuid,
-        event: ClientEvent,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        self.sender.send((player_id, event))?;
-        Ok(())
-    }
-
-    pub async fn next_event(&self) -> Option<(Uuid, ClientEvent)> {
-        let mut receiver = self.receiver.lock().await;
-        receiver.recv().await
-    }
-}
-
-impl Default for EventSystem {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use uuid::Uuid;
-
-    #[tokio::test]
-    async fn test_event_system_send_and_receive() {
-        let event_system = EventSystem::new();
-        let player_id = Uuid::new_v4();
-
-        let join_event = ClientEvent::Join {
-            username: "test_user".to_string(),
-        };
-
-        let send_result = event_system.send_event(player_id, join_event).await;
-        assert!(send_result.is_ok(), "Should send event successfully");
-
-        let received = event_system.next_event().await;
-        assert!(received.is_some(), "Should receive sent event");
-
-        let (received_id, received_event) = received.unwrap();
-        assert_eq!(received_id, player_id, "Should receive correct player ID");
-
-        match received_event {
-            ClientEvent::Join { username } => {
-                assert_eq!(username, "test_user", "Should receive correct username");
-            }
-            _ => panic!("Should receive Join event"),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_event_system_clone() {
-        let event_system1 = EventSystem::new();
-        let event_system2 = event_system1.clone();
-
-        let player_id = Uuid::new_v4();
-        let event = ClientEvent::FindMatch;
-
-        event_system1.send_event(player_id, event).await.unwrap();
-
-        let received = event_system2.next_event().await;
-        assert!(
-            received.is_some(),
-            "Cloned event system should receive events"
-        );
-    }
-}

server/src/main.rs

@@ -1,6 +1,6 @@
 mod connection;
-mod events;
 mod matchmaking;
+mod messages;
 use tokio::net::TcpListener;
 
 #[tokio::main]
@@ -14,15 +14,11 @@ async fn main() -> anyhow::Result<()> {
     let matches = connection::new_match_map();
     let waiting_queue = connection::new_waiting_queue();
 
-    // Event system for communication between components
-    let event_system = events::EventSystem::new();
-
     // Start matchmaking background task
     let matchmaker = matchmaking::MatchmakingSystem::new(
         connections.clone(),
         matches.clone(),
         waiting_queue.clone(),
-        event_system.clone(),
     );
     tokio::spawn(async move {
         matchmaker.run().await;
@@ -33,17 +29,10 @@ async fn main() -> anyhow::Result<()> {
         let connections = connections.clone();
         let matches = matches.clone();
         let waiting_queue = waiting_queue.clone();
-        let event_system = event_system.clone();
 
         tokio::spawn(async move {
-            if let Err(e) = connection::handle_connection(
-                stream,
-                connections,
-                matches,
-                waiting_queue,
-                event_system,
-            )
-            .await
+            if let Err(e) =
+                connection::handle_connection(stream, connections, matches, waiting_queue).await
             {
                 eprintln!("Connection error: {}", e);
             }

server/src/matchmaking.rs

@@ -1,5 +1,4 @@
 use crate::connection::{ConnectionMap, GameMatch, MatchMap, WaitingQueue};
-use crate::events::EventSystem;
 use rand::random;
 use uuid::Uuid;
 
@@ -7,21 +6,14 @@ pub struct MatchmakingSystem {
     connections: ConnectionMap,
     matches: MatchMap,
     waiting_queue: WaitingQueue,
-    event_system: EventSystem,
 }
 
 impl MatchmakingSystem {
-    pub fn new(
-        connections: ConnectionMap,
-        matches: MatchMap,
-        waiting_queue: WaitingQueue,
-        event_system: EventSystem,
-    ) -> Self {
+    pub fn new(connections: ConnectionMap, matches: MatchMap, waiting_queue: WaitingQueue) -> Self {
         Self {
             connections,
             matches,
             waiting_queue,
-            event_system,
         }
     }
 
@@ -114,7 +106,6 @@ impl MatchmakingSystem {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::events::EventSystem;
     use uuid::Uuid;
 
     use crate::connection::new_connection_map;
@@ -126,14 +117,9 @@ mod tests {
         let connections = new_connection_map();
         let matches = new_match_map();
         let waiting_queue = new_waiting_queue();
-        let event_system = EventSystem::new();
 
-        let matchmaking = MatchmakingSystem::new(
-            connections.clone(),
-            matches.clone(),
-            waiting_queue.clone(),
-            event_system.clone(),
-        );
+        let matchmaking =
+            MatchmakingSystem::new(connections.clone(), matches.clone(), waiting_queue.clone());
 
         let player1 = Uuid::new_v4();
         let player2 = Uuid::new_v4();
@@ -172,14 +158,9 @@ mod tests {
         let connections = new_connection_map();
         let matches = new_match_map();
         let waiting_queue = new_waiting_queue();
-        let event_system = EventSystem::new();
 
-        let matchmaking = MatchmakingSystem::new(
-            connections.clone(),
-            matches.clone(),
-            waiting_queue.clone(),
-            event_system.clone(),
-        );
+        let matchmaking =
+            MatchmakingSystem::new(connections.clone(), matches.clone(), waiting_queue.clone());
 
         let player1 = Uuid::new_v4();
         {