Merge branch 'master' into UI/Settings

Fullscreen/ablakos mód, felbontás opciók hozzáadva

.github/workflows/dispatcher.yml

@@ -77,7 +77,7 @@ jobs:
 
 
   release:
-    needs: [engine, server, ui]
+    needs: test-data-upload
     if: github.ref == 'refs/heads/master'
     uses: ./.github/workflows/release.yml
     secrets: inherit
@@ -93,6 +93,3 @@ jobs:
           cd "$GITHUB_WORKSPACE"
           git clean -fdx
           git reset --hard
-
-
-

.github/workflows/release.yml

@@ -12,6 +12,9 @@ jobs:
     name: Build and release (master only)
     runs-on: self-hosted
     steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
       - name: Build Engine for Linux
         run: |
           cd $(git rev-parse --show-toplevel)
@@ -98,5 +101,3 @@ jobs:
             release/windows.zip
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-

.github/workflows/upload_data.yml

@@ -20,7 +20,7 @@ jobs:
           echo "$GOOGLE_SERVICE_ACCOUNT_JSON" > service_account.json
           
           python <<'PYCODE'
-          import gspread, json, subprocess, time
+          import gspread, json, subprocess
 
           creds = json.load(open("service_account.json"))
           gc = gspread.service_account_from_dict(creds)
@@ -38,7 +38,6 @@ 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:

Docs/kovspec.md

@@ -22,68 +22,6 @@ A vágyálom rendszer alapját egy központi szerver képezné, amely kezeli a f
 A platform célja a megbízható és folyamatos működés, akár nagyobb terhelés mellett is. A rendszer fejlesztése során kiemelt szempont lenne a biztonság (adatvédelem, csalás elleni védelem), a stabil hálózati kommunikáció, valamint a bővíthetőség – például ranglisták, versenyek vagy mobilalkalmazás későbbi integrálásának lehetősége.
 
 Összességében a vágyálom rendszer egy minden szempontból teljes értékű, közösségorientált sakkalkalmazás lenne, amely a mostani, helyi hálózaton működő változatból fejlődne tovább egy interneten keresztül bárhonnan elérhető platformmá.
-
-## 3. Igényelt funkciók
-
-### Alapok
-- Két játékos közti sakkjátszma lebonyolítása.
-- Teljes szabályrendszer megvalósítása (érvényes lépések, sakk/sakkmatt/patt felismerése).
-- Új játék indítása.
-- Játékosok nevének megadása a játszma elején.
-- Felhasználóbarát grafikus felület (UI) – látható tábla, figurák, órák, státuszjelzések.
-- Játékoslépések vizuális kiemelése (pl. kijelölt mező, lehetséges lépések megjelenítése).
-- A játék állapotának kijelzése (folyamatban, sakk, matt, döntetlen).
-  
-### LAN és hálózati funkciók
-- „Szerver indítása” funkció – a játékos hostként indíthat egy helyi szervert.
-- „Csatlakozás” funkció – másik játékos IP-cím alapján tud csatlakozni.
-- Helyi hálózaton keresztüli valós idejű kommunikáció.
-- LAN játék automatikus felfedezése (broadcast keresés).
-- Játék mentése és visszatöltése hálózati módban.
-
-### Online vágyálom funkciók
-- Felhasználói regisztráció és bejelentkezés.
-- Jelszóval védett fiókok, email- vagy OAuth-alapú hitelesítés (Google, GitHub stb.).
-- Profiloldal megtekintése (név, avatar, statisztikák, értékszám).
-- Automatikus matchmaking rendszer.
-- Kézi játékindítás – meghívó küldése barátnak.
-- Játszmák mentése és visszajátszása.
-- Játszmaelemzés – lépések listázása, hibák kiemelése.
-- Webes felület vagy mobilalkalmazás támogatása.
-- Játék előzményeinek és statisztikáinak megtekintése (győzelmek, vereségek, döntetlenek).
-- Automatikus szervermentés és adatbázis szinkronizáció.
-
-### Felhasználói felület
-- Letisztult, reszponzív, platformfüggetlen felület (asztali és webes verzió).
-- Sötét/világos téma lehetősége.
-- Egyéni figurakészlet vagy tábla kinézet választása.
-- Animált figuramozgások.
-- Egérrel és billentyűzettel is vezérelhető játék.
-- Hangjelzések a lépésekhez és az idő lejártához.
-- Lépéselőzmények (move list) megjelenítése oldalt.
-- Tábla forgatásának lehetősége (pl. a fehér vagy fekete nézőpontból).
-- Állapotjelzők (sakk, matt, döntetlen, várakozás az ellenfélre).
-- Teljes képernyős mód.
-
-### Technikai / fejlesztői funkciók
-- Kliens–szerver architektúra.
-- REST API vagy WebSocket alapú kommunikáció.
-- Adatbázis a felhasználói adatok és meccsek tárolására (pl. SQLite, PostgreSQL, MongoDB).
-- Logolási és hibakezelési rendszer.
-- Automatikus mentés és adatvisszaállítás.
-- Verziókezelés (Git).
-- Tesztelhető, moduláris kódszerkezet (külön modulok: logika, UI, hálózat, adat).
-- Cross-platform működés (Windows, Linux, esetleg web).
-
-### További funkciók
-- Egyszemélyes mód (ember vs. gép, AI-bot).
-- Több nehézségi szintű AI.
-- Oktató mód (javasolt lépések, hibák magyarázata).
-- Hivatalos FEN/PGN formátum export/import.
-- Beépített sakkfeladványok, kihívások.
-- Érintéses vezérlés mobilon.
-- Többnyelvű felület (pl. magyar, angol).
-
 ## 4. Rendszer követelmények
 
 A rendszer célja egy kétjátékos sakkalkalmazás megvalósítása, amely alapvetően hálózati kapcsolat (LAN vagy internet) segítségével biztosítja a valós idejű játékot. A rendszer kliens–szerver architektúrán alapul, ahol az egyes komponensek jól elkülönülten, meghatározott feladatokat látnak el.

