From e58629c2f14f996ae891b9121cbf9f910bd34b65 Mon Sep 17 00:00:00 2001
From: Michael Bradley <michaelmbrad@gmail.com>
Date: Sat, 5 Jul 2025 18:09:46 -0400
Subject: [PATCH] Don't immediately send heartbeat

---
 src/net/io.rs     | 29 +++++------------------------
 src/net/mod.rs    |  3 ++-
 src/net/packet.rs | 20 ++++++++++++++++++++
 src/net/peer.rs   | 34 +++++++++++++++++++---------------
 src/net/plugin.rs | 10 ++++------
 5 files changed, 50 insertions(+), 46 deletions(-)
 create mode 100644 src/net/packet.rs

diff --git a/src/net/io.rs b/src/net/io.rs
index 0367696..d02a3da 100644
--- a/src/net/io.rs
+++ b/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},
 };
@@ -65,11 +66,9 @@ 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() {
-                continue;
-            }
+        // Allow for 2 consecutive missed heartbeats without timing out
+        if last.time() + TIMEOUT / 3 > time.elapsed() {
+            continue;
         }
         outbound.write(OutboundPacket(Packet::new(Vec::new(), peer.uuid)));
     }
@@ -81,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));
@@ -100,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);
diff --git a/src/net/mod.rs b/src/net/mod.rs
index c7d405c..c310356 100644
--- a/src/net/mod.rs
+++ b/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};
 }
diff --git a/src/net/packet.rs b/src/net/packet.rs
new file mode 100644
index 0000000..d9bf240
--- /dev/null
+++ b/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);
diff --git a/src/net/peer.rs b/src/net/peer.rs
index c7e8ad1..650ee32 100644
--- a/src/net/peer.rs
+++ b/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
     }
 }
 
@@ -130,3 +125,12 @@ pub fn handle_peer_change(
     }
     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)));
+    }
+}
diff --git a/src/net/plugin.rs b/src/net/plugin.rs
index c803caa..8d3064a 100644
--- a/src/net/plugin.rs
+++ b/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,