From d4fc5dff2eff501d13dc0a2178b8b5afe2dfdb3e Mon Sep 17 00:00:00 2001 From: szymon Date: Sun, 16 Aug 2026 21:33:36 +0200 Subject: [PATCH] feat: add network identity --- src/bin/client.rs | 2 -- src/network/mod.rs | 1 + src/network/network_identity.rs | 43 ++++++++++++++++++++++++++++++++ src/network/server.rs | 44 ++++++++++++++++++++++++++++----- 4 files changed, 82 insertions(+), 8 deletions(-) create mode 100644 src/network/network_identity.rs diff --git a/src/bin/client.rs b/src/bin/client.rs index 5174288..8540db4 100644 --- a/src/bin/client.rs +++ b/src/bin/client.rs @@ -1,11 +1,9 @@ use std::{ fmt::Display, io::{self, Write}, - time::Duration, }; use checkers::network::client::Client; -use env_logger::TimestampPrecision::Seconds; use log::{error, info}; const QUIT_COMMAND: &str = "/quit"; diff --git a/src/network/mod.rs b/src/network/mod.rs index 101e02a..3c74f01 100644 --- a/src/network/mod.rs +++ b/src/network/mod.rs @@ -1,4 +1,5 @@ pub mod client; pub mod connection; pub mod message; +mod network_identity; pub mod server; diff --git a/src/network/network_identity.rs b/src/network/network_identity.rs new file mode 100644 index 0000000..4753e00 --- /dev/null +++ b/src/network/network_identity.rs @@ -0,0 +1,43 @@ +use serde::{Deserialize, Serialize}; +use tokio::sync::mpsc::Sender; + +use crate::network::message::{Message, ServerMessage}; + +#[derive(Deserialize, Serialize)] +pub struct NetworkIdentity { + pub name: String, + pub id: uuid::Uuid, + pub is_ready: bool, +} + +impl Default for NetworkIdentity { + fn default() -> Self { + Self { + name: String::new(), + id: uuid::Uuid::nil(), + is_ready: false, + } + } +} + +pub struct NetworkServerIdentity { + // this feels silly but i have no better idea rn (i've been + // writing this since 10 a.m. and it's 9 p.m. already) + pub identity: NetworkIdentity, + pub sender: Sender>, +} + +impl NetworkServerIdentity { + pub fn new(sender: Sender>) -> Self { + Self { + identity: NetworkIdentity::default(), + sender, + } + } +} + +impl AsMut for NetworkServerIdentity { + fn as_mut(&mut self) -> &mut NetworkIdentity { + &mut self.identity + } +} diff --git a/src/network/server.rs b/src/network/server.rs index b9940e4..e3e8648 100644 --- a/src/network/server.rs +++ b/src/network/server.rs @@ -16,6 +16,7 @@ use crate::{ ClientMessage::{self}, Message, ServerMessage, }, + network_identity::{NetworkIdentity, NetworkServerIdentity}, }, }; @@ -49,7 +50,7 @@ impl Default for ServerState { pub struct Server { listener: Option, - connections: HashMap>>, + connections: HashMap, reciever: Receiver<(SocketAddr, Message)>, sender: Sender<(SocketAddr, Message)>, @@ -126,6 +127,7 @@ impl Server { // TODO! Add waiting for reconnect let disconnect_msg = Message::new(ClientMessage::ConnectionDead { addr }); + let _ = disconnect_sender .send(( addr, @@ -147,7 +149,8 @@ impl Server { new_client_opt = self.welcoming_reciever.as_mut().expect("Welcoming reciever was not set. Was the server started?").recv() => { if let Some((addr, sender)) = new_client_opt { if self.state.stage == ServerStage::Lobby && self.connections.keys().len() < self.settings.max_connections && !self.settings.allow_spectators { - self.connections.insert(addr, sender); + let identity = NetworkServerIdentity::new(sender); + self.connections.insert(addr, identity); self.request_handshake(addr).await; } else { let reason = "There is currently game going and it doesn't allow spectators".to_string(); @@ -183,16 +186,25 @@ impl Server { // TODO! Should decrement ready_counter if player was ready. But // how to check that? Maybe create new struct that will hold // sender and ready and maybe some other data. + + let is_ready = &mut self.connections.get_mut(&addr).expect("Couldn't get the identity of disconnected player. I don't think i should panic but i don't care fuck you").identity.is_ready; + + if *is_ready { + *is_ready = false; + self.state.ready_count -= 1; + info!("Currently {}/{} players are ready", self.state.ready_count, self.settings.max_connections); + } self.remove_client(addr); }, ClientMessage::SignalReadiness => { self.state.ready_count += 1; info!("{} signaled readiness. Currently ready: {}/{}", addr, self.state.ready_count, self.settings.max_connections); + self.connections.get_mut(&addr).expect("Couldn't get the identity of the ready player. I guess this should never happen so i'm panicking like a little bitch").identity.is_ready = true; + if self.state.ready_count == self.settings.max_connections { info!("All players are ready! Changing state to ServerStage::Game"); self.state.stage = ServerStage::Game; - self.start_game(); } }, @@ -228,6 +240,26 @@ impl Server { info!("Client: {:?} sent us his name: {}", addr, player_name); self.send_message(addr, Message::new(ServerMessage::AcceptHandshake)) .await; + + let fixed_name: String; + + if self + .connections + .values() + .any(|v| v.identity.name == player_name) + { + fixed_name = format!("{}(2)", player_name) + } else { + fixed_name = player_name + } + + let Some(identity) = self.connections.get_mut(&addr) else { + error!("Could not get network identity while processing the handshake!"); + return; + }; + + identity.identity.name = fixed_name + // TODO! Validate if the name isn't already in use and append something to it if it is } @@ -263,8 +295,8 @@ impl Server { ) { let conn_opt = self.connections.get_mut(&addr); - let Some(conn) = conn_opt else { - error!("Could not get connection from connections list"); + let Some(identity) = conn_opt else { + error!("Could not get identity from connections list"); return; }; @@ -273,7 +305,7 @@ impl Server { error!("There was an error while creating message: {}", e); return; } - Ok(msg) => conn.send(msg).await, + Ok(msg) => identity.sender.send(msg).await, }; }