From 08958c2278b15ebeac8a964f392ebb792e479b61 Mon Sep 17 00:00:00 2001
From: mat <27899617+mat-1@users.noreply.github.com>
Date: Wed, 27 Nov 2024 19:31:40 -0600
Subject: Refactor azalea-protocol (#190)

* start updating to 1.21.4

* fix block codegen and stop using block data from burger

* rename packet related modules and structs to be simpler

* ItemSlot -> ItemStack for more consistency with mojmap

* .get() -> .into_packet()

* simplify declare_state_packets by removing packet ids

* rename read_from and write_into to azalea_read and azalea_write

* rename McBufReadable and McBufWritable to AzaleaRead and AzaleaWrite

* McBuf -> AzBuf

* remove most uses of into_variant

* update codegen and use resourcelocation names for packets

* implement #[limit(i)] attribute for AzBuf derive macro

* fixes for 1.21.4

* fix examples

* update some physics code and fix ChatType

* remove unused imports in codegen

* re-add some things to migrate.py and update +mc version numbers automatically

* downgrade to 1.21.3 lol
---
 azalea-buf/src/read.rs | 195 ++++++++++++++++++++++++++-----------------------
 1 file changed, 104 insertions(+), 91 deletions(-)

(limited to 'azalea-buf/src/read.rs')

diff --git a/azalea-buf/src/read.rs b/azalea-buf/src/read.rs
index 8e406acb..4353539a 100755
--- a/azalea-buf/src/read.rs
+++ b/azalea-buf/src/read.rs
@@ -81,7 +81,7 @@ fn read_bytes<'a>(buf: &'a mut Cursor<&[u8]>, length: usize) -> Result<&'a [u8],
 }
 
 fn read_utf_with_len(buf: &mut Cursor<&[u8]>, max_length: u32) -> Result<String, BufReadError> {
-    let length = u32::var_read_from(buf)?;
+    let length = u32::azalea_read_var(buf)?;
     // i don't know why it's multiplied by 4 but it's like that in mojang's code so
     if length > max_length * 4 {
         return Err(BufReadError::StringLengthTooLong {
@@ -105,30 +105,40 @@ fn read_utf_with_len(buf: &mut Cursor<&[u8]>, max_length: u32) -> Result<String,
     Ok(string)
 }
 
-pub trait McBufReadable
+pub trait AzaleaRead
 where
     Self: Sized,
 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError>;
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError>;
 }
 
-pub trait McBufVarReadable
+pub trait AzaleaReadVar
 where
     Self: Sized,
 {
-    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError>;
+    fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError>;
 }
 
-impl McBufReadable for i32 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+// note that there's no Write equivalent for this trait since we don't really
+// care if we're writing over the limit (and maybe we already know that the
+// server implementation accepts it)
+pub trait AzaleaReadLimited
+where
+    Self: Sized,
+{
+    fn azalea_read_limited(buf: &mut Cursor<&[u8]>, limit: usize) -> Result<Self, BufReadError>;
+}
+
+impl AzaleaRead for i32 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_i32::<BE>()?)
     }
 }
 
