feat: basic Decode derive

crawlspace-macro/src/lib.rs

···
 use proc_macro::{Span, TokenStream};
-use quote::{quote, TokenStreamExt};
-use syn::{parse_macro_input, DeriveInput, Fields, Ident, Index, Lit};
+use quote::quote;
+use syn::{parse_macro_input, parse_quote, DeriveInput, Fields, Ident, Index, Lit};
 
 #[proc_macro_derive(Packet, attributes(packet))]
 pub fn derive_packet(input: TokenStream) -> TokenStream {
···
     }
     .into()
 }
+
+/// Automatically implements "straight-across" decoding for the given struct, i.e. fields are
+/// deserialized in order as is. Supports #[varint] and #[varlong] attributes on integer types to
+/// deserialize as those formats instead.
+#[proc_macro_derive(Decode, attributes(varint, varlong))]
+pub fn derive_decode(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    let syn::Data::Struct(data) = input.data else {
+        panic!("Can only derive Decode on a struct");
+    };
+
+    let name = input.ident;
+
+    let struct_tokens = match data.fields {
+        Fields::Named(fields) => {
+            let mut field_tokens = proc_macro2::TokenStream::new();
+
+            for field in fields.named {
+                let field_name = field.ident.expect("couldn't get ident for named field");
+                let ty = field.ty;
+
+                let wrapped = format!("for field {field_name} in {name}");
+
+                if field
+                    .attrs
+                    .iter()
+                    .any(|attr| attr.meta.path().is_ident("varint"))
+                {
+                    field_tokens.extend(quote! {
+                        #field_name: VarInt::decode(r)
+                            .wrap_err(#wrapped)?
+                            .try_into()?,
+                    });
+                } else if field
+                    .attrs
+                    .iter()
+                    .any(|attr| attr.meta.path().is_ident("varlong"))
+                {
+                    field_tokens.extend(quote! {
+                        #field_name: VarLong::decode(r)
+                            .wrap_err(#wrapped)?
+                            .try_into()?,
+                    });
+                } else {
+                    field_tokens.extend(quote! {
+                        #field_name: <#ty as Decode>::decode(r)
+                            .wrap_err(#wrapped)?,
+                    });
+                }
+            }
+            quote! {
+                Self {
+                    #field_tokens
+                }
+            }
+        }
+        Fields::Unnamed(fields) => {
+            let mut field_tokens = proc_macro2::TokenStream::new();
+            for (i, field) in fields.unnamed.into_iter().enumerate() {
+                let ty = field.ty;
+
+                let wrapped = format!("for field {i} in {name}");
+
+                if field
+                    .attrs
+                    .iter()
+                    .any(|attr| attr.meta.path().is_ident("varint"))
+                {
+                    field_tokens.extend(quote! {
+                        VarInt::decode(r)
+                            .wrap_err(#wrapped)?
+                            .try_into()?,
+                    });
+                } else if field
+                    .attrs
+                    .iter()
+                    .any(|attr| attr.meta.path().is_ident("varlong"))
+                {
+                    field_tokens.extend(quote! {
+                        VarLong::decode(r)
+                            .wrap_err(#wrapped)?
+                            .try_into()?,
+                    });
+                } else {
+                    field_tokens.extend(quote! {
+                        <#ty as Decode>::decode(r)
+                            .wrap_err(#wrapped)?,
+                    });
+                }
+            }
+            quote! {
+                Self(#field_tokens)
+            }
+        }
+        Fields::Unit => quote! { Self },
+    };
+
+    let struct_generics = input.generics;
+    let where_clause = struct_generics.where_clause.clone();
+
+    let mut impl_generics = struct_generics.clone();
+    if impl_generics.lifetimes().count() == 0 {
+        impl_generics.params.push(parse_quote!('a));
+    }
+
+    quote! {
+        impl #impl_generics Decode #impl_generics for #name #struct_generics #where_clause {
+            fn decode(r: &mut &'a [u8]) -> color_eyre::Result<Self>
+            where
+                Self: Sized,
+            {
+                use color_eyre::eyre::WrapErr;
+                Ok(#struct_tokens)
+            }
+        }
+    }
+    .into()
+}

crawlspace/src/protocol/datatypes/impls.rs

···
     }
 }
 
+impl<'a> Decode<'a> for i8 {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(r.read_i8()?)
+    }
+}
+
 impl Encode for i8 {
     fn encode(&self, mut w: impl std::io::Write) -> Result<()> {
         Ok(w.write_i8(*self)?)
     }
 }
 
+impl<'a> Decode<'a> for u8 {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(r.read_u8()?)
+    }
+}
+
 impl Encode for u8 {
     fn encode(&self, mut w: impl std::io::Write) -> Result<()> {
         Ok(w.write_u8(*self)?)
     }
 }
 
+impl<'a> Decode<'a> for i16 {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(r.read_i16::<BigEndian>()?)
+    }
+}
+
 impl Encode for i16 {
     fn encode(&self, mut w: impl std::io::Write) -> Result<()> {
         Ok(w.write_i16::<BigEndian>(*self)?)
     }
 }
 
+impl<'a> Decode<'a> for u16 {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(r.read_u16::<BigEndian>()?)
+    }
+}
+
+impl<'a> Decode<'a> for i32 {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(r.read_i32::<BigEndian>()?)
+    }
+}
+
 impl Encode for i32 {
     fn encode(&self, mut w: impl std::io::Write) -> Result<()> {
         Ok(w.write_i32::<BigEndian>(*self)?)
···
 }
 
 impl<'a> Decode<'a> for i64 {
-    fn decode(r: &mut &'a [u8]) -> Result<Self> {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
         Ok(r.read_i64::<BigEndian>()?)
     }
 }
···
     }
 }
 
+impl<'a> Decode<'a> for u64 {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(r.read_u64::<BigEndian>()?)
+    }
+}
+
 impl Encode for u64 {
     fn encode(&self, mut w: impl std::io::Write) -> Result<()> {
         Ok(w.write_u64::<BigEndian>(*self)?)
     }
 }
 
+impl<'a> Decode<'a> for u128 {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(r.read_u128::<BigEndian>()?)
+    }
+}
+
 impl Encode for u128 {
     fn encode(&self, mut w: impl std::io::Write) -> Result<()> {
         Ok(w.write_u128::<BigEndian>(*self)?)
     }
 }
 
