Board squares flipping

Server/logging

.github/workflows/upload_data.yml

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

Docs/kovspec.md

@@ -22,6 +22,68 @@ 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,3 +5,5 @@ edition = "2024"
 
 [dependencies]
 once_cell = "1.19"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"

engine/src/bitboard.rs

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

engine/src/bitboard/attackmaps.rs

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

engine/src/bitboard/attacks.rs

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

engine/src/bitboard/bitmove.rs

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

engine/src/bitboard/board.rs

@@ -64,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) {
@@ -179,4 +179,21 @@ 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}
+       _  => ()
+    }
+  }
 }

engine/src/bitboard/legality.rs

@@ -1,8 +1,56 @@
 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;
@@ -45,4 +93,42 @@ 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/movebuffer.rs

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

engine/src/bitboard/movegen.rs

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

engine/src/bitboard/movegen/bishops.rs

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

engine/src/bitboard/movegen/kings.rs

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

engine/src/bitboard/movegen/knights.rs

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

engine/src/bitboard/movegen/pawns.rs

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

engine/src/bitboard/movegen/queens.rs

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

engine/src/bitboard/movegen/rooks.rs

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

engine/src/bitboard/utils.rs

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

engine/src/boardsquare.rs

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

engine/src/chessmove.rs

@@ -1,71 +1,188 @@
-use crate::piecetype;
+use crate::{bitboard::{bitmove::{BitMove, BitMoveType}, board::Board}};
 
 use super::boardsquare::BoardSquare;
 use super::piecetype::PieceType;
-use super::movetype::MoveType;
+use serde::{Deserialize, Serialize};
 
