maj client

client/src/main.rs

@@ -3,7 +3,10 @@ use bevy_renet::RenetClientPlugin;
 use std::{net::UdpSocket, time::SystemTime};
 
 use renet::{
-    transport::{ClientAuthentication, NetcodeClientTransport, NETCODE_USER_DATA_BYTES},
+    transport::{
+        ClientAuthentication, NetcodeClientTransport, NetcodeTransportError,
+        NETCODE_USER_DATA_BYTES,
+    },
     ConnectionConfig, RenetClient,
 };
 
@@ -15,7 +18,7 @@ fn main() {
     let args = std::env::args().collect::<Vec<String>>();
     let username = &args[1];
 
-    let client = RenetClient::new(ConnectionConfig::default());
+    let (client, transport) = new_renet_client(&username).unwrap();
     App::new()
         // Lets add a nice dark grey background color
         .insert_resource(ClearColor(Color::hex("282828").unwrap()))
@@ -31,15 +34,16 @@ fn main() {
         // Renet setup
         .add_plugins(RenetClientPlugin)
         .insert_resource(client)
-        .insert_resource(new_renet_transport(&username).unwrap())
+        .insert_resource(transport)
-        // .add_system(handle_renet_error)
+        .add_systems(Update, panic_on_error_system)
         .run();
 }
 
 ////////// RENET NETWORKING //////////
 // Creates a RenetClient thats already connected to a server.
 // Returns an Err if connection fails
-fn new_renet_transport(username: &String) -> anyhow::Result<NetcodeClientTransport> {
+fn new_renet_client(username: &String) -> anyhow::Result<(RenetClient, NetcodeClientTransport)> {
+    let client = RenetClient::new(ConnectionConfig::default());
     let server_addr = "127.0.0.1:5000".parse()?;
     let socket = UdpSocket::bind("127.0.0.1:0")?;
     let current_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?;
@@ -61,13 +65,12 @@ fn new_renet_transport(username: &String) -> anyhow::Result<NetcodeClientTranspo
     };
     let transport = NetcodeClientTransport::new(current_time, authentication, socket).unwrap();
 
-    Ok(transport)
+    Ok((client, transport))
 }
 
-// If there's any network error we just panic 🤷‍♂️
+// If any error is found we just panic
-// Ie. Client has lost connection to server, if internet is gone or server shut down etc.
+fn panic_on_error_system(mut renet_error: EventReader<NetcodeTransportError>) {
-// fn handle_renet_error(mut renet_error: EventReader<RenetError>) {
+    for e in renet_error.iter() {
-//     for err in renet_error.iter() {
+        panic!("{}", e);
-//         panic!("{}", err);
+    }
-//     }
+}
-// }

server/src/main.rs

@@ -1,14 +1,14 @@
-use log::{info, trace, warn};
-use std::thread;
 use bincode;
-use std::net::{SocketAddr, UdpSocket, IpAddr, Ipv4Addr};
+use log::{info, trace, warn};
+use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
+use std::thread;
 use std::time::{Duration, Instant, SystemTime};
 
 use renet::{
     transport::{
         NetcodeServerTransport, ServerAuthentication, ServerConfig, NETCODE_USER_DATA_BYTES,
     },
-    ConnectionConfig, DefaultChannel, RenetClient, RenetServer, ServerEvent,
+    ConnectionConfig, RenetServer, ServerEvent,
 };
 
 // Only clients that can provide the same PROTOCOL_ID that the server is using will be able to connect.
@@ -39,7 +39,9 @@ fn main() {
         public_addr: SERVER_ADDR,
         authentication: ServerAuthentication::Unsecure,
     };
-    let current_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+    let current_time = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .unwrap();
     let mut transport = NetcodeServerTransport::new(current_time, server_config, socket).unwrap();
 
     trace!("❂ TricTrac server listening on {}", SERVER_ADDR);
@@ -56,6 +58,7 @@ fn main() {
 
         // Receive connection events from clients
         while let Some(event) = server.get_event() {
+            trace!("event received");
             match event {
                 ServerEvent::ClientConnected { client_id } => {
                     let user_data = transport.user_data(client_id).unwrap();
@@ -83,7 +86,9 @@ fn main() {
                     info!("Client {} connected.", client_id);
                     // In TicTacTussle the game can begin once two players has joined
                     if game_state.players.len() == 2 {
-                        let event = store::GameEvent::BeginGame { goes_first: client_id };
+                        let event = store::GameEvent::BeginGame {
+                            goes_first: client_id,
+                        };
                         game_state.consume(&event);
                         server.broadcast_message(0, bincode::serialize(&event).unwrap());
                         trace!("The game gas begun");
@@ -91,14 +96,18 @@ fn main() {
                 }
                 ServerEvent::ClientDisconnected { client_id, reason } => {
                     // First consume a disconnect event
-                    let event = store::GameEvent::PlayerDisconnected { player_id: client_id };
+                    let event = store::GameEvent::PlayerDisconnected {
+                        player_id: client_id,
+                    };
                     game_state.consume(&event);
                     server.broadcast_message(0, bincode::serialize(&event).unwrap());
                     info!("Client {} disconnected", client_id);
 
                     // Then end the game, since tic tac toe can't go on with a single player
                     let event = store::GameEvent::EndGame {
-                        reason: store::EndGameReason::PlayerLeft { player_id: client_id },
+                        reason: store::EndGameReason::PlayerLeft {
+                            player_id: client_id,
+                        },
                     };
                     game_state.consume(&event);
                     server.broadcast_message(0, bincode::serialize(&event).unwrap());
@@ -133,5 +142,6 @@ fn main() {
         }
 
         transport.send_packets(&mut server);
-        thread::sleep(Duration::from_millis(50));}
+        thread::sleep(Duration::from_millis(50));
+    }
 }