+impl<'a> Decode<'a> for f32 {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(r.read_f32::<BigEndian>()?)
+    }
+}
+
 impl Encode for f32 {
     fn encode(&self, mut w: impl std::io::Write) -> Result<()> {
         Ok(w.write_f32::<BigEndian>(*self)?)
+    }
+}
+
+impl<'a> Decode<'a> for f64 {
+    fn decode(r: &mut &'a [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        Ok(r.read_f64::<BigEndian>()?)
     }
 }
 

crawlspace/src/protocol/datatypes/variable.rs

···
         }
     }
 }
+
+impl From<VarInt> for i32 {
+    fn from(value: VarInt) -> Self {
+        value.0
+    }
+}

crawlspace/src/protocol/mod.rs

···
 mod encoder;
 
 use bit_vec::BitVec;
-use color_eyre::eyre::{Context, Result};
+use color_eyre::eyre::{bail, Context, Result};
 use datatypes::{Bounded, VarInt};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
···
     Status,
     Login,
     Transfer,
+}
+
+impl Decode<'_> for ProtocolState {
+    fn decode(r: &mut &'_ [u8]) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        let state = VarInt::decode(r)?;
+
+        match state.0 {
+            1 => Ok(ProtocolState::Status),
+            2 => Ok(ProtocolState::Login),
+            3 => Ok(ProtocolState::Transfer),
+            e => bail!("Invalid next state requested: {e}"),
+        }
+    }
 }
 
 #[derive(Error, Debug)]

crawlspace/src/protocol/packets/login/config.rs

···
  */
 
 use color_eyre::eyre::{ensure, Result};
-use crawlspace_macro::{Encode, Packet};
+use crawlspace_macro::{Decode, Encode, Packet};
 
 use crate::protocol::{
     datatypes::{Bounded, VarInt},
···
     known_packs: Vec<KnownPack<'a>>,
 }
 
-#[derive(Debug, Encode)]
+#[derive(Debug, Encode, Decode)]
 pub struct KnownPack<'a> {
     namespace: Bounded<&'a str>,
     id: Bounded<&'a str>,
···
     }
 }
 
-impl<'a> Decode<'a> for KnownPack<'a> {
-    fn decode(r: &mut &'a [u8]) -> Result<Self> {
-        Ok(Self {
-            namespace: Bounded::<&'a str>::decode(r)?,
-            id: Bounded::<&'a str>::decode(r)?,
-            version: Bounded::<&'a str>::decode(r)?,
-        })
-    }
-}
-
 #[derive(Debug, Packet, Encode)]
 #[packet(
     id = "minecraft:finish_configuration",
···
 )]
 pub struct FinishConfigurationC;
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(
     id = "minecraft:finish_configuration",
     serverbound,
     state = "PacketState::Configuration"
 )]
 pub struct FinishConfigurationAckS;
-
-impl<'a> Decode<'a> for FinishConfigurationAckS {
-    fn decode(_r: &mut &'a [u8]) -> Result<Self> {
-        Ok(Self)
-    }
-}

crawlspace/src/protocol/packets/login/handshake.rs

···
  * <https://www.gnu.org/licenses/>.
  */
 