-impl McBufVarReadable for i32 {
+impl AzaleaReadVar for i32 {
     // fast varints modified from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L67
     /// Read a single varint from the reader and return the value
-    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+    fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let mut buffer = [0];
         let mut ans = 0;
         for i in 0..5 {
@@ -142,9 +152,9 @@ impl McBufVarReadable for i32 {
     }
 }
 
-impl McBufVarReadable for i64 {
+impl AzaleaReadVar for i64 {
     // fast varints modified from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L54
-    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+    fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let mut buffer = [0];
         let mut ans = 0;
         for i in 0..10 {
@@ -158,14 +168,14 @@ impl McBufVarReadable for i64 {
         Ok(ans)
     }
 }
-impl McBufVarReadable for u64 {
-    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        i64::var_read_from(buf).map(|i| i as u64)
+impl AzaleaReadVar for u64 {
+    fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        i64::azalea_read_var(buf).map(|i| i as u64)
     }
 }
 
-impl McBufReadable for UnsizedByteArray {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for UnsizedByteArray {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         // read to end of the buffer
         let data = buf.get_ref()[buf.position() as usize..].to_vec();
         buf.set_position((buf.position()) + data.len() as u64);
@@ -173,111 +183,114 @@ impl McBufReadable for UnsizedByteArray {
     }
 }
 
-impl<T: McBufReadable + Send> McBufReadable for Vec<T> {
-    default fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        let length = u32::var_read_from(buf)? as usize;
+impl<T: AzaleaRead + Send> AzaleaRead for Vec<T> {
+    default fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let length = u32::azalea_read_var(buf)? as usize;
         // we limit the capacity to not get exploited into allocating a bunch
         let mut contents = Vec::with_capacity(usize::min(length, 65536));
         for _ in 0..length {
-            contents.push(T::read_from(buf)?);
+            contents.push(T::azalea_read(buf)?);
         }
         Ok(contents)
     }
 }
 
-impl<K: McBufReadable + Send + Eq + Hash, V: McBufReadable + Send> McBufReadable for HashMap<K, V> {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        let length = i32::var_read_from(buf)? as usize;
+impl<K: AzaleaRead + Send + Eq + Hash, V: AzaleaRead + Send> AzaleaRead for HashMap<K, V> {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let length = i32::azalea_read_var(buf)? as usize;
         let mut contents = HashMap::with_capacity(usize::min(length, 65536));
         for _ in 0..length {
-            contents.insert(K::read_from(buf)?, V::read_from(buf)?);
+            contents.insert(K::azalea_read(buf)?, V::azalea_read(buf)?);
         }
         Ok(contents)
     }
 }
 
-impl<K: McBufReadable + Send + Eq + Hash, V: McBufVarReadable + Send> McBufVarReadable
-    for HashMap<K, V>
-{
-    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        let length = i32::var_read_from(buf)? as usize;
+impl<K: AzaleaRead + Send + Eq + Hash, V: AzaleaReadVar + Send> AzaleaReadVar for HashMap<K, V> {
+    fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let length = i32::azalea_read_var(buf)? as usize;
         let mut contents = HashMap::with_capacity(usize::min(length, 65536));
         for _ in 0..length {
-            contents.insert(K::read_from(buf)?, V::var_read_from(buf)?);
+            contents.insert(K::azalea_read(buf)?, V::azalea_read_var(buf)?);
         }
         Ok(contents)
     }
 }
 
-impl McBufReadable for Vec<u8> {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        let length = i32::var_read_from(buf)? as usize;
+impl AzaleaRead for Vec<u8> {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let length = i32::azalea_read_var(buf)? as usize;
         read_bytes(buf, length).map(|b| b.to_vec())
     }
 }
 
-impl McBufReadable for String {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for String {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         read_utf_with_len(buf, MAX_STRING_LENGTH.into())
     }
 }
+impl AzaleaReadLimited for String {
+    fn azalea_read_limited(buf: &mut Cursor<&[u8]>, limit: usize) -> Result<Self, BufReadError> {
+        read_utf_with_len(buf, limit as u32)
+    }
+}
 
-impl McBufReadable for u32 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        Ok(i32::read_from(buf)? as u32)
+impl AzaleaRead for u32 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        Ok(i32::azalea_read(buf)? as u32)
     }
 }
 
-impl McBufVarReadable for u32 {
-    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        Ok(i32::var_read_from(buf)? as u32)
+impl AzaleaReadVar for u32 {
+    fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        Ok(i32::azalea_read_var(buf)? as u32)
     }
 }
 
-impl McBufReadable for u16 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        i16::read_from(buf).map(|i| i as u16)
+impl AzaleaRead for u16 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        i16::azalea_read(buf).map(|i| i as u16)
     }
 }
 
-impl McBufReadable for i16 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for i16 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_i16::<BE>()?)
     }
 }
 
-impl McBufVarReadable for u16 {
-    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        Ok(i32::var_read_from(buf)? as u16)
+impl AzaleaReadVar for u16 {
+    fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        Ok(i32::azalea_read_var(buf)? as u16)
     }
 }
 
-impl<T: McBufVarReadable> McBufVarReadable for Vec<T> {
-    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        let length = i32::var_read_from(buf)? as usize;
+impl<T: AzaleaReadVar> AzaleaReadVar for Vec<T> {
+    fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let length = i32::azalea_read_var(buf)? as usize;
         let mut contents = Vec::with_capacity(usize::min(length, 65536));
         for _ in 0..length {
-            contents.push(T::var_read_from(buf)?);
+            contents.push(T::azalea_read_var(buf)?);
         }
         Ok(contents)
     }
 }
 