engine/Cargo.toml

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

engine/src/bitboard.rs

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

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/bitmove.rs

@@ -1,77 +0,0 @@
-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/board.rs

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

engine/src/bitboard/legality.rs

@@ -1,56 +1,8 @@
 use super::board::Board;
 use super::attackmaps::RAY_TABLE;
-use super::checkinfo::CheckInfo;
-use super::attacks::get_raycast_from_square_in_direction;
 
 impl Board {
 
-  pub fn check_test(&self) -> CheckInfo {
-    let mut check_info: CheckInfo = CheckInfo::new();
-    let offset: usize = 6 * self.side_to_move as usize;
-    let king: u64 = self.bitboards[5 + offset];
-    let king_sq = king.trailing_zeros() as usize;
-    let occupancy = self.occupancy[2];
-
-    // queen-rook checks (+)
-    let attacker_mask = self.bitboards[10 - offset] | self.bitboards[9 - offset];
-
-    for dir in [0, 2, 4, 6] {
-      let threat_mask: u64 = get_raycast_from_square_in_direction(occupancy, king_sq, dir);
-      if threat_mask & attacker_mask != 0 {
-        check_info.add_checker(threat_mask);
-      }
-    }
-
-    // queen-bishop checks (x)
-    let attacker_mask = self.bitboards[10 - offset] | self.bitboards[8 - offset];
-
-    for dir in [1, 3, 5, 7] {
-      let threat_mask = get_raycast_from_square_in_direction(occupancy, king_sq, dir);
-      if threat_mask & attacker_mask != 0 {
-        check_info.add_checker(threat_mask);
-      }
-    }
-
-    // knight checks (L)
-    let attacker_mask = self.bitboards[7 - offset];
-    let threat_mask = self.get_pseudo_knight_moves(king_sq as u32);
-    let checker = threat_mask & attacker_mask;
-    if checker != 0 {
-      check_info.add_checker(checker);
-    }
-
-    // pawn checks (v)
-    let attacker_mask = self.bitboards[6 - offset];
-    let threat_mask = self.get_pseudo_pawn_captures(king_sq as u32);
-    let checker = threat_mask & attacker_mask;
-    if checker != 0 {
-      check_info.add_checker(checker);
-    }
-
-    return check_info;
-  }
-
   pub(in super) fn calc_pinned_squares(&mut self) {
     self.pinned_squares = [4; 64];
     self.pin_mask = 0u64;
@@ -93,42 +45,4 @@ 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 ----->
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-
-  #[test]
-  fn check_test_test() {
-
-    let fens = [
-      "rnb1k1nr/pppppppp/4q3/8/1b6/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",      // no check
-      "rnb1k1nr/pppppppp/4q3/8/1b1P4/8/PPP1PPPP/RNBQKBNR w KQkq d3 0 1",   // single check
-      "rnb1k1nr/ppp1p2p/3pq1p1/8/1b1P1P2/8/PPP2PPP/RNBQKBNR w KQkq - 0 1"  // double check
-      ];
-    let expected_results = [
-      CheckInfo { check_count: 0, move_mask: 0xFFFF_FFFF_FFFF_FFFF },
-      CheckInfo { check_count: 1, move_mask: 0x0000_0000_0204_0800 },
-      CheckInfo { check_count: 2, move_mask: 0x0000_0000_0000_0000 }
-    ];
-
-    for test_nr in 0..3 {
-      let fen = fens[test_nr];
-      let board =  Board::build(fen);
-      let check_test_actual = board.check_test();
-      assert_eq!(check_test_actual.check_count, expected_results[test_nr].check_count);
-      assert_eq!(check_test_actual.move_mask, expected_results[test_nr].move_mask);
-    }
-
-  }
 }

engine/src/bitboard/makemove.rs

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

engine/src/bitboard/makemove/captures.rs

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

engine/src/bitboard/makemove/castles.rs

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

engine/src/bitboard/makemove/quiets.rs

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

engine/src/bitboard/movebuffer.rs

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

@@ -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 {
+pub fn pop_lsb(value: &mut u64) -> usize {
-  let idx = value.trailing_zeros();
+  let idx = value.trailing_zeros() as usize;
   *value &= !(1 << idx);
   return idx;
 }
 
 #[inline(always)]
-pub fn pop_msb(value: &mut u64) -> u32 {
+pub fn pop_msb(value: &mut u64) -> usize {
-  let idx = 63 - value.leading_zeros();
+  let idx = 63 - value.leading_zeros() as usize;
   *value &= !(1 << idx);
   return idx;
 }
@@ -48,11 +48,6 @@ 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 ----->
 
@@ -72,7 +67,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 +87,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/boardsquare.rs

@@ -1,50 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct BoardSquare {
-    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!"
-                );
-            }
-        }
-        return Self { x: x, y: y };
-    }
-
-    pub(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(super) fn to_index(&self) -> u8 {
-        return (8 * self.y + self.x) as u8;
-    }
-}

