Update to Bevy 0.17.2

src/net/distribution.rs

@@ -6,7 +6,7 @@ use super::{
 };
 
 fn spawner<T: TryFrom<Vec<u8>> + Component>(
-    mut inbound: EventReader<InboundPacket>,
+    mut inbound: MessageReader<InboundPacket>,
     mut commands: Commands,
 ) {
     for InboundPacket(packet) in inbound.read() {
@@ -19,7 +19,7 @@ fn spawner<T: TryFrom<Vec<u8>> + Component>(
 fn sender<T: Into<Vec<u8>> + Component + Clone>(
     peers: Query<&PeerID, Added<Peer>>,
     entities: Query<&T>,
-    mut outbound: EventWriter<OutboundPacket>,
+    mut outbound: MessageWriter<OutboundPacket>,
 ) {
     for peer in peers {
         for entity in entities {

src/net/heartbeat.rs

@@ -7,7 +7,7 @@ use crate::net::{packet::PacketType, peer::PotentialPeers};
 use super::{
     io::{Config, format_message},
     packet::{OutboundPacket, Packet},
-    peer::{Peer, PeerChangeEvent, PeerID, PeerReceiveTiming, PeerSendTiming},
+    peer::{Peer, PeerChangeMessage, PeerID, PeerReceiveTiming, PeerSendTiming},
     queues::NetworkSend,
 };
 
@@ -19,7 +19,7 @@ const MISSED_PINGS: u32 = 3;
 pub fn heartbeat(
     peers: Query<(&PeerID, &PeerSendTiming)>,
     time: Res<Time>,
-    mut outbound: EventWriter<OutboundPacket>,
+    mut outbound: MessageWriter<OutboundPacket>,
 ) -> Result {
     for (peer, last) in peers {
         // Allow for 2 consecutive missed heartbeats without timing out
@@ -34,12 +34,12 @@ pub fn heartbeat(
 pub fn timeout(
     peers: Query<(&PeerID, &PeerReceiveTiming), With<Peer>>, // I mean... With<Peer> is inherent, but I guess I'll keep it as that might change
     time: Res<Time>,
-    mut delete: EventWriter<PeerChangeEvent>,
+    mut delete: MessageWriter<PeerChangeMessage>,
 ) {
     for (peer, last) in peers {
         if last.time() + PING_FREQUENCY * MISSED_PINGS < time.elapsed() {
             warn!("Peer {} timed out", peer.id);
-            delete.write(PeerChangeEvent::new(peer.id, None));
+            delete.write(PeerChangeMessage::new(peer.id, None));
         }
     }
 }
@@ -65,7 +65,7 @@ pub fn ping_potential_peers(
     config: Res<Config>,
 ) -> Result {
     timer.timer.tick(time.delta());
-    if timer.timer.finished() {
+    if timer.timer.is_finished() {
         for peer in &peers.addresses {
             to_socket.send(
                 format_message(&Vec::new(), PacketType::Peer, config.id),

src/net/io.rs

@@ -5,7 +5,7 @@ use crate::net::packet::PacketType;
 
 use super::{
     packet::{InboundPacket, OutboundPacket, Packet},
-    peer::{PeerChangeEvent, PeerData, PeerMap, PeerReceiveTiming, PeerSendTiming},
+    peer::{PeerChangeMessage, PeerData, PeerMap, PeerReceiveTiming, PeerSendTiming},
     queues::{NetworkReceive, NetworkSend},
 };
 
@@ -28,9 +28,9 @@ pub fn handle_network_input(
     from_socket: Res<NetworkReceive>,
     peer_map: Res<PeerMap>,
     mut peers: Query<(&PeerData, &mut PeerReceiveTiming)>,
-    mut to_app: EventWriter<InboundPacket>,
+    mut to_app: MessageWriter<InboundPacket>,
     time: Res<Time>,
-    mut change_peer: EventWriter<PeerChangeEvent>,
+    mut change_peer: MessageWriter<PeerChangeMessage>,
 ) -> Result {
     for (message, address) in from_socket.iter() {
         match Packet::try_from(message) {
@@ -46,7 +46,7 @@ pub fn handle_network_input(
                         continue;
                     }
                 }
-                change_peer.write(PeerChangeEvent::new(packet.peer, Some(address)));
+                change_peer.write(PeerChangeMessage::new(packet.peer, Some(address)));
             }
             Err(err) => warn!("Error reading packet: {:?}", err),
         }
@@ -55,7 +55,7 @@ pub fn handle_network_input(
 }
 
 pub fn handle_network_output(
-    mut from_app: EventReader<OutboundPacket>,
+    mut from_app: MessageReader<OutboundPacket>,
     peer_map: Res<PeerMap>,
     mut peers: Query<(&PeerData, &mut PeerSendTiming)>,
     config: Res<Config>,

src/net/packet.rs

@@ -77,7 +77,7 @@ impl TryFrom<Vec<u8>> for Packet {
     }
 }
 
-#[derive(Debug, Event)]
+#[derive(Debug, Message)]
 pub struct OutboundPacket(pub Packet);
 
 impl From<Packet> for OutboundPacket {
@@ -86,7 +86,7 @@ impl From<Packet> for OutboundPacket {
     }
 }
 
-#[derive(Debug, Event)]
+#[derive(Debug, Message)]
 pub struct InboundPacket(pub Packet);
 
 impl From<Packet> for InboundPacket {

src/net/peer.rs

@@ -181,20 +181,20 @@ impl PeerMap {
     }
 }
 
-#[derive(Debug, Event)]
-pub struct PeerChangeEvent {
+#[derive(Debug, Message)]
+pub struct PeerChangeMessage {
     peer: Uuid,
     addr: Option<SocketAddr>,
 }
 
-impl PeerChangeEvent {
+impl PeerChangeMessage {
     pub fn new(peer: Uuid, addr: Option<SocketAddr>) -> Self {
         Self { peer, addr }
     }
 }
 
 pub fn handle_peer_change(
-    mut changes: EventReader<PeerChangeEvent>,
+    mut changes: MessageReader<PeerChangeMessage>,
     mut peer_map: ResMut<PeerMap>,
     mut peers: Query<&mut PeerData>,
     mut potential_peers: ResMut<PotentialPeers>,
@@ -242,7 +242,7 @@ pub fn handle_peer_change(
 }
 
 pub fn new_peer_message(
-    mut from_network: EventReader<InboundPacket>,
+    mut from_network: MessageReader<InboundPacket>,
     peers: Query<&PeerData>,
     mut potential_peers: ResMut<PotentialPeers>,
 ) {
@@ -264,7 +264,7 @@ pub fn new_peer_message(
 // TODO: Make this a more generic system
 pub fn handle_new_peer(
     peers: Query<(Ref<Peer>, &PeerID, &PeerData)>,
-    mut outbound: EventWriter<OutboundPacket>,
+    mut outbound: MessageWriter<OutboundPacket>,
 ) {
     for (change, peer, _) in peers {
         if change.is_added() {

src/net/plugin.rs

@@ -7,7 +7,7 @@ use super::{
     io::{Config, handle_network_input, handle_network_output},
     packet::{InboundPacket, OutboundPacket},
     peer::{
-        PeerChangeEvent, PeerMap, PotentialPeers, handle_new_peer, handle_peer_change,
+        PeerChangeMessage, PeerMap, PotentialPeers, handle_new_peer, handle_peer_change,
         new_peer_message,
     },
     queues::{NetworkReceive, NetworkSend},
@@ -46,9 +46,9 @@ impl Plugin for NetIOPlugin {
         .init_resource::<PeerMap>()
         .init_resource::<PotentialPeerTimer>()
         .insert_resource(PotentialPeers::new(self.initial_peers.clone()))
-        .add_event::<PeerChangeEvent>()
-        .add_event::<InboundPacket>()
-        .add_event::<OutboundPacket>();
+        .add_message::<PeerChangeMessage>()
+        .add_message::<InboundPacket>()
+        .add_message::<OutboundPacket>();
 
         match bind_socket(self.listen) {
             Ok((send, receive)) => {