-use byteorder::{BigEndian, ReadBytesExt};
-use color_eyre::eyre::Result;
-use crawlspace_macro::Packet;
+use crawlspace_macro::{Decode, Packet};
 
 use crate::protocol::{
     datatypes::{Bounded, VarInt},
     Decode, Packet, PacketDirection, PacketState, ProtocolState,
 };
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(
     id = "minecraft:intention",
     serverbound,
···
     _server_port: u16,
     pub next_state: ProtocolState,
 }
-
-impl<'a> Decode<'a> for HandshakeS<'a> {
-    fn decode(buf: &mut &'a [u8]) -> Result<Self> {
-        Ok(Self {
-            protocol_version: VarInt::decode(buf)?,
-            _server_address: Bounded::<&'a str, 255>::decode(buf)?,
-            _server_port: buf.read_u16::<BigEndian>()?,
-            next_state: ProtocolState::try_from(VarInt::decode(buf)?.0)?,
-        })
-    }
-}

crawlspace/src/protocol/packets/login/login.rs

···
  */
 
 use color_eyre::eyre::Result;
-use crawlspace_macro::Packet;
+use crawlspace_macro::{Decode, Packet};
 use uuid::Uuid;
 
 use crate::protocol::{
···
     Decode, Encode, Packet, PacketDirection, PacketState, Property,
 };
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(id = "minecraft:hello", serverbound, state = "PacketState::Login")]
 pub struct LoginStartS<'a> {
     pub name: Bounded<&'a str, 16>,
     pub player_uuid: Uuid,
-}
-
-impl<'a> Decode<'a> for LoginStartS<'a> {
-    fn decode(buf: &mut &'a [u8]) -> Result<Self> {
-        Ok(Self {
-            name: Bounded::<&'a str, 16>::decode(buf)?,
-            player_uuid: Uuid::decode(buf)?,
-        })
-    }
 }
 
 #[derive(Debug, Packet)]
···
     }
 }
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(
     id = "minecraft:login_acknowledged",
     serverbound,
     state = "PacketState::Login"
 )]
 pub struct LoginAckS;
-
-impl Decode<'_> for LoginAckS {
-    fn decode(_r: &mut &'_ [u8]) -> Result<Self> {
-        Ok(Self)
-    }
-}

crawlspace/src/protocol/packets/login/status.rs

···
 
 use std::io::Write;
 
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
+use byteorder::{BigEndian, WriteBytesExt};
 use color_eyre::eyre::Result;
-use crawlspace_macro::Packet;
+use crawlspace_macro::{Decode, Packet};
 
 use crate::protocol::{Decode, Encode, Packet, PacketDirection, PacketState};
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(
     id = "minecraft:status_request",
     serverbound,
···
 )]
 pub struct StatusRequestS;
 
-impl<'a> Decode<'a> for StatusRequestS {
-    fn decode(_buf: &mut &'a [u8]) -> Result<Self> {
-        Ok(Self)
-    }
-}
-
 #[derive(Debug, Packet)]
 #[packet(
     id = "minecraft:status_response",
···
     pub payload: i64,
 }
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(id = "minecraft:pong", clientbound, state = "PacketState::Status")]
 pub struct PingS {
     pub payload: i64,
···
         Ok(w.write_i64::<BigEndian>(self.payload)?)
     }
 }
-
-impl<'a> Decode<'a> for PingS {
-    fn decode(buf: &mut &'a [u8]) -> Result<Self> {
-        Ok(Self {
-            payload: buf.read_i64::<BigEndian>()?,
-        })
-    }
-}

crawlspace/src/protocol/packets/play/interactions.rs

···
  */
 
 use byteorder::{BigEndian, ReadBytesExt};
-use crawlspace_macro::Packet;
+use crawlspace_macro::{Decode, Packet};
 
 use crate::protocol::{
     datatypes::{Position, VarInt},
     Decode, Packet, PacketDirection, PacketState,
 };
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(id = "minecraft:use_item_on", serverbound, state = "PacketState::Play")]
 pub struct UseItemOnS {
+    #[varint]
     pub hand: Hand,
     pub location: Position,
+    #[varint]
     pub face: Face,
     pub cursor_x: f32,
     pub cursor_y: f32,
···
         }
     }
 }
-
-impl Decode<'_> for UseItemOnS {
-    fn decode(r: &mut &'_ [u8]) -> color_eyre::eyre::Result<Self>
-    where
-        Self: Sized,
-    {
-        Ok(Self {
-            hand: VarInt::decode(r)?.try_into()?,
-            location: Position::decode(r)?,
-            face: VarInt::decode(r)?.try_into()?,
-            cursor_x: r.read_f32::<BigEndian>()?,
-            cursor_y: r.read_f32::<BigEndian>()?,
-            cursor_z: r.read_f32::<BigEndian>()?,
-            inside_block: r.read_u8()? == 1,
-            world_border_hit: r.read_u8()? == 1,
-            sequence: VarInt::decode(r)?,
-        })
-    }
-}

