From f2829efd6c94e5ec91ad6a6fe6434b4f159360dc Mon Sep 17 00:00:00 2001 From: szymon Date: Wed, 19 Aug 2026 11:29:47 +0200 Subject: [PATCH] refactor: move update function of the network client to the constructor --- src/bin/client.rs | 4 +- src/network/client.rs | 46 ++++-------- src/super_advanced_ai.rs | 153 ++++++++++++++++++++------------------- 3 files changed, 96 insertions(+), 107 deletions(-) diff --git a/src/bin/client.rs b/src/bin/client.rs index 05be414..c96a384 100644 --- a/src/bin/client.rs +++ b/src/bin/client.rs @@ -88,13 +88,11 @@ async fn run_bot() { async fn main() -> Result<(), Box> { env_logger::init(); - let Some(mut client) = Client::new().await else { + let Some(mut client) = Client::new(None).await else { println!("Not worky, ending"); return Ok(()); }; - client.update(); - let (stdin_sender, mut stdin_receiver) = mpsc::channel(1024); let mut context: ClientContext = ClientContext::default(); diff --git a/src/network/client.rs b/src/network/client.rs index 4d6eaea..7feb5d7 100644 --- a/src/network/client.rs +++ b/src/network/client.rs @@ -23,25 +23,24 @@ pub enum ClientCommands { } pub struct Client { - conn_reciever_incoming: Option)>>, conn_sender_outgoing: Sender>, - settings: ClientSettings, - - update_sender: Sender, update_receiver: Option>, } impl Client { + /// Creates a new instance of clients, connects it to the server and starts update loop pub async fn new(settings: Option) -> Option { let Some(settings) = settings.or(Some(ClientSettings::new())) else { error!("Could not load client settings"); return None; }; - let (conn_sender, conn_reciever) = + let (conn_sender, mut conn_reciever) = mpsc::channel::<(SocketAddr, Message)>(1024); + let mut conn: Connection = Connection::new(ConnectionType::Server, conn_sender); + let conn_sender_outgoing = conn.get_sender(); let (update_sender, update_receiver) = mpsc::channel(1024); @@ -55,32 +54,14 @@ impl Client { conn.start_listening().await; }); - Some(Client { - conn_reciever_incoming: Some(conn_reciever), - conn_sender_outgoing, - - settings, - - update_sender, - update_receiver: Some(update_receiver), - }) - } - - pub fn update(&mut self) { - let Some(mut conn_reciever_incoming) = self.conn_reciever_incoming.take() else { - error!("Tried updating, but there's no conn_reciever of incoming messages!"); - return; - }; - - let conn_sender = self.conn_sender_outgoing.clone(); - - let settings = self.settings.clone(); - let update_sender = self.update_sender.clone(); + let conn_sender_outgoing_clone = conn_sender_outgoing.clone(); + let settings_clone = settings.clone(); + let update_sender_clone = update_sender.clone(); tokio::spawn(async move { loop { tokio::select! { - oldest_msg = conn_reciever_incoming.recv() => { + oldest_msg = conn_reciever.recv() => { if let Some(oldest_msg) = oldest_msg { let (addr, msg) = oldest_msg; debug!("Got message from: {:?}", addr); @@ -89,10 +70,10 @@ impl Client { ServerMessage::RequestHandshake => { info!("Server requested handshake!"); let msg = Message::new(ClientMessage::AnswerHandshake { - player_name: settings.name.clone(), + player_name: settings_clone.name.clone(), }); - let _ = conn_sender.send(msg.unwrap()).await; + let _ = conn_sender_outgoing_clone.send(msg.unwrap()).await; } ServerMessage::AcceptHandshake => { @@ -106,7 +87,7 @@ impl Client { _ => { // Pass all messages that require player intervention to the // local client - let _ = update_sender.send(msg.content).await; + let _ = update_sender_clone.send(msg.content).await; } } } else { @@ -117,6 +98,11 @@ impl Client { } } }); + + Some(Client { + conn_sender_outgoing, + update_receiver: Some(update_receiver), + }) } async fn send_message(&mut self, msg: Result, postcard::Error>) { diff --git a/src/super_advanced_ai.rs b/src/super_advanced_ai.rs index a97aee9..e36a5b0 100644 --- a/src/super_advanced_ai.rs +++ b/src/super_advanced_ai.rs @@ -1,7 +1,12 @@ use log::{error, info}; use rand::seq::IndexedRandom; +use uuid::Uuid; -use crate::{logic::game_master::GameResult, network::client::Client}; +use crate::{ + logic::game_master::GameResult, + network::client::Client, + settings::{client_settings::ClientSettings, general_settings::DEFAULT_URL}, +}; #[derive(PartialEq, Eq, Clone, Copy)] pub enum BotDificulty { @@ -23,12 +28,14 @@ impl Bot { Self { dificulty } } - pub async fn game_loop(&self) { - let mut client = Client::new() - .await - .expect("Couldn't connect to the server. Is it online?"); + pub async fn game_loop(&self) -> Option { + let mut client = Client::new(Some(ClientSettings { + name: "Bot".to_string(), + server_url: DEFAULT_URL, + })) + .await + .expect("Couldn't connect to the server. Is it online?"); - client.update(); client.signal_readiness().await; // bot is always ready let mut receiver = client @@ -37,76 +44,74 @@ impl Bot { let dificulty = self.dificulty; - tokio::spawn(async move { - loop { - match receiver.recv().await { - Some(message) => match message { - crate::network::message::ServerMessage::GameStart { identity } => { - info!("Bot got identity: {}", identity); - } - crate::network::message::ServerMessage::AvailableCaptures { captures } => { - let capture = captures - .choose(&mut rand::rng()) - .expect("Could not select random capture"); - client.send_capture(capture.clone()).await; - } - crate::network::message::ServerMessage::AvailableMoves { moves } => { - let rand_pawn = moves - .choose(&mut rand::rng()) - .expect("Couldn't select random move"); - let rand_move = rand_pawn - .available_steps - .choose(&mut rand::rng()) - .expect("Could not get random move"); - - client.send_move(rand_pawn.from, rand_move.clone()).await; - } - crate::network::message::ServerMessage::BroadcastBoardState { - board: _, - } => { - info!("Got server state!"); - - match dificulty.clone() { - BotDificulty::Easy => {} // we do nothing with it because easy bot - // just does random stuff. In future - // board_view can be used to calculate the - // best possible move atm - BotDificulty::Normal => todo!(), - BotDificulty::Hard => todo!(), - } - } - crate::network::message::ServerMessage::BroadcastCurrentTurn { - active_player: _, - } => {} // we do nothing with this - bot doesn't need to know if it's the - // active player, as it's only responding to messages - crate::network::message::ServerMessage::BroadCastTextMessage { - sender, - content, - } => { - info!("Bot got message from [{}] - {}", sender, content); - } - - crate::network::message::ServerMessage::GameEnd { result } => { - info!("Game has ended!"); - match result { - GameResult::Draw => { - info!("Draw!"); - } - GameResult::Lost(loser) => { - info!("ID: {} lost!", loser); - } - } - } - - _ => {} - }, - - None => { - error!("Connection broken! Super advanced ai logging out!"); - break; + loop { + match receiver.recv().await { + Some(message) => match message { + crate::network::message::ServerMessage::GameStart { identity } => { + info!("Bot got identity: {}", identity); } + crate::network::message::ServerMessage::AvailableCaptures { captures } => { + let capture = captures + .choose(&mut rand::rng()) + .expect("Could not select random capture"); + client.send_capture(capture.clone()).await; + } + crate::network::message::ServerMessage::AvailableMoves { moves } => { + let rand_pawn = moves + .choose(&mut rand::rng()) + .expect("Couldn't select random move"); + let rand_move = rand_pawn + .available_steps + .choose(&mut rand::rng()) + .expect("Could not get random move"); + + client.send_move(rand_pawn.from, rand_move.clone()).await; + } + crate::network::message::ServerMessage::BroadcastBoardState { board: _ } => { + info!("Got server state!"); + + match dificulty.clone() { + BotDificulty::Easy => {} // we do nothing with it because easy bot + // just does random stuff. In future + // board_view can be used to calculate the + // best possible move atm + BotDificulty::Normal => todo!(), + BotDificulty::Hard => todo!(), + } + } + crate::network::message::ServerMessage::BroadcastCurrentTurn { + active_player: _, + } => {} // we do nothing with this - bot doesn't need to know if it's the + // active player, as it's only responding to messages + crate::network::message::ServerMessage::BroadCastTextMessage { + sender, + content, + } => { + info!("Bot got message from [{}] - {}", sender, content); + } + + crate::network::message::ServerMessage::GameEnd { result } => { + info!("Game has ended!"); + match result { + GameResult::Draw => { + info!("Draw!"); + return None; + } + GameResult::Lost(loser) => { + info!("ID: {} lost!", loser); + return Some(loser); + } + } + } + + _ => {} + }, + + None => { + error!("Connection broken! Super advanced ai logging out!"); + return None; } } - }); + } } }