switch all current macro types to the new system

4 files changed, 136 insertions, 42 deletions

diff --git a/azalea-protocol/packet-macros/src/lib.rs b/azalea-protocol/packet-macros/src/lib.rs
index 5b2088a1..ba963111 100644
--- a/azalea-protocol/packet-macros/src/lib.rs
+++ b/azalea-protocol/packet-macros/src/lib.rs
@@ -25,31 +25,14 @@ fn as_packet_derive(
             // if it's a string, use buf.write_string
             match field_type {
                 syn::Type::Path(syn::TypePath { path, .. }) => {
-                    if path.is_ident("String") {
-                        quote! { buf.write_utf(&self.#field_name)?; }
-                    } else if path.is_ident("ResourceLocation") {
-                        quote! { buf.write_resource_location(&self.#field_name)?; }
-                    } else if path.is_ident("u32") {
-                        if f.attrs.iter().any(|attr| attr.path.is_ident("varint")) {
-                            quote! { buf.write_varint(self.#field_name as i32)?; }
-                        } else {
-                            quote! { buf.write_u32(self.#field_name)?; }
+                    if f.attrs.iter().any(|attr| attr.path.is_ident("varint")) {
+                        quote! {
+                            crate::mc_buf::McBufVarintWritable::varint_write_into(&self.#field_name, buf)?;
                         }
-                    } else if path.is_ident("u16") {
-                        quote! { buf.write_short(self.#field_name as i16)?; }
-                    } else if path.is_ident("ConnectionProtocol") {
-                        quote! { buf.write_varint(self.#field_name.clone() as i32)?; }
                     } else {
-                        if f.attrs.iter().any(|attr| attr.path.is_ident("varint")) {
-                            quote! {
-                                crate::mc_buf::McBufVarintWritable::varint_write_into(&self.#field_name, buf)?;
-                            }
-                        } else {
-                            quote! {
-                                crate::mc_buf::McBufWritable::write_into(&self.#field_name, buf)?;
-                            }
+                        quote! {
+                            crate::mc_buf::McBufWritable::write_into(&self.#field_name, buf)?;
                         }
-
                     }
                 }
                 _ => panic!(
@@ -70,24 +53,6 @@ fn as_packet_derive(
             // if it's a string, use buf.write_string
             match field_type {
                 syn::Type::Path(syn::TypePath { path, .. }) => {
-                    if path.is_ident("String") {
-                        quote! { let #field_name = buf.read_utf().await?; }
-                    } else if path.is_ident("ResourceLocation") {
-                        quote! { let #field_name = buf.read_resource_location().await?; }
-                    } else if path.is_ident("u32") {
-                        if f.attrs.iter().any(|a| a.path.is_ident("varint")) {
-                            quote! { let #field_name = buf.read_varint().await? as u32; }
-                        } else {
-                            quote! { let #field_name = buf.read_u32().await?; }
-                        }
-                    } else if path.is_ident("u16") {
-                        quote! { let #field_name = buf.read_short().await? as u16; }
-                    } else if path.is_ident("ConnectionProtocol") {
-                        quote! {
-                            let #field_name = ConnectionProtocol::from_i32(buf.read_varint().await?)
-                                .ok_or_else(|| "Invalid intention".to_string())?;
-                        }
-                    } else {
                         if f.attrs.iter().any(|a| a.path.is_ident("varint")) {
                             quote! {
                                 let #field_name = crate::mc_buf::McBufVarintReadable::varint_read_into(buf).await?;
@@ -96,7 +61,6 @@ fn as_packet_derive(
                             quote! {
                                 let #field_name = crate::mc_buf::McBufReadable::read_into(buf).await?;
                             }
-                        }
                     }
                 }
                 _ => panic!(
diff --git a/azalea-protocol/src/mc_buf/read.rs b/azalea-protocol/src/mc_buf/read.rs
index 683c7d9a..374e5443 100644
--- a/azalea-protocol/src/mc_buf/read.rs
+++ b/azalea-protocol/src/mc_buf/read.rs
@@ -238,3 +238,69 @@ impl McBufReadable for Vec<u8> {
         buf.read_bytes().await
     }
 }
+
+// string
+#[async_trait]
+impl McBufReadable for String {
+    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
+    where
+        R: AsyncRead + std::marker::Unpin + std::marker::Send,
+    {
+        buf.read_utf().await
+    }
+}
+
+// ResourceLocation
+#[async_trait]
+impl McBufReadable for ResourceLocation {
+    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
+    where
+        R: AsyncRead + std::marker::Unpin + std::marker::Send,
+    {
+        buf.read_resource_location().await
+    }
+}
+
+// u32
+#[async_trait]
+impl McBufReadable for u32 {
+    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
+    where
+        R: AsyncRead + std::marker::Unpin + std::marker::Send,
+    {
+        buf.read_int().await.map(|i| i as u32)
+    }
+}
+
+// u32 varint
+#[async_trait]
+impl McBufVarintReadable for u32 {
+    async fn varint_read_into<R>(buf: &mut R) -> Result<Self, String>
+    where
+        R: AsyncRead + std::marker::Unpin + std::marker::Send,
+    {
+        buf.read_varint().await.map(|i| i as u32)
+    }
+}
+
+// u16
+#[async_trait]
+impl McBufReadable for u16 {
+    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
+    where
+        R: AsyncRead + std::marker::Unpin + std::marker::Send,
+    {
+        buf.read_short().await.map(|i| i as u16)
+    }
+}
+
+// u16 varint
+#[async_trait]
+impl McBufVarintReadable for u16 {
+    async fn varint_read_into<R>(buf: &mut R) -> Result<Self, String>
+    where
+        R: AsyncRead + std::marker::Unpin + std::marker::Send,
+    {
+        buf.read_varint().await.map(|i| i as u16)
+    }
+}
diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
index 7b1ac861..f22b218a 100644
--- a/azalea-protocol/src/mc_buf/write.rs
+++ b/azalea-protocol/src/mc_buf/write.rs
@@ -184,3 +184,45 @@ impl McBufWritable for Vec<u8> {
         buf.write_bytes(self)
     }
 }
+
+// string
+impl McBufWritable for String {
+    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+        buf.write_utf(self)
+    }
+}
+
+// ResourceLocation
+impl McBufWritable for ResourceLocation {
+    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+        buf.write_resource_location(self)
+    }
+}
+
+// u32
+impl McBufWritable for u32 {
+    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+        buf.write_varint(*self as i32)
+    }
+}
+
+// u32 varint
+impl McBufVarintWritable for u32 {
+    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+        buf.write_varint(*self as i32)
+    }
+}
+
+// u16
+impl McBufWritable for u16 {
+    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+        buf.write_varint(*self as i32)
+    }
+}
+
+// u16 varint
+impl McBufVarintWritable for u16 {
+    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+        buf.write_varint(*self as i32)
+    }
+}
diff --git a/azalea-protocol/src/packets/mod.rs b/azalea-protocol/src/packets/mod.rs
index 0f1cd2f0..f35451c6 100644
--- a/azalea-protocol/src/packets/mod.rs
+++ b/azalea-protocol/src/packets/mod.rs
@@ -3,9 +3,14 @@ pub mod handshake;
 pub mod login;
 pub mod status;
 
-use crate::connect::PacketFlow;
+use crate::{
+    connect::PacketFlow,
+    mc_buf::{McBufReadable, McBufWritable, Readable, Writable},
+};
 use async_trait::async_trait;
 use num_derive::FromPrimitive;
+use num_traits::FromPrimitive;
+use tokio::io::AsyncRead;
 
 pub const PROTOCOL_VERSION: u32 = 757;
 
@@ -44,3 +49,20 @@ where
 
     fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error>;
 }
+
+#[async_trait]
+impl McBufReadable for ConnectionProtocol {
+    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
+    where
+        R: AsyncRead + std::marker::Unpin + std::marker::Send,
+    {
+        ConnectionProtocol::from_i32(buf.read_varint().await?)
+            .ok_or_else(|| "Invalid intention".to_string())
+    }
+}
+
+impl McBufWritable for ConnectionProtocol {
+    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+        buf.write_varint(self.clone() as i32)
+    }
+}