Merge branch 'main' into declare-commands-packet

.gitignore

@@ -1,2 +1,2 @@
 /target
-/doc
+/doc

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

@@ -1,10 +1,12 @@
+use proc_macro::TokenStream;
 use quote::{quote, ToTokens};
-use syn::{self, parse_macro_input, DeriveInput, FieldsNamed};
+use syn::{
+    self, braced,
+    parse::{Parse, ParseStream, Result},
+    parse_macro_input, DeriveInput, FieldsNamed, Ident, LitInt, Token,
+};
 
-fn as_packet_derive(
+fn as_packet_derive(input: TokenStream, state: proc_macro2::TokenStream) -> TokenStream {
-    input: proc_macro::TokenStream,
-    state: proc_macro2::TokenStream,
-) -> proc_macro::TokenStream {
     let DeriveInput { ident, data, .. } = parse_macro_input!(input);
 
     let fields = match data {
@@ -99,21 +101,198 @@ fn as_packet_derive(
 }
 
 #[proc_macro_derive(GamePacket, attributes(varint))]
-pub fn derive_game_packet(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn derive_game_packet(input: TokenStream) -> TokenStream {
     as_packet_derive(input, quote! {crate::packets::game::GamePacket})
 }
 
 #[proc_macro_derive(HandshakePacket, attributes(varint))]
-pub fn derive_handshake_packet(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn derive_handshake_packet(input: TokenStream) -> TokenStream {
     as_packet_derive(input, quote! {crate::packets::handshake::HandshakePacket})
 }
 
 #[proc_macro_derive(LoginPacket, attributes(varint))]
-pub fn derive_login_packet(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn derive_login_packet(input: TokenStream) -> TokenStream {
     as_packet_derive(input, quote! {crate::packets::login::LoginPacket})
 }
 
 #[proc_macro_derive(StatusPacket, attributes(varint))]
-pub fn derive_status_packet(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn derive_status_packet(input: TokenStream) -> TokenStream {
     as_packet_derive(input, quote! {crate::packets::status::StatusPacket})
 }
+
+#[derive(Debug)]
+struct PacketIdPair {
+    id: u32,
+    module: Ident,
+    name: Ident,
+}
+#[derive(Debug)]
+struct PacketIdMap {
+    packets: Vec<PacketIdPair>,
+}
+
+impl Parse for PacketIdMap {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut packets = vec![];
+        loop {
+            // 0x0e: clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
+            // 0x0e
+            let packet_id: LitInt = match input.parse() {
+                Ok(i) => i,
+                Err(_) => break,
+            };
+            let packet_id = packet_id.base10_parse::<u32>()?;
+            // :
+            input.parse::<Token![:]>()?;
+            // clientbound_change_difficulty_packet
+            let module: Ident = input.parse()?;
+            // ::
+            input.parse::<Token![::]>()?;
+            // ClientboundChangeDifficultyPacket
+            let name: Ident = input.parse()?;
+            input.parse::<Token![,]>()?;
+
+            packets.push(PacketIdPair {
+                id: packet_id,
+                module,
+                name,
+            });
+        }
+
+        Ok(PacketIdMap { packets })
+    }
+}
+
+#[derive(Debug)]
+struct DeclareStatePackets {
+    name: Ident,
+    serverbound: PacketIdMap,
+    clientbound: PacketIdMap,
+}
+
+impl Parse for DeclareStatePackets {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let name = input.parse()?;
+        input.parse::<Token![,]>()?;
+
+        let serverbound_token: Ident = input.parse()?;
+        if serverbound_token != "Serverbound" {
+            return Err(syn::Error::new(
+                serverbound_token.span(),
+                "Expected `Serverbound`",
+            ));
+        }
+        input.parse::<Token![=>]>()?;
+        let content;
+        braced!(content in input);
+        let serverbound = content.parse()?;
+
+        input.parse::<Token![,]>()?;
+
+        let clientbound_token: Ident = input.parse()?;
+        if clientbound_token != "Clientbound" {
+            return Err(syn::Error::new(
+                clientbound_token.span(),
+                "Expected `Clientbound`",
+            ));
+        }
+        input.parse::<Token![=>]>()?;
+        let content;
+        braced!(content in input);
+        let clientbound = content.parse()?;
+
+        Ok(DeclareStatePackets {
+            name,
+            serverbound,
+            clientbound,
+        })
+    }
+}
+#[proc_macro]
+pub fn declare_state_packets(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeclareStatePackets);
+
+    let state_name = input.name;
+    let state_name_litstr = syn::LitStr::new(&state_name.to_string(), state_name.span());
+
+    let mut enum_contents = quote!();
+    let mut id_match_contents = quote!();
+    let mut 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! {
+            #name(#module::#name),
+        });
+        id_match_contents.extend(quote! {
+            #state_name::#name(_packet) => #id,
+        });
+        write_match_contents.extend(quote! {
+            #state_name::#name(packet) => packet.write(buf),
+        });
+        serverbound_read_match_contents.extend(quote! {
+            #id => #module::#name::read(buf).await?,
+        });
+    }
+    for PacketIdPair { id, module, name } in input.clientbound.packets {
+        enum_contents.extend(quote! {
+            #name(#module::#name),
+        });
+        id_match_contents.extend(quote! {
+            #state_name::#name(_packet) => #id,
+        });
+        write_match_contents.extend(quote! {
+            #state_name::#name(packet) => packet.write(buf),
+        });
+        clientbound_read_match_contents.extend(quote! {
+            #id => #module::#name::read(buf).await?,
+        });
+    }
+
+    quote! {
+        #[derive(Clone, Debug)]
+        pub enum #state_name
+        where
+            Self: Sized,
+        {
+            #enum_contents
+        }
+
+        #[async_trait::async_trait]
+        impl crate::packets::ProtocolPacket for #state_name {
+            fn id(&self) -> u32 {
+                match self {
+                    #id_match_contents
+                }
+            }
+
+            fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+                match self {
+                    #write_match_contents
+                }
+            }
+
+            /// Read a packet by its id, ConnectionProtocol, and flow
+            async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+                id: u32,
+                flow: &crate::connect::PacketFlow,
+                buf: &mut T,
+            ) -> Result<#state_name, String>
+            where
+                Self: Sized,
+            {
+                Ok(match flow {
+                    crate::connect::PacketFlow::ServerToClient => match id {
+                        #serverbound_read_match_contents
+                        _ => panic!("Unknown ServerToClient {} packet id: {}", #state_name_litstr, id),
+                    },
+                    crate::connect::PacketFlow::ClientToServer => match id {
+                        #clientbound_read_match_contents
+                        _ => return Err(format!("Unknown ClientToServer {} packet id: {}", #state_name_litstr, id)),
+                    },
+                })
+            }
+        }
+    }
+    .into()
+}

azalea-protocol/src/mc_buf/write.rs

@@ -3,7 +3,6 @@ use azalea_core::{
     difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
 };
 use byteorder::{BigEndian, WriteBytesExt};
-use num_traits::FromPrimitive;
 use std::io::Write;
 
 use super::MAX_STRING_LENGTH;

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

@@ -4,81 +4,16 @@ pub mod clientbound_declare_commands_packet;
 pub mod clientbound_login_packet;
 pub mod clientbound_update_view_distance_packet;
 
-use super::ProtocolPacket;
+use packet_macros::declare_state_packets;
-use crate::connect::PacketFlow;
-use async_trait::async_trait;
 
-#[derive(Clone, Debug)]
+declare_state_packets!(
-pub enum GamePacket
+    GamePacket,
-where
+    Serverbound => {},
-    Self: Sized,
+    Clientbound => {
-{
+        0x0e: clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
-    ClientboundLoginPacket(clientbound_login_packet::ClientboundLoginPacket),
+        0x18: clientbound_custom_payload_packet::ClientboundCustomPayloadPacket,
-    ClientboundUpdateViewDistancePacket(
+        0x26: clientbound_login_packet::ClientboundLoginPacket,
-        clientbound_update_view_distance_packet::ClientboundUpdateViewDistancePacket,
+        0x4a: clientbound_update_view_distance_packet::ClientboundUpdateViewDistancePacket,
-    ),
+        0x12: clientbound_declare_commands_packet::ClientboundDeclareCommandsPacket
-    ClientboundCustomPayloadPacket(
-        clientbound_custom_payload_packet::ClientboundCustomPayloadPacket,
-    ),
-    ClientboundChangeDifficultyPacket(
-        clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
-    ),
-    ClientboundDeclareCommandsPacket(
-        clientbound_declare_commands_packet::ClientboundDeclareCommandsPacket,
-    ),
-}
-
-#[async_trait]
-impl ProtocolPacket for GamePacket {
-    fn id(&self) -> u32 {
-        match self {
-            GamePacket::ClientboundChangeDifficultyPacket(_packet) => 0x0e,
-            GamePacket::ClientboundCustomPayloadPacket(_packet) => 0x18,
-            GamePacket::ClientboundLoginPacket(_packet) => 0x26,
-            GamePacket::ClientboundUpdateViewDistancePacket(_packet) => 0x4a,
-            GamePacket::ClientboundDeclareCommandsPacket(_packet) => 0x12,
-        }
     }
-
+);
-    fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
-        match self {
-            GamePacket::ClientboundChangeDifficultyPacket(packet) => packet.write(buf),
-            GamePacket::ClientboundCustomPayloadPacket(packet) => packet.write(buf),
-            GamePacket::ClientboundLoginPacket(packet) => packet.write(buf),
-            GamePacket::ClientboundUpdateViewDistancePacket(packet) => packet.write(buf),
-            GamePacket::ClientboundDeclareCommandsPacket(packet) => packet.write(buf),
-        }
-    }
-
-    /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        id: u32,
-        flow: &PacketFlow,
-        buf: &mut T,
-    ) -> Result<GamePacket, String>
-    where
-        Self: Sized,
-    {
-        Ok(match flow {
-            PacketFlow::ServerToClient => match id {
-                0x0e => clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket
-                    ::read(buf)
-                    .await?,
-                0x18 => clientbound_custom_payload_packet::ClientboundCustomPayloadPacket::read(buf).await?,
-                0x26 => clientbound_login_packet::ClientboundLoginPacket::read(buf).await?,
-                0x4a => clientbound_update_view_distance_packet::ClientboundUpdateViewDistancePacket
-                    ::read(buf)
-                    .await?,
-                0x12 => clientbound_declare_commands_packet::ClientboundDeclareCommandsPacket
-                    ::read(buf)
-                    .await?,
-                // _ => return Err(format!("Unknown ServerToClient game packet id: {}", id)),
-                _ => panic!("Unknown ServerToClient game packet id: {}", id),
-            },
-            PacketFlow::ClientToServer => match id {
-                // 0x00 => serverbound_hello_packet::ServerboundHelloPacket::read(buf).await?,
-                _ => return Err(format!("Unknown ClientToServer game packet id: {}", id)),
-            },
-        })
-    }
-}

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

@@ -1,48 +1,11 @@
 pub mod client_intention_packet;
 
-use async_trait::async_trait;
+use packet_macros::declare_state_packets;
 
-use crate::connect::PacketFlow;
+declare_state_packets!(
-
+    HandshakePacket,
-use super::ProtocolPacket;
+    Serverbound => {},
-
+    Clientbound => {
-#[derive(Clone, Debug)]
+        0x00: client_intention_packet::ClientIntentionPacket,
-pub enum HandshakePacket
-where
-    Self: Sized,
-{
-    ClientIntentionPacket(client_intention_packet::ClientIntentionPacket),
-}
-
-#[async_trait]
-impl ProtocolPacket for HandshakePacket {
-    fn id(&self) -> u32 {
-        match self {
-            HandshakePacket::ClientIntentionPacket(_packet) => 0x00,
-        }
     }
-
+);
-    fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
-        match self {
-            HandshakePacket::ClientIntentionPacket(packet) => packet.write(buf),
-        }
-    }
-
-    /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        id: u32,
-        flow: &PacketFlow,
-        buf: &mut T,
-    ) -> Result<HandshakePacket, String>
-    where
-        Self: Sized,
-    {
-        match flow {
-            PacketFlow::ServerToClient => Err("HandshakePacket::read not implemented".to_string()),
-            PacketFlow::ClientToServer => match id {
-                0x00 => Ok(client_intention_packet::ClientIntentionPacket::read(buf).await?),
-                _ => Err(format!("Unknown ClientToServer status packet id: {}", id)),
-            },
-        }
-    }
-}

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