crawlspace/src/protocol/packets/play/keepalive.rs

···
  * <https://www.gnu.org/licenses/>.
  */
 
-use crawlspace_macro::{Encode, Packet};
+use crawlspace_macro::{Decode, Encode, Packet};
 
 use crate::protocol::{Decode, Encode, Packet, PacketDirection, PacketState};
 
···
 #[packet(id = "minecraft:keep_alive", clientbound, state = "PacketState::Play")]
 pub struct KeepAliveC(pub i64);
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(id = "minecraft:keep_alive", serverbound, state = "PacketState::Play")]
 #[expect(unused)]
 pub struct KeepAliveS(i64);
-
-impl<'a> Decode<'a> for KeepAliveS {
-    fn decode(r: &mut &'a [u8]) -> color_eyre::eyre::Result<Self> {
-        Ok(Self(i64::decode(r)?))
-    }
-}

crawlspace/src/protocol/packets/play/position.rs

···
  */
 
 use byteorder::{BigEndian, ReadBytesExt};
-use crawlspace_macro::Packet;
+use crawlspace_macro::{Decode, Packet};
 
 use crate::protocol::{Decode, Packet, PacketDirection, PacketState};
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(
     id = "minecraft:move_player_pos",
     serverbound,
···
     pub x: f64,
     pub feet_y: f64,
     pub z: f64,
-    pub on_ground: bool,
-}
-
-impl Decode<'_> for SetPlayerPositionS {
-    fn decode(r: &mut &'_ [u8]) -> color_eyre::eyre::Result<Self>
-    where
-        Self: Sized,
-    {
-        Ok(Self {
-            x: r.read_f64::<BigEndian>()?,
-            feet_y: r.read_f64::<BigEndian>()?,
-            z: r.read_f64::<BigEndian>()?,
-            on_ground: r.read_u8()? == 1,
-        })
-    }
+    pub on_ground: PosRotFlags,
 }
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(
     id = "minecraft:move_player_pos_rot",
     serverbound,
···
     pub z: f64,
     pub yaw: f32,
     pub pitch: f32,
-    pub on_ground: bool,
+    pub flags: PosRotFlags,
+}
+
+#[derive(Clone, Debug)]
+pub struct PosRotFlags {
+    on_ground: bool,
+    against_wall: bool,
 }
 
-impl Decode<'_> for SetPlayerPositionAndRotationS {
+impl Decode<'_> for PosRotFlags {
     fn decode(r: &mut &'_ [u8]) -> color_eyre::eyre::Result<Self>
     where
         Self: Sized,
     {
-        Ok(Self {
-            x: r.read_f64::<BigEndian>()?,
-            feet_y: r.read_f64::<BigEndian>()?,
-            z: r.read_f64::<BigEndian>()?,
-            yaw: r.read_f32::<BigEndian>()?,
-            pitch: r.read_f32::<BigEndian>()?,
-            on_ground: r.read_u8()? == 1,
+        let field = u8::decode(r)?;
+
+        Ok(PosRotFlags {
+            on_ground: field & 0b00000001 != 0,
+            against_wall: field & 0b00000010 != 0,
         })
     }
 }

crawlspace/src/protocol/packets/play/teleport.rs

···
 
 use std::sync::atomic::{AtomicI32, Ordering};
 
-use crawlspace_macro::{Encode, Packet};
+use crawlspace_macro::{Decode, Encode, Packet};
 
 use crate::protocol::{datatypes::VarInt, Decode, Encode, Packet, PacketDirection, PacketState};
 
···
     }
 }
 
-#[derive(Debug, Packet)]
+#[derive(Debug, Packet, Decode)]
 #[packet(
     id = "minecraft:accept_teleportation",
     serverbound,
     state = "PacketState::Play"
 )]
 pub struct ConfirmTeleportS {
+    #[varint]
     pub id: i32,
 }
-
-impl Decode<'_> for ConfirmTeleportS {
-    fn decode(r: &mut &'_ [u8]) -> color_eyre::eyre::Result<Self> {
-        Ok(Self {
-            id: VarInt::decode(r)?.0,
-        })
-    }
-}

crawlspace/src/server/mod.rs

···
             match player.handle_all_packets().await {
                 Ok(()) => (),
                 Err(why) => {
-                    error!("error handling packets for player {}: {why}", player.id());
+                    error!(
+                        "error handling packets for player {}: {:?}",
+                        player.id(),
+                        why
+                    );
                     invalid_players.insert(*id);
                     continue;
                 }