added resign event and deleting finished matches

engine/src/gameend.rs

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

server/src/bin/client.rs

@@ -1,17 +1,27 @@
+use engine::gameend::GameEnd;
+use engine::{boardsquare::BoardSquare, chessmove::ChessMove, piecetype::PieceType};
 use futures_util::{SinkExt, StreamExt};
 use serde::{Deserialize, Serialize};
 use std::io::{self, Write};
 use tokio_tungstenite::{connect_async, tungstenite::Message};
 use url::Url;
+use uuid::Uuid;
 
 #[derive(Serialize, Deserialize, Debug)]
+struct Step {
+    from: String,
+    to: String,
+}
+
+#[derive(Serialize, Deserialize)]
 #[serde(tag = "type")]
 enum ClientMessage {
     Join { username: String },
     FindMatch,
-    Move { from: String, to: String },
+    Move { step: ChessMove, fen: String },
     Resign,
     Chat { text: String },
+    RequestLegalMoves { fen: String },
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -25,6 +35,21 @@ struct ServerMessage {
     reason: Option<String>,
 }
 
+#[derive(Serialize, Deserialize)]
+pub enum ServerMessage2 {
+    GameEnd {
+        winner: GameEnd,
+    },
+    UIUpdate {
+        fen: String,
+    },
+    MatchFound {
+        match_id: Uuid,
+        color: String,
+        opponent_name: String,
+    },
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Knightly Chess Client");
@@ -60,15 +85,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                         println!("\nServer: {}", text);
 
                         // Try to parse as structured message
-                        if let Ok(parsed) = serde_json::from_str::<ServerMessage>(text) {
+                        if let Ok(parsed) = serde_json::from_str::<ServerMessage2>(text) {
-                            match parsed.message_type.as_str() {
+                            match parsed {
-                                "welcome" => {
+                                ServerMessage2::MatchFound {
-                                    if let Some(player_id) = parsed.player_id {
+                                    match_id,
-                                        println!("Welcome! Your player ID: {}", player_id);
+                                    color,
-                                    }
+                                    opponent_name,
+                                } => {
+                                    println!(
+                                        "opponent: {}, match_id: {}, color: {}",
+                                        opponent_name, match_id, color
+                                    );
                                 }
                                 _ => {
-                                    println!("cucc: {:?}", parsed);
+                                    println!("cucc");
                                 }
                             }
                         }
@@ -128,11 +158,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             }
             "move" => {
                 if parts.len() >= 3 {
-                    let from = parts[1].to_string();
+                    //let from = parts[1].to_string();
-                    let to = parts[2].to_string();
+                    //let to = parts[2].to_string();
-                    let message = ClientMessage::Move { from, to };
+                    let fen = parts[1].to_string();
+
+                    let step = ChessMove::quiet(
+                        engine::piecetype::PieceType::WhiteBishop,
+                        BoardSquare::new(),
+                        BoardSquare { x: 1, y: 1 },
+                        None,
+                    );
+
+                    let message = ClientMessage::Move { step, fen };
                     send_message(&mut write, &message).await?;
-                    println!("♟️  Sent move: {} -> {}", parts[1], parts[2]);
+                    //println!("♟️  Sent move: {} -> {}", parts[1], parts[2]);
                 } else {
                     println!("Usage: move <from> <to> (e.g., move e2 e4)");
                 }
@@ -154,6 +193,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "help" => {
                 print_help();
             }
+            "requestmoves" => {
+                if parts.len() >= 2 {
+                    let fen = parts[1..].join(" ");
+                    let message = ClientMessage::RequestLegalMoves { fen };
+                    send_message(&mut write, &message).await?;
+                }
+            }
             _ => {
                 println!(
                     "Unknown command: {}. Type 'help' for available commands.",
@@ -191,5 +237,6 @@ fn print_help() {
     println!("  resign             - Resign from current game");
     println!("  help               - Show this help");
     println!("  quit               - Exit the client");
+    println!("  requestmoves       - Request the legal moves");
     println!();
 }

server/src/connection.rs

@@ -1,7 +1,11 @@
 use crate::connection::ClientEvent::*;
-use engine::get_available_moves;
+use crate::matchmaking;
+use engine::chessmove::ChessMove;
+use engine::gameend::GameEnd::{self, *};
+use engine::{get_available_moves, is_game_over};
 use futures_util::{SinkExt, StreamExt};
 use serde::{Deserialize, Serialize};
+use std::char::from_u32_unchecked;
 use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
 use tokio::net::TcpStream;
@@ -15,6 +19,10 @@ pub type ConnectionMap = Arc<Mutex<HashMap<Uuid, PlayerConnection>>>;
 pub type MatchMap = Arc<Mutex<HashMap<Uuid, GameMatch>>>;
 pub type WaitingQueue = Arc<Mutex<VecDeque<Uuid>>>;
 
+pub async fn clean_up_match(matches: &MatchMap, match_id: &Uuid) {
+    matches.lock().await.remove(&match_id);
+}
+
 // Helper functions to create new instances
 pub fn new_connection_map() -> ConnectionMap {
     Arc::new(Mutex::new(HashMap::new()))
@@ -28,28 +36,53 @@ pub fn new_waiting_queue() -> WaitingQueue {
     Arc::new(Mutex::new(VecDeque::new()))
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Step {
     pub from: String,
     pub to: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+/*#[derive(Serialize, Deserialize, Debug)]
+struct ServerMessage {
+    #[serde(rename = "type")]
+    message_type: String,
+    player_id: Option<Uuid>,
+    match_id: Option<Uuid>,
+    opponent: Option<Uuid>,
+    color: Option<String>,
+    reason: Option<String>,
+    response: Option<String>,
+}*/
+
+#[derive(Serialize, Deserialize)]
+pub enum ServerMessage2 {
+    GameEnd {
+        winner: GameEnd,
+    },
+    UIUpdate {
+        fen: String,
+    },
+    MatchFound {
+        match_id: Uuid,
+        color: String,
+        opponent_name: String,
+    },
+    Ok {
+        response: Result<(), String>,
+    },
+}
+
+#[derive(Serialize, Deserialize)]
 #[serde(tag = "type")]
 enum ClientEvent {
     Join { username: String },
     FindMatch,
-    Move { from: String, to: String },
+    Move { step: ChessMove },
     Resign,
     Chat { text: String },
     RequestLegalMoves { fen: String },
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct EventResponse {
-    pub response: Result<(), String>,
-}
-
 #[derive(Debug)]
 pub struct PlayerConnection {
     pub id: Uuid,
@@ -64,23 +97,24 @@ pub struct GameMatch {
     pub player_white: Uuid,
     pub player_black: Uuid,
     pub board_state: String,
-    pub move_history: Vec<String>,
+    pub move_history: Vec<Step>,
 }
 
 // Message sending utilities
-pub async fn send_message_to_player(
+pub async fn send_message_to_player_connection(
-    connections: &ConnectionMap,
+    connection: Option<&mut PlayerConnection>,
-    player_id: Uuid,
     message: &str,
-) -> Result<(), Box<dyn std::error::Error>> {
+) -> Result<(), tokio_tungstenite::tungstenite::Error> {
-    let mut connections_lock = connections.lock().await;
+    match connection {
-    if let Some(connection) = connections_lock.get_mut(&player_id) {
+        Some(connection) => {
-        connection
+            println!("sending message to: {}", connection.id);
-            .tx
+            connection.tx.send(Message::Text(message.to_string())).await
-            .send(Message::Text(message.to_string()))
+        }
-            .await?;
+        None => {
+            eprintln!("No connection provided");
+            Err(tokio_tungstenite::tungstenite::Error::ConnectionClosed)
+        }
     }
-    Ok(())
 }
 
 pub async fn broadcast_to_all(connections: &ConnectionMap, message: &str) {
@@ -108,8 +142,16 @@ pub async fn broadcast_to_match(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let matches_lock = matches.lock().await;
     if let Some(game_match) = matches_lock.get(&match_id) {
-        send_message_to_player(connections, game_match.player_white, message).await?;
+        send_message_to_player_connection(
-        send_message_to_player(connections, game_match.player_black, message).await?;
+            connections.lock().await.get_mut(&game_match.player_white),
+            message,
+        )
+        .await?;
+        send_message_to_player_connection(
+            connections.lock().await.get_mut(&game_match.player_black),
+            message,
+        )
+        .await?;
     }
     Ok(())
 }
@@ -144,14 +186,6 @@ pub async fn handle_connection(
 
     println!("New connection: {}", player_id);
 
-    // Send welcome message
-    let _ = send_message_to_player(
-        &connections,
-        player_id,
-        &format!(r#"{{"type": "welcome", "player_id": "{}"}}"#, player_id),
-    )
-    .await;
-
     // Message processing loop
     while let Some(Ok(message)) = read.next().await {
         if message.is_text() {
@@ -161,8 +195,6 @@ pub async fn handle_connection(
             let client_data: ClientEvent = serde_json::from_str(text)
                 .expect("Failed to convert data into json at handle_connection");
 
-            println!("client: {:?}", client_data);
-
             match client_data {
                 Join { username } => {
                     {
@@ -172,15 +204,11 @@ pub async fn handle_connection(
                     }
 
                     //respone to client
-                    let response: EventResponse = EventResponse {
+                    let response = ServerMessage2::Ok { response: Ok(()) };
-                        response: core::result::Result::Ok(()),
-                    };
 
-                    println!("response: {:?}", response);
+                    let mut conn_map = connections.lock().await;
-
+                    let _ = send_message_to_player_connection(
-                    let _ = send_message_to_player(
+                        conn_map.get_mut(&player_id),
-                        &connections,
-                        player_id,
                         &serde_json::to_string(&response).unwrap(),
                     )
                     .await;
@@ -191,18 +219,136 @@ pub async fn handle_connection(
                     println!("Appended {} to the waiting queue", player_id);
                     println!("queue {:?}", wait_queue);
                 }
-                Move { from, to } => {}
+                Move { step } => {
+                    let match_id = connections
+                        .lock()
+                        .await
+                        .get(&player_id)
+                        .unwrap()
+                        .current_match
+                        .unwrap();
+
+                    {
+                        let mut matches = matches.lock().await;
+                        matches.get_mut(&match_id).unwrap().board_state =
+                            engine::get_board_after_move(
+                                &matches.get(&match_id).unwrap().board_state,
+                                &step,
+                            );
+                    }
+                    let message = ServerMessage2::UIUpdate {
+                        fen: matches
+                            .lock()
+                            .await
+                            .get(&match_id)
+                            .unwrap()
+                            .board_state
+                            .clone(),
+                    };
+
+                    let _ = broadcast_to_match(
+                        &connections,
+                        &matches,
+                        match_id,
+                        &serde_json::to_string(&message).unwrap(),
+                    )
+                    .await;
+
+                    {
+                        let is_game_end = engine::is_game_over(
+                            &matches.lock().await.get(&match_id).unwrap().board_state,
+                        );
+
+                        match is_game_end {
+                            Some(res) => {
+                                let message = ServerMessage2::GameEnd { winner: res };
+                                let _ = broadcast_to_match(
+                                    &connections,
+                                    &matches,
+                                    match_id,
+                                    &serde_json::to_string(&message).unwrap(),
+                                )
+                                .await;
+                                clean_up_match(&matches, &match_id);
+                            }
+                            None => {
+                                println!("No winner match continues.")
+                            }
+                        }
+                    }
+                }
                 RequestLegalMoves { fen } => {
                     let moves = get_available_moves(&fen);
-                    let _ = send_message_to_player(
+                    let _ = send_message_to_player_connection(
-                        &connections,
+                        connections.lock().await.get_mut(&player_id),
-                        player_id,
                         &serde_json::to_string(&moves).unwrap(),
                     )
                     .await;
                     println!("Sent moves to player: {}", player_id);
                 }
-                _ => {}
+                Resign => {
+                    let (fuck, fuck_id): (ServerMessage2, &Uuid) = {
+                        let matches = matches.lock().await;
+
+                        let curr_match = matches
+                            .get(
+                                &connections
+                                    .lock()
+                                    .await
+                                    .get(&player_id)
+                                    .unwrap()
+                                    .current_match
+                                    .unwrap(),
+                            )
+                            .unwrap();
+
+                        if player_id == curr_match.player_white {
+                            (
+                                ServerMessage2::GameEnd {
+                                    winner: GameEnd::BlackWon("Resigned".to_string()),
+                                },
+                                &connections
+                                    .lock()
+                                    .await
+                                    .get(&player_id)
+                                    .unwrap()
+                                    .current_match
+                                    .unwrap(),
+                            )
+                        } else {
+                            (
+                                ServerMessage2::GameEnd {
+                                    winner: GameEnd::WhiteWon("Resigned".to_string()),
+                                },
+                                &connections
+                                    .lock()
+                                    .await
+                                    .get(&player_id)
+                                    .unwrap()
+                                    .current_match
+                                    .unwrap(),
+                            )
+                        }
+                    };
+
+                    broadcast_to_match(
+                        &connections,
+                        &matches,
+                        connections
+                            .lock()
+                            .await
+                            .get(&player_id)
+                            .unwrap()
+                            .current_match
+                            .unwrap(),
+                        &serde_json::to_string(&fuck).unwrap(),
+                    )
+                    .await;
+                    clean_up_match(&matches, fuck_id);
+                }
+                _ => {
+                    println!("Not known client event");
+                }
             }
         }
     }
@@ -239,8 +385,24 @@ mod tests {
         let connections = new_connection_map();
         let player_id = Uuid::new_v4();
 
-        let result = send_message_to_player(&connections, player_id, "test message").await;
+        // Test 1: Pass None directly (non-existent player)
-        assert!(result.is_ok(), "Should handle missing player gracefully");
+        let result = send_message_to_player_connection(None, "test message").await;
+
+        assert!(result.is_err(), "Should return error for None connection");
+        println!("Test passed: Handles None connection correctly");
+
+        // Test 2: Try to get non-existent player from map
+        let mut conn = connections.lock().await;
+        let non_existent_connection = conn.get_mut(&player_id); // This will be None
+
+        let result2 =
+            send_message_to_player_connection(non_existent_connection, "test message").await;
+
+        assert!(
+            result2.is_err(),
+            "Should return error for non-existent player"
+        );
+        println!("Test passed: Handles non-existent player in map correctly");
     }
 
     #[tokio::test]

server/src/main.rs

@@ -1,6 +1,5 @@
 mod connection;
 mod matchmaking;
-mod messages;
 use tokio::net::TcpListener;
 
 #[tokio::main]

server/src/matchmaking.rs

@@ -1,3 +1,4 @@
+use crate::connection::ServerMessage2;
 use crate::connection::{ConnectionMap, GameMatch, MatchMap, WaitingQueue};
 use rand::random;
 use uuid::Uuid;
@@ -20,10 +21,14 @@ impl MatchmakingSystem {
     pub async fn run(&self) {
         loop {
             self.try_create_match().await;
-            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+            tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
         }
     }
 
+    pub async fn clean_up(&self, match_id: Uuid) {
+        self.matches.lock().await.remove(&match_id);
+    }
+
     async fn try_create_match(&self) {
         let mut queue = self.waiting_queue.lock().await;
 
@@ -61,42 +66,54 @@ impl MatchmakingSystem {
             }
 
             // Notify players
+            println!(
+                "Notifying player for a match: {:?} | {:?}",
+                white_player, black_player
+            );
             self.notify_players(white_player, black_player, match_id)
                 .await;
         }
     }
 
     async fn notify_players(&self, white: Uuid, black: Uuid, match_id: Uuid) {
-        let conn_map = self.connections.lock().await;
+        let mut conn_map = self.connections.lock().await;
-
-        // Get opponent names
-        let white_name = conn_map
-            .get(&black)
-            .and_then(|c| c.username.as_deref())
-            .unwrap_or("Opponent");
-        let black_name = conn_map
-            .get(&white)
-            .and_then(|c| c.username.as_deref())
-            .unwrap_or("Opponent");
 
         // Notify white player
         if let Some(_) = conn_map.get(&white) {
-            let message = format!(
+            let message = ServerMessage2::MatchFound {
-                r#"{{"type": "match_found", "match_id": "{}", "opponent": "{}", "color": "white"}}"#,
+                match_id: match_id.clone(),
-                match_id, black_name
+                color: String::from("white"),
-            );
+                opponent_name: conn_map
-            let _ =
+                    .get(&white)
-                crate::connection::send_message_to_player(&self.connections, white, &message).await;
+                    .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!(
+            let message = ServerMessage2::MatchFound {
-                r#"{{"type": "match_found", "match_id": "{}", "opponent": "{}", "color": "black"}}"#,
+                match_id: match_id.clone(),
-                match_id, white_name
+                color: String::from("black"),
-            );
+                opponent_name: conn_map
-            let _ =
+                    .get(&black)
-                crate::connection::send_message_to_player(&self.connections, black, &message).await;
+                    .and_then(|c| c.username.as_deref())
+                    .unwrap_or("Opponent")
+                    .to_string(),
+            };
+
+            let _ = crate::connection::send_message_to_player_connection(
+                conn_map.get_mut(&white),
+                &serde_json::to_string(&message).unwrap(),
+            )
+            .await;
         }
 
         println!("Match created: {} (white) vs {} (black)", white, black);

server/src/messages.rs

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