@@ -4,76 +4,17 @@ pub mod clientbound_hello_packet;
 pub mod clientbound_login_compression_packet;
 pub mod serverbound_hello_packet;
 
-use super::ProtocolPacket;
+use packet_macros::declare_state_packets;
-use crate::connect::PacketFlow;
-use async_trait::async_trait;
 
-#[derive(Clone, Debug)]
+declare_state_packets!(
-pub enum LoginPacket
+    LoginPacket,
-where
+    Serverbound => {
-    Self: Sized,
+        0x00: serverbound_hello_packet::ServerboundHelloPacket,
-{
+    },
-    ClientboundCustomQueryPacket(clientbound_custom_query_packet::ClientboundCustomQueryPacket),
+    Clientbound => {
-    ClientboundGameProfilePacket(clientbound_game_profile_packet::ClientboundGameProfilePacket),
+        0x00: clientbound_hello_packet::ClientboundHelloPacket,
-    ClientboundHelloPacket(clientbound_hello_packet::ClientboundHelloPacket),
+        0x02: clientbound_game_profile_packet::ClientboundGameProfilePacket,
-    ClientboundLoginCompressionPacket(
+        0x03: clientbound_login_compression_packet::ClientboundLoginCompressionPacket,
-        clientbound_login_compression_packet::ClientboundLoginCompressionPacket,
+        0x04: clientbound_custom_query_packet::ClientboundCustomQueryPacket,
-    ),
-    ServerboundHelloPacket(serverbound_hello_packet::ServerboundHelloPacket),
-}
-
-#[async_trait]
-impl ProtocolPacket for LoginPacket {
-    fn id(&self) -> u32 {
-        match self {
-            LoginPacket::ClientboundCustomQueryPacket(_packet) => 0x04,
-            LoginPacket::ClientboundGameProfilePacket(_packet) => 0x02,
-            LoginPacket::ClientboundHelloPacket(_packet) => 0x01,
-            LoginPacket::ClientboundLoginCompressionPacket(_packet) => 0x03,
-            LoginPacket::ServerboundHelloPacket(_packet) => 0x00,
-        }
     }
-
+);
-    fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
-        match self {
-            LoginPacket::ClientboundCustomQueryPacket(packet) => packet.write(buf),
-            LoginPacket::ClientboundGameProfilePacket(packet) => packet.write(buf),
-            LoginPacket::ClientboundHelloPacket(packet) => packet.write(buf),
-            LoginPacket::ClientboundLoginCompressionPacket(packet) => packet.write(buf),
-            LoginPacket::ServerboundHelloPacket(packet) => packet.write(buf),
-        }
-    }
-
-    /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        id: u32,
-        flow: &PacketFlow,
-        buf: &mut T,
-    ) -> Result<LoginPacket, String>
-    where
-        Self: Sized,
-    {
-        Ok(match flow {
-            PacketFlow::ServerToClient => match id {
-                0x01 => clientbound_hello_packet::ClientboundHelloPacket::read(buf).await?,
-                0x02 => {
-                    clientbound_game_profile_packet::ClientboundGameProfilePacket::read(buf).await?
-                }
-                0x04 => {
-                    clientbound_custom_query_packet::ClientboundCustomQueryPacket::read(buf).await?
-                }
-                0x03 => {
-                    clientbound_login_compression_packet::ClientboundLoginCompressionPacket::read(
-                        buf,
-                    )
-                    .await?
-                }
-                _ => return Err(format!("Unknown ServerToClient login packet id: {}", id)),
-            },
-            PacketFlow::ClientToServer => match id {
-                0x00 => serverbound_hello_packet::ServerboundHelloPacket::read(buf).await?,
-                _ => return Err(format!("Unknown ClientToServer login packet id: {}", id)),
-            },
-        })
-    }
-}

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