engine/src/chessmove.rs

@@ -1,238 +0,0 @@
-use crate::bitboard::{
-    bitmove::{BitMove, BitMoveType},
-    board::Board,
-};
-
-use super::boardsquare::BoardSquare;
-use super::piecetype::PieceType;
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-/*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::Quiet {
-            piece_type,
-            from_square,
-            to_square,
-            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(
-        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(super) fn from_bitmove(bitmove: &BitMove, board: &Board) -> Self {
-        match bitmove.move_type() {
-            BitMoveType::Quiet => {
-                let from_square_index = bitmove.from_square();
-                let piece_type = PieceType::from_index(board.piece_board(from_square_index));
-                let from_square = BoardSquare::from_index(from_square_index);
-                let to_square = BoardSquare::from_index(bitmove.to_square());
-                let promotion_piece = match bitmove.promotion_piece() {
-                    Some(piece) => Some(PieceType::from_index(piece)),
-                    None => None,
-                };
-
-                return ChessMove::Quiet {
-                    piece_type,
-                    from_square,
-                    to_square,
-                    promotion_piece,
-                };
-            }
-            BitMoveType::Capture => {
-                let from_square_index = bitmove.from_square();
-                let to_square_index = bitmove.to_square();
-                let piece_type = PieceType::from_index(board.piece_board(from_square_index));
-                let from_square = BoardSquare::from_index(from_square_index);
-                let to_square = BoardSquare::from_index(to_square_index);
-                let captured_piece = PieceType::from_index(board.piece_board(to_square_index));
-                let promotion_piece = match bitmove.promotion_piece() {
-                    Some(piece) => Some(PieceType::from_index(piece)),
-                    None => None,
-                };
-
-                return ChessMove::Capture {
-                    piece_type,
-                    from_square,
-                    to_square,
-                    captured_piece,
-                    promotion_piece,
-                };
-            }
-            BitMoveType::Castle => {
-                let from_square_index = bitmove.from_square();
-                let to_square_index = bitmove.to_square();
-                let king_type = PieceType::from_index(board.piece_board(from_square_index));
-                let king_from = BoardSquare::from_index(from_square_index);
-                let king_to = BoardSquare::from_index(to_square_index);
-                let rook_type = if bitmove.from_square() < 32 {
-                    PieceType::WhiteRook
-                } else {
-                    PieceType::BlackRook
-                };
-                let rook_from_index = if bitmove.to_square() > bitmove.from_square() {
-                    bitmove.from_square() + 3
-                } else {
-                    bitmove.from_square() - 4
-                };
-                let rook_from = BoardSquare::from_index(rook_from_index);
-                let rook_to_index = if bitmove.to_square() > bitmove.from_square() {
-                    bitmove.from_square() + 1
-                } else {
-                    bitmove.from_square() - 1
-                };
-                let rook_to = BoardSquare::from_index(rook_to_index);
-
-                return ChessMove::Castle {
-                    king_type,
-                    king_from,
-                    king_to,
-                    rook_type,
-                    rook_from,
-                    rook_to,
-                };
-            }
-            BitMoveType::EnPassant => {
-                panic!("ChessMove::from_bitmove was left unimplemented");
-            }
-        }
-    }
-    pub(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;
-    }
-
-    pub fn notation(&self) -> String {
-        return self.to_bitmove().uci_notation();
-    }
-}

engine/src/gameend.rs

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

engine/src/lib.rs

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

engine/src/movetype.rs

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

link

@@ -1 +0,0 @@
-https://docs.google.com/presentation/d/16Niob9Z0Y8RPFdfZfuh8XyRbdUf83NaPepvQiLAnCIU/edit?usp=drivesdk

server/Cargo.toml

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

server/src/bin/client.rs

@@ -1,228 +0,0 @@
-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)]
-#[serde(tag = "type")]
-enum ClientMessage {
-    Join { username: String },
-    FindMatch,
-    Move { step: ChessMove, fen: String },
-    Resign,
-    Chat { text: String },
-    RequestLegalMoves { fen: 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>,
-    },
-}
-
-#[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::<ServerMessage2>(text) {
-                            match parsed {
-                                ServerMessage2::MatchFound {
-                                    match_id,
-                                    color,
-                                    opponent_name,
-                                } => {
-                                    println!(
-                                        "opponent: {}, match_id: {}, color: {}",
-                                        opponent_name, match_id, color
-                                    );
-                                }
-                                _ => {
-                                    println!("cucc");
-                                }
-                            }
-                        }
-                    }
-                }
-                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 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]);
-                } 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();
-            }
-            "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.",
-                    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!("  requestmoves       - Request the legal moves");
-    println!();
-}

server/src/connection.rs

@@ -1,10 +1,4 @@
-use crate::connection::ClientEvent::*;
-use crate::matchmaking;
-use engine::chessmove::ChessMove;
-use engine::gameend::GameEnd::{self, *};
-use engine::{get_available_moves, is_game_over};
 use futures_util::{SinkExt, StreamExt};
-use log::{error, info, warn};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
@@ -19,70 +13,19 @@ pub type ConnectionMap = Arc<Mutex<HashMap<Uuid, PlayerConnection>>>;
 pub type MatchMap = Arc<Mutex<HashMap<Uuid, GameMatch>>>;
 pub type WaitingQueue = Arc<Mutex<VecDeque<Uuid>>>;
 
-pub async fn clean_up_match(matches: &MatchMap, match_id: &Uuid) {
-    matches.lock().await.remove(&match_id);
-}
-
 // Helper functions to create new instances
 pub fn new_connection_map() -> ConnectionMap {
-    warn!("Created new connection map");
     Arc::new(Mutex::new(HashMap::new()))
 }
 
 pub fn new_match_map() -> MatchMap {
-    warn!("Created new match map");
     Arc::new(Mutex::new(HashMap::new()))
 }
 
 pub fn new_waiting_queue() -> WaitingQueue {
-    warn!("Created new waiting queue");
     Arc::new(Mutex::new(VecDeque::new()))
 }
 
-#[derive(Serialize, Deserialize)]
-pub enum ServerMessage2 {
-    GameEnd {
-        winner: GameEnd,
-    },
-    UIUpdate {
-        fen: String,
-        turn_player: String,
-        move_history: Vec<String>,
-    },
-    MatchFound {
-        match_id: Uuid,
-        color: String,
-        opponent_name: String,
-    },
-    LegalMoves {
-        moves: Vec<ChessMove>,
-    },
-    Ok {
-        response: Result<(), String>,
-    },
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(tag = "type")]
-enum ClientEvent {
-    Join {
-        username: String,
-    },
-    FindMatch,
-    Move {
-        step: ChessMove,
-        turn_player: String,
-    },
-    Resign,
-    Chat {
-        text: String,
-    },
-    RequestLegalMoves {
-        fen: String,
-    },
-    CloseConnection,
-}
-
 #[derive(Debug)]
 pub struct PlayerConnection {
     pub id: Uuid,
@@ -100,21 +43,26 @@ 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_connection(
+pub async fn send_message_to_player(
-    connection: Option<&mut PlayerConnection>,
+    connections: &ConnectionMap,
+    player_id: Uuid,
     message: &str,
-) -> Result<(), tokio_tungstenite::tungstenite::Error> {
+) -> Result<(), Box<dyn std::error::Error>> {
-    match connection {
+    let mut connections_lock = connections.lock().await;
-        Some(connection) => {
+    if let Some(connection) = connections_lock.get_mut(&player_id) {
-            info!("sending message to: {}", connection.id);
+        connection
-            connection.tx.send(Message::Text(message.to_string())).await
+            .tx
-        }
+            .send(Message::Text(message.to_string()))
-        None => {
+            .await?;
-            error!("No connection provided");
-            Err(tokio_tungstenite::tungstenite::Error::ConnectionClosed)
-        }
     }
+    Ok(())
 }
 
 pub async fn broadcast_to_all(connections: &ConnectionMap, message: &str) {
@@ -123,7 +71,7 @@ pub async fn broadcast_to_all(connections: &ConnectionMap, message: &str) {
 
     for (id, connection) in connections_lock.iter_mut() {
         if let Err(e) = connection.tx.send(Message::Text(message.to_string())).await {
-            error!("Failed to send to {}: {}", id, e);
+            eprintln!("Failed to send to {}: {}", id, e);
             dead_connections.push(*id);
         }
     }
@@ -140,19 +88,10 @@ pub async fn broadcast_to_match(
     match_id: Uuid,
     message: &str,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    info!("Broadcasting data to match: {}", &match_id);
     let matches_lock = matches.lock().await;
     if let Some(game_match) = matches_lock.get(&match_id) {
-        send_message_to_player_connection(
+        send_message_to_player(connections, game_match.player_white, message).await?;
-            connections.lock().await.get_mut(&game_match.player_white),
+        send_message_to_player(connections, game_match.player_black, message).await?;
-            message,
-        )
-        .await?;
-        send_message_to_player_connection(
-            connections.lock().await.get_mut(&game_match.player_black),
-            message,
-        )
-        .await?;
     }
     Ok(())
 }
@@ -163,12 +102,12 @@ pub async fn handle_connection(
     connections: ConnectionMap,
     matches: MatchMap,
     waiting_queue: WaitingQueue,
+    event_system: crate::events::EventSystem,
 ) -> anyhow::Result<()> {
     use tokio_tungstenite::accept_async;
 
     let ws_stream = accept_async(stream).await?;
     let (write, mut read) = ws_stream.split();
-    warn!("Accepted new connection");
 
     let player_id = Uuid::new_v4();
 
@@ -186,205 +125,30 @@ pub async fn handle_connection(
         );
     }
 
-    info!("id: {}", &player_id);
+    println!("New connection: {}", player_id);
 
-    println!("\n\n\n");
+    // Send welcome message
-    println!(
+    let _ = send_message_to_player(
-        "{:?}",
+        &connections,
-        engine::get_available_moves("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
+        player_id,
-    );
+        &format!(r#"{{"type": "welcome", "player_id": "{}"}}"#, player_id),
-    println!("\n\n\n");
+    )
+    .await;
 
     // Message processing loop
     while let Some(Ok(message)) = read.next().await {
         if message.is_text() {
             let text = message.to_text()?;
-            info!("Received from {}: {}", player_id, text);
+            println!("Received from {}: {}", player_id, text);
 
-            let client_data: ClientEvent = serde_json::from_str(text)
+            // TODO: Parse and handle message with event system
-                .expect("Failed to convert data into json at handle_connection");
+            // This will be implemented when we integrate the event system
-
-            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.clone());
-                        info!("player: {}, set username: {}", &player_id, username);
-                    }
-
-                    //respone to client
-                    let response = ServerMessage2::Ok { response: Ok(()) };
-
-                    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;
-                }
-                FindMatch => {
-                    let mut wait_queue = waiting_queue.lock().await;
-                    wait_queue.push_back(player_id.clone());
-                    info!("Appended {} to the waiting queue", player_id);
-                    info!("queue {:?}", wait_queue);
-                }
-                Move { step, turn_player } => {
-                    let match_id = connections
-                        .lock()
-                        .await
-                        .get(&player_id)
-                        .unwrap()
-                        .current_match
-                        .unwrap();
-
-                    println!("\n\nstep: {:?}\n", step);
-
-                    {
-                        info!("updating board state in match: {}", &match_id);
-                        let mut matches = matches.lock().await;
-                        matches.get_mut(&match_id).unwrap().board_state =
-                            engine::get_board_after_move(
-                                &matches.get(&match_id).unwrap().board_state,
-                                &step,
-                            );
-
-                        info!(
-                            "board after engine fn: {}",
-                            matches.get_mut(&match_id).unwrap().board_state.clone()
-                        );
-
-                        matches
-                            .get_mut(&match_id)
-                            .unwrap()
-                            .move_history
-                            .push(step.clone().notation());
-                    }
-
-                    let message = ServerMessage2::UIUpdate {
-                        fen: {
-                            let mut matches = matches.lock().await;
-                            matches.get(&match_id).unwrap().board_state.clone()
-                        },
-                        turn_player: turn_player,
-                        move_history: {
-                            let mut matches = matches.lock().await;
-                            matches.get(&match_id).unwrap().move_history.clone()
-                        },
-                    };
-
-                    let _ = broadcast_to_match(
-                        &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) => {
-                                warn!("A player won the match: {}", &match_id);
-                                let message = ServerMessage2::GameEnd { winner: res };
-                                let _ = broadcast_to_match(
-                                    &connections,
-                                    &matches,
-                                    match_id,
-                                    &serde_json::to_string(&message).unwrap(),
-                                )
-                                .await;
-                                clean_up_match(&matches, &match_id).await;
-                            }
-                            None => {
-                                info!("No winner match continues. Id: {}", &match_id);
-                            }
-                        }
-                    }
-                }
-                RequestLegalMoves { fen } => {
-                    info!("Requesting legal moves player: {}", &player_id);
-                    let moves = get_available_moves(&fen);
-                    let message = ServerMessage2::LegalMoves { moves };
-                    let _ = send_message_to_player_connection(
-                        connections.lock().await.get_mut(&player_id),
-                        &serde_json::to_string(&message).unwrap(),
-                    )
-                    .await;
-                    info!("Sent moves to player: {}", player_id);
-                }
-                Resign => {
-                    warn!("Resigned!");
-                    let (fuck, fuck_id): (ServerMessage2, &Uuid) = {
-                        let matches = matches.lock().await;
-
-                        let curr_match = matches
-                            .get(
-                                &connections
-                                    .lock()
-                                    .await
-                                    .get(&player_id)
-                                    .unwrap()
-                                    .current_match
-                                    .unwrap(),
-                            )
-                            .unwrap();
-
-                        if player_id == curr_match.player_white {
-                            (
-                                ServerMessage2::GameEnd {
-                                    winner: GameEnd::BlackWon("Resigned".to_string()),
-                                },
-                                &connections
-                                    .lock()
-                                    .await
-                                    .get(&player_id)
-                                    .unwrap()
-                                    .current_match
-                                    .unwrap(),
-                            )
-                        } else {
-                            (
-                                ServerMessage2::GameEnd {
-                                    winner: GameEnd::WhiteWon("Resigned".to_string()),
-                                },
-                                &connections
-                                    .lock()
-                                    .await
-                                    .get(&player_id)
-                                    .unwrap()
-                                    .current_match
-                                    .unwrap(),
-                            )
-                        }
-                    };
-
-                    let _ = broadcast_to_match(
-                        &connections,
-                        &matches,
-                        fuck_id.clone(),
-                        &serde_json::to_string(&fuck).unwrap(),
-                    )
-                    .await;
-                    clean_up_match(&matches, fuck_id).await;
-                }
-                CloseConnection => {
-                    warn!("Closing connection for: {}", &player_id);
-                    break;
-                }
-                _ => {
-                    warn!("Not known client event");
-                }
-            }
         }
     }
 
     // Cleanup on disconnect
     cleanup_player(player_id, &connections, &matches, &waiting_queue).await;
-    warn!("Connection {} closed", player_id);
+    println!("Connection {} closed", player_id);
 
     Ok(())
 }
@@ -401,7 +165,7 @@ async fn cleanup_player(
     // Remove from connections
     connections.lock().await.remove(&player_id);
 
-    warn!("Cleaned up player {}", player_id);
+    println!("Cleaned up player {}", player_id);
 }
 
 #[cfg(test)]
@@ -414,24 +178,8 @@ mod tests {
         let connections = new_connection_map();
         let player_id = Uuid::new_v4();
 
-        // Test 1: Pass None directly (non-existent player)
+        let result = send_message_to_player(&connections, player_id, "test message").await;
-        let result = send_message_to_player_connection(None, "test message").await;
+        assert!(result.is_ok(), "Should handle missing player gracefully");
-
-        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/events.rs

@@ -0,0 +1,126 @@
+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,28 +1,28 @@
 mod connection;
+mod events;
 mod matchmaking;
-use env_logger::Env;
-use log::{error, info};
 use tokio::net::TcpListener;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    let env = Env::default().filter_or("MY_LOG_LEVEL", "INFO");
-    env_logger::init_from_env(env);
-
     let address = "0.0.0.0:9001";
     let listener = TcpListener::bind(address).await?;
-    info!("Server running on ws://{}", address);
+    println!("Server running on ws://{}", address);
 
     // Shared state initialization using the new helper functions
     let connections = connection::new_connection_map();
     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,12 +33,19 @@ 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) =
+            if let Err(e) = connection::handle_connection(
-                connection::handle_connection(stream, connections, matches, waiting_queue).await
+                stream,
+                connections,
+                matches,
+                waiting_queue,
+                event_system,
+            )
+            .await
             {
-                error!("Connection error: {}", e);
+                eprintln!("Connection error: {}", e);
             }
         });
     }

server/src/matchmaking.rs

@@ -1,6 +1,5 @@
-use crate::connection::ServerMessage2;
 use crate::connection::{ConnectionMap, GameMatch, MatchMap, WaitingQueue};
-use log::{error, info, warn};
+use crate::events::EventSystem;
 use rand::random;
 use uuid::Uuid;
 
@@ -8,40 +7,42 @@ 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) -> Self {
+    pub fn new(
+        connections: ConnectionMap,
+        matches: MatchMap,
+        waiting_queue: WaitingQueue,
+        event_system: EventSystem,
+    ) -> Self {
         Self {
             connections,
             matches,
             waiting_queue,
+            event_system,
         }
     }
 
     pub async fn run(&self) {
         loop {
             self.try_create_match().await;
-            tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
         }
     }
 
     async fn try_create_match(&self) {
-        //info!("Checking for new matches!");
         let mut queue = self.waiting_queue.lock().await;
 
         while queue.len() >= 2 {
             let player1 = queue.pop_front().unwrap();
             let player2 = queue.pop_front().unwrap();
 
-            info!("Creating new match. Players: {}, {}", &player1, &player2);
-
             let match_id = Uuid::new_v4();
             let (white_player, black_player) = if random::<bool>() {
-                info!("player1 is white, player2 is black");
                 (player1, player2)
             } else {
-                info!("player2 is white, player1 is black");
                 (player2, player1)
             };
 
@@ -53,8 +54,6 @@ impl MatchmakingSystem {
                 move_history: Vec::new(),
             };
 
-            info!("Match id: {}", &game_match.id);
-
             // Store the match
             self.matches.lock().await.insert(match_id, game_match);
 
@@ -63,75 +62,59 @@ impl MatchmakingSystem {
                 let mut conn_map = self.connections.lock().await;
                 if let Some(player) = conn_map.get_mut(&white_player) {
                     player.current_match = Some(match_id);
-                } else {
-                    error!("Could not store match id for white player");
                 }
                 if let Some(player) = conn_map.get_mut(&black_player) {
                     player.current_match = Some(match_id);
-                    //TODO: at the end of a match delete this from player
-                } else {
-                    error!("Could not store match id for black player");
                 }
             }
 
             // Notify players
-            info!(
-                "Notifying player for a match: {:?} | {:?}",
-                white_player, black_player
-            );
             self.notify_players(white_player, black_player, match_id)
                 .await;
         }
     }
 
     async fn notify_players(&self, white: Uuid, black: Uuid, match_id: Uuid) {
-        let mut conn_map = self.connections.lock().await;
+        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");
 
         // Notify white player
         if let Some(_) = conn_map.get(&white) {
-            let message = ServerMessage2::MatchFound {
+            let message = format!(
-                match_id: match_id.clone(),
+                r#"{{"type": "match_found", "match_id": "{}", "opponent": "{}", "color": "white"}}"#,
-                color: String::from("white"),
+                match_id, black_name
-                opponent_name: conn_map
+            );
-                    .get(&white)
+            let _ =
-                    .and_then(|c| c.username.as_deref())
+                crate::connection::send_message_to_player(&self.connections, white, &message).await;
-                    .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 = ServerMessage2::MatchFound {
+            let message = format!(
-                match_id: match_id.clone(),
+                r#"{{"type": "match_found", "match_id": "{}", "opponent": "{}", "color": "black"}}"#,
-                color: String::from("black"),
+                match_id, white_name
-                opponent_name: conn_map
+            );
-                    .get(&black)
+            let _ =
-                    .and_then(|c| c.username.as_deref())
+                crate::connection::send_message_to_player(&self.connections, black, &message).await;
-                    .unwrap_or("Opponent")
-                    .to_string(),
-            };
-
-            let _ = crate::connection::send_message_to_player_connection(
-                conn_map.get_mut(&black),
-                &serde_json::to_string(&message).unwrap(),
-            )
-            .await;
         }
 
-        info!("Match created: {} (white) vs {} (black)", white, black);
+        println!("Match created: {} (white) vs {} (black)", white, black);
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::events::EventSystem;
     use uuid::Uuid;
 
     use crate::connection::new_connection_map;
@@ -143,9 +126,14 @@ 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 =
+        let matchmaking = MatchmakingSystem::new(
-            MatchmakingSystem::new(connections.clone(), matches.clone(), waiting_queue.clone());
+            connections.clone(),
+            matches.clone(),
+            waiting_queue.clone(),
+            event_system.clone(),
+        );
 
         let player1 = Uuid::new_v4();
         let player2 = Uuid::new_v4();
@@ -184,9 +172,14 @@ 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 =
+        let matchmaking = MatchmakingSystem::new(
-            MatchmakingSystem::new(connections.clone(), matches.clone(), waiting_queue.clone());
+            connections.clone(),
+            matches.clone(),
+            waiting_queue.clone(),
+            event_system.clone(),
+        );
 
         let player1 = Uuid::new_v4();
         {

server/src/messages.rs

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

ui/.cargo/config.toml

@@ -1,4 +0,0 @@
-[target.x86_64-unknown-linux-gnu]
-linker = "x86_64-linux-gnu-gcc"
-[target.x86_64-pc-windows-gnu]
-linker = "x86_64-w64-mingw32-gcc"

ui/.gitignore

@@ -1 +0,0 @@
-/target

ui/Cargo.toml

@@ -6,17 +6,5 @@ edition = "2024"
 [dependencies]
 eframe = "0.33.0"
 egui = "0.33.0"
+tokio-tungstenite = "0.28.0"
 winit = "0.30.12"
-tokio = { version = "1", features = ["full"] }
-tokio-tungstenite = "0.21"
-tungstenite = "0.21"
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-futures-util = "0.3.31"
-url = "2.5.7"
-uuid = {version = "1.18.1", features = ["v4", "serde"] }
-engine = {path = "../engine/"}
-log = {version = "0.4.28"}
-env_logger = "0.11.8"
-local-ip-address = "0.6.5"
-anyhow = "1.0.100"

ui/src/connection.rs

@@ -1,117 +0,0 @@
-use engine::{chessmove::ChessMove, gameend::GameEnd};
-use futures_util::{SinkExt, StreamExt};
-use local_ip_address::local_ip;
-use log::{error, info, warn};
-use serde::{Deserialize, Serialize};
-use std::{
-    net::{IpAddr, Ipv4Addr},
-    sync::{Arc, Mutex},
-};
-use tokio_tungstenite::connect_async;
-use tungstenite::Message;
-use url::Url;
-use uuid::Uuid;
-
-use crate::{ChessApp, ClientEvent, SharedGameState};
-
-#[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 ClientMessage {
-    Join { username: String },
-    FindMatch,
-    Move { step: ChessMove, fen: String },
-    Resign,
-    Chat { text: String },
-    RequestLegalMoves { fen: String },
-}
-
-fn get_ip_address() -> IpAddr {
-    let ip = local_ip().unwrap_or(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)));
-
-    ip
-}
-
-pub async fn handle_connection(
-    server_port: &str,
-    shared_state: SharedGameState,
-    ui_events: Arc<Mutex<Vec<ClientEvent>>>,
-) -> anyhow::Result<()> {
-    let address = get_ip_address();
-
-    //start main loop
-    let server_address = String::from("ws://") + &address.to_string() + ":" + server_port;
-    warn!(
-        "Machine IpAddress is bound for listener. Ip: {}",
-        server_address
-    );
-
-    let url = Url::parse(&server_address)?;
-
-    let (ws_stream, _) = connect_async(url).await?;
-    let (mut write, mut read) = ws_stream.split();
-
-    while let Some(message) = read.next().await {
-        info!("connection");
-        match message {
-            Ok(msg) => {
-                if msg.is_text() {
-                    let text = msg.to_text().unwrap();
-                    info!("text: {}", text);
-
-                    /*if let Ok(parsed) = serde_json::from_str::<ServerMessage2>(text) {
-                        match parsed {
-                            ServerMessage2::GameEnd { winner } => {}
-                            ServerMessage2::UIUpdate { fen } => {}
-                            ServerMessage2::MatchFound {
-                                match_id,
-                                color,
-                                opponent_name,
-                            } => {
-                                //chess_app.player_color = Some(color);
-                            }
-                            ServerMessage2::Ok { response } => {}
-                            _ => {
-                                error!("Received unkown servermessage2");
-                            }
-                        }
-                    }*/
-
-                    if let Ok(parsed) = serde_json::from_str::<ServerMessage2>(text) {
-                        // Update shared state with server message
-                        shared_state.update_from_server_message(parsed);
-                    }
-
-                    // Send UI events to server
-                    let events = ui_events.lock().unwrap().drain(..).collect::<Vec<_>>();
-                    for event in events {
-                        let message = serde_json::to_string(&event)?;
-                        write.send(Message::Text(message)).await?;
-                    }
-                }
-            }
-            Err(e) => {
-                error!("Error receiving message: {}", e);
-            }
-        }
-    }
-
-    Ok(())
-}