src/net/io.rs

@@ -4,7 +4,6 @@ use bevy::prelude::*;
 use uuid::Uuid;
 
 use super::{
-    packet::{InboundPacket, OutboundPacket, Packet},
     peer::{Peer, PeerChangeEvent, PeerMap, PeerReceiveTiming, PeerSendTiming},
     queues::{NetworkReceive, NetworkSend},
 };
@@ -19,13 +18,10 @@ pub fn handle_network_input(
 ) -> Result {
     for (mut message, address) in from_socket.iter() {
         if message.len() < 16 {
-            return Err(format!(
-                "Message of length {} is not large enough to contain UUID",
-                message.len()
-            )
-            .into());
+            return Err(format!("Message of length {} cannot contain UUID", message.len()).into());
         }
         let uuid = Uuid::from_slice(message.split_off(message.len() - 16).as_slice())?;
+        info!("Receiving: {:?} from {}", message, uuid);
         to_app.write(InboundPacket(Packet::new(message, uuid)));
         if let Some(peer_id) = peer_map.get(&uuid) {
             let (peer, mut last) = peers.get_mut(*peer_id)?;
@@ -50,6 +46,7 @@ pub fn handle_network_output(
     for packet in from_app.read() {
         let peer_id = peer_map.try_get(&packet.0.peer)?;
         let (peer, mut last) = peers.get_mut(*peer_id)?;
+        warn!("Sending: {:?} to {}", packet.0.message, peer.uuid);
         // Append our UUID for client identification
         let message = [packet.0.message.as_slice(), config.id.as_bytes()].concat();
         to_socket.send(message, peer.addr)?;
@@ -66,9 +63,11 @@ pub fn heartbeat(
     mut outbound: EventWriter<OutboundPacket>,
 ) {
     for (peer, last) in peers {
-        // Allow for 2 consecutive missed heartbeats without timing out
-        if last.time() + TIMEOUT / 3 > time.elapsed() {
-            continue;
+        if let Some(previous) = last.timestamp() {
+            // Allow for 2 consecutive missed heartbeats without timing out
+            if previous + TIMEOUT / 3 > time.elapsed() {
+                continue;
+            }
         }
         outbound.write(OutboundPacket(Packet::new(Vec::new(), peer.uuid)));
     }
@@ -80,7 +79,7 @@ pub fn timeouts(
     mut delete: EventWriter<PeerChangeEvent>,
 ) {
     for (peer, last) in peers {
-        if let Some(previous) = last.time() {
+        if let Some(previous) = last.timestamp() {
             if previous + TIMEOUT < time.elapsed() {
                 warn!("Peer {} timed out", peer.uuid);
                 delete.write(PeerChangeEvent::new(peer.uuid, None));
@@ -99,3 +98,21 @@ impl Config {
         Self { id: Uuid::new_v4() }
     }
 }
+
+#[derive(Debug)]
+pub struct Packet {
+    pub message: Vec<u8>,
+    pub peer: Uuid,
+}
+
+impl Packet {
+    pub fn new(message: Vec<u8>, peer: Uuid) -> Self {
+        Self { peer, message }
+    }
+}
+
+#[derive(Debug, Event)]
+pub struct OutboundPacket(pub Packet);
+
+#[derive(Debug, Event)]
+pub struct InboundPacket(pub Packet);

src/net/mod.rs

@@ -1,5 +1,4 @@
 mod io;
-mod packet;
 mod peer;
 mod plugin;
 mod queues;
@@ -8,7 +7,7 @@ mod thread;
 
 #[allow(unused_imports)]
 pub mod prelude {
-    pub use super::packet::{InboundPacket, OutboundPacket, Packet};
+    pub use super::io::{InboundPacket, OutboundPacket, Packet};
     pub use super::peer::Peer;
     pub use super::plugin::{NetIOPlugin, NetworkState};
 }

src/net/packet.rs

@@ -1,20 +0,0 @@
-use bevy::prelude::*;
-use uuid::Uuid;
-
-#[derive(Debug)]
-pub struct Packet {
-    pub message: Vec<u8>,
-    pub peer: Uuid,
-}
-
-impl Packet {
-    pub fn new(message: Vec<u8>, peer: Uuid) -> Self {
-        Self { peer, message }
-    }
-}
-
-#[derive(Debug, Event)]
-pub struct OutboundPacket(pub Packet);
-
-#[derive(Debug, Event)]
-pub struct InboundPacket(pub Packet);

src/net/peer.rs

@@ -3,35 +3,40 @@ use std::{collections::HashMap, net::SocketAddr, time::Duration};
 use bevy::prelude::*;
 use uuid::Uuid;
 
-use super::packet::{OutboundPacket, Packet};
+#[derive(Debug, Default)]
+struct Timing {
+    timestamp: Option<Duration>,
+}
 
 #[derive(Component, Debug, Default)]
-pub struct PeerSendTiming(Duration);
+pub struct PeerSendTiming(Timing);
 
 impl PeerSendTiming {
     pub fn update(&mut self, time: &Res<Time>) {
-        self.0 = time.elapsed()
+        self.0.timestamp = Some(time.elapsed())
     }
 
-    pub fn time(&self) -> Duration {
-        self.0
+    pub fn timestamp(&self) -> Option<Duration> {
+        self.0.timestamp
     }
 }
 
 #[derive(Component, Debug, Default)]
-pub struct PeerReceiveTiming(Option<Duration>);
+pub struct PeerReceiveTiming(Timing);
 
 impl PeerReceiveTiming {
     pub fn new(time: &Res<Time>) -> Self {
-        Self(Some(time.elapsed()))
+        Self(Timing {
+            timestamp: Some(time.elapsed()),
+        })
     }
 
     pub fn update(&mut self, time: &Res<Time>) {
-        self.0 = Some(time.elapsed())
+        self.0.timestamp = Some(time.elapsed())
     }
 
-    pub fn time(&self) -> Option<Duration> {
-        self.0
+    pub fn timestamp(&self) -> Option<Duration> {
+        self.0.timestamp
     }
 }
 
@@ -103,6 +108,7 @@ pub fn handle_peer_change(
                     warn!("Peer {} doesn't exist (just added?)", change.peer);
                 }
             } else {
+                info!("Removing peer {}", change.peer);
                 commands.get_entity(*entity)?.despawn();
                 peer_map.remove(&change.peer);
             }
@@ -120,17 +126,9 @@ pub fn handle_peer_change(
     }
     if peer_map.len() > 1 {
         if let Some(entity) = peer_map.remove(&Uuid::nil()) {
+            warn!("Removing initial Peer");
             commands.get_entity(entity)?.despawn();
         }
     }
     Ok(())
 }
-
-pub fn handle_new_peer(
-    new_peers: Query<&Peer, Added<Peer>>,
-    mut outbound: EventWriter<OutboundPacket>,
-) {
-    for peer in new_peers {
-        outbound.write(OutboundPacket(Packet::new(Vec::new(), peer.uuid)));
-    }
-}

src/net/plugin.rs

@@ -4,9 +4,11 @@ use bevy::prelude::*;
 use uuid::Uuid;
 
 use super::{
-    io::{Config, handle_network_input, handle_network_output, heartbeat, timeouts},
-    packet::{InboundPacket, OutboundPacket},
-    peer::{Peer, PeerChangeEvent, PeerMap, handle_new_peer, handle_peer_change},
+    io::{
+        Config, InboundPacket, OutboundPacket, handle_network_input, handle_network_output,
+        heartbeat, timeouts,
+    },
+    peer::{Peer, PeerChangeEvent, PeerMap, handle_peer_change},
     queues::{NetworkReceive, NetworkSend},
     socket::bind_socket,
 };
@@ -40,7 +42,7 @@ impl Plugin for NetIOPlugin {
             )
             .add_systems(
                 FixedUpdate,
-                (heartbeat, timeouts, handle_new_peer).run_if(in_state(NetworkState::MultiPlayer)),
+                (heartbeat, timeouts).run_if(in_state(NetworkState::MultiPlayer)),
             )
             .add_systems(
                 FixedPostUpdate,