@@ -36,7 +36,7 @@ pub struct ClientboundStatusResponsePacket {
 
 impl ClientboundStatusResponsePacket {
     pub fn get(self) -> StatusPacket {
-        StatusPacket::ClientboundStatusResponsePacket(Box::new(self))
+        StatusPacket::ClientboundStatusResponsePacket(self)
     }
 
     pub fn write(&self, _buf: &mut Vec<u8>) -> Result<(), std::io::Error> {

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

@@ -1,65 +1,14 @@
 pub mod clientbound_status_response_packet;
 pub mod serverbound_status_request_packet;
 
-use async_trait::async_trait;
+use packet_macros::declare_state_packets;
 
-use crate::connect::PacketFlow;
+declare_state_packets!(
-
+    StatusPacket,
-use super::ProtocolPacket;
+    Serverbound => {
-
+        0x00: serverbound_status_request_packet::ServerboundStatusRequestPacket,
-#[derive(Clone, Debug)]
+    },
-pub enum StatusPacket
+    Clientbound => {
-where
+        0x00: clientbound_status_response_packet::ClientboundStatusResponsePacket,
-    Self: Sized,
-{
-    ServerboundStatusRequestPacket(
-        serverbound_status_request_packet::ServerboundStatusRequestPacket,
-    ),
-    ClientboundStatusResponsePacket(
-        Box<clientbound_status_response_packet::ClientboundStatusResponsePacket>,
-    ),
-}
-
-#[async_trait]
-impl ProtocolPacket for StatusPacket {
-    fn id(&self) -> u32 {
-        match self {
-            StatusPacket::ServerboundStatusRequestPacket(_packet) => 0x00,
-            StatusPacket::ClientboundStatusResponsePacket(_packet) => 0x00,
-        }
     }
-
+);
-    fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
-        match self {
-            StatusPacket::ServerboundStatusRequestPacket(packet) => packet.write(buf),
-            StatusPacket::ClientboundStatusResponsePacket(packet) => packet.write(buf),
-        }
-    }
-
-    /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        id: u32,
-        flow: &PacketFlow,
-        buf: &mut T,
-    ) -> Result<StatusPacket, String>
-    where
-        Self: Sized,
-    {
-        match flow {
-            PacketFlow::ServerToClient => match id {
-                0x00 => Ok(
-                    clientbound_status_response_packet::ClientboundStatusResponsePacket::read(buf)
-                        .await?,
-                ),
-                _ => Err(format!("Unknown ServerToClient status packet id: {}", id)),
-            },
-            PacketFlow::ClientToServer => match id {
-                0x00 => Ok(
-                    serverbound_status_request_packet::ServerboundStatusRequestPacket::read(buf)
-                        .await?,
-                ),
-                _ => Err(format!("Unknown ClientToServer status packet id: {}", id)),
-            },
-        }
-    }
-}