feat: add client::{start, update}

src/bin/client.rs

@@ -0,0 +1,11 @@
+use checkers::network::client::Client;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    env_logger::init();
+
+    let mut client: Client = Client::new().await;
+    client.update().await;
+
+    return Ok(());
+}

src/network/client.rs

@@ -1 +1,92 @@
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 
+use log::{debug, error, info};
+use tokio::sync::mpsc::{self, Receiver, Sender};
+
+use crate::network::{
+    connection::{Connection, ConnectionType},
+    message::{ClientMessage, Message, ServerMessage},
+};
+
+pub struct ClientSettings {
+    server_url: SocketAddr,
+    name: String,
+}
+
+pub struct Client {
+    conn_reciever_incoming: Receiver<(SocketAddr, Message<ServerMessage>)>,
+    conn_sender_outgoing: Sender<Message<ClientMessage>>,
+    settings: ClientSettings,
+}
+
+impl Client {
+    pub async fn new() -> Client {
+        let settings = ClientSettings {
+            server_url: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 6767),
+            name: "Szymon".into(),
+        };
+
+        let (conn_sender, conn_reciever) =
+            mpsc::channel::<(SocketAddr, Message<ServerMessage>)>(1024);
+
+        let mut conn: Connection<ServerMessage, ClientMessage> =
+            Connection::new(ConnectionType::Server, conn_sender);
+
+        let conn_sender_outgoing = conn.get_sender();
+
+        conn.connect_to_server(settings.server_url).await;
+
+        tokio::spawn(async move {
+            conn.start_listening().await;
+        });
+
+        Client {
+            conn_reciever_incoming: conn_reciever,
+            conn_sender_outgoing,
+            settings,
+        }
+    }
+
+    pub async fn update(&mut self) {
+        loop {
+            if let Some(oldest_msg) = self.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: self.settings.name.clone(),
+                        });
+
+                        self.send_message(msg).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!(),
+                }
+            }
+        }
+    }
+
+    async fn send_message(&mut self, msg: Result<Message<ClientMessage>, postcard::Error>) {
+        debug!("Sending message to the server!");
+        let _ = match msg {
+            Err(e) => {
+                error!("There was an error while creating the message: {}", e);
+                return;
+            }
+            Ok(msg) => {
+                if let Err(e) = self.conn_sender_outgoing.send(msg).await {
+                    error!("Error while sending a message to connection thread: {}", e);
+                    return;
+                }
+            }
+        };
+    }
+}

src/network/connection.rs

@@ -138,7 +138,7 @@ where
                             self.send(msg).await;
                         },
                         None => {
-                            info!("Server closed the channel for {:?}. Disconnecting...", self.peer);
+                            info!("Remote closed the channel for {:?}. Disconnecting...", self.peer);
                             break;
                         }
                     }

src/network/server.rs

@@ -48,7 +48,7 @@ impl Server {
             allow_spectators: false,
         };
 
-        let (sender, mut reciever) =
+        let (sender, reciever) =
             tokio::sync::mpsc::channel::<(SocketAddr, Message<ClientMessage>)>(1024); // random
         // number
 
@@ -69,7 +69,7 @@ impl Server {
     }
 
     pub async fn start(&mut self) {
-        let (welcoming_tx, mut welcoming_rx) =
+        let (welcoming_tx, welcoming_rx) =
             tokio::sync::mpsc::channel::<(SocketAddr, Sender<Message<ServerMessage>>)>(10);
 
         self.welcoming_reciever = Some(welcoming_rx);