added resign event and deleting finished matches

engine/src/bitboard.rs

@@ -5,6 +5,5 @@ mod checkinfo;
 mod attacks;
 mod bitmove;
 mod movebuffer;
-mod movegen;
 
 pub mod board;

engine/src/bitboard/attackmaps.rs

@@ -94,64 +94,6 @@ 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,8 +5,6 @@ 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;
@@ -73,111 +71,6 @@ 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/legality.rs

@@ -93,13 +93,6 @@ 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/movegen.rs

@@ -1,67 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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) -> u32 {
-  let idx = value.trailing_zeros();
+pub fn pop_lsb(value: &mut u64) -> usize {
+  let idx = value.trailing_zeros() as usize;
   *value &= !(1 << idx);
   return idx;
 }
 
 #[inline(always)]
-pub fn pop_msb(value: &mut u64) -> u32 {
-  let idx = 63 - value.leading_zeros();
+pub fn pop_msb(value: &mut u64) -> usize {
+  let idx = 63 - value.leading_zeros() as usize;
   *value &= !(1 << idx);
   return idx;
 }
@@ -72,7 +72,7 @@ mod tests {
       0xBEAC_DBE0_903A_AC00,
       0x01E8_C895_A6F0_0000
     ];
-    let expected_values: [u32; 6] = [63, 0, 4, 2, 10, 20];
+    let expected_values: [usize; 6] = [63, 0, 4, 2, 10, 20];
 
     // tests
     for index in 0..6 {
@@ -92,7 +92,7 @@ mod tests {
       0x0000_C1C3_201C_0DB1,
       0x0000_0203_0DE4_E944
     ];
-    let expected_values: [u32; 6] = [63, 0, 61, 57, 47, 41];
+    let expected_values: [usize; 6] = [63, 0, 61, 57, 47, 41];
 
     // tests
     for index in 0..6 {

engine/src/gameend.rs

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

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,11 @@
 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 serde::{Deserialize, Serialize};
+use std::char::from_u32_unchecked;
 use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
 use tokio::net::TcpStream;
@@ -15,6 +19,10 @@ 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 {
     Arc::new(Mutex::new(HashMap::new()))
@@ -28,28 +36,53 @@ pub fn new_waiting_queue() -> WaitingQueue {
     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 +97,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) => {
+            println!("sending message to: {}", connection.id);
+            connection.tx.send(Message::Text(message.to_string())).await
+        }
+        None => {
+            eprintln!("No connection provided");
+            Err(tokio_tungstenite::tungstenite::Error::ConnectionClosed)
+        }
     }
-    Ok(())
 }
 
 pub async fn broadcast_to_all(connections: &ConnectionMap, message: &str) {
@@ -108,8 +142,16 @@ pub async fn broadcast_to_match(
 ) -> Result<(), Box<dyn std::error::Error>> {
     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(())
 }
@@ -144,14 +186,6 @@ 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;
-
     // Message processing loop
     while let Some(Ok(message)) = read.next().await {
         if message.is_text() {
@@ -161,8 +195,6 @@ pub async fn handle_connection(
             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 } => {
                     {
@@ -172,15 +204,11 @@ pub async fn handle_connection(
                     }
 
                     //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;
@@ -191,18 +219,136 @@ pub async fn handle_connection(
                     println!("Appended {} to the waiting queue", player_id);
                     println!("queue {:?}", wait_queue);
                 }
-                Move { from, to } => {}
+                Move { step } => {
+                    let match_id = connections
+                        .lock()
+                        .await
+                        .get(&player_id)
+                        .unwrap()
+                        .current_match
+                        .unwrap();
+
+                    {
+                        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,
+                        &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) => {
+                                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 => {
+                                println!("No winner match continues.")
+                            }
+                        }
+                    }
+                }
                 RequestLegalMoves { fen } => {
                     let moves = get_available_moves(&fen);
-                    let _ = send_message_to_player(
-                        &connections,
-                        player_id,
+                    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);
                 }
-                _ => {}
+                Resign => {
+                    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);
+                }
+                _ => {
+                    println!("Not known client event");
+                }
             }
         }
     }
@@ -239,8 +385,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,6 +1,5 @@
 mod connection;
 mod matchmaking;
-mod messages;
 use tokio::net::TcpListener;
 
 #[tokio::main]

server/src/matchmaking.rs

@@ -1,3 +1,4 @@
+use crate::connection::ServerMessage2;
 use crate::connection::{ConnectionMap, GameMatch, MatchMap, WaitingQueue};
 use rand::random;
 use uuid::Uuid;
@@ -20,10 +21,14 @@ 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) {
         let mut queue = self.waiting_queue.lock().await;
 
@@ -61,42 +66,54 @@ impl MatchmakingSystem {
             }
 
             // Notify players
+            println!(
+                "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);

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,
-    },
-}