upgrade bevy to 0.17.0-rc.2

7 files changed, 87 insertions, 125 deletions

diff --git a/azalea-client/src/plugins/packet/config/events.rs b/azalea-client/src/plugins/packet/config/events.rs
index a9237e75..be5cfdb1 100644
--- a/azalea-client/src/plugins/packet/config/events.rs
+++ b/azalea-client/src/plugins/packet/config/events.rs
@@ -9,7 +9,7 @@ use tracing::{debug, error};
 
 use crate::{InConfigState, connection::RawConnection};
 
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct ReceiveConfigPacketEvent {
     /// The client entity that received the packet.
     pub entity: Entity,
@@ -19,8 +19,9 @@ pub struct ReceiveConfigPacketEvent {
 
 /// An event for sending a packet to the server while we're in the
 /// `configuration` state.
-#[derive(Event, Clone)]
+#[derive(EntityEvent, Clone)]
 pub struct SendConfigPacketEvent {
+    #[event_target]
     pub sent_by: Entity,
     pub packet: ServerboundConfigPacket,
 }
@@ -32,41 +33,33 @@ impl SendConfigPacketEvent {
 }
 
 pub fn handle_outgoing_packets_observer(
-    trigger: Trigger<SendConfigPacketEvent>,
+    send_config_packet: On<SendConfigPacketEvent>,
     mut query: Query<(&mut RawConnection, Option<&InConfigState>)>,
 ) {
-    let event = trigger.event();
-    if let Ok((mut raw_conn, in_configuration_state)) = query.get_mut(event.sent_by) {
+    if let Ok((mut raw_conn, in_configuration_state)) = query.get_mut(send_config_packet.sent_by) {
         if in_configuration_state.is_none() {
             error!(
                 "Tried to send a configuration packet {:?} while not in configuration state",
-                event.packet
+                send_config_packet.packet
             );
             return;
         }
-        debug!("Sending config packet: {:?}", event.packet);
-        if let Err(e) = raw_conn.write(event.packet.clone()) {
+        debug!("Sending config packet: {:?}", send_config_packet.packet);
+        if let Err(e) = raw_conn.write(send_config_packet.packet.clone()) {
             error!("Failed to send packet: {e}");
         }
     }
 }
-/// A system that converts [`SendConfigPacketEvent`] events into triggers so
-/// they get received by [`handle_outgoing_packets_observer`].
-pub fn handle_outgoing_packets(
-    mut commands: Commands,
-    mut events: EventReader<SendConfigPacketEvent>,
-) {
-    for event in events.read() {
-        commands.trigger(event.clone());
-    }
-}
 
 /// A Bevy trigger that's sent when our client receives a [`ClientboundPing`]
 /// packet in the config state.
 ///
-/// See [`PingEvent`] for more information.
+/// Also see [`PingEvent`].
 ///
 /// [`ClientboundPing`]: azalea_protocol::packets::config::ClientboundPing
 /// [`PingEvent`]: crate::packet::game::PingEvent
 #[derive(Event, Debug, Clone)]
-pub struct ConfigPingEvent(pub azalea_protocol::packets::config::ClientboundPing);
+pub struct ConfigPingEvent {
+    pub entity: Entity,
+    pub packet: azalea_protocol::packets::config::ClientboundPing,
+}
diff --git a/azalea-client/src/plugins/packet/config/mod.rs b/azalea-client/src/plugins/packet/config/mod.rs
index 416019e8..e8bb017d 100644
--- a/azalea-client/src/plugins/packet/config/mod.rs
+++ b/azalea-client/src/plugins/packet/config/mod.rs
@@ -84,7 +84,7 @@ impl ConfigPacketHandler<'_> {
 
     pub fn disconnect(&mut self, p: &ClientboundDisconnect) {
         warn!("Got disconnect packet {p:?}");
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(DisconnectEvent {
                 entity: self.player,
                 reason: Some(p.reason.clone()),
@@ -126,7 +126,7 @@ impl ConfigPacketHandler<'_> {
             self.player
         );
 
-        as_system::<(Commands, EventWriter<_>)>(self.ecs, |(mut commands, mut events)| {
+        as_system::<(Commands, MessageWriter<_>)>(self.ecs, |(mut commands, mut events)| {
             events.write(KeepAliveEvent {
                 entity: self.player,
                 id: p.id,
@@ -142,14 +142,17 @@ impl ConfigPacketHandler<'_> {
         debug!("Got ping packet (in configuration) {p:?}");
 
         as_system::<Commands>(self.ecs, |mut commands| {
-            commands.trigger_targets(ConfigPingEvent(p.clone()), self.player);
+            commands.trigger(ConfigPingEvent {
+                entity: self.player,
+                packet: p.clone(),
+            });
         });
     }
 
     pub fn resource_pack_push(&mut self, p: &ClientboundResourcePackPush) {
         debug!("Got resource pack push packet {p:?}");
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(ResourcePackEvent {
                 entity: self.player,
                 id: p.id,
diff --git a/azalea-client/src/plugins/packet/game/events.rs b/azalea-client/src/plugins/packet/game/events.rs
index e341db3e..4ae51734 100644
--- a/azalea-client/src/plugins/packet/game/events.rs
+++ b/azalea-client/src/plugins/packet/game/events.rs
@@ -18,9 +18,9 @@ use crate::{client::InGameState, connection::RawConnection, player::PlayerInfo};
 /// ```
 /// # use azalea_client::packet::game::ReceiveGamePacketEvent;
 /// # use azalea_protocol::packets::game::ClientboundGamePacket;
-/// # use bevy_ecs::event::EventReader;
+/// # use bevy_ecs::event::MessageReader;
 ///
-/// fn handle_packets(mut events: EventReader<ReceiveGamePacketEvent>) {
+/// fn handle_packets(mut events: MessageReader<ReceiveGamePacketEvent>) {
 ///     for ReceiveGamePacketEvent { entity, packet } in events.read() {
 ///         match packet.as_ref() {
 ///             ClientboundGamePacket::LevelParticles(p) => {
@@ -31,7 +31,7 @@ use crate::{client::InGameState, connection::RawConnection, player::PlayerInfo};
 ///     }
 /// }
 /// ```
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct ReceiveGamePacketEvent {
     /// The client entity that received the packet.
     pub entity: Entity,
@@ -40,8 +40,9 @@ pub struct ReceiveGamePacketEvent {
 }
 
 /// An event for sending a packet to the server while we're in the `game` state.
-#[derive(Event, Clone, Debug)]
+#[derive(EntityEvent, Clone, Debug)]
 pub struct SendPacketEvent {
+    #[event_target]
     pub sent_by: Entity,
     pub packet: ServerboundGamePacket,
 }
@@ -53,7 +54,7 @@ impl SendPacketEvent {
 }
 
 pub fn handle_outgoing_packets_observer(
-    trigger: Trigger<SendPacketEvent>,
+    trigger: On<SendPacketEvent>,
     mut query: Query<(&mut RawConnection, Option<&InGameState>)>,
 ) {
     let event = trigger.event();
@@ -76,17 +77,9 @@ pub fn handle_outgoing_packets_observer(
     }
 }
 
-/// A system that converts [`SendPacketEvent`] events into triggers so they get
-/// received by [`handle_outgoing_packets_observer`].
-pub fn handle_outgoing_packets(mut commands: Commands, mut events: EventReader<SendPacketEvent>) {
-    for event in events.read() {
-        commands.trigger(event.clone());
-    }
-}
-
 /// A player joined the game (or more specifically, was added to the tab
 /// list of a local player).
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct AddPlayerEvent {
     /// The local player entity that received this event.
     pub entity: Entity,
@@ -94,7 +87,7 @@ pub struct AddPlayerEvent {
 }
 /// A player left the game (or maybe is still in the game and was just
 /// removed from the tab list of a local player).
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct RemovePlayerEvent {
     /// The local player entity that received this event.
     pub entity: Entity,
@@ -102,7 +95,7 @@ pub struct RemovePlayerEvent {
 }
 /// A player was updated in the tab list of a local player (gamemode, display
 /// name, or latency changed).
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct UpdatePlayerEvent {
     /// The local player entity that received this event.
     pub entity: Entity,
@@ -112,7 +105,7 @@ pub struct UpdatePlayerEvent {
 /// Event for when an entity dies. dies. If it's a local player and there's a
 /// reason in the death screen, the [`ClientboundPlayerCombatKill`] will
 /// be included.
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct DeathEvent {
     pub entity: Entity,
     pub packet: Option<ClientboundPlayerCombatKill>,
@@ -120,7 +113,7 @@ pub struct DeathEvent {
 
 /// A KeepAlive packet is sent from the server to verify that the client is
 /// still connected.
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct KeepAliveEvent {
     pub entity: Entity,
     /// The ID of the keepalive. This is an arbitrary number, but vanilla
@@ -128,7 +121,7 @@ pub struct KeepAliveEvent {
     pub id: u64,
 }
 
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct ResourcePackEvent {
     pub entity: Entity,
     /// The random ID for this request to download the resource pack. The packet
@@ -144,7 +137,7 @@ pub struct ResourcePackEvent {
 ///
 /// Since the instance is given to you as a weak reference, it won't be able to
 /// be `upgrade`d if all local players leave it.
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct InstanceLoadedEvent {
     pub entity: Entity,
     pub name: ResourceLocation,
@@ -156,15 +149,10 @@ pub struct InstanceLoadedEvent {
 ///
 /// Also see [`ConfigPingEvent`] which is used for the config state.
 ///
-/// This is not an event and can't be listened to from a normal system,
-///so  `EventReader<PingEvent>` will not work.
-///
-/// To use it, add your "system" with `add_observer` instead of `add_systems`
-/// and use `Trigger<PingEvent>` instead of `EventReader`.
-///
-/// The client Entity that received the packet will be attached to the trigger.
-///
 /// [`ClientboundPing`]: azalea_protocol::packets::game::ClientboundPing
 /// [`ConfigPingEvent`]: crate::packet::config::ConfigPingEvent
-#[derive(Event, Debug, Clone)]
-pub struct PingEvent(pub azalea_protocol::packets::game::ClientboundPing);
+#[derive(EntityEvent, Debug, Clone)]
+pub struct PingEvent {
+    pub entity: Entity,
+    pub packet: azalea_protocol::packets::game::ClientboundPing,
+}
diff --git a/azalea-client/src/plugins/packet/game/mod.rs b/azalea-client/src/plugins/packet/game/mod.rs
index fc8f34cf..dbdc8e26 100644
--- a/azalea-client/src/plugins/packet/game/mod.rs
+++ b/azalea-client/src/plugins/packet/game/mod.rs
@@ -207,7 +207,7 @@ impl GamePacketHandler<'_> {
                 ),
                 With<LocalEntity>,
             >,
-            EventWriter<InstanceLoadedEvent>,
+            MessageWriter<InstanceLoadedEvent>,
             ResMut<InstanceContainer>,
             ResMut<EntityUuidIndex>,
             Query<&mut LoadedBy, Without<LocalEntity>>,
@@ -336,7 +336,7 @@ impl GamePacketHandler<'_> {
         // ends
         debug!("Got chunk batch start");
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(chunks::ChunkBatchStartEvent {
                 entity: self.player,
             });
@@ -346,7 +346,7 @@ impl GamePacketHandler<'_> {
     pub fn chunk_batch_finished(&mut self, p: &ClientboundChunkBatchFinished) {
         debug!("Got chunk batch finished {p:?}");
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(chunks::ChunkBatchFinishedEvent {
                 entity: self.player,
                 batch_size: p.batch_size,
@@ -387,7 +387,7 @@ impl GamePacketHandler<'_> {
     pub fn disconnect(&mut self, p: &ClientboundDisconnect) {
         warn!("Got disconnect packet {p:?}");
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(DisconnectEvent {
                 entity: self.player,
                 reason: Some(p.reason.clone()),
@@ -440,8 +440,8 @@ impl GamePacketHandler<'_> {
 
         as_system::<(
             Query<&mut TabList>,
-            EventWriter<AddPlayerEvent>,
-            EventWriter<UpdatePlayerEvent>,
+            MessageWriter<AddPlayerEvent>,
+            MessageWriter<UpdatePlayerEvent>,
             ResMut<TabList>,
         )>(
             self.ecs,
@@ -500,7 +500,7 @@ impl GamePacketHandler<'_> {
 
         as_system::<(
             Query<&mut TabList>,
-            EventWriter<RemovePlayerEvent>,
+            MessageWriter<RemovePlayerEvent>,
             ResMut<TabList>,
         )>(
             self.ecs,
@@ -542,7 +542,7 @@ impl GamePacketHandler<'_> {
     pub fn level_chunk_with_light(&mut self, p: &ClientboundLevelChunkWithLight) {
         debug!("Got chunk with light packet {} {}", p.x, p.z);
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(chunks::ReceiveChunkEvent {
                 entity: self.player,
                 packet: p.clone(),
@@ -740,7 +740,7 @@ impl GamePacketHandler<'_> {
                     instance_holder.partial_instance.clone(),
                     move |entity_mut| {
                         entity_mut.world_scope(|world| {
-                            world.send_event(KnockbackEvent { entity, knockback })
+                            world.write_message(KnockbackEvent { entity, knockback })
                         });
                     },
                 ));
@@ -957,7 +957,7 @@ impl GamePacketHandler<'_> {
     pub fn keep_alive(&mut self, p: &ClientboundKeepAlive) {
         debug!("Got keep alive packet {p:?} for {:?}", self.player);
 
-        as_system::<(EventWriter<KeepAliveEvent>, Commands)>(
+        as_system::<(MessageWriter<KeepAliveEvent>, Commands)>(
             self.ecs,
             |(mut keepalive_events, mut commands)| {
                 keepalive_events.write(KeepAliveEvent {
@@ -1011,7 +1011,7 @@ impl GamePacketHandler<'_> {
     pub fn player_chat(&mut self, p: &ClientboundPlayerChat) {
         debug!("Got player chat packet {p:?}");
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(ChatReceivedEvent {
                 entity: self.player,
                 packet: ChatPacket::Player(Arc::new(p.clone())),
@@ -1022,7 +1022,7 @@ impl GamePacketHandler<'_> {
     pub fn system_chat(&mut self, p: &ClientboundSystemChat) {
         debug!("Got system chat packet {p:?}");
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(ChatReceivedEvent {
                 entity: self.player,
                 packet: ChatPacket::System(Arc::new(p.clone())),
@@ -1033,7 +1033,7 @@ impl GamePacketHandler<'_> {
     pub fn disguised_chat(&mut self, p: &ClientboundDisguisedChat) {
         debug!("Got disguised chat packet {p:?}");
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(ChatReceivedEvent {
                 entity: self.player,
                 packet: ChatPacket::Disguised(Arc::new(p.clone())),
@@ -1227,7 +1227,7 @@ impl GamePacketHandler<'_> {
     pub fn explode(&mut self, p: &ClientboundExplode) {
         trace!("Got explode packet {p:?}");
 
-        as_system::<EventWriter<_>>(self.ecs, |mut knockback_events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut knockback_events| {
             if let Some(knockback) = p.knockback {
                 knockback_events.write(KnockbackEvent {
                     entity: self.player,
@@ -1278,7 +1278,10 @@ impl GamePacketHandler<'_> {
         debug!("Got ping packet {p:?}");
 
         as_system::<Commands>(self.ecs, |mut commands| {
-            commands.trigger_targets(PingEvent(p.clone()), self.player);
+            commands.trigger(PingEvent {
+                entity: self.player,
+                packet: p.clone(),
+            });
         });
     }
 
@@ -1294,7 +1297,7 @@ impl GamePacketHandler<'_> {
         as_system::<(
             Commands,
             Query<(&MinecraftEntityId, Option<&Dead>)>,
-            EventWriter<_>,
+            MessageWriter<_>,
         )>(self.ecs, |(mut commands, mut query, mut events)| {
             let (entity_id, dead) = query.get_mut(self.player).unwrap();
 
@@ -1315,7 +1318,7 @@ impl GamePacketHandler<'_> {
     pub fn resource_pack_push(&mut self, p: &ClientboundResourcePackPush) {
         debug!("Got resource pack packet {p:?}");
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(ResourcePackEvent {
                 entity: self.player,
                 id: p.id,
@@ -1343,7 +1346,7 @@ impl GamePacketHandler<'_> {
                 ),
                 With<LocalEntity>,
             >,
-            EventWriter<_>,
+            MessageWriter<_>,
             ResMut<InstanceContainer>,
             Query<&mut LoadedBy, Without<LocalEntity>>,
         )>(
diff --git a/azalea-client/src/plugins/packet/login/events.rs b/azalea-client/src/plugins/packet/login/events.rs
index fc7a6b22..f50c1423 100644
--- a/azalea-client/src/plugins/packet/login/events.rs
+++ b/azalea-client/src/plugins/packet/login/events.rs
@@ -12,7 +12,7 @@ use tracing::{debug, error};
 use super::InLoginState;
 use crate::{Account, connection::RawConnection};
 
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct ReceiveLoginPacketEvent {
     /// The client entity that received the packet.
     pub entity: Entity,
@@ -20,13 +20,14 @@ pub struct ReceiveLoginPacketEvent {
     pub packet: Arc<ClientboundLoginPacket>,
 }
 
-#[derive(Event, Debug, Clone)]
+#[derive(EntityEvent, Debug, Clone)]
 pub struct ReceiveHelloEvent {
+    pub entity: Entity,
     pub account: Account,
     pub packet: ClientboundHello,
 }
 
-#[derive(Event, Debug, Clone)]
+#[derive(Message, Debug, Clone)]
 pub struct ReceiveCustomQueryEvent {
     /// The client entity that received the packet.
     pub entity: Entity,
@@ -40,8 +41,9 @@ pub struct ReceiveCustomQueryEvent {
 }
 
 /// Event for sending a login packet to the server.
-#[derive(Event, Debug, Clone)]
+#[derive(EntityEvent, Debug, Clone)]
 pub struct SendLoginPacketEvent {
+    #[event_target]
     pub sent_by: Entity,
     pub packet: ServerboundLoginPacket,
 }
@@ -56,7 +58,7 @@ impl SendLoginPacketEvent {
 }
 
 pub fn handle_outgoing_packets_observer(
-    trigger: Trigger<SendLoginPacketEvent>,
+    trigger: On<SendLoginPacketEvent>,
     mut query: Query<(&mut RawConnection, Option<&InLoginState>)>,
 ) {
     let event = trigger.event();
@@ -74,13 +76,3 @@ pub fn handle_outgoing_packets_observer(
         }
     }
 }
-/// A system that converts [`SendLoginPacketEvent`] events into triggers so
-/// they get received by [`handle_outgoing_packets_observer`].
-pub fn handle_outgoing_packets(
-    mut commands: Commands,
-    mut events: EventReader<SendLoginPacketEvent>,
-) {
-    for event in events.read() {
-        commands.trigger(event.clone());
-    }
-}
diff --git a/azalea-client/src/plugins/packet/login/mod.rs b/azalea-client/src/plugins/packet/login/mod.rs
index 03e87920..63226124 100644
--- a/azalea-client/src/plugins/packet/login/mod.rs
+++ b/azalea-client/src/plugins/packet/login/mod.rs
@@ -59,19 +59,17 @@ impl LoginPacketHandler<'_> {
                 );
                 return;
             };
-            commands.trigger_targets(
-                ReceiveHelloEvent {
-                    account: account.clone(),
-                    packet: p.clone(),
-                },
-                self.player,
-            );
+            commands.trigger(ReceiveHelloEvent {
+                entity: self.player,
+                account: account.clone(),
+                packet: p.clone(),
+            });
         });
     }
     pub fn login_disconnect(&mut self, p: &ClientboundLoginDisconnect) {
         debug!("Got disconnect {:?}", p);
 
-        as_system::<EventWriter<_>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<_>>(self.ecs, |mut events| {
             events.write(DisconnectEvent {
                 entity: self.player,
                 reason: Some(p.reason.clone()),
@@ -120,7 +118,7 @@ impl LoginPacketHandler<'_> {
     pub fn custom_query(&mut self, p: &ClientboundCustomQuery) {
         debug!("Got custom query {p:?}");
 
-        as_system::<EventWriter<ReceiveCustomQueryEvent>>(self.ecs, |mut events| {
+        as_system::<MessageWriter<ReceiveCustomQueryEvent>>(self.ecs, |mut events| {
             events.write(ReceiveCustomQueryEvent {
                 entity: self.player,
                 packet: p.clone(),
diff --git a/azalea-client/src/plugins/packet/mod.rs b/azalea-client/src/plugins/packet/mod.rs
index 2602e878..30503d50 100644
--- a/azalea-client/src/plugins/packet/mod.rs
+++ b/azalea-client/src/plugins/packet/mod.rs
@@ -16,7 +16,7 @@ pub struct PacketPlugin;
 
 pub fn death_event_on_0_health(
     query: Query<(Entity, &Health), Changed<Health>>,
-    mut death_events: EventWriter<DeathEvent>,
+    mut death_events: MessageWriter<DeathEvent>,
 ) {
     for (entity, health) in query.iter() {
         if **health == 0. {
@@ -33,35 +33,20 @@ impl Plugin for PacketPlugin {
         app.add_observer(game::handle_outgoing_packets_observer)
             .add_observer(config::handle_outgoing_packets_observer)
             .add_observer(login::handle_outgoing_packets_observer)
-            .add_systems(
-                Update,
-                (
-                    (
-                        config::handle_outgoing_packets,
-                        game::handle_outgoing_packets,
-                        login::handle_outgoing_packets,
-                    )
-                        .chain(),
-                    death_event_on_0_health.before(death_listener),
-                ),
-            )
-            .add_event::<game::ReceiveGamePacketEvent>()
-            .add_event::<config::ReceiveConfigPacketEvent>()
-            .add_event::<login::ReceiveLoginPacketEvent>()
+            .add_systems(Update, death_event_on_0_health.before(death_listener))
+            .add_message::<game::ReceiveGamePacketEvent>()
+            .add_message::<config::ReceiveConfigPacketEvent>()
+            .add_message::<login::ReceiveLoginPacketEvent>()
             //
-            .add_event::<game::SendPacketEvent>()
-            .add_event::<config::SendConfigPacketEvent>()
-            .add_event::<login::SendLoginPacketEvent>()
-            //
-            .add_event::<game::AddPlayerEvent>()
-            .add_event::<game::RemovePlayerEvent>()
-            .add_event::<game::UpdatePlayerEvent>()
-            .add_event::<ChatReceivedEvent>()
-            .add_event::<game::DeathEvent>()
-            .add_event::<game::KeepAliveEvent>()
-            .add_event::<game::ResourcePackEvent>()
-            .add_event::<game::InstanceLoadedEvent>()
-            .add_event::<login::ReceiveCustomQueryEvent>();
+            .add_message::<game::AddPlayerEvent>()
+            .add_message::<game::RemovePlayerEvent>()
+            .add_message::<game::UpdatePlayerEvent>()
+            .add_message::<ChatReceivedEvent>()
+            .add_message::<game::DeathEvent>()
+            .add_message::<game::KeepAliveEvent>()
+            .add_message::<game::ResourcePackEvent>()
+            .add_message::<game::InstanceLoadedEvent>()
+            .add_message::<login::ReceiveCustomQueryEvent>();
     }
 }