-
-pub struct ChessMove {
-  pub move_type: MoveType,
-  pub piece_type: PieceType,
-  pub from_square: BoardSquare,
-  pub to_square: BoardSquare,
-  pub rook_from: BoardSquare,
-  pub rook_to: BoardSquare,
-  pub promotion_piece: Option<PieceType>
+#[derive(Serialize, Deserialize, Debug)]
+/*pub struct ChessMove {
+    pub move_type: MoveType,
+    pub piece_type: PieceType,
+    pub from_square: BoardSquare,
+    pub to_square: BoardSquare,
+    pub rook_from: BoardSquare,
+    pub rook_to: BoardSquare,
+    pub promotion_piece: Option<PieceType>,
+}*/
+pub enum ChessMove {
+    Quiet {
+        piece_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        promotion_piece: Option<PieceType>
+    },
+    Capture {
+        piece_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        captured_piece: PieceType,
+        promotion_piece: Option<PieceType>
+    },
+    Castle {
+        king_type: PieceType,
+        king_from: BoardSquare,
+        king_to: BoardSquare,
+        rook_type: PieceType,
+        rook_from: BoardSquare,
+        rook_to: BoardSquare
+    },
+    EnPassant {
+        pawn_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        captured_piece: PieceType,
+        captured_from: BoardSquare
+    }
 }
 
 impl ChessMove {
-
-  pub fn quiet(
-    piece_type: PieceType,
-    from_square: BoardSquare,
-    to_square: BoardSquare,
-    promotion_piece: Option<PieceType>
-  ) -> Self {
-    return Self {
-      move_type: MoveType::Quiet,
-      piece_type: piece_type,
-      from_square: from_square,
-      to_square: to_square,
-      rook_from: BoardSquare::new(),
-      rook_to: BoardSquare::new(),
-      promotion_piece: promotion_piece
+    pub fn quiet(
+        piece_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        promotion_piece: Option<PieceType>,
+    ) -> Self {
+        return Self::Quiet {
+            piece_type,
+            from_square,
+            to_square,
+            promotion_piece
+        };
     }
-  }
 
-  pub fn capture(
-    piece_type: PieceType,
-    from_square: BoardSquare,
-    to_square: BoardSquare,
-    promotion_piece: Option<PieceType>
-  ) -> Self {
-    return Self {
-      move_type: MoveType::Capture,
-      piece_type: piece_type,
-      from_square: from_square,
-      to_square: to_square,
-      rook_from: BoardSquare::new(),
-      rook_to: BoardSquare::new(),
-      promotion_piece: promotion_piece
+    pub fn capture(
+        piece_type: PieceType,
+        from_square: BoardSquare,
+        to_square: BoardSquare,
+        captured_piece: PieceType,
+        promotion_piece: Option<PieceType>,
+    ) -> Self {
+        return Self::Capture {
+            piece_type,
+            from_square,
+            to_square,
+            captured_piece,
+            promotion_piece
+        };
     }
-  }
 
-  pub fn castle(
-    piece_type: PieceType,
-    from_square: BoardSquare,
-    to_square: BoardSquare,
-    rook_from: BoardSquare,
-    rook_to: BoardSquare
-  ) -> Self {
-    return Self {
-      move_type: MoveType::Quiet,
-      piece_type: piece_type,
-      from_square: from_square,
-      to_square: to_square,
-      rook_from: rook_from,
-      rook_to: rook_to,
-      promotion_piece: None
+    pub fn castle(
+        king_type: PieceType,
+        king_from: BoardSquare,
+        king_to: BoardSquare,
+        rook_type: PieceType,
+        rook_from: BoardSquare,
+        rook_to: BoardSquare,
+    ) -> Self {
+        return Self::Castle {
+            king_type,
+            king_from,
+            king_to,
+            rook_type,
+            rook_from,
+            rook_to
+        };
+    }
+
+    pub(in super) fn from_bitmove(bitmove: &BitMove, board: &Board) -> Self {
+        match bitmove.move_type() {
+            BitMoveType::Quiet => {
+                let from_square_index = bitmove.from_square();
+                let piece_type = PieceType::from_index(board.piece_board(from_square_index));
+                let from_square = BoardSquare::from_index(from_square_index);
+                let to_square = BoardSquare::from_index(bitmove.to_square());
+                let promotion_piece = match bitmove.promotion_piece() {
+                    Some(piece) => Some(PieceType::from_index(piece)),
+                    None => None
+                };
+
+                return ChessMove::Quiet { piece_type, from_square, to_square, promotion_piece }
+            },
+            BitMoveType::Capture => {
+                let from_square_index = bitmove.from_square();
+                let to_square_index = bitmove.to_square();
+                let piece_type = PieceType::from_index(board.piece_board(from_square_index));
+                let from_square = BoardSquare::from_index(from_square_index);
+                let to_square = BoardSquare::from_index(to_square_index);
+                let captured_piece = PieceType::from_index(board.piece_board(to_square_index));
+                let promotion_piece = match bitmove.promotion_piece() {
+                    Some(piece) => Some(PieceType::from_index(piece)),
+                    None => None
+                };
+
+                return ChessMove::Capture { piece_type, from_square, to_square, captured_piece, promotion_piece }
+            },
+            BitMoveType::Castle => {
+                let from_square_index = bitmove.from_square();
+                let to_square_index = bitmove.to_square();
+                let king_type = PieceType::from_index(board.piece_board(from_square_index));
+                let king_from = BoardSquare::from_index(from_square_index);
+                let king_to = BoardSquare::from_index(to_square_index);
+                let rook_type = if bitmove.from_square() < 32 { PieceType::WhiteRook } else { PieceType::BlackRook };
+                let rook_from_index = if bitmove.to_square() > bitmove.from_square() {
+                    bitmove.from_square() + 3
+                } else {
+                    bitmove.from_square() - 4
+                };
+                let rook_from = BoardSquare::from_index(rook_from_index);
+                let rook_to_index = if bitmove.to_square() > bitmove.from_square() {
+                    bitmove.from_square() + 1
+                } else {
+                    bitmove.from_square() - 1
+                };
+                let rook_to = BoardSquare::from_index(rook_to_index);
+
+                return ChessMove::Castle { king_type, king_from, king_to, rook_type, rook_from, rook_to }
+            },
+            BitMoveType::EnPassant => {
+                panic!("ChessMove::from_bitmove was left unimplemented");
+            }
+        }
+    }
+    pub(in super) fn to_bitmove(&self) -> BitMove {
+        let bitmove = match self {
+            ChessMove::Quiet { piece_type, from_square, to_square, promotion_piece } => {
+                let promotion_piece = match promotion_piece {
+                    Some(piece) => Some(piece.to_index()),
+                    None => None
+                };
+                return BitMove::quiet(
+                    from_square.to_index(),
+                    to_square.to_index(),
+                    promotion_piece
+                );
+            },
+            ChessMove::Capture { piece_type, from_square, to_square, captured_piece, promotion_piece } => {
+                let promotion_piece = match promotion_piece {
+                    Some(piece) => Some(piece.to_index()),
+                    None => None
+                };
+                return BitMove::capture(
+                    from_square.to_index(),
+                    to_square.to_index(),
+                    promotion_piece
+                );
+            },
+            ChessMove::Castle { king_type, king_from, king_to, rook_type, rook_from, rook_to } => {
+                return BitMove::castle(
+                    king_from.to_index(),
+                    king_to.to_index()
+                );
+            },
+            ChessMove::EnPassant { pawn_type, from_square, to_square, captured_piece, captured_from } => {
+                panic!("ChessMove::to_bitmove was left unimplemented");
+            }
+        };
+        return bitmove;
     }
-  }
 }

engine/src/gameend.rs

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

engine/src/lib.rs

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

engine/src/movetype.rs

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

engine/src/piecetype.rs

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

server/Cargo.toml

@@ -14,3 +14,11 @@ 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

@@ -0,0 +1,228 @@
+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,4 +1,10 @@
+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;
@@ -13,19 +19,73 @@ pub type ConnectionMap = Arc<Mutex<HashMap<Uuid, PlayerConnection>>>;
 pub type MatchMap = Arc<Mutex<HashMap<Uuid, GameMatch>>>;
 pub type WaitingQueue = Arc<Mutex<VecDeque<Uuid>>>;
 
+pub async fn clean_up_match(matches: &MatchMap, match_id: &Uuid) {
+    matches.lock().await.remove(&match_id);
+}
+
 // Helper functions to create new instances
 pub fn new_connection_map() -> ConnectionMap {
+    warn!("Created new connection map");
     Arc::new(Mutex::new(HashMap::new()))
 }
 
 pub fn new_match_map() -> MatchMap {
+    warn!("Created new match map");
     Arc::new(Mutex::new(HashMap::new()))
 }
 
 pub fn new_waiting_queue() -> WaitingQueue {
+    warn!("Created new waiting queue");
     Arc::new(Mutex::new(VecDeque::new()))
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Step {
+    pub from: String,
+    pub to: String,
+}
+
+/*#[derive(Serialize, Deserialize, Debug)]
+struct ServerMessage {
+    #[serde(rename = "type")]
+    message_type: String,
+    player_id: Option<Uuid>,
+    match_id: Option<Uuid>,
+    opponent: Option<Uuid>,
+    color: Option<String>,
+    reason: Option<String>,
+    response: Option<String>,
+}*/
+
+#[derive(Serialize, Deserialize)]
+pub enum ServerMessage2 {
+    GameEnd {
+        winner: GameEnd,
+    },
+    UIUpdate {
+        fen: String,
+    },
+    MatchFound {
+        match_id: Uuid,
+        color: String,
+        opponent_name: String,
+    },
+    Ok {
+        response: Result<(), String>,
+    },
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(tag = "type")]
+enum ClientEvent {
+    Join { username: String },
+    FindMatch,
+    Move { step: ChessMove },
+    Resign,
+    Chat { text: String },
+    RequestLegalMoves { fen: String },
+}
+
 #[derive(Debug)]
 pub struct PlayerConnection {
     pub id: Uuid,
@@ -40,29 +100,24 @@ pub struct GameMatch {
     pub player_white: Uuid,
     pub player_black: Uuid,
     pub board_state: String,
-    pub move_history: Vec<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Step {
-    pub from: String,
-    pub to: String,
+    pub move_history: Vec<Step>,
 }
 
 // Message sending utilities
-pub async fn send_message_to_player(
-    connections: &ConnectionMap,
-    player_id: Uuid,
+pub async fn send_message_to_player_connection(
+    connection: Option<&mut PlayerConnection>,
     message: &str,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let mut connections_lock = connections.lock().await;
-    if let Some(connection) = connections_lock.get_mut(&player_id) {
-        connection
-            .tx
-            .send(Message::Text(message.to_string()))
-            .await?;
+) -> Result<(), tokio_tungstenite::tungstenite::Error> {
+    match connection {
+        Some(connection) => {
+            info!("sending message to: {}", connection.id);
+            connection.tx.send(Message::Text(message.to_string())).await
+        }
+        None => {
+            error!("No connection provided");
+            Err(tokio_tungstenite::tungstenite::Error::ConnectionClosed)
+        }
     }
-    Ok(())
 }
 
 pub async fn broadcast_to_all(connections: &ConnectionMap, message: &str) {
@@ -71,7 +126,7 @@ pub async fn broadcast_to_all(connections: &ConnectionMap, message: &str) {
 
     for (id, connection) in connections_lock.iter_mut() {
         if let Err(e) = connection.tx.send(Message::Text(message.to_string())).await {
-            eprintln!("Failed to send to {}: {}", id, e);
+            error!("Failed to send to {}: {}", id, e);
             dead_connections.push(*id);
         }
     }
@@ -88,10 +143,19 @@ pub async fn broadcast_to_match(
     match_id: Uuid,
     message: &str,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    info!("Broadcasting data to match: {}", &match_id);
     let matches_lock = matches.lock().await;
     if let Some(game_match) = matches_lock.get(&match_id) {
-        send_message_to_player(connections, game_match.player_white, message).await?;
-        send_message_to_player(connections, game_match.player_black, message).await?;
+        send_message_to_player_connection(
+            connections.lock().await.get_mut(&game_match.player_white),
+            message,
+        )
+        .await?;
+        send_message_to_player_connection(
+            connections.lock().await.get_mut(&game_match.player_black),
+            message,
+        )
+        .await?;
     }
     Ok(())
 }
@@ -102,12 +166,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();
 
@@ -125,30 +189,183 @@ pub async fn handle_connection(
         );
     }
 
-    println!("New connection: {}", player_id);
-
-    // Send welcome message
-    let _ = send_message_to_player(
-        &connections,
-        player_id,
-        &format!(r#"{{"type": "welcome", "player_id": "{}"}}"#, player_id),
-    )
-    .await;
+    info!("id: {}", &player_id);
 
     // Message processing loop
     while let Some(Ok(message)) = read.next().await {
         if message.is_text() {
             let text = message.to_text()?;
-            println!("Received from {}: {}", player_id, text);
+            info!("Received from {}: {}", player_id, text);
 
-            // TODO: Parse and handle message with event system
-            // This will be implemented when we integrate the event system
+            let client_data: ClientEvent = serde_json::from_str(text)
+                .expect("Failed to convert data into json at handle_connection");
+
+            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 } => {
+                    let match_id = connections
+                        .lock()
+                        .await
+                        .get(&player_id)
+                        .unwrap()
+                        .current_match
+                        .unwrap();
+
+                    {
+                        info!("updating board state in match: {}", &match_id);
+                        let mut matches = matches.lock().await;
+                        matches.get_mut(&match_id).unwrap().board_state =
+                            engine::get_board_after_move(
+                                &matches.get(&match_id).unwrap().board_state,
+                                &step,
+                            );
+                    }
+                    let message = ServerMessage2::UIUpdate {
+                        fen: matches
+                            .lock()
+                            .await
+                            .get(&match_id)
+                            .unwrap()
+                            .board_state
+                            .clone(),
+                    };
+
+                    let _ = broadcast_to_match(
+                        &connections,
+                        &matches,
+                        match_id,
+                        &serde_json::to_string(&message).unwrap(),
+                    )
+                    .await;
+
+                    {
+                        let is_game_end = engine::is_game_over(
+                            &matches.lock().await.get(&match_id).unwrap().board_state,
+                        );
+
+                        match is_game_end {
+                            Some(res) => {
+                                warn!("A player won the match: {}", &match_id);
+                                let message = ServerMessage2::GameEnd { winner: res };
+                                let _ = broadcast_to_match(
+                                    &connections,
+                                    &matches,
+                                    match_id,
+                                    &serde_json::to_string(&message).unwrap(),
+                                )
+                                .await;
+                                clean_up_match(&matches, &match_id);
+                            }
+                            None => {
+                                info!("No winner match continues. Id: {}", &match_id);
+                            }
+                        }
+                    }
+                }
+                RequestLegalMoves { fen } => {
+                    info!("Requesting legal moves player: {}", &player_id);
+                    let moves = get_available_moves(&fen);
+                    let _ = send_message_to_player_connection(
+                        connections.lock().await.get_mut(&player_id),
+                        &serde_json::to_string(&moves).unwrap(),
+                    )
+                    .await;
+                    info!("Sent moves to player: {}", player_id);
+                }
+                Resign => {
+                    warn!("Resigned!");
+                    let (fuck, fuck_id): (ServerMessage2, &Uuid) = {
+                        let matches = matches.lock().await;
+
+                        let curr_match = matches
+                            .get(
+                                &connections
+                                    .lock()
+                                    .await
+                                    .get(&player_id)
+                                    .unwrap()
+                                    .current_match
+                                    .unwrap(),
+                            )
+                            .unwrap();
+
+                        if player_id == curr_match.player_white {
+                            (
+                                ServerMessage2::GameEnd {
+                                    winner: GameEnd::BlackWon("Resigned".to_string()),
+                                },
+                                &connections
+                                    .lock()
+                                    .await
+                                    .get(&player_id)
+                                    .unwrap()
+                                    .current_match
+                                    .unwrap(),
+                            )
+                        } else {
+                            (
+                                ServerMessage2::GameEnd {
+                                    winner: GameEnd::WhiteWon("Resigned".to_string()),
+                                },
+                                &connections
+                                    .lock()
+                                    .await
+                                    .get(&player_id)
+                                    .unwrap()
+                                    .current_match
+                                    .unwrap(),
+                            )
+                        }
+                    };
+
+                    broadcast_to_match(
+                        &connections,
+                        &matches,
+                        connections
+                            .lock()
+                            .await
+                            .get(&player_id)
+                            .unwrap()
+                            .current_match
+                            .unwrap(),
+                        &serde_json::to_string(&fuck).unwrap(),
+                    )
+                    .await;
+                    clean_up_match(&matches, fuck_id);
+                }
+                _ => {
+                    warn!("Not known client event");
+                }
+            }
         }
     }
 
     // Cleanup on disconnect
     cleanup_player(player_id, &connections, &matches, &waiting_queue).await;
-    println!("Connection {} closed", player_id);
+    warn!("Connection {} closed", player_id);
 
     Ok(())
 }
@@ -165,7 +382,7 @@ async fn cleanup_player(
     // Remove from connections
     connections.lock().await.remove(&player_id);
 
-    println!("Cleaned up player {}", player_id);
+    warn!("Cleaned up player {}", player_id);
 }
 
 #[cfg(test)]
@@ -178,8 +395,24 @@ mod tests {
         let connections = new_connection_map();
         let player_id = Uuid::new_v4();
 
-        let result = send_message_to_player(&connections, player_id, "test message").await;
-        assert!(result.is_ok(), "Should handle missing player gracefully");
+        // Test 1: Pass None directly (non-existent player)
+        let result = send_message_to_player_connection(None, "test message").await;
+
+        assert!(result.is_err(), "Should return error for None connection");
+        println!("Test passed: Handles None connection correctly");
+
+        // Test 2: Try to get non-existent player from map
+        let mut conn = connections.lock().await;
+        let non_existent_connection = conn.get_mut(&player_id); // This will be None
+
+        let result2 =
+            send_message_to_player_connection(non_existent_connection, "test message").await;
+
+        assert!(
+            result2.is_err(),
+            "Should return error for non-existent player"
+        );
+        println!("Test passed: Handles non-existent player in map correctly");
     }
 
     #[tokio::test]

server/src/events.rs

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

server/src/main.rs

@@ -1,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?;
-    println!("Server running on ws://{}", address);
+    info!("Server running on ws://{}", address);
 
     // Shared state initialization using the new helper functions
     let connections = connection::new_connection_map();
     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,19 +33,12 @@ async fn main() -> anyhow::Result<()> {
         let connections = connections.clone();
         let matches = matches.clone();
         let waiting_queue = waiting_queue.clone();
-        let event_system = event_system.clone();
 
         tokio::spawn(async move {
-            if let Err(e) = connection::handle_connection(
-                stream,
-                connections,
-                matches,
-                waiting_queue,
-                event_system,
-            )
-            .await
+            if let Err(e) =
+                connection::handle_connection(stream, connections, matches, waiting_queue).await
             {
-                eprintln!("Connection error: {}", e);
+                error!("Connection error: {}", e);
             }
         });
     }

server/src/matchmaking.rs

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

server/src/messages.rs

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

ui/Cargo.toml

@@ -4,3 +4,19 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+eframe = "0.33.0"
+egui = "0.33.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

@@ -0,0 +1,96 @@
+use engine::{chessmove::ChessMove, gameend::GameEnd};
+use futures_util::StreamExt;
+use local_ip_address::local_ip;
+use log::{error, info, warn};
+use serde::{Deserialize, Serialize};
+use std::{
+    error::Error,
+    net::{IpAddr, Ipv4Addr},
+};
+use tokio_tungstenite::connect_async;
+use url::Url;
+use uuid::Uuid;
+
+#[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) -> 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();
+
+    let read_handle = 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,
+                            } => {}
+                            ServerMessage2::Ok { response } => {}
+                            _ => {
+                                error!("Received unkown servermessage2");
+                            }
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                error!("Error receiving message: {}", e);
+            }
+        }
+    };
+
+    Ok(())
+}

ui/src/main.rs

@@ -1,3 +1,553 @@
-fn main() {
-    println!("Hello, world!");
+use eframe::egui;
+use env_logger::Env;
+use log::{error, info, warn};
+
+use crate::connection::handle_connection;
+mod connection;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<(), eframe::Error> {
+    //set up for logging
+    let env = Env::default().filter_or("MY_LOG_LEVEL", "INFO");
+    env_logger::init_from_env(env);
+    warn!("Initialized logger");
+
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default()
+            .with_fullscreen(false)
+            .with_min_inner_size(egui::vec2(800.0, 600.0)) // Minimum width, height
+            .with_inner_size(egui::vec2(7680.0, 4320.0)), // Initial size
+        ..Default::default()
+    };
+    eframe::run_native(
+        "Knightly",
+        options,
+        Box::new(|cc| {
+            let mut fonts = egui::FontDefinitions::default();
+            fonts.font_data.insert(
+                "symbols".to_owned(),
+                egui::FontData::from_static(include_bytes!("../fonts/DejaVuSans.ttf")).into(),
+            );
+            fonts
+                .families
+                .entry(egui::FontFamily::Proportional)
+                .or_default()
+                .insert(0, "symbols".to_owned());
+            cc.egui_ctx.set_fonts(fonts);
+            Ok(Box::new(ChessApp::default()))
+        }),
+    )
+}
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+enum Piece {
+    King(char),
+    Queen(char),
+    Rook(char),
+    Bishop(char),
+    Knight(char),
+    Pawn(char),
+    Empty,
+}
+
+impl Piece {
+    fn symbol(&self) -> &'static str {
+        match self {
+            Piece::King('w') => "♚",
+            Piece::Queen('w') => "♛",
+            Piece::Rook('w') => "♜",
+            Piece::Bishop('w') => "♝",
+            Piece::Knight('w') => "♞",
+            Piece::Pawn('w') => "♟︎",
+            Piece::King('b') => "♚",
+            Piece::Queen('b') => "♛",
+            Piece::Rook('b') => "♜",
+            Piece::Bishop('b') => "♝",
+            Piece::Knight('b') => "♞",
+            Piece::Pawn('b') => "♟︎",
+            Piece::Empty => "",
+            _ => "",
+        }
+    }
+}
+
+#[derive(PartialEq, Debug)]
+enum Turn {
+    White,
+    Black,
+}
+
+enum AppState {
+    MainMenu,
+    InGame,
+    Settings,
+}
+
+struct ChessApp {
+    fullscreen: bool,
+    resolutions: Vec<(u32, u32)>,
+    selected_resolution: usize,
+    state: AppState,
+    board: [[Piece; 8]; 8],
+    selected: Option<(usize, usize)>,
+    turn: Turn,
+    pending_settings: PendingSettings,
+    server_port: String,
+}
+
+#[derive(Default)]
+struct PendingSettings {
+    fullscreen: bool,
+    selected_resolution: usize,
+    server_port: String,
+}
+
+impl Default for ChessApp {
+    fn default() -> Self {
+        Self {
+            fullscreen: true,
+            resolutions: vec![
+                (1280, 720),
+                (1600, 900),
+                (1920, 1080),
+                (2560, 1440),
+                (3840, 2160),
+                (7680, 4320),
+            ],
+            selected_resolution: 2, // Default to 1920x1080
+            state: AppState::MainMenu,
+            board: Self::starting_board(),
+            selected: None,
+            turn: Turn::White,
+            pending_settings: PendingSettings::default(),
+            server_port: "9001".to_string(), // Default port
+        }
+    }
+}
+
+impl ChessApp {
+    fn starting_board() -> [[Piece; 8]; 8] {
+        use Piece::*;
+        [
+            [
+                Rook('b'),
+                Knight('b'),
+                Bishop('b'),
+                Queen('b'),
+                King('b'),
+                Bishop('b'),
+                Knight('b'),
+                Rook('b'),
+            ],
+            [Pawn('b'); 8],
+            [Empty; 8],
+            [Empty; 8],
+            [Empty; 8],
+            [Empty; 8],
+            [Pawn('w'); 8],
+            [
+                Rook('w'),
+                Knight('w'),
+                Bishop('w'),
+                Queen('w'),
+                King('w'),
+                Bishop('w'),
+                Knight('w'),
+                Rook('w'),
+            ],
+        ]
+    }
+
+    fn handle_click(&mut self, row: usize, col: usize) {
+        if let Some((r, c)) = self.selected {
+            let piece = self.board[r][c];
+            self.board[r][c] = Piece::Empty;
+            self.board[row][col] = piece;
+            self.selected = None;
+            self.turn = if self.turn == Turn::White {
+                Turn::Black
+            } else {
+                Turn::White
+            };
+        } else {
+            if self.board[row][col] != Piece::Empty {
+                self.selected = Some((row, col));
+            }
+        }
+    }
+
+    fn apply_settings(&mut self, ctx: &egui::Context) {
+        self.fullscreen = self.pending_settings.fullscreen;
+        self.selected_resolution = self.pending_settings.selected_resolution;
+        self.server_port = self.pending_settings.server_port.clone();
+
+        if let Some(resolution) = self.resolutions.get(self.selected_resolution) {
+            ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(egui::Vec2::new(
+                resolution.0 as f32,
+                resolution.1 as f32,
+            )));
+        }
+
+        ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(self.fullscreen));
+    }
+
+    fn enter_settings(&mut self) {
+        self.pending_settings.fullscreen = self.fullscreen;
+        self.pending_settings.selected_resolution = self.selected_resolution;
+        self.pending_settings.server_port = self.server_port.clone();
+        self.state = AppState::Settings;
+    }
+}
+
+impl eframe::App for ChessApp {
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        match self.state {
+            AppState::MainMenu => {
+                egui::CentralPanel::default().show(ctx, |ui| {
+                    ui.vertical_centered(|ui| {
+                        ui.heading("♞ Knightly ♞");
+                        ui.add_space(30.0);
+
+                        if ui
+                            .add_sized([300.0, 60.0], egui::Button::new("Play"))
+                            .clicked()
+                        {
+                            let port = self.server_port.clone();
+                            info!("\nstarting connection\n");
+
+                            //create a TCPlistener with tokio and bind machine ip for connection
+                            tokio::spawn(async move {
+                                info!("tokoi");
+                                handle_connection(&port).await
+                            });
+
+                            self.state = AppState::InGame;
+                        }
+                        ui.add_space(8.0);
+
+                        if ui
+                            .add_sized([300.0, 60.0], egui::Button::new("Settings"))
+                            .clicked()
+                        {
+                            self.enter_settings();
+                        }
+                        ui.add_space(8.0);
+
+                        if ui
+                            .add_sized([300.0, 60.0], egui::Button::new("Quit"))
+                            .clicked()
+                        {
+                            std::process::exit(0);
+                        }
+                    });
+                });
+            }
+
+            AppState::Settings => {
+                egui::CentralPanel::default().show(ctx, |ui| {
+                    ui.vertical_centered(|ui| {
+                        ui.heading("Settings");
+                        ui.add_space(30.0);
+
+                        // Fullscreen toggle
+                        ui.horizontal(|ui| {
+                            ui.label("Fullscreen:");
+                            if ui
+                                .checkbox(&mut self.pending_settings.fullscreen, "")
+                                .changed()
+                            {
+                                // If enabling fullscreen, we might want to disable resolution selection
+                            }
+                        });
+                        ui.add_space(10.0);
+
+                        // Resolution dropdown
+                        ui.horizontal(|ui| {
+                            ui.label("Resolution:");
+                            egui::ComboBox::new("resolution_combo", "")
+                                .selected_text(format!(
+                                    "{}x{}",
+                                    self.resolutions[self.pending_settings.selected_resolution].0,
+                                    self.resolutions[self.pending_settings.selected_resolution].1
+                                ))
+                                .show_ui(ui, |ui| {
+                                    for (i, &(width, height)) in self.resolutions.iter().enumerate()
+                                    {
+                                        ui.selectable_value(
+                                            &mut self.pending_settings.selected_resolution,
+                                            i,
+                                            format!("{}x{}", width, height),
+                                        );
+                                    }
+                                });
+                        });
+                        ui.add_space(10.0);
+
+                        // Server port input field
+                        ui.horizontal(|ui| {
+                            ui.label("Local Server Port:");
+                            ui.add(
+                                egui::TextEdit::singleline(&mut self.pending_settings.server_port)
+                                    .desired_width(100.0)
+                                    .hint_text("9001"),
+                            );
+                        });
+                        ui.add_space(30.0);
+
+                        // Apply and Cancel buttons
+                        ui.horizontal(|ui| {
+                            if ui
+                                .add_sized([140.0, 40.0], egui::Button::new("Apply"))
+                                .clicked()
+                            {
+                                self.apply_settings(ctx);
+                                self.state = AppState::MainMenu;
+                            }
+
+                            if ui
+                                .add_sized([140.0, 40.0], egui::Button::new("Cancel"))
+                                .clicked()
+                            {
+                                self.state = AppState::MainMenu;
+                            }
+                        });
+                    });
+                });
+            }
+
+            AppState::InGame => {
+                egui::TopBottomPanel::top("menu_bar").show(ctx, |ui| {
+                    ui.horizontal(|ui| {
+                        if ui.button("Main Menu").clicked() {
+                            self.state = AppState::MainMenu;
+                        }
+                        if ui.button("Settings").clicked() {
+                            self.enter_settings();
+                        }
+                        if ui.button("New Game").clicked() {
+                            *self = ChessApp::default();
+                            self.state = AppState::InGame;
+                        }
+                        ui.separator();
+                        ui.label(format!("Turn: {:?}", self.turn));
+                    });
+                });
+
+                egui::CentralPanel::default().show(ctx, |ui| {
+                    ui.vertical_centered(|ui| {
+                        let full_avail = ui.available_rect_before_wrap();
+                        let board_tile = (full_avail.width().min(full_avail.height())) / 8.0;
+                        let board_size = board_tile * 8.0;
+
+                        // Create a child UI at the board position
+                        let (response, painter) = ui.allocate_painter(
+                            egui::Vec2::new(board_size, board_size),
+                            egui::Sense::click(),
+                        );
+
+                        let board_rect = egui::Rect::from_center_size(
+                            full_avail.center(),
+                            egui::vec2(board_size, board_size),
+                        );
+
+                        // Draw the chess board
+                        let player = "black";
+                        if player =="white"{
+                        let tile_size = board_size / 8.0;
+                        for row in 0..8 {
+                            for col in 0..8 {
+                                let color = if (row + col) % 2 == 0 {
+                                    egui::Color32::from_rgb(217, 217, 217)
+                                } else {
+                                    egui::Color32::from_rgb(100, 97, 97)
+                                };
+
+                                let rect = egui::Rect::from_min_size(
+                                    egui::Pos2::new(
+                                        board_rect.min.x + col as f32 * tile_size,
+                                        board_rect.min.y + row as f32 * tile_size,
+                                    ),
+                                    egui::Vec2::new(tile_size, tile_size),
+                                );
+
+                                painter.rect_filled(rect, 0.0, color);
+
+                                // Draw piece
+                                let piece = self.board[row][col];
+                                if piece != Piece::Empty {
+                                    let symbol = piece.symbol();
+                                    let font_id = egui::FontId::proportional(tile_size * 0.75);
+                                    painter.text(
+                                        rect.center(),
+                                        egui::Align2::CENTER_CENTER,
+                                        symbol,
+                                        font_id,
+                                        if matches!(
+                                            piece,
+                                            Piece::King('w')
+                                                | Piece::Queen('w')
+                                                | Piece::Rook('w')
+                                                | Piece::Bishop('w')
+                                                | Piece::Knight('w')
+                                                | Piece::Pawn('w')
+                                        ) {
+                                            egui::Color32::WHITE
+                                        } else {
+                                            egui::Color32::BLACK
+                                        },
+                                    );
+                                }
+
+                                // Draw selection highlight
+                                if self.selected == Some((row, col)) {
+                                    painter.rect_stroke(
+                                        rect,
+                                        0.0,
+                                        egui::Stroke::new(3.0, egui::Color32::RED),
+                                        egui::StrokeKind::Inside,
+                                    );
+                                }
+
+                                // Handle clicks
+                                if ui.ctx().input(|i| i.pointer.primary_clicked()) {
+                                    let click_pos =
+                                        ui.ctx().input(|i| i.pointer.interact_pos()).unwrap();
+                                    if rect.contains(click_pos) {
+                                        self.handle_click(row, col);
+                                    }
+                                }
+                            }
+                        }
+                        }
+                        if player=="black"{
+                        {
+                        let tile_size = board_size / 8.0;
+                        for row in 0..8 {
+                            for col in 0..8 {
+                                let color = if (row + col) % 2 == 0 {
+                                    egui::Color32::from_rgb(217, 217, 217)
+                                } else {
+                                    egui::Color32::from_rgb(100, 97, 97)
+                                };
+
+                                let rect = egui::Rect::from_min_size(
+                                    egui::Pos2::new(
+                                        board_rect.min.x + col as f32 * tile_size,
+                                        board_rect.min.y + row as f32 * tile_size,
+                                    ),
+                                    egui::Vec2::new(tile_size, tile_size),
+                                );
+
+                                painter.rect_filled(rect, 0.0, color);
+
+                                // Draw piece
+                                let piece = self.board[row][col];
+                                if piece != Piece::Empty {
+                                    let symbol = piece.symbol();
+                                    let font_id = egui::FontId::proportional(tile_size * 0.75);
+                                    painter.text(
+                                        rect.center(),
+                                        egui::Align2::CENTER_CENTER,
+                                        symbol,
+                                        font_id,
+                                        if matches!(
+                                            piece,
+                                            Piece::King('w')
+                                                | Piece::Queen('w')
+                                                | Piece::Rook('w')
+                                                | Piece::Bishop('w')
+                                                | Piece::Knight('w')
+                                                | Piece::Pawn('w')
+                                        ) {
+                                            egui::Color32::BLACK
+                                        } else {
+                                            egui::Color32::WHITE
+                                        },
+                                    );
+                                }
+
+                                // Draw selection highlight
+                                if self.selected == Some((row, col)) {
+                                    painter.rect_stroke(
+                                        rect,
+                                        0.0,
+                                        egui::Stroke::new(3.0, egui::Color32::RED),
+                                        egui::StrokeKind::Inside,
+                                    );
+                                }
+
+                                // Handle clicks
+                                if ui.ctx().input(|i| i.pointer.primary_clicked()) {
+                                    let click_pos =
+                                        ui.ctx().input(|i| i.pointer.interact_pos()).unwrap();
+                                    if rect.contains(click_pos) {
+                                        self.handle_click(row, col);
+                                    }
+                                }
+                            }
+                        }
+                        }
+                        }
+                        
+
+                    });
+                });
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_initial_board_setup() {
+        let app = ChessApp::default();
+        assert!(matches!(app.board[0][0], Piece::Rook('b')));
+        assert!(matches!(app.board[7][0], Piece::Rook('w')));
+
+        assert!(matches!(app.board[1][0], Piece::Pawn('b')));
+        assert!(matches!(app.board[6][0], Piece::Pawn('w')));
+    }
+
+    #[test]
+    fn test_piece_symbols() {
+        assert_eq!(Piece::King('w').symbol(), "♔");
+        assert_eq!(Piece::King('b').symbol(), "♚");
+        assert_eq!(Piece::Empty.symbol(), "");
+    }
+
+    #[test]
+    fn test_piece_selection() {
+        let mut app = ChessApp::default();
+        app.handle_click(6, 0);
+        assert_eq!(app.selected, Some((6, 0)));
+        app.handle_click(6, 0);
+        assert_eq!(app.selected, None);
+    }
+
+    #[test]
+    fn test_piece_movement() {
+        let mut app = ChessApp::default();
+        // Select and move a piece
+        app.handle_click(6, 0); // Select white pawn
+        app.handle_click(5, 0); // Move to empty square
+        assert_eq!(app.board[6][0], Piece::Empty);
+        assert!(matches!(app.board[5][0], Piece::Pawn('w')));
+    }
+
+    #[test]
+    fn test_turn_switching() {
+        let mut app = ChessApp::default();
+        assert_eq!(app.turn, Turn::White);
+        app.handle_click(6, 0); // White selects
+        app.handle_click(5, 0); // White moves
+        assert_eq!(app.turn, Turn::Black); // Should now be Black's turn
+    }
+
+    #[test]
+    fn test_server_port_default() {
+        let app = ChessApp::default();
+        assert_eq!(app.server_port, "8080");
+    }
 }