-impl McBufReadable for i64 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for i64 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_i64::<BE>()?)
     }
 }
 
-impl McBufReadable for u64 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        i64::read_from(buf).map(|i| i as u64)
+impl AzaleaRead for u64 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        i64::azalea_read(buf).map(|i| i as u64)
     }
 }
 
-impl McBufReadable for bool {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        let byte = u8::read_from(buf)?;
+impl AzaleaRead for bool {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let byte = u8::azalea_read(buf)?;
         if byte > 1 {
             warn!("Boolean value was not 0 or 1, but {}", byte);
         }
@@ -285,46 +298,46 @@ impl McBufReadable for bool {
     }
 }
 
-impl McBufReadable for u8 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for u8 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_u8()?)
     }
 }
 
-impl McBufReadable for i8 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        u8::read_from(buf).map(|i| i as i8)
+impl AzaleaRead for i8 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        u8::azalea_read(buf).map(|i| i as i8)
     }
 }
 
-impl McBufReadable for f32 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for f32 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_f32::<BE>()?)
     }
 }
 
-impl McBufReadable for f64 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for f64 {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(buf.read_f64::<BE>()?)
     }
 }
 
-impl<T: McBufReadable> McBufReadable for Option<T> {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        let present = bool::read_from(buf)?;
+impl<T: AzaleaRead> AzaleaRead for Option<T> {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let present = bool::azalea_read(buf)?;
         Ok(if present {
-            Some(T::read_from(buf)?)
+            Some(T::azalea_read(buf)?)
         } else {
             None
         })
     }
 }
 
-impl<T: McBufVarReadable> McBufVarReadable for Option<T> {
-    fn var_read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        let present = bool::read_from(buf)?;
+impl<T: AzaleaReadVar> AzaleaReadVar for Option<T> {
+    fn azalea_read_var(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let present = bool::azalea_read(buf)?;
         Ok(if present {
-            Some(T::var_read_from(buf)?)
+            Some(T::azalea_read_var(buf)?)
         } else {
             None
         })
@@ -332,11 +345,11 @@ impl<T: McBufVarReadable> McBufVarReadable for Option<T> {
 }
 
 // [String; 4]
-impl<T: McBufReadable, const N: usize> McBufReadable for [T; N] {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl<T: AzaleaRead, const N: usize> AzaleaRead for [T; N] {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         let mut contents = Vec::with_capacity(N);
         for _ in 0..N {
-            contents.push(T::read_from(buf)?);
+            contents.push(T::azalea_read(buf)?);
         }
         contents.try_into().map_err(|_| {
             unreachable!("Panic is not possible since the Vec is the same size as the array")
@@ -344,14 +357,14 @@ impl<T: McBufReadable, const N: usize> McBufReadable for [T; N] {
     }
 }
 
-impl McBufReadable for simdnbt::owned::NbtTag {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for simdnbt::owned::NbtTag {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(simdnbt::owned::read_tag(buf).map_err(simdnbt::Error::from)?)
     }
 }
 
-impl McBufReadable for simdnbt::owned::NbtCompound {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for simdnbt::owned::NbtCompound {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         match simdnbt::owned::read_tag(buf).map_err(simdnbt::Error::from)? {
             simdnbt::owned::NbtTag::Compound(compound) => Ok(compound),
             _ => Err(BufReadError::Custom("Expected compound tag".to_string())),
@@ -359,17 +372,17 @@ impl McBufReadable for simdnbt::owned::NbtCompound {
     }
 }
 
-impl McBufReadable for simdnbt::owned::Nbt {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for simdnbt::owned::Nbt {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(simdnbt::owned::read_unnamed(buf)?)
     }
 }
 
-impl<T> McBufReadable for Box<T>
+impl<T> AzaleaRead for Box<T>
 where
-    T: McBufReadable,
+    T: AzaleaRead,
 {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
-        Ok(Box::new(T::read_from(buf)?))
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        Ok(Box::new(T::azalea_read(buf)?))
     }
 }
-- 
cgit v1.2.3