Board squares flipping

Server/logging

engine/src/bitboard.rs

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

engine/src/boardsquare.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct BoardSquare {
     pub x: usize,
     pub y: usize,

engine/src/chessmove.rs

@@ -4,7 +4,7 @@ use super::boardsquare::BoardSquare;
 use super::piecetype::PieceType;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 /*pub struct ChessMove {
     pub move_type: MoveType,
     pub piece_type: PieceType,
@@ -94,7 +94,7 @@ impl ChessMove {
         };
     }
 
-    pub(in super) fn from_bitmove(bitmove: &BitMove, board: Board) -> Self {
+    pub(in super) fn from_bitmove(bitmove: &BitMove, board: &Board) -> Self {
         match bitmove.move_type() {
             BitMoveType::Quiet => {
                 let from_square_index = bitmove.from_square();
@@ -128,10 +128,6 @@ impl ChessMove {
                 let king_type = PieceType::from_index(board.piece_board(from_square_index));
                 let king_from = BoardSquare::from_index(from_square_index);
                 let king_to = BoardSquare::from_index(to_square_index);
-                let promotion_piece = match bitmove.promotion_piece() {
-                    Some(piece) => Some(PieceType::from_index(piece)),
-                    None => None
-                };
                 let rook_type = if bitmove.from_square() < 32 { PieceType::WhiteRook } else { PieceType::BlackRook };
                 let rook_from_index = if bitmove.to_square() > bitmove.from_square() {
                     bitmove.from_square() + 3

engine/src/gameend.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Debug)]
 pub enum GameEnd {
     WhiteWon(String),
     BlackWon(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");
+  let mut board = Board::build(fen);
-  return vec![];
+  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/piecetype.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub enum PieceType {
     WhitePawn,
     WhiteKnight,

server/src/bin/client.rs

@@ -7,12 +7,6 @@ use tokio_tungstenite::{connect_async, tungstenite::Message};
 use url::Url;
 use uuid::Uuid;
 
-#[derive(Serialize, Deserialize, Debug)]
-struct Step {
-    from: String,
-    to: String,
-}
-
 #[derive(Serialize, Deserialize)]
 #[serde(tag = "type")]
 enum ClientMessage {
@@ -24,17 +18,6 @@ enum ClientMessage {
     RequestLegalMoves { fen: String },
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-struct ServerMessage {
-    #[serde(rename = "type")]
-    message_type: String,
-    player_id: Option<String>,
-    match_id: Option<String>,
-    opponent: Option<String>,
-    color: Option<String>,
-    reason: Option<String>,
-}
-
 #[derive(Serialize, Deserialize)]
 pub enum ServerMessage2 {
     GameEnd {
@@ -48,6 +31,9 @@ pub enum ServerMessage2 {
         color: String,
         opponent_name: String,
     },
+    Ok {
+        response: Result<(), String>,
+    },
 }
 
 #[tokio::main]

server/src/connection.rs

@@ -6,7 +6,6 @@ use engine::{get_available_moves, is_game_over};
 use futures_util::{SinkExt, StreamExt};
 use log::{error, info, warn};
 use serde::{Deserialize, Serialize};
-use std::char::from_u32_unchecked;
 use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
 use tokio::net::TcpStream;

server/src/main.rs

@@ -1,8 +1,7 @@
 mod connection;
 mod matchmaking;
-use env_logger::{Env, Logger};
+use env_logger::Env;
-use log::{error, info, warn};
+use log::{error, info};
-use std::env;
 use tokio::net::TcpListener;
 
 #[tokio::main]

server/src/matchmaking.rs

@@ -26,12 +26,8 @@ impl MatchmakingSystem {
         }
     }
 
-    pub async fn clean_up(&self, match_id: Uuid) {
-        self.matches.lock().await.remove(&match_id);
-    }
-
     async fn try_create_match(&self) {
-        info!("Checking for new matches!");
+        //info!("Checking for new matches!");
         let mut queue = self.waiting_queue.lock().await;
 
         while queue.len() >= 2 {
@@ -72,6 +68,7 @@ impl MatchmakingSystem {
                 }
                 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");
                 }

ui/Cargo.toml

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

ui/src/connection.rs

@@ -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,31 +1,42 @@
 use eframe::egui;
+use env_logger::Env;
+use log::{error, info, warn};
 
-fn main() -> eframe::Result<()> {
+use crate::connection::handle_connection;
-    let options = eframe::NativeOptions{
+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(true)
+            .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",
+        "Knightly",
-    options,
+        options,
-    Box::new(|cc| {
+        Box::new(|cc| {
-        let mut fonts = egui::FontDefinitions::default();
+            let mut fonts = egui::FontDefinitions::default();
-        fonts.font_data.insert(
+            fonts.font_data.insert(
-            "symbols".to_owned(),
+                "symbols".to_owned(),
-            egui::FontData::from_static(include_bytes!("../fonts/DejaVuSans.ttf")).into(),
+                egui::FontData::from_static(include_bytes!("../fonts/DejaVuSans.ttf")).into(),
-        );
+            );
-        fonts
+            fonts
-            .families
+                .families
-            .entry(egui::FontFamily::Proportional)
+                .entry(egui::FontFamily::Proportional)
-            .or_default()
+                .or_default()
-            .insert(0, "symbols".to_owned());
+                .insert(0, "symbols".to_owned());
-        cc.egui_ctx.set_fonts(fonts);
+            cc.egui_ctx.set_fonts(fonts);
-        Ok(Box::new(ChessApp::default()))
+            Ok(Box::new(ChessApp::default()))
-    }),
+        }),
-)
+    )
 }
 
 #[derive(Clone, Copy, PartialEq, Debug)]
@@ -42,12 +53,12 @@ enum Piece {
 impl Piece {
     fn symbol(&self) -> &'static str {
         match self {
-            Piece::King('w') => "♔",
+            Piece::King('w') => "♚",
-            Piece::Queen('w') => "♕",
+            Piece::Queen('w') => "♛",
-            Piece::Rook('w') => "♖",
+            Piece::Rook('w') => "♜",
-            Piece::Bishop('w') => "♗",
+            Piece::Bishop('w') => "♝",
-            Piece::Knight('w') => "♘",
+            Piece::Knight('w') => "♞",
-            Piece::Pawn('w') => "♙",
+            Piece::Pawn('w') => "♟︎",
             Piece::King('b') => "♚",
             Piece::Queen('b') => "♛",
             Piece::Rook('b') => "♜",
@@ -109,7 +120,7 @@ impl Default for ChessApp {
             selected: None,
             turn: Turn::White,
             pending_settings: PendingSettings::default(),
-            server_port: "8080".to_string(), // Default port
+            server_port: "9001".to_string(), // Default port
         }
     }
 }
@@ -169,13 +180,14 @@ impl ChessApp {
         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(
+            ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(egui::Vec2::new(
-                egui::Vec2::new(resolution.0 as f32, resolution.1 as f32)
+                resolution.0 as f32,
-            ));
+                resolution.1 as f32,
+            )));
         }
-        
+
         ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(self.fullscreen));
     }
 
@@ -196,16 +208,31 @@ impl eframe::App for ChessApp {
                         ui.heading("♞ Knightly ♞");
                         ui.add_space(30.0);
 
-                        if ui.add_sized([300.0, 60.0], egui::Button::new("Play")).clicked() {
+                        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() {
+                        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()
@@ -225,7 +252,10 @@ impl eframe::App for ChessApp {
                         // Fullscreen toggle
                         ui.horizontal(|ui| {
                             ui.label("Fullscreen:");
-                            if ui.checkbox(&mut self.pending_settings.fullscreen, "").changed() {
+                            if ui
+                                .checkbox(&mut self.pending_settings.fullscreen, "")
+                                .changed()
+                            {
                                 // If enabling fullscreen, we might want to disable resolution selection
                             }
                         });
@@ -241,7 +271,8 @@ impl eframe::App for ChessApp {
                                     self.resolutions[self.pending_settings.selected_resolution].1
                                 ))
                                 .show_ui(ui, |ui| {
-                                    for (i, &(width, height)) in self.resolutions.iter().enumerate() {
+                                    for (i, &(width, height)) in self.resolutions.iter().enumerate()
+                                    {
                                         ui.selectable_value(
                                             &mut self.pending_settings.selected_resolution,
                                             i,
@@ -255,20 +286,28 @@ impl eframe::App for ChessApp {
                         // Server port input field
                         ui.horizontal(|ui| {
                             ui.label("Local Server Port:");
-                            ui.add(egui::TextEdit::singleline(&mut self.pending_settings.server_port)
+                            ui.add(
-                                .desired_width(100.0)
+                                egui::TextEdit::singleline(&mut self.pending_settings.server_port)
-                                .hint_text("8080"));
+                                    .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() {
+                            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() {
+                            if ui
+                                .add_sized([140.0, 40.0], egui::Button::new("Cancel"))
+                                .clicked()
+                            {
                                 self.state = AppState::MainMenu;
                             }
                         });
@@ -293,44 +332,46 @@ impl eframe::App for ChessApp {
                         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()
+                            egui::Sense::click(),
                         );
-                        
+
                         let board_rect = egui::Rect::from_center_size(
                             full_avail.center(),
-                            egui::vec2(board_size, board_size)
+                            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(100, 97, 97)
-                                } else {
                                     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
+                                        board_rect.min.y + row as f32 * tile_size,
                                     ),
-                                    egui::Vec2::new(tile_size, 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 {
@@ -341,33 +382,114 @@ impl eframe::App for ChessApp {
                                         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')) {
+                                        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, 
+                                        rect,
-                                        0.0, 
+                                        0.0,
                                         egui::Stroke::new(3.0, egui::Color32::RED),
-                                        egui::StrokeKind::Inside
+                                        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();
+                                    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);
+                                    }
+                                }
+                            }
+                        }
+                        }
+                        }
+                        
+
                     });
                 });
             }
@@ -387,14 +509,14 @@ mod tests {
         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();
@@ -403,7 +525,7 @@ mod tests {
         app.handle_click(6, 0);
         assert_eq!(app.selected, None);
     }
-    
+
     #[test]
     fn test_piece_movement() {
         let mut app = ChessApp::default();
@@ -422,7 +544,7 @@ mod tests {
         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();