Split clientbound and serverbound packets

azalea-protocol/packet-macros/src/lib.rs

@@ -40,24 +40,56 @@ fn as_packet_derive(input: TokenStream, state: proc_macro2::TokenStream) -> Toke
     contents.into()
 }
 
-#[proc_macro_derive(GamePacket, attributes(var))]
+#[proc_macro_derive(ServerboundGamePacket, attributes(var))]
-pub fn derive_game_packet(input: TokenStream) -> TokenStream {
+pub fn derive_serverbound_game_packet(input: TokenStream) -> TokenStream {
-    as_packet_derive(input, quote! {crate::packets::game::GamePacket})
+    as_packet_derive(input, quote! {crate::packets::game::ServerboundGamePacket})
+}
+#[proc_macro_derive(ServerboundHandshakePacket, attributes(var))]
+pub fn derive_serverbound_handshake_packet(input: TokenStream) -> TokenStream {
+    as_packet_derive(
+        input,
+        quote! {crate::packets::handshake::ServerboundHandshakePacket},
+    )
+}
+#[proc_macro_derive(ServerboundLoginPacket, attributes(var))]
+pub fn derive_serverbound_login_packet(input: TokenStream) -> TokenStream {
+    as_packet_derive(
+        input,
+        quote! {crate::packets::login::ServerboundLoginPacket},
+    )
+}
+#[proc_macro_derive(ServerboundStatusPacket, attributes(var))]
+pub fn derive_serverbound_status_packet(input: TokenStream) -> TokenStream {
+    as_packet_derive(
+        input,
+        quote! {crate::packets::status::ServerboundStatusPacket},
+    )
 }
 
-#[proc_macro_derive(HandshakePacket, attributes(var))]
+#[proc_macro_derive(ClientboundGamePacket, attributes(var))]
-pub fn derive_handshake_packet(input: TokenStream) -> TokenStream {
+pub fn derive_clientbound_game_packet(input: TokenStream) -> TokenStream {
-    as_packet_derive(input, quote! {crate::packets::handshake::HandshakePacket})
+    as_packet_derive(input, quote! {crate::packets::game::ClientboundGamePacket})
 }
-
+#[proc_macro_derive(ClientboundHandshakePacket, attributes(var))]
-#[proc_macro_derive(LoginPacket, attributes(var))]
+pub fn derive_clientbound_handshake_packet(input: TokenStream) -> TokenStream {
-pub fn derive_login_packet(input: TokenStream) -> TokenStream {
+    as_packet_derive(
-    as_packet_derive(input, quote! {crate::packets::login::LoginPacket})
+        input,
+        quote! {crate::packets::handshake::ClientboundHandshakePacket},
+    )
 }
-
+#[proc_macro_derive(ClientboundLoginPacket, attributes(var))]
-#[proc_macro_derive(StatusPacket, attributes(var))]
+pub fn derive_clientbound_login_packet(input: TokenStream) -> TokenStream {
-pub fn derive_status_packet(input: TokenStream) -> TokenStream {
+    as_packet_derive(
-    as_packet_derive(input, quote! {crate::packets::status::StatusPacket})
+        input,
+        quote! {crate::packets::login::ClientboundLoginPacket},
+    )
+}
+#[proc_macro_derive(ClientboundStatusPacket, attributes(var))]
+pub fn derive_clientbound_status_packet(input: TokenStream) -> TokenStream {
+    as_packet_derive(
+        input,
+        quote! {crate::packets::status::ClientboundStatusPacket},
+    )
 }
 
 #[derive(Debug)]
@@ -154,23 +186,34 @@ impl Parse for DeclareStatePackets {
 pub fn declare_state_packets(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeclareStatePackets);
 
-    let state_name = input.name;
+    let serverbound_state_name =
-    let state_name_litstr = syn::LitStr::new(&state_name.to_string(), state_name.span());
+        Ident::new(&format!("Serverbound{}", input.name), input.name.span());
+    let clientbound_state_name =
+        Ident::new(&format!("Clientbound{}", input.name), input.name.span());
 
-    let mut enum_contents = quote!();
+    let state_name_litstr = syn::LitStr::new(&input.name.to_string(), input.name.span());
-    let mut id_match_contents = quote!();
+
-    let mut write_match_contents = quote!();
+    let has_serverbound_packets = !input.serverbound.packets.is_empty();
+    let has_clientbound_packets = !input.clientbound.packets.is_empty();
+
+    let mut serverbound_enum_contents = quote!();
+    let mut clientbound_enum_contents = quote!();
+    let mut serverbound_id_match_contents = quote!();
+    let mut clientbound_id_match_contents = quote!();
+    let mut serverbound_write_match_contents = quote!();
+    let mut clientbound_write_match_contents = quote!();
     let mut serverbound_read_match_contents = quote!();
     let mut clientbound_read_match_contents = quote!();
+
     for PacketIdPair { id, module, name } in input.serverbound.packets {
-        enum_contents.extend(quote! {
+        serverbound_enum_contents.extend(quote! {
             #name(#module::#name),
         });
-        id_match_contents.extend(quote! {
+        serverbound_id_match_contents.extend(quote! {
-            #state_name::#name(_packet) => #id,
+            #serverbound_state_name::#name(_packet) => #id,
         });
-        write_match_contents.extend(quote! {
+        serverbound_write_match_contents.extend(quote! {
-            #state_name::#name(packet) => packet.write(buf),
+            #serverbound_state_name::#name(packet) => packet.write(buf),
         });
         serverbound_read_match_contents.extend(quote! {
             #id => #module::#name::read(buf)?,
@@ -178,63 +221,100 @@ pub fn declare_state_packets(input: TokenStream) -> TokenStream {
     }
     for PacketIdPair { id, module, name } in input.clientbound.packets {
         // let name_litstr = syn::LitStr::new(&name.to_string(), name.span());
-        enum_contents.extend(quote! {
+        clientbound_enum_contents.extend(quote! {
             #name(#module::#name),
         });
-        id_match_contents.extend(quote! {
+        clientbound_id_match_contents.extend(quote! {
-            #state_name::#name(_packet) => #id,
+            #clientbound_state_name::#name(_packet) => #id,
         });
-        write_match_contents.extend(quote! {
+        clientbound_write_match_contents.extend(quote! {
-            #state_name::#name(packet) => packet.write(buf),
+            #clientbound_state_name::#name(packet) => packet.write(buf),
         });
         clientbound_read_match_contents.extend(quote! {
             #id => #module::#name::read(buf)?,
         });
     }
 
-    quote! {
+    let mut contents = quote! {
         #[derive(Clone, Debug)]
-        pub enum #state_name
+        pub enum #serverbound_state_name
+        where
+        Self: Sized,
+        {
+            #serverbound_enum_contents
+        }
+        #[derive(Clone, Debug)]
+        pub enum #clientbound_state_name
         where
             Self: Sized,
         {
-            #enum_contents
+            #clientbound_enum_contents
         }
+    };
 
-        impl crate::packets::ProtocolPacket for #state_name {
+    contents.extend(quote!{
-            fn id(&self) -> u32 {
+            impl crate::packets::ProtocolPacket for #serverbound_state_name {
-                match self {
+                fn id(&self) -> u32 {
-                    #id_match_contents
+                    match self {
+                        #serverbound_id_match_contents
+                        _ => panic!("Impossible state, this packet shouldn't exist.")
+                    }
                 }
-            }
 
-            fn write(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
+                fn write(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
-                match self {
+                    match self {
-                    #write_match_contents
+                        #serverbound_write_match_contents
+                        _ => panic!("Impossible state, this packet shouldn't exist.")
+                    }
                 }
-            }
 
-            /// Read a packet by its id, ConnectionProtocol, and flow
+                /// Read a packet by its id, ConnectionProtocol, and flow
-            fn read(
+                fn read(
-                id: u32,
+                    id: u32,
-                flow: &crate::connect::PacketFlow,
+                    buf: &mut impl std::io::Read,
-                buf: &mut impl std::io::Read,
+                ) -> Result<#serverbound_state_name, String>
-            ) -> Result<#state_name, String>
+                where
-            where
+                    Self: Sized,
-                Self: Sized,
+                {
-            {
+                    Ok(match id {
-                Ok(match flow {
-                    crate::connect::PacketFlow::ServerToClient => match id {
-                        #clientbound_read_match_contents
-                        _ => return Err(format!("Unknown ServerToClient {} packet id: {}", #state_name_litstr, id)),
-                    },
-                    crate::connect::PacketFlow::ClientToServer => match id {
                         #serverbound_read_match_contents
-                        _ => return Err(format!("Unknown ClientToServer {} packet id: {}", #state_name_litstr, id)),
+                        _ => return Err(format!("Unknown Serverbound {} packet id: {}", #state_name_litstr, id)),
-                    },
+                    })
-                })
+                }
             }
-        }
+        });
-    }
+
-    .into()
+    contents.extend(quote!{
+            impl crate::packets::ProtocolPacket for #clientbound_state_name {
+                fn id(&self) -> u32 {
+                    match self {
+                        #clientbound_id_match_contents
+                        _ => panic!("Impossible state, this packet shouldn't exist.")
+                    }
+                }
+
+                fn write(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
+                    match self {
+                        #clientbound_write_match_contents
+                        _ => panic!("Impossible state, this packet shouldn't exist.")
+                    }
+                }
+
+                /// Read a packet by its id, ConnectionProtocol, and flow
+                fn read(
+                    id: u32,
+                    buf: &mut impl std::io::Read,
+                ) -> Result<#clientbound_state_name, String>
+                where
+                    Self: Sized,
+                {
+                    Ok(match id {
+                        #clientbound_read_match_contents
+                        _ => return Err(format!("Unknown Clientbound {} packet id: {}", #state_name_litstr, id)),
+                    })
+                }
+            }
+        });
+
+    contents.into()
 }

azalea-protocol/src/connect.rs

@@ -1,29 +1,21 @@
 //! parse sending and receiving packets with a server.
 
-use crate::packets::game::GamePacket;
+use crate::packets::game::{ClientboundGamePacket, ServerboundGamePacket};
-use crate::packets::handshake::HandshakePacket;
+use crate::packets::handshake::{ClientboundHandshakePacket, ServerboundHandshakePacket};
-use crate::packets::login::LoginPacket;
+use crate::packets::login::{ClientboundLoginPacket, ServerboundLoginPacket};
-use crate::packets::status::StatusPacket;
+use crate::packets::status::{ClientboundStatusPacket, ServerboundStatusPacket};
 use crate::read::read_packet;
 use crate::write::write_packet;
 use crate::ServerIpAddress;
 use azalea_crypto::{Aes128CfbDec, Aes128CfbEnc};
 use tokio::net::TcpStream;
 
-#[derive(Debug, Clone, Copy)]
-pub enum PacketFlow {
-    ClientToServer,
-    ServerToClient,
-}
-
 pub struct HandshakeConnection {
-    pub flow: PacketFlow,
     /// The buffered writer
     pub stream: TcpStream,
 }
 
 pub struct GameConnection {
-    pub flow: PacketFlow,
     /// The buffered writer
     pub stream: TcpStream,
     pub compression_threshold: Option<u32>,
@@ -32,13 +24,11 @@ pub struct GameConnection {
 }
 
 pub struct StatusConnection {
-    pub flow: PacketFlow,
     /// The buffered writer
     pub stream: TcpStream,
 }
 
 pub struct LoginConnection {
-    pub flow: PacketFlow,
     /// The buffered writer
     pub stream: TcpStream,
     pub compression_threshold: Option<u32>,
@@ -60,15 +50,11 @@ impl HandshakeConnection {
             .set_nodelay(true)
             .expect("Error enabling tcp_nodelay");
 
-        Ok(HandshakeConnection {
+        Ok(HandshakeConnection { stream })
-            flow: PacketFlow::ServerToClient,
-            stream,
-        })
     }
 
     pub fn login(self) -> LoginConnection {
         LoginConnection {
-            flow: self.flow,
             stream: self.stream,
             compression_threshold: None,
             enc_cipher: None,
@@ -78,25 +64,23 @@ impl HandshakeConnection {
 
     pub fn status(self) -> StatusConnection {
         StatusConnection {
-            flow: self.flow,
             stream: self.stream,
         }
     }
 
-    pub async fn read(&mut self) -> Result<HandshakePacket, String> {
+    pub async fn read(&mut self) -> Result<ClientboundHandshakePacket, String> {
-        read_packet::<HandshakePacket, _>(&self.flow, &mut self.stream, None, &mut None).await
+        read_packet::<ClientboundHandshakePacket, _>(&mut self.stream, None, &mut None).await
     }
 
     /// Write a packet to the server
-    pub async fn write(&mut self, packet: HandshakePacket) {
+    pub async fn write(&mut self, packet: ServerboundHandshakePacket) {
         write_packet(packet, &mut self.stream, None, &mut None).await;
     }
 }
 
 impl GameConnection {
-    pub async fn read(&mut self) -> Result<GamePacket, String> {
+    pub async fn read(&mut self) -> Result<ClientboundGamePacket, String> {
-        read_packet::<GamePacket, _>(
+        read_packet::<ClientboundGamePacket, _>(
-            &self.flow,
             &mut self.stream,
             self.compression_threshold,
             &mut self.dec_cipher,
@@ -105,7 +89,7 @@ impl GameConnection {
     }
 
     /// Write a packet to the server
-    pub async fn write(&mut self, packet: GamePacket) {
+    pub async fn write(&mut self, packet: ServerboundGamePacket) {
         write_packet(
             packet,
             &mut self.stream,
@@ -117,20 +101,19 @@ impl GameConnection {
 }
 
 impl StatusConnection {
-    pub async fn read(&mut self) -> Result<StatusPacket, String> {
+    pub async fn read(&mut self) -> Result<ClientboundStatusPacket, String> {
-        read_packet::<StatusPacket, _>(&self.flow, &mut self.stream, None, &mut None).await
+        read_packet::<ClientboundStatusPacket, _>(&mut self.stream, None, &mut None).await
     }
 
     /// Write a packet to the server
-    pub async fn write(&mut self, packet: StatusPacket) {
+    pub async fn write(&mut self, packet: ServerboundStatusPacket) {
         write_packet(packet, &mut self.stream, None, &mut None).await;
     }
 }
 
 impl LoginConnection {
-    pub async fn read(&mut self) -> Result<LoginPacket, String> {
+    pub async fn read(&mut self) -> Result<ClientboundLoginPacket, String> {
-        read_packet::<LoginPacket, _>(
+        read_packet::<ClientboundLoginPacket, _>(
-            &self.flow,
             &mut self.stream,
             self.compression_threshold,
             &mut self.dec_cipher,
@@ -139,7 +122,7 @@ impl LoginConnection {
     }
 
     /// Write a packet to the server
-    pub async fn write(&mut self, packet: LoginPacket) {
+    pub async fn write(&mut self, packet: ServerboundLoginPacket) {
         write_packet(
             packet,
             &mut self.stream,
@@ -167,7 +150,6 @@ impl LoginConnection {
 
     pub fn game(self) -> GameConnection {
         GameConnection {
-            flow: self.flow,
             stream: self.stream,
             compression_threshold: self.compression_threshold,
             enc_cipher: self.enc_cipher,

azalea-protocol/src/packets/game/clientbound_add_entity_packet.rs

@@ -1,10 +1,10 @@
 use azalea_buf::McBuf;
 use azalea_core::EntityPos;
 use azalea_entity::Entity;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use uuid::Uuid;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundAddEntityPacket {
     /// The id of the entity.
     #[var]

azalea-protocol/src/packets/game/clientbound_add_player_packet.rs

@@ -1,11 +1,11 @@
 use azalea_buf::McBuf;
 use azalea_core::EntityPos;
 use azalea_entity::Entity;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use uuid::Uuid;
 
 /// This packet is sent by the server when a player comes into visible range, not when a player joins.
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundAddPlayerPacket {
     #[var]
     pub id: u32,

azalea-protocol/src/packets/game/clientbound_animate_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundAnimatePacket {
     #[var]
     pub id: u32,

azalea-protocol/src/packets/game/clientbound_block_changed_ack_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundBlockChangedAckPacket {
     #[var]
     pub sequence: i32,

azalea-protocol/src/packets/game/clientbound_block_update_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_core::BlockPos;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundBlockUpdatePacket {
     pub pos: BlockPos,
     // TODO: in vanilla this is a BlockState, but here we just have it as a number.

azalea-protocol/src/packets/game/clientbound_change_difficulty_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_core::Difficulty;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundChangeDifficultyPacket {
     pub difficulty: Difficulty,
     pub locked: bool,

azalea-protocol/src/packets/game/clientbound_chat_preview_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_chat::component::Component;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundChatPreviewPacket {
     pub query_id: i32,
     pub preview: Option<Component>,

azalea-protocol/src/packets/game/clientbound_container_set_content_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_core::Slot;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundContainerSetContentPacket {
     pub container_id: u8,
     #[var]

azalea-protocol/src/packets/game/clientbound_custom_chat_completions_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundCustomChatCompletionsPacket {
     pub action: Action,
     pub entries: Vec<String>,

azalea-protocol/src/packets/game/clientbound_custom_payload_packet.rs

@@ -1,9 +1,9 @@
 use azalea_buf::McBuf;
 use azalea_buf::UnsizedByteArray;
 use azalea_core::ResourceLocation;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundCustomPayloadPacket {
     pub identifier: ResourceLocation,
     pub data: UnsizedByteArray,

azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs

@@ -2,13 +2,13 @@ use azalea_buf::McBuf;
 use azalea_buf::McBufVarReadable;
 use azalea_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_core::ResourceLocation;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::{
     hash::Hash,
     io::{Read, Write},
 };
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundDeclareCommandsPacket {
     pub entries: Vec<BrigadierNodeStub>,
     #[var]

azalea-protocol/src/packets/game/clientbound_delete_chat_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_crypto::MessageSignature;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundDeleteChatPacket {
     pub message_signature: MessageSignature,
 }

azalea-protocol/src/packets/game/clientbound_disconnect_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_chat::component::Component;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundDisconnectPacket {
     pub reason: Component,
 }

azalea-protocol/src/packets/game/clientbound_entity_event_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
 // we can't identify the status in azalea-protocol since they vary depending on the entity
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundEntityEventPacket {
     pub entity_id: u32,
     pub event_id: u8,

azalea-protocol/src/packets/game/clientbound_entity_velocity_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundEntityVelocityPacket {
     #[var]
     pub entity_id: u32,

azalea-protocol/src/packets/game/clientbound_game_event_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundGameEventPacket {
     pub event: EventType,
     pub param: f32,

azalea-protocol/src/packets/game/clientbound_initialize_border_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundInitializeBorderPacket {
     pub new_center_x: f64,
     pub new_center_z: f64,

azalea-protocol/src/packets/game/clientbound_keep_alive_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundKeepAlivePacket {
     pub id: u64,
 }

azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs

@@ -1,9 +1,9 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
 use super::clientbound_light_update_packet::ClientboundLightUpdatePacketData;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundLevelChunkWithLightPacket {
     pub x: i32,
     pub z: i32,

azalea-protocol/src/packets/game/clientbound_level_event_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_core::BlockPos;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundLevelEventPacket {
     pub type_: i32,
     pub pos: BlockPos,

azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs

@@ -1,9 +1,9 @@
 use azalea_buf::{McBufReadable, McBufVarReadable, McBufWritable};
 use azalea_core::ParticleData;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::io::{Read, Write};
 
-#[derive(Clone, Debug, GamePacket)]
+#[derive(Clone, Debug, ClientboundGamePacket)]
 pub struct ClientboundLevelParticlesPacket {
     #[var]
     pub particle_id: u32,

azalea-protocol/src/packets/game/clientbound_light_update_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::{BitSet, McBuf};
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundLightUpdatePacket {
     pub x: i32,
     pub z: i32,

azalea-protocol/src/packets/game/clientbound_login_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_core::{GameType, GlobalPos, OptionalGameType, ResourceLocation};
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundLoginPacket {
     pub player_id: u32,
     pub hardcore: bool,

azalea-protocol/src/packets/game/clientbound_move_entity_pos_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_core::PositionDelta8;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundMoveEntityPosPacket {
     #[var]
     pub entity_id: u32,

azalea-protocol/src/packets/game/clientbound_move_entity_posrot_packet.rs

@@ -1,9 +1,9 @@
 use azalea_buf::McBuf;
 use azalea_core::PositionDelta8;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
 /// This packet is sent by the server when an entity moves less then 8 blocks.
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundMoveEntityPosrotPacket {
     #[var]
     pub entity_id: u32,

azalea-protocol/src/packets/game/clientbound_move_entity_rot_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundMoveEntityRotPacket {
     #[var]
     pub entity_id: i32,

azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs

@@ -1,9 +1,9 @@
 use azalea_buf::McBuf;
 use azalea_buf::{McBufReadable, McBufWritable, Readable};
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::io::{Read, Write};
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundPlayerAbilitiesPacket {
     pub flags: PlayerAbilitiesFlags,
     pub flying_speed: f32,

azalea-protocol/src/packets/game/clientbound_player_chat_header_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_crypto::{MessageSignature, SignedMessageHeader};
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundPlayerChatHeaderPacket {
     pub header: SignedMessageHeader,
     pub header_signature: MessageSignature,

azalea-protocol/src/packets/game/clientbound_player_chat_packet.rs

@@ -2,11 +2,11 @@ use azalea_buf::{BitSet, McBuf, McBufReadable, McBufVarWritable};
 use azalea_buf::{McBufVarReadable, McBufWritable};
 use azalea_chat::component::Component;
 use azalea_crypto::{MessageSignature, SignedMessageHeader};
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::io::{Read, Write};
 use uuid::Uuid;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundPlayerChatPacket {
     pub message: PlayerChatMessage,
     pub chat_type: ChatTypeBound,

azalea-protocol/src/packets/game/clientbound_player_info_packet.rs

@@ -1,11 +1,11 @@
 use azalea_buf::McBuf;
 use azalea_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_chat::component::Component;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::io::{Read, Write};
 use uuid::Uuid;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundPlayerInfoPacket {
     pub action: Action,
 }

azalea-protocol/src/packets/game/clientbound_player_position_packet.rs

@@ -1,9 +1,9 @@
 use azalea_buf::McBuf;
 use azalea_buf::{McBufReadable, McBufWritable, Readable};
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::io::{Read, Write};
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundPlayerPositionPacket {
     pub x: f64,
     pub y: f64,

azalea-protocol/src/packets/game/clientbound_recipe_packet.rs

@@ -1,10 +1,10 @@
 use azalea_buf::McBuf;
 use azalea_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_core::ResourceLocation;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::io::{Read, Write};
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundRecipePacket {
     pub action: State,
     pub settings: RecipeBookSettings,

azalea-protocol/src/packets/game/clientbound_remove_entities_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundRemoveEntitiesPacket {
     #[var]
     pub entity_ids: Vec<u32>,

azalea-protocol/src/packets/game/clientbound_rotate_head_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundRotateHeadPacket {
     #[var]
     pub entity_id: u32,

azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs

@@ -1,10 +1,10 @@
 use azalea_buf::McBuf;
 use azalea_buf::{McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable};
 use azalea_core::{ChunkSectionBlockPos, ChunkSectionPos};
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::io::{Read, Write};
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSectionBlocksUpdatePacket {
     pub section_pos: ChunkSectionPos,
     pub suppress_light_updates: bool,

azalea-protocol/src/packets/game/clientbound_server_data_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_chat::component::Component;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundServerDataPacket {
     pub motd: Option<Component>,
     pub icon_base64: Option<String>,

azalea-protocol/src/packets/game/clientbound_set_carried_item_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
 /// Sent to change the player's slot selection.
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetCarriedItemPacket {
     pub slot: u8,
 }

azalea-protocol/src/packets/game/clientbound_set_chunk_cache_center_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetChunkCacheCenterPacket {
     #[var]
     pub x: i32,

azalea-protocol/src/packets/game/clientbound_set_default_spawn_position_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_core::BlockPos;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetDefaultSpawnPositionPacket {
     pub pos: BlockPos,
     pub angle: f32,

azalea-protocol/src/packets/game/clientbound_set_display_chat_preview_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetDisplayChatPreviewPacket {
     pub enabled: bool,
 }

azalea-protocol/src/packets/game/clientbound_set_entity_data_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_entity::EntityMetadata;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetEntityDataPacket {
     #[var]
     pub id: u32,

azalea-protocol/src/packets/game/clientbound_set_entity_link_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetEntityLinkPacket {
     pub source_id: u32,
     pub dest_id: u32,

azalea-protocol/src/packets/game/clientbound_set_equipment_packet.rs

@@ -1,10 +1,10 @@
 use azalea_buf::McBuf;
 use azalea_core::Slot;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
 use azalea_buf::{McBufReadable, McBufWritable};
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetEquipmentPacket {
     #[var]
     pub entity: i32,

azalea-protocol/src/packets/game/clientbound_set_experience_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetExperiencePacket {
     pub experience_progress: f32,
     #[var]

azalea-protocol/src/packets/game/clientbound_set_health_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetHealthPacket {
     pub health: f32,
     #[var]

azalea-protocol/src/packets/game/clientbound_set_time_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSetTimePacket {
     pub game_time: u64,
     pub day_time: u64,

azalea-protocol/src/packets/game/clientbound_sound_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSoundPacket {
     #[var]
     // TODO: use the sound registry instead of just being a u32

azalea-protocol/src/packets/game/clientbound_system_chat_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_chat::component::Component;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundSystemChatPacket {
     pub content: Component,
     pub overlay: bool,

azalea-protocol/src/packets/game/clientbound_teleport_entity_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundTeleportEntityPacket {
     #[var]
     pub id: u32,

azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs

@@ -1,13 +1,13 @@
 use azalea_buf::{McBuf, McBufReadable, McBufWritable};
 use azalea_chat::component::Component;
 use azalea_core::{ResourceLocation, Slot};
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::{
     collections::HashMap,
     io::{Read, Write},
 };
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundUpdateAdvancementsPacket {
     pub reset: bool,
     pub added: HashMap<ResourceLocation, Advancement>,

azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs

@@ -1,11 +1,11 @@
 use azalea_buf::McBuf;
 use azalea_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_core::ResourceLocation;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::io::{Read, Write};
 use uuid::Uuid;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundUpdateAttributesPacket {
     #[var]
     pub entity_id: u32,

azalea-protocol/src/packets/game/clientbound_update_mob_effect_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundUpdateMobEffectPacket {
     #[var]
     pub entity_id: u32,

azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs

@@ -2,11 +2,11 @@ use std::io::{Read, Write};
 
 use azalea_buf::McBuf;
 use azalea_core::{ResourceLocation, Slot};
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
 use azalea_buf::{McBufReadable, McBufWritable, Readable, Writable};
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundUpdateRecipesPacket {
     pub recipes: Vec<Recipe>,
 }

azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs

@@ -1,14 +1,14 @@
 use azalea_buf::McBuf;
 use azalea_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_core::ResourceLocation;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 use std::ops::Deref;
 use std::{
     collections::HashMap,
     io::{Read, Write},
 };
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundUpdateTagsPacket {
     pub tags: TagMap,
 }

azalea-protocol/src/packets/game/clientbound_update_view_distance_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundUpdateViewDistancePacket {
     #[var]
     pub view_distance: i32,

azalea-protocol/src/packets/game/serverbound_accept_teleportation_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundAcceptTeleportationPacket {
     #[var]
     pub id: u32,

azalea-protocol/src/packets/game/serverbound_chat_ack_packet.rs

@@ -1,8 +1,8 @@
 use crate::packets::game::clientbound_player_chat_packet::LastSeenMessagesUpdate;
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundChatAckPacket {
     pub last_seen_messages: LastSeenMessagesUpdate,
 }

azalea-protocol/src/packets/game/serverbound_chat_command_packet.rs

@@ -1,10 +1,10 @@
 use azalea_buf::McBuf;
 use azalea_crypto::MessageSignature;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
 use super::clientbound_player_chat_packet::LastSeenMessagesUpdate;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundChatCommandPacket {
     pub command: String,
     // TODO: Choose a real timestamp type

azalea-protocol/src/packets/game/serverbound_chat_packet.rs

@@ -1,9 +1,9 @@
 use crate::packets::game::clientbound_player_chat_packet::LastSeenMessagesUpdate;
 use azalea_buf::McBuf;
 use azalea_crypto::MessageSignature;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundChatPacket {
     pub message: String,
     pub timestamp: u64,

azalea-protocol/src/packets/game/serverbound_chat_preview_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundChatPreviewPacket {
     pub query_id: i32,
     pub query: String,

azalea-protocol/src/packets/game/serverbound_custom_payload_packet.rs

@@ -1,9 +1,9 @@
 use azalea_buf::McBuf;
 use azalea_buf::UnsizedByteArray;
 use azalea_core::ResourceLocation;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundCustomPayloadPacket {
     pub identifier: ResourceLocation,
     pub data: UnsizedByteArray,

azalea-protocol/src/packets/game/serverbound_keep_alive_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundKeepAlivePacket {
     pub id: u64,
 }

azalea-protocol/src/packets/game/serverbound_move_player_packet_pos.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundMovePlayerPacketPos {
     pub x: f64,
     pub y: f64,

azalea-protocol/src/packets/game/serverbound_move_player_packet_pos_rot.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundMovePlayerPacketPosRot {
     pub x: f64,
     pub y: f64,

azalea-protocol/src/packets/game/serverbound_move_player_packet_rot.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundMovePlayerPacketRot {
     pub y_rot: f32,
     pub x_rot: f32,

azalea-protocol/src/packets/game/serverbound_move_player_packet_status_only.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::GamePacket;
+use packet_macros::ServerboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, GamePacket)]
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
 pub struct ServerboundMovePlayerPacketStatusOnly {
     pub on_ground: bool,
 }

azalea-protocol/src/packets/handshake/client_intention_packet.rs

@@ -1,9 +1,9 @@
 use crate::packets::ConnectionProtocol;
 use azalea_buf::McBuf;
-use packet_macros::HandshakePacket;
+use packet_macros::ClientboundHandshakePacket;
 use std::hash::Hash;
 
-#[derive(Hash, Clone, Debug, McBuf, HandshakePacket)]
+#[derive(Hash, Clone, Debug, McBuf, ClientboundHandshakePacket)]
 pub struct ClientIntentionPacket {
     #[var]
     pub protocol_version: u32,

azalea-protocol/src/packets/login/clientbound_custom_query_packet.rs

@@ -1,9 +1,9 @@
 use azalea_buf::{McBuf, UnsizedByteArray};
 use azalea_core::ResourceLocation;
-use packet_macros::LoginPacket;
+use packet_macros::ClientboundLoginPacket;
 use std::hash::Hash;
 
-#[derive(Hash, Clone, Debug, McBuf, LoginPacket)]
+#[derive(Hash, Clone, Debug, McBuf, ClientboundLoginPacket)]
 pub struct ClientboundCustomQueryPacket {
     #[var]
     pub transaction_id: u32,

azalea-protocol/src/packets/login/clientbound_game_profile_packet.rs

@@ -1,6 +1,6 @@
 use std::io::{Read, Write};
 
-use super::LoginPacket;
+use super::ClientboundLoginPacket;
 use azalea_auth::game_profile::GameProfile;
 use azalea_buf::{McBufReadable, Readable, SerializableUuid, Writable};
 use uuid::Uuid;
@@ -12,8 +12,8 @@ pub struct ClientboundGameProfilePacket {
 
 // TODO: add derives to GameProfile and have an impl McBufReadable/Writable for GameProfile
 impl ClientboundGameProfilePacket {
-    pub fn get(self) -> LoginPacket {
+    pub fn get(self) -> ClientboundLoginPacket {
-        LoginPacket::ClientboundGameProfilePacket(self)
+        ClientboundLoginPacket::ClientboundGameProfilePacket(self)
     }
 
     pub fn write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
@@ -24,7 +24,7 @@ impl ClientboundGameProfilePacket {
         Ok(())
     }
 
-    pub fn read(buf: &mut impl Read) -> Result<LoginPacket, String> {
+    pub fn read(buf: &mut impl Read) -> Result<ClientboundLoginPacket, String> {
         let uuid = Uuid::read_from(buf)?;
         let name = buf.read_utf_with_len(16)?;
         Ok(ClientboundGameProfilePacket {

azalea-protocol/src/packets/login/clientbound_hello_packet.rs

@@ -1,7 +1,7 @@
 use azalea_buf::McBuf;
-use packet_macros::LoginPacket;
+use packet_macros::ClientboundLoginPacket;
 
-#[derive(Clone, Debug, McBuf, LoginPacket)]
+#[derive(Clone, Debug, McBuf, ClientboundLoginPacket)]
 pub struct ClientboundHelloPacket {
     // TODO: make this len thing work
     // #[len(20)]

azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs

@@ -5,7 +5,7 @@ use std::{
 
 use azalea_buf::{Readable, Writable};
 
-use super::LoginPacket;
+use super::ClientboundLoginPacket;
 
 #[derive(Hash, Clone, Debug)]
 pub struct ClientboundLoginCompressionPacket {
@@ -13,8 +13,8 @@ pub struct ClientboundLoginCompressionPacket {
 }
 
 impl ClientboundLoginCompressionPacket {
-    pub fn get(self) -> LoginPacket {
+    pub fn get(self) -> ClientboundLoginPacket {
-        LoginPacket::ClientboundLoginCompressionPacket(self)
+        ClientboundLoginPacket::ClientboundLoginCompressionPacket(self)
     }
 
     pub fn write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
@@ -22,7 +22,7 @@ impl ClientboundLoginCompressionPacket {
         Ok(())
     }
 
-    pub fn read(buf: &mut impl Read) -> Result<LoginPacket, String> {
+    pub fn read(buf: &mut impl Read) -> Result<ClientboundLoginPacket, String> {
         let compression_threshold = buf.read_varint()?;
 
         Ok(ClientboundLoginCompressionPacket {

azalea-protocol/src/packets/login/clientbound_login_disconnect_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
 use azalea_chat::component::Component;
-use packet_macros::LoginPacket;
+use packet_macros::ClientboundLoginPacket;
 
-#[derive(Clone, Debug, McBuf, LoginPacket)]
+#[derive(Clone, Debug, McBuf, ClientboundLoginPacket)]
 pub struct ClientboundLoginDisconnectPacket {
     pub reason: Component,
 }

azalea-protocol/src/packets/login/serverbound_hello_packet.rs

@@ -1,8 +1,8 @@
 use azalea_buf::McBuf;
-use packet_macros::LoginPacket;
+use packet_macros::ServerboundLoginPacket;
 use uuid::Uuid;
 
-#[derive(Clone, Debug, McBuf, LoginPacket)]
+#[derive(Clone, Debug, McBuf, ServerboundLoginPacket)]
 pub struct ServerboundHelloPacket {
     pub username: String,
     pub public_key: Option<ProfilePublicKeyData>,

azalea-protocol/src/packets/login/serverbound_key_packet.rs

@@ -1,11 +1,11 @@
 use azalea_buf::McBuf;
 use azalea_crypto::SaltSignaturePair;
-use packet_macros::LoginPacket;
+use packet_macros::ServerboundLoginPacket;
 use std::io::{Read, Write};
 
 use azalea_buf::{McBufReadable, McBufWritable};
 
-#[derive(Clone, Debug, McBuf, LoginPacket)]
+#[derive(Clone, Debug, McBuf, ServerboundLoginPacket)]
 pub struct ServerboundKeyPacket {
     pub key_bytes: Vec<u8>,
     pub nonce_or_salt_signature: NonceOrSaltSignature,

azalea-protocol/src/packets/mod.rs

@@ -3,7 +3,6 @@ pub mod handshake;
 pub mod login;
 pub mod status;
 
-use crate::connect::PacketFlow;
 use azalea_buf::{McBufWritable, Readable, Writable};
 use std::io::{Read, Write};
 
@@ -29,14 +28,6 @@ impl ConnectionProtocol {
     }
 }
 
-#[derive(Clone, Debug)]
-pub enum Packet {
-    Game(Box<game::GamePacket>),
-    Handshake(Box<handshake::HandshakePacket>),
-    Login(Box<login::LoginPacket>),
-    Status(Box<status::StatusPacket>),
-}
-
 /// An enum of packets for a certain protocol
 pub trait ProtocolPacket
 where
@@ -45,7 +36,7 @@ where
     fn id(&self) -> u32;
 
     /// Read a packet by its id, ConnectionProtocol, and flow
-    fn read(id: u32, flow: &PacketFlow, buf: &mut impl Read) -> Result<Self, String>;
+    fn read(id: u32, buf: &mut impl Read) -> Result<Self, String>;
 
     fn write(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }

azalea-protocol/src/packets/status/clientbound_status_response_packet.rs

@@ -1,12 +1,9 @@
-use std::io::{Read, Write};
+use super::ClientboundStatusPacket;
-
+use azalea_buf::Readable;
 use azalea_chat::component::Component;
 use serde::Deserialize;
 use serde_json::Value;
-
+use std::io::{Read, Write};
-use azalea_buf::Readable;
-
-use super::StatusPacket;
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct Version {
@@ -37,15 +34,15 @@ pub struct ClientboundStatusResponsePacket {
 }
 
 impl ClientboundStatusResponsePacket {
-    pub fn get(self) -> StatusPacket {
+    pub fn get(self) -> ClientboundStatusPacket {
-        StatusPacket::ClientboundStatusResponsePacket(self)
+        ClientboundStatusPacket::ClientboundStatusResponsePacket(self)
     }
 
     pub fn write(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
         Ok(())
     }
 
-    pub fn read(buf: &mut impl Read) -> Result<StatusPacket, String> {
+    pub fn read(buf: &mut impl Read) -> Result<ClientboundStatusPacket, String> {
         let status_string = buf.read_utf()?;
         let status_json: Value =
             serde_json::from_str(status_string.as_str()).expect("Server status isn't valid JSON");

azalea-protocol/src/packets/status/serverbound_status_request_packet.rs

@@ -1,5 +1,5 @@
 use azalea_buf::McBuf;
-use packet_macros::StatusPacket;
+use packet_macros::ServerboundStatusPacket;
 
-#[derive(Clone, Debug, McBuf, StatusPacket)]
+#[derive(Clone, Debug, McBuf, ServerboundStatusPacket)]
 pub struct ServerboundStatusRequestPacket {}

azalea-protocol/src/read.rs

@@ -1,4 +1,4 @@
-use crate::{connect::PacketFlow, packets::ProtocolPacket};
+use crate::packets::ProtocolPacket;
 use azalea_buf::{read_varint_async, Readable};
 use azalea_crypto::Aes128CfbDec;
 use flate2::read::ZlibDecoder;
@@ -31,13 +31,10 @@ where
     }
 }
 
-fn packet_decoder<P: ProtocolPacket>(
+fn packet_decoder<P: ProtocolPacket>(stream: &mut impl Read) -> Result<P, String> {
-    stream: &mut impl Read,
-    flow: &PacketFlow,
-) -> Result<P, String> {
     // Packet ID
     let packet_id = stream.read_varint()?;
-    P::read(packet_id.try_into().unwrap(), flow, stream)
+    P::read(packet_id.try_into().unwrap(), stream)
 }
 
 // this is always true in multiplayer, false in singleplayer
@@ -121,7 +118,6 @@ where
 }
 
 pub async fn read_packet<'a, P: ProtocolPacket, R>(
-    flow: &PacketFlow,
     stream: &'a mut R,
     compression_threshold: Option<u32>,
     cipher: &mut Option<Aes128CfbDec>,
@@ -150,7 +146,7 @@ where
     }
 
     // println!("decoding packet ({}ms)", start_time.elapsed().as_millis());
-    let packet = packet_decoder(&mut buf.as_slice(), flow)?;
+    let packet = packet_decoder(&mut buf.as_slice())?;
     // println!("decoded packet ({}ms)", start_time.elapsed().as_millis());
 
     Ok(packet)