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

1 files changed, 98 insertions, 98 deletions

diff --git a/azalea-buf/src/write.rs b/azalea-buf/src/write.rs
index 49215a5a..1092586d 100755
--- a/azalea-buf/src/write.rs
+++ b/azalea-buf/src/write.rs
@@ -16,26 +16,26 @@ fn write_utf_with_len(
             len
         );
     }
-    string.as_bytes().to_vec().write_into(buf)?;
+    string.as_bytes().to_vec().azalea_write(buf)?;
     Ok(())
 }
 
-pub trait McBufWritable {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
+pub trait AzaleaWrite {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }
 
-pub trait McBufVarWritable {
-    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
+pub trait AzaleaWriteVar {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }
 
-impl McBufWritable for i32 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for i32 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         WriteBytesExt::write_i32::<BigEndian>(buf, *self)
     }
 }
 
-impl McBufVarWritable for i32 {
-    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWriteVar for i32 {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let mut buffer = [0];
         let mut value = *self;
         if value == 0 {
@@ -53,85 +53,85 @@ impl McBufVarWritable for i32 {
     }
 }
 
-impl McBufWritable for UnsizedByteArray {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for UnsizedByteArray {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_all(self)
     }
 }
 
-impl<T: McBufWritable> McBufWritable for Vec<T> {
-    default fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        self[..].write_into(buf)
+impl<T: AzaleaWrite> AzaleaWrite for Vec<T> {
+    default fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        self[..].azalea_write(buf)
     }
 }
 
-impl<T: McBufWritable> McBufWritable for [T] {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        (self.len() as u32).var_write_into(buf)?;
+impl<T: AzaleaWrite> AzaleaWrite for [T] {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        (self.len() as u32).azalea_write_var(buf)?;
         for item in self {
-            T::write_into(item, buf)?;
+            T::azalea_write(item, buf)?;
         }
         Ok(())
     }
 }
 
-impl<K: McBufWritable, V: McBufWritable> McBufWritable for HashMap<K, V> {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        u32::var_write_into(&(self.len() as u32), buf)?;
+impl<K: AzaleaWrite, V: AzaleaWrite> AzaleaWrite for HashMap<K, V> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        u32::azalea_write_var(&(self.len() as u32), buf)?;
         for (key, value) in self {
-            key.write_into(buf)?;
-            value.write_into(buf)?;
+            key.azalea_write(buf)?;
+            value.azalea_write(buf)?;
         }
 
         Ok(())
     }
 }
 
-impl<K: McBufWritable, V: McBufVarWritable> McBufVarWritable for HashMap<K, V> {
-    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        u32::var_write_into(&(self.len() as u32), buf)?;
+impl<K: AzaleaWrite, V: AzaleaWriteVar> AzaleaWriteVar for HashMap<K, V> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        u32::azalea_write_var(&(self.len() as u32), buf)?;
         for (key, value) in self {
-            key.write_into(buf)?;
-            value.var_write_into(buf)?;
+            key.azalea_write(buf)?;
+            value.azalea_write_var(buf)?;
         }
 
         Ok(())
     }
 }
 
-impl McBufWritable for Vec<u8> {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        (self.len() as u32).var_write_into(buf)?;
+impl AzaleaWrite for Vec<u8> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        (self.len() as u32).azalea_write_var(buf)?;
         buf.write_all(self)
     }
 }
 
-impl McBufWritable for String {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for String {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         write_utf_with_len(buf, self, MAX_STRING_LENGTH.into())
     }
 }
 
-impl McBufWritable for &str {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for &str {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         write_utf_with_len(buf, self, MAX_STRING_LENGTH.into())
     }
 }
 
-impl McBufWritable for u32 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        i32::write_into(&(*self as i32), buf)
+impl AzaleaWrite for u32 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        i32::azalea_write(&(*self as i32), buf)
     }
 }
 
-impl McBufVarWritable for u32 {
-    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        i32::var_write_into(&(*self as i32), buf)
+impl AzaleaWriteVar for u32 {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        i32::azalea_write_var(&(*self as i32), buf)
     }
 }
 
-impl McBufVarWritable for i64 {
-    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWriteVar for i64 {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let mut buffer = [0];
         let mut value = *self;
         if value == 0 {
@@ -149,146 +149,146 @@ impl McBufVarWritable for i64 {
     }
 }
 
-impl McBufVarWritable for u64 {
-    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        i64::var_write_into(&(*self as i64), buf)
+impl AzaleaWriteVar for u64 {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        i64::azalea_write_var(&(*self as i64), buf)
     }
 }
 
-impl McBufWritable for u16 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        i16::write_into(&(*self as i16), buf)
+impl AzaleaWrite for u16 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        i16::azalea_write(&(*self as i16), buf)
     }
 }
 
