Don't immediately send heartbeat

src/net/io.rs

@@ -4,6 +4,7 @@ use bevy::prelude::*;
 use uuid::Uuid;
 
 use super::{
+    packet::{InboundPacket, OutboundPacket, Packet},
     peer::{Peer, PeerChangeEvent, PeerMap, PeerReceiveTiming, PeerSendTiming},
     queues::{NetworkReceive, NetworkSend},
 };
@@ -18,10 +19,13 @@ pub fn handle_network_input(
 ) -> Result {
     for (mut message, address) in from_socket.iter() {
         if message.len() < 16 {
-            return Err(format!("Message of length {} cannot contain UUID", message.len()).into());
+            return Err(format!(
+                "Message of length {} is not large enough to 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)?;
@@ -46,7 +50,6 @@ 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)?;
@@ -63,12 +66,10 @@ pub fn heartbeat(
     mut outbound: EventWriter<OutboundPacket>,
 ) {
     for (peer, last) in peers {
-        if let Some(previous) = last.timestamp() {
         // Allow for 2 consecutive missed heartbeats without timing out
-            if previous + TIMEOUT / 3 > time.elapsed() {
+        if last.time() + TIMEOUT / 3 > time.elapsed() {
             continue;
         }
-        }
         outbound.write(OutboundPacket(Packet::new(Vec::new(), peer.uuid)));
     }
 }
@@ -79,7 +80,7 @@ pub fn timeouts(
     mut delete: EventWriter<PeerChangeEvent>,
 ) {
     for (peer, last) in peers {
-        if let Some(previous) = last.timestamp() {
+        if let Some(previous) = last.time() {
             if previous + TIMEOUT < time.elapsed() {
                 warn!("Peer {} timed out", peer.uuid);
                 delete.write(PeerChangeEvent::new(peer.uuid, None));
@@ -98,21 +99,3 @@ 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,4 +1,5 @@
 mod io;
+mod packet;
 mod peer;
 mod plugin;
 mod queues;
@@ -7,7 +8,7 @@ mod thread;
 
 #[allow(unused_imports)]
 pub mod prelude {
-    pub use super::io::{InboundPacket, OutboundPacket, Packet};
+    pub use super::packet::{InboundPacket, OutboundPacket, Packet};
     pub use super::peer::Peer;
     pub use super::plugin::{NetIOPlugin, NetworkState};
 }

src/net/packet.rs

@@ -0,0 +1,20 @@
+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,40 +3,35 @@ use std::{collections::HashMap, net::SocketAddr, time::Duration};
 use bevy::prelude::*;
 use uuid::Uuid;
 
-#[derive(Debug, Default)]
-struct Timing {
-    timestamp: Option<Duration>,
-}
+use super::packet::{OutboundPacket, Packet};
 
 #[derive(Component, Debug, Default)]
-pub struct PeerSendTiming(Timing);
+pub struct PeerSendTiming(Duration);
 
 impl PeerSendTiming {
     pub fn update(&mut self, time: &Res<Time>) {
-        self.0.timestamp = Some(time.elapsed())
+        self.0 = time.elapsed()
     }
 
-    pub fn timestamp(&self) -> Option<Duration> {
-        self.0.timestamp
+    pub fn time(&self) -> Duration {
+        self.0
     }
 }
 
 #[derive(Component, Debug, Default)]
-pub struct PeerReceiveTiming(Timing);
+pub struct PeerReceiveTiming(Option<Duration>);
 
 impl PeerReceiveTiming {
     pub fn new(time: &Res<Time>) -> Self {
-        Self(Timing {
-            timestamp: Some(time.elapsed()),
-        })
+        Self(Some(time.elapsed()))
     }
 
     pub fn update(&mut self, time: &Res<Time>) {
-        self.0.timestamp = Some(time.elapsed())
+        self.0 = Some(time.elapsed())
     }
 
-    pub fn timestamp(&self) -> Option<Duration> {
-        self.0.timestamp
+    pub fn time(&self) -> Option<Duration> {
+        self.0
     }
 }
 
@@ -108,7 +103,6 @@ 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);
             }
@@ -126,9 +120,17 @@ 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,11 +4,9 @@ use bevy::prelude::*;
 use uuid::Uuid;
 
 use super::{
-    io::{
-        Config, InboundPacket, OutboundPacket, handle_network_input, handle_network_output,
-        heartbeat, timeouts,
-    },
-    peer::{Peer, PeerChangeEvent, PeerMap, handle_peer_change},
+    io::{Config, handle_network_input, handle_network_output, heartbeat, timeouts},
+    packet::{InboundPacket, OutboundPacket},
+    peer::{Peer, PeerChangeEvent, PeerMap, handle_new_peer, handle_peer_change},
     queues::{NetworkReceive, NetworkSend},
     socket::bind_socket,
 };
@@ -42,7 +40,7 @@ impl Plugin for NetIOPlugin {
             )
             .add_systems(
                 FixedUpdate,
-                (heartbeat, timeouts).run_if(in_state(NetworkState::MultiPlayer)),
+                (heartbeat, timeouts, handle_new_peer).run_if(in_state(NetworkState::MultiPlayer)),
             )
             .add_systems(
                 FixedPostUpdate,