feat: add sending text messages

src/bin/client.rs

@@ -1,3 +1,5 @@
+use std::io;
+
 use checkers::network::client::Client;
 
 #[tokio::main]
@@ -5,7 +7,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     env_logger::init();
 
     let mut client: Client = Client::new().await;
-    client.update().await;
+    client.update();
+
+    println!("=== Write to stding to send text messages ===");
+    println!("Write /close to leave");
+    let mut buffer = String::new();
+    loop {
+        io::stdin().read_line(&mut buffer)?;
+        if buffer == "/close\n" {
+            break;
+        }
+
+        client.send_text_message(buffer.clone()).await;
+        buffer.clear();
+    }
 
     return Ok(());
 }

src/network/client.rs

@@ -5,16 +5,20 @@ use tokio::sync::mpsc::{self, Receiver, Sender};
 
 use crate::network::{
     connection::{Connection, ConnectionType},
-    message::{ClientMessage, Message, ServerMessage},
+    message::{
+        ClientMessage::{self, TextMessage},
+        Message, ServerMessage,
+    },
 };
 
+#[derive(Clone)]
 pub struct ClientSettings {
     server_url: SocketAddr,
     name: String,
 }
 
 pub struct Client {
-    conn_reciever_incoming: Receiver<(SocketAddr, Message<ServerMessage>)>,
+    conn_reciever_incoming: Option<Receiver<(SocketAddr, Message<ServerMessage>)>>,
     conn_sender_outgoing: Sender<Message<ClientMessage>>,
     settings: ClientSettings,
 }
@@ -41,37 +45,53 @@ impl Client {
         });
 
         Client {
-            conn_reciever_incoming: conn_reciever,
+            conn_reciever_incoming: Some(conn_reciever),
             conn_sender_outgoing,
             settings,
         }
     }
 
-    pub async fn update(&mut self) {
+    pub fn update(&mut self) {
-        loop {
+        let Some(mut conn_reciever_incoming) = self.conn_reciever_incoming.take() else {
-            if let Some(oldest_msg) = self.conn_reciever_incoming.recv().await {
+            error!("Tried updating, but there's no conn_reciever of incoming messages!");
-                let (addr, msg) = oldest_msg;
+            return;
-                info!("Got message from: {:?}", addr);
+        };
 
-                match msg.content {
+        let sender = self.conn_sender_outgoing.clone();
-                    ServerMessage::RequestHandshake => {
-                        info!("Server requested handshake!");
-                        let msg = Message::new(ClientMessage::AnswerHandshake {
-                            player_name: self.settings.name.clone(),
-                        });
 
-                        self.send_message(msg).await;
+        let settings = self.settings.clone();
+
+        tokio::spawn(async move {
+            loop {
+                if let Some(oldest_msg) = conn_reciever_incoming.recv().await {
+                    let (addr, msg) = oldest_msg;
+                    info!("Got message from: {:?}", addr);
+
+                    match msg.content {
+                        ServerMessage::RequestHandshake => {
+                            info!("Server requested handshake!");
+                            let msg = Message::new(ClientMessage::AnswerHandshake {
+                                player_name: settings.name.clone(),
+                            });
+
+                            let _ = sender.send(msg.unwrap()).await;
+                        }
+                        ServerMessage::AcceptHandshake { player_id } => todo!(),
+                        ServerMessage::DeclineHandshake { reason } => todo!(),
+                        ServerMessage::AvailableCaptures { captures } => todo!(),
+                        ServerMessage::AvailableMoves { moves } => todo!(),
+                        ServerMessage::BroadcastBoardState { board } => todo!(),
+                        ServerMessage::BroadcastCurrentTurn { active_player } => todo!(),
+                        ServerMessage::GameEnd { result } => todo!(),
                     }
-                    ServerMessage::AcceptHandshake { player_id } => todo!(),
-                    ServerMessage::DeclineHandshake { reason } => todo!(),
-                    ServerMessage::AvailableCaptures { captures } => todo!(),
-                    ServerMessage::AvailableMoves { moves } => todo!(),
-                    ServerMessage::BroadcastBoardState { board } => todo!(),
-                    ServerMessage::BroadcastCurrentTurn { active_player } => todo!(),
-                    ServerMessage::GameEnd { result } => todo!(),
                 }
             }
-        }
+        });
+    }
+
+    pub async fn send_text_message(&mut self, content: String) {
+        let msg = Message::new(TextMessage(content));
+        self.send_message(msg).await;
     }
 
     async fn send_message(&mut self, msg: Result<Message<ClientMessage>, postcard::Error>) {

src/network/message.rs

@@ -1,4 +1,4 @@
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use uuid::Uuid;
 
 use crate::logic::{
@@ -53,6 +53,8 @@ pub enum ClientMessage {
 
     RequestCapture { capture_path: CapturePath },
     RequestMove { from: Position, to: Position },
+
+    TextMessage(String),
 }
 
 pub struct Message<T>

src/network/server.rs

@@ -120,11 +120,11 @@ impl Server {
 
                 msg_opt = self.reciever.recv() => {
                  if let Some(oldest_message) = msg_opt {
-                            let (_addr, msg) = oldest_message;
+                            let (addr, msg) = oldest_message;
 
                             match msg.content {
-                                ClientMessage::AnswerHandshake { player_name: _ } => {
+                                ClientMessage::AnswerHandshake { player_name } => {
-                                    self.process_handshake();
+                                    self.process_handshake(addr, player_name);
                                 }
                                 ClientMessage::RequestCapture { capture_path: _ } => {
                                     self.process_capture();
@@ -132,6 +132,9 @@ impl Server {
                                 ClientMessage::RequestMove { from: _, to: _ } => {
                                     self.process_move();
                                 }
+                                ClientMessage::TextMessage (content) => {
+                                    info!("{} sent us a message: {}", addr, content);
+                                }
                             }
                  } else {
                      warn!("Couldn't get latest message!");
@@ -144,8 +147,9 @@ impl Server {
 
     /* ======= Processing messages :D helper functions ======== */
 
-    fn process_handshake(&self) {
+    fn process_handshake(&self, addr: SocketAddr, player_name: String) {
-        todo!();
+        info!("Client: {:?} sent us his name: {}", addr, player_name);
+        // TODO! Do something with this name i guess
     }
 
     fn process_capture(&self) {