-impl McBufVarWritable for u16 {
-    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        i32::var_write_into(&(*self as i32), buf)
+impl AzaleaWriteVar for u16 {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        i32::azalea_write_var(&(*self as i32), buf)
     }
 }
 
-impl<T: McBufVarWritable> McBufVarWritable for Vec<T> {
-    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        u32::var_write_into(&(self.len() as u32), buf)?;
+impl<T: AzaleaWriteVar> AzaleaWriteVar for Vec<T> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        u32::azalea_write_var(&(self.len() as u32), buf)?;
         for i in self {
-            i.var_write_into(buf)?;
+            i.azalea_write_var(buf)?;
         }
         Ok(())
     }
 }
 
-impl McBufWritable for u8 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for u8 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         WriteBytesExt::write_u8(buf, *self)
     }
 }
 
-impl McBufWritable for i16 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for i16 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         WriteBytesExt::write_i16::<BigEndian>(buf, *self)
     }
 }
 
-impl McBufWritable for i64 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for i64 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         WriteBytesExt::write_i64::<BigEndian>(buf, *self)
     }
 }
 
-impl McBufWritable for u64 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        i64::write_into(&(*self as i64), buf)
+impl AzaleaWrite for u64 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        i64::azalea_write(&(*self as i64), buf)
     }
 }
 
-impl McBufWritable for bool {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for bool {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let byte = u8::from(*self);
-        byte.write_into(buf)
+        byte.azalea_write(buf)
     }
 }
 
-impl McBufWritable for i8 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        (*self as u8).write_into(buf)
+impl AzaleaWrite for i8 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        (*self as u8).azalea_write(buf)
     }
 }
 
-impl McBufWritable for f32 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for f32 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         WriteBytesExt::write_f32::<BigEndian>(buf, *self)
     }
 }
 
-impl McBufWritable for f64 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for f64 {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         WriteBytesExt::write_f64::<BigEndian>(buf, *self)
     }
 }
 
-impl<T: McBufWritable> McBufWritable for Option<T> {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl<T: AzaleaWrite> AzaleaWrite for Option<T> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         if let Some(s) = self {
-            true.write_into(buf)?;
-            s.write_into(buf)?;
+            true.azalea_write(buf)?;
+            s.azalea_write(buf)?;
         } else {
-            false.write_into(buf)?;
+            false.azalea_write(buf)?;
         };
         Ok(())
     }
 }
 
-impl<T: McBufVarWritable> McBufVarWritable for Option<T> {
-    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl<T: AzaleaWriteVar> AzaleaWriteVar for Option<T> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         if let Some(s) = self {
-            true.write_into(buf)?;
-            s.var_write_into(buf)?;
+            true.azalea_write(buf)?;
+            s.azalea_write_var(buf)?;
         } else {
-            false.write_into(buf)?;
+            false.azalea_write(buf)?;
         };
         Ok(())
     }
 }
 
 // [T; N]
-impl<T: McBufWritable, const N: usize> McBufWritable for [T; N] {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl<T: AzaleaWrite, const N: usize> AzaleaWrite for [T; N] {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         for i in self {
-            i.write_into(buf)?;
+            i.azalea_write(buf)?;
         }
         Ok(())
     }
 }
 
-impl McBufWritable for simdnbt::owned::NbtTag {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for simdnbt::owned::NbtTag {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let mut data = Vec::new();
         self.write(&mut data);
         buf.write_all(&data)
     }
 }
 
-impl McBufWritable for simdnbt::owned::NbtCompound {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for simdnbt::owned::NbtCompound {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let mut data = Vec::new();
         simdnbt::owned::NbtTag::Compound(self.clone()).write(&mut data);
         buf.write_all(&data)
     }
 }
 
-impl McBufWritable for simdnbt::owned::Nbt {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for simdnbt::owned::Nbt {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let mut data = Vec::new();
         self.write_unnamed(&mut data);
         buf.write_all(&data)
     }
 }
 
-impl<T> McBufWritable for Box<T>
+impl<T> AzaleaWrite for Box<T>
 where
-    T: McBufWritable,
+    T: AzaleaWrite,
 {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        T::write_into(&**self, buf)
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        T::azalea_write(&**self, buf)
     }
 }