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

4 files changed, 267 insertions, 251 deletions

diff --git a/azalea-buf/src/lib.rs b/azalea-buf/src/lib.rs
index e1d1281f..ef3bd3a8 100755
--- a/azalea-buf/src/lib.rs
+++ b/azalea-buf/src/lib.rs
@@ -10,9 +10,9 @@ mod write;
 
 pub use azalea_buf_macros::*;
 pub use definitions::*;
-pub use read::{BufReadError, McBufReadable, McBufVarReadable};
+pub use read::{AzaleaRead, AzaleaReadLimited, AzaleaReadVar, BufReadError};
 pub use serializable_uuid::*;
-pub use write::{McBufVarWritable, McBufWritable};
+pub use write::{AzaleaWrite, AzaleaWriteVar};
 
 // const DEFAULT_NBT_QUOTA: u32 = 2097152;
 const MAX_STRING_LENGTH: u16 = 32767;
@@ -27,110 +27,113 @@ mod tests {
     #[test]
     fn test_write_varint() {
         let mut buf = Vec::new();
-        0.var_write_into(&mut buf).unwrap();
+        0.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![0]);
 
         let mut buf = Vec::new();
-        1.var_write_into(&mut buf).unwrap();
+        1.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![1]);
 
         let mut buf = Vec::new();
-        2.var_write_into(&mut buf).unwrap();
+        2.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![2]);
 
         let mut buf = Vec::new();
-        127.var_write_into(&mut buf).unwrap();
+        127.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![127]);
 
         let mut buf = Vec::new();
-        128.var_write_into(&mut buf).unwrap();
+        128.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![128, 1]);
 
         let mut buf = Vec::new();
-        255.var_write_into(&mut buf).unwrap();
+        255.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![255, 1]);
 
         let mut buf = Vec::new();
-        25565.var_write_into(&mut buf).unwrap();
+        25565.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![221, 199, 1]);
 
         let mut buf = Vec::new();
-        2097151.var_write_into(&mut buf).unwrap();
+        2097151.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![255, 255, 127]);
 
         let mut buf = Vec::new();
-        2147483647.var_write_into(&mut buf).unwrap();
+        2147483647.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![255, 255, 255, 255, 7]);
 
         let mut buf = Vec::new();
-        (-1).var_write_into(&mut buf).unwrap();
+        (-1).azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![255, 255, 255, 255, 15]);
 
         let mut buf = Vec::new();
-        (-2147483648).var_write_into(&mut buf).unwrap();
+        (-2147483648).azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![128, 128, 128, 128, 8]);
     }
 
     #[test]
     fn test_read_varint() {
         // let buf = &mut &vec![0][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), 0);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), 0);
         let buf = vec![0];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 0);
+        assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 0);
 
         // let buf = &mut &vec![1][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), 1);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), 1);
         let buf = vec![1];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 1);
+        assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 1);
 
         // let buf = &mut &vec![2][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), 2);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), 2);
         let buf = vec![2];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 2);
+        assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 2);
 
         // let buf = &mut &vec![127][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), 127);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), 127);
         let buf = vec![127];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 127);
+        assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 127);
 
         // let buf = &mut &vec![128, 1][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), 128);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), 128);
         let buf = vec![128, 1];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 128);
+        assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 128);
 
         // let buf = &mut &vec![255, 1][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), 255);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), 255);
         let buf = vec![255, 1];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 255);
+        assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 255);
 
         // let buf = &mut &vec![221, 199, 1][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), 25565);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), 25565);
         let buf = vec![221, 199, 1];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 25565);
+        assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 25565);
 
         // let buf = &mut &vec![255, 255, 127][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), 2097151);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), 2097151);
         let buf = vec![255, 255, 127];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 2097151);
+        assert_eq!(
+            i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(),
+            2097151
+        );
 
         // let buf = &mut &vec![255, 255, 255, 255, 7][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), 2147483647);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), 2147483647);
         let buf = vec![255, 255, 255, 255, 7];
         assert_eq!(
-            i32::var_read_from(&mut Cursor::new(&buf)).unwrap(),
+            i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(),
             2147483647
         );
 
         // let buf = &mut &vec![255, 255, 255, 255, 15][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), -1);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), -1);
         let buf = vec![255, 255, 255, 255, 15];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), -1);
+        assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), -1);
 
         // let buf = &mut &vec![128, 128, 128, 128, 8][..];
-        // assert_eq!(i32::var_read_from(buf).unwrap(), -2147483648);
+        // assert_eq!(i32::azalea_read_var(buf).unwrap(), -2147483648);
         let buf = vec![128, 128, 128, 128, 8];
         assert_eq!(
-            i32::var_read_from(&mut Cursor::new(&buf)).unwrap(),
+            i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(),
             -2147483648
         );
     }
@@ -138,21 +141,21 @@ mod tests {
     #[test]
     fn test_read_varint_longer() {
         let buf = vec![138, 56, 0, 135, 56, 123];
-        assert_eq!(i32::var_read_from(&mut Cursor::new(&buf)).unwrap(), 7178);
+        assert_eq!(i32::azalea_read_var(&mut Cursor::new(&buf)).unwrap(), 7178);
     }
 
     #[test]
     fn test_write_varlong() {
         let mut buf = Vec::new();
-        0u64.var_write_into(&mut buf).unwrap();
+        0u64.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![0]);
 
         let mut buf = Vec::new();
-        1u64.var_write_into(&mut buf).unwrap();
+        1u64.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![1]);
 
         let mut buf = Vec::new();
