Add in proc macro decoder generation

protocol-derive/src/lib.rs

@@ -37,23 +37,16 @@ fn impl_encoder_trait(name: &Ident, fields: &Fields) -> TokenStream2 {
         let unparsed_meta = get_packet_field_meta(field);
         let parsed_meta = parse_packet_field_meta(&unparsed_meta);
 
-        match parsed_meta.module {
-            Some(module) => {
-                let module_ident = Ident::new(&module, Span::call_site());
+        let module = parsed_meta.module.as_deref().unwrap_or("Encoder");
+        let module_ident = Ident::new(&module, Span::call_site());
 
-                quote! {
-                    crate::#module_ident::encode(&self.#name, writer)?;
-                }
-            }
-            None => {
-                quote! {
-                    crate::Encoder::encode(&self.#name, writer)?;
-                }
-            }
+        quote! {
+            crate::#module_ident::encode(&self.#name, writer)?;
         }
     });
 
     quote! {
+        #[automatically_derived]
         impl crate::Encoder for #name {
             fn encode<W: std::io::Write>(&self, writer: &mut W) -> Result<(), crate::EncodeError> {
                 #encode
@@ -65,18 +58,48 @@ fn impl_encoder_trait(name: &Ident, fields: &Fields) -> TokenStream2 {
 }
 
 fn impl_decoder_trait(name: &Ident, fields: &Fields) -> TokenStream2 {
-    let decode = quote_field(fields, |_field| {
+    let decode = quote_field(fields, |field| {
+        let name = &field.ident;
+        let ty = &field.ty;
+
+        let unparsed_meta = get_packet_field_meta(field);
+        let parsed_meta = parse_packet_field_meta(&unparsed_meta);
+
+        match parsed_meta.module {
+            Some(module) => {
+                let module_ident = Ident::new(&module, Span::call_site());
+
+                quote! {
+                    let #name = crate::#module_ident::decode(reader)?;
+                }
+            }
+            None => {
+                quote! {
+                    let #name = <#ty as crate::Decoder>::decode(reader)?;
+                }
+            }
+        }
+    });
+
+    let create = quote_field(fields, |field| {
+        let name = &field.ident;
+
         quote! {
-           todo!();
+             #name,
         }
     });
 
     quote! {
+        #[automatically_derived]
         impl crate::Decoder for #name {
             type Output = Self;
 
             fn decode<R: std::io::Read>(reader: &mut R) -> Result<Self::Output, crate::DecodeError> {
                 #decode
+
+                Ok(#name {
+                    #create
+                })
             }
         }
     }

protocol/src/lib.rs

@@ -480,7 +480,7 @@ macro_rules! impl_json_encoder_decoder (
 );
 
 mod var_int {
-    use crate::{DecodeError, EncodeError, Encoder};
+    use crate::{DecodeError, EncodeError};
     use mc_varint::{VarIntRead, VarIntWrite};
     use std::io::{Read, Write};
 
@@ -496,7 +496,7 @@ mod var_int {
 }
 
 mod var_long {
-    use crate::{DecodeError, EncodeError, Encoder};
+    use crate::{DecodeError, EncodeError};
     use mc_varint::{VarIntRead, VarIntWrite};
     use std::io::{Read, Write};
 
@@ -512,7 +512,7 @@ mod var_long {
 }
 
 mod rest {
-    use crate::{DecodeError, Decoder, EncodeError, Encoder};
+    use crate::{DecodeError, EncodeError};
     use std::io::{Read, Write};
 
     pub fn encode<W: Write>(value: &[u8], writer: &mut W) -> Result<(), EncodeError> {
@@ -531,8 +531,7 @@ mod rest {
 
 mod uuid_hyp_str {
     use crate::{
-        DecodeError, Decoder, DecoderReadExt, EncodeError, Encoder, EncoderWriteExt,
-        HYPHENATED_UUID_LENGTH,
+        DecodeError, DecoderReadExt, EncodeError, EncoderWriteExt, HYPHENATED_UUID_LENGTH,
     };
     use std::io::{Read, Write};
     use uuid::Uuid;

protocol/src/login.rs

@@ -115,7 +115,7 @@ impl LoginStart {
     }
 }
 
-#[derive(Packet, Debug)]
+#[derive(Debug)]
 pub struct EncryptionResponse {
     pub shared_secret: Vec<u8>,
     pub verify_token: Vec<u8>,
@@ -132,6 +132,28 @@ impl EncryptionResponse {
     }
 }
 
+impl crate::Encoder for EncryptionResponse {
+    fn encode<W: std::io::Write>(&self, writer: &mut W) -> Result<(), crate::EncodeError> {
+        crate::Encoder::encode(&self.shared_secret, writer)?;
+        crate::Encoder::encode(&self.verify_token, writer)?;
+        Ok(())
+    }
+}
+
+impl crate::Decoder for EncryptionResponse {
+    type Output = Self;
+
+    fn decode<R: std::io::Read>(reader: &mut R) -> Result<Self::Output, crate::DecodeError> {
+        let shared_secret = <Vec<u8> as crate::Decoder>::decode(reader)?;
+        let verify_token = <Vec<u8> as crate::Decoder>::decode(reader)?;
+
+        Ok(EncryptionResponse {
+            shared_secret,
+            verify_token,
+        })
+    }
+}
+
 #[derive(Packet, Debug)]
 pub struct LoginPluginResponse {
     #[packet(with = "var_int")]