-        9223372036854775807u64.var_write_into(&mut buf).unwrap();
+        9223372036854775807u64.azalea_write_var(&mut buf).unwrap();
         assert_eq!(buf, vec![255, 255, 255, 255, 255, 255, 255, 255, 127]);
     }
 
@@ -161,20 +164,20 @@ mod tests {
         let original_vec = vec!["a".to_string(), "bc".to_string(), "def".to_string()];
 
         let mut buf = Vec::new();
-        original_vec.write_into(&mut buf).unwrap();
+        original_vec.azalea_write(&mut buf).unwrap();
 
         dbg!(&buf);
 
-        let result = Vec::<String>::read_from(&mut Cursor::new(&buf)).unwrap();
+        let result = Vec::<String>::azalea_read(&mut Cursor::new(&buf)).unwrap();
         assert_eq!(result, original_vec);
     }
 
     #[test]
     fn test_int_id_list() {
         let mut buf = Vec::new();
-        vec![1, 2, 3].var_write_into(&mut buf).unwrap();
+        vec![1, 2, 3].azalea_write_var(&mut buf).unwrap();
 
-        let result = Vec::<i32>::var_read_from(&mut Cursor::new(&buf)).unwrap();
+        let result = Vec::<i32>::azalea_read_var(&mut Cursor::new(&buf)).unwrap();
         assert_eq!(result, vec![1, 2, 3]);
     }
 
@@ -186,9 +189,9 @@ mod tests {
             ("def".to_string(), 456),
         ]);
         let mut buf = Vec::new();
-        original_map.var_write_into(&mut buf).unwrap();
+        original_map.azalea_write_var(&mut buf).unwrap();
 
-        let result = HashMap::<String, i32>::var_read_from(&mut Cursor::new(&buf)).unwrap();
+        let result = HashMap::<String, i32>::azalea_read_var(&mut Cursor::new(&buf)).unwrap();
 
         assert_eq!(result, original_map);
     }
@@ -196,8 +199,8 @@ mod tests {
     #[test]
     fn test_long() {
         let mut buf: Vec<u8> = Vec::new();
-        123456u64.write_into(&mut buf).unwrap();
+        123456u64.azalea_write(&mut buf).unwrap();
 
-        assert_eq!(u64::read_from(&mut Cursor::new(&buf)).unwrap(), 123456);
+        assert_eq!(u64::azalea_read(&mut Cursor::new(&buf)).unwrap(), 123456);
     }
 }
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)?))
     }
 }
diff --git a/azalea-buf/src/serializable_uuid.rs b/azalea-buf/src/serializable_uuid.rs
index d4ec0315..53eccbbb 100755
--- a/azalea-buf/src/serializable_uuid.rs
+++ b/azalea-buf/src/serializable_uuid.rs
@@ -2,7 +2,7 @@ use std::io::{Cursor, Write};
 
 use uuid::Uuid;
 
-use crate::{read::BufReadError, McBufReadable, McBufWritable};
+use crate::{read::BufReadError, AzaleaRead, AzaleaWrite};
 
 pub trait SerializableUuid {
     fn to_int_array(&self) -> [u32; 4];
@@ -34,24 +34,24 @@ impl SerializableUuid for Uuid {
     }
 }
 
-impl McBufReadable for Uuid {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+impl AzaleaRead for Uuid {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
         Ok(Uuid::from_int_array([
-            u32::read_from(buf)?,
-            u32::read_from(buf)?,
-            u32::read_from(buf)?,
-            u32::read_from(buf)?,
+            u32::azalea_read(buf)?,
+            u32::azalea_read(buf)?,
+            u32::azalea_read(buf)?,
+            u32::azalea_read(buf)?,
         ]))
     }
 }
 
-impl McBufWritable for Uuid {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl AzaleaWrite for Uuid {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let [a, b, c, d] = self.to_int_array();
-        a.write_into(buf)?;
-        b.write_into(buf)?;
-        c.write_into(buf)?;
-        d.write_into(buf)?;
+        a.azalea_write(buf)?;
+        b.azalea_write(buf)?;
+        c.azalea_write(buf)?;
+        d.azalea_write(buf)?;
         Ok(())
     }
 }
@@ -79,10 +79,10 @@ mod tests {
     fn read_write() {
         let u = Uuid::parse_str("6536bfed-8695-48fd-83a1-ecd24cf2a0fd").unwrap();
         let mut buf = Vec::new();
-        u.write_into(&mut buf).unwrap();
+        u.azalea_write(&mut buf).unwrap();
         println!("{buf:?}");
         assert_eq!(buf.len(), 16);
-        let u2 = Uuid::read_from(&mut Cursor::new(&buf)).unwrap();
+        let u2 = Uuid::azalea_read(&mut Cursor::new(&buf)).unwrap();
         assert_eq!(u, u2);
     }
 }
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)
     }
 }