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

9 files changed, 358 insertions, 300 deletions

diff --git a/azalea-buf/Cargo.toml b/azalea-buf/Cargo.toml
index c8b29c6f..3c8572c8 100644
--- a/azalea-buf/Cargo.toml
+++ b/azalea-buf/Cargo.toml
@@ -4,7 +4,7 @@ edition = "2021"
 license = "MIT"
 name = "azalea-buf"
 repository = "https://github.com/azalea-rs/azalea/tree/main/azalea-buf"
-version = "0.10.3+mc1.21.1"
+version = "0.10.3+mc1.21.3"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/azalea-buf/azalea-buf-macros/Cargo.toml b/azalea-buf/azalea-buf-macros/Cargo.toml
index 85545a75..8920d035 100644
--- a/azalea-buf/azalea-buf-macros/Cargo.toml
+++ b/azalea-buf/azalea-buf-macros/Cargo.toml
@@ -1,10 +1,10 @@
 [package]
-description = "#[derive(McBuf)]"
+description = "#[derive(AzBuf)]"
 edition = "2021"
 license = "MIT"
 name = "azalea-buf-macros"
 repository = "https://github.com/azalea-rs/azalea/tree/main/azalea-buf"
-version = "0.10.3+mc1.21.1"
+version = "0.10.3+mc1.21.3"
 
 [lib]
 proc-macro = true
diff --git a/azalea-buf/azalea-buf-macros/src/lib.rs b/azalea-buf/azalea-buf-macros/src/lib.rs
index 4d17daa6..dec624e3 100755
--- a/azalea-buf/azalea-buf-macros/src/lib.rs
+++ b/azalea-buf/azalea-buf-macros/src/lib.rs
@@ -5,26 +5,26 @@ use proc_macro::TokenStream;
 use quote::quote;
 use syn::{parse_macro_input, DeriveInput};
 
-#[proc_macro_derive(McBufReadable, attributes(var))]
-pub fn derive_mcbufreadable(input: TokenStream) -> TokenStream {
+#[proc_macro_derive(AzaleaRead, attributes(var))]
+pub fn derive_azalearead(input: TokenStream) -> TokenStream {
     let DeriveInput { ident, data, .. } = parse_macro_input!(input);
 
-    read::create_impl_mcbufreadable(&ident, &data).into()
+    read::create_impl_azalearead(&ident, &data).into()
 }
 
-#[proc_macro_derive(McBufWritable, attributes(var))]
-pub fn derive_mcbufwritable(input: TokenStream) -> TokenStream {
+#[proc_macro_derive(AzaleaWrite, attributes(var))]
+pub fn derive_azaleawrite(input: TokenStream) -> TokenStream {
     let DeriveInput { ident, data, .. } = parse_macro_input!(input);
 
-    write::create_impl_mcbufwritable(&ident, &data).into()
+    write::create_impl_azaleawrite(&ident, &data).into()
 }
 
-#[proc_macro_derive(McBuf, attributes(var))]
-pub fn derive_mcbuf(input: TokenStream) -> TokenStream {
+#[proc_macro_derive(AzBuf, attributes(var, limit))]
+pub fn derive_azbuf(input: TokenStream) -> TokenStream {
     let DeriveInput { ident, data, .. } = parse_macro_input!(input);
 
-    let writable = write::create_impl_mcbufwritable(&ident, &data);
-    let readable = read::create_impl_mcbufreadable(&ident, &data);
+    let writable = write::create_impl_azaleawrite(&ident, &data);
+    let readable = read::create_impl_azalearead(&ident, &data);
     quote! {
         #writable
         #readable
diff --git a/azalea-buf/azalea-buf-macros/src/read.rs b/azalea-buf/azalea-buf-macros/src/read.rs
index c5c484e7..c093d4a1 100644
--- a/azalea-buf/azalea-buf-macros/src/read.rs
+++ b/azalea-buf/azalea-buf-macros/src/read.rs
@@ -9,17 +9,38 @@ fn read_named_fields(
         .map(|f| {
             let field_name = &f.ident;
             let field_type = &f.ty;
+
+            let is_variable_length = f.attrs.iter().any(|a| a.path().is_ident("var"));
+            let limit = f
+                .attrs
+                .iter()
+                .find(|a| a.path().is_ident("limit"))
+                .map(|a| {
+                    a.parse_args::<syn::LitInt>()
+                        .unwrap()
+                        .base10_parse::<usize>()
+                        .unwrap()
+                });
+
+            if is_variable_length && limit.is_some() {
+                panic!("Fields cannot have both var and limit attributes");
+            }
+
             // do a different buf.write_* for each field depending on the type
             // if it's a string, use buf.write_string
             match field_type {
                 syn::Type::Path(_) | syn::Type::Array(_) => {
-                    if f.attrs.iter().any(|a| a.path().is_ident("var")) {
+                    if is_variable_length {
+                        quote! {
+                            let #field_name = azalea_buf::AzaleaReadVar::azalea_read_var(buf)?;
+                        }
+                    } else if let Some(limit) = limit {
                         quote! {
-                            let #field_name = azalea_buf::McBufVarReadable::var_read_from(buf)?;
+                            let #field_name = azalea_buf::AzaleaReadLimited::azalea_read_limited(buf, #limit)?;
                         }
                     } else {
                         quote! {
-                            let #field_name = azalea_buf::McBufReadable::read_from(buf)?;
+                            let #field_name = azalea_buf::AzaleaRead::azalea_read(buf)?;
                         }
                     }
                 }
@@ -36,15 +57,15 @@ fn read_named_fields(
     (read_fields, read_field_names)
 }
 
-pub fn create_impl_mcbufreadable(ident: &Ident, data: &Data) -> proc_macro2::TokenStream {
+pub fn create_impl_azalearead(ident: &Ident, data: &Data) -> proc_macro2::TokenStream {
     match data {
         syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
             syn::Fields::Named(FieldsNamed { named, .. }) => {
                 let (read_fields, read_field_names) = read_named_fields(named);
 
                 quote! {
-                impl azalea_buf::McBufReadable for #ident {
-                    fn read_from(buf: &mut std::io::Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
+                impl azalea_buf::AzaleaRead for #ident {
+                    fn azalea_read(buf: &mut std::io::Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
                         #(#read_fields)*
                         Ok(Self {
                             #(#read_field_names: #read_field_names),*
@@ -55,15 +76,15 @@ pub fn create_impl_mcbufreadable(ident: &Ident, data: &Data) -> proc_macro2::Tok
             }
             syn::Fields::Unit => {
                 quote! {
-                impl azalea_buf::McBufReadable for #ident {
-                    fn read_from(buf: &mut std::io::Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
+                impl azalea_buf::AzaleaRead for #ident {
+                    fn azalea_read(buf: &mut std::io::Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
                         Ok(Self)
                     }
                 }
                 }
             }
             _ => {
-                panic!("#[derive(McBuf)] can only be used on structs with named fields")
+                panic!("#[derive(AzBuf)] can only be used on structs with named fields")
             }
         },
         syn::Data::Enum(syn::DataEnum { variants, .. }) => {
@@ -108,13 +129,34 @@ pub fn create_impl_mcbufreadable(ident: &Ident, data: &Data) -> proc_macro2::Tok
                     syn::Fields::Unnamed(fields) => {
                         let mut reader_code = quote! {};
                         for f in &fields.unnamed {
-                            if f.attrs.iter().any(|attr| attr.path().is_ident("var")) {
+                            let is_variable_length =
+                                f.attrs.iter().any(|a| a.path().is_ident("var"));
+                            let limit =
+                                f.attrs
+                                    .iter()
+                                    .find(|a| a.path().is_ident("limit"))
+                                    .map(|a| {
+                                        a.parse_args::<syn::LitInt>()
+                                            .unwrap()
+                                            .base10_parse::<usize>()
+                                            .unwrap()
+                                    });
+
+                            if is_variable_length && limit.is_some() {
+                                panic!("Fields cannot have both var and limit attributes");
+                            }
+
+                            if is_variable_length {
+                                reader_code.extend(quote! {
+                                    Self::#variant_name(azalea_buf::AzaleaReadVar::azalea_read_var(buf)?),
+                                });
+                            } else if let Some(limit) = limit {
                                 reader_code.extend(quote! {
-                                    Self::#variant_name(azalea_buf::McBufVarReadable::var_read_from(buf)?),
+                                    Self::#variant_name(azalea_buf::AzaleaReadLimited::azalea_read_limited(buf, #limit)?),
                                 });
                             } else {
                                 reader_code.extend(quote! {
-                                    Self::#variant_name(azalea_buf::McBufReadable::read_from(buf)?),
+                                    Self::#variant_name(azalea_buf::AzaleaRead::azalea_read(buf)?),
                                 });
                             }
                         }
@@ -139,15 +181,15 @@ pub fn create_impl_mcbufreadable(ident: &Ident, data: &Data) -> proc_macro2::Tok
             let first_reader = first_reader.expect("There should be at least one variant");
 
             quote! {
-            impl azalea_buf::McBufReadable for #ident {
-                fn read_from(buf: &mut std::io::Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
-                    let id = azalea_buf::McBufVarReadable::var_read_from(buf)?;
-                    Self::read_from_id(buf, id)
+            impl azalea_buf::AzaleaRead for #ident {
+                fn azalea_read(buf: &mut std::io::Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
+                    let id = azalea_buf::AzaleaReadVar::azalea_read_var(buf)?;
+                    Self::azalea_read_id(buf, id)
                 }
             }
 
             impl #ident {
-                pub fn read_from_id(buf: &mut std::io::Cursor<&[u8]>, id: u32) -> Result<Self, azalea_buf::BufReadError> {
+                pub fn azalea_read_id(buf: &mut std::io::Cursor<&[u8]>, id: u32) -> Result<Self, azalea_buf::BufReadError> {
                     match id {
                         #match_contents
                         // you'd THINK this throws an error, but mojang decided to make it default for some reason
@@ -157,6 +199,6 @@ pub fn create_impl_mcbufreadable(ident: &Ident, data: &Data) -> proc_macro2::Tok
             }
             }
         }
-        _ => panic!("#[derive(McBuf)] can only be used on structs"),
+        _ => panic!("#[derive(AzBuf)] can only be used on structs"),
     }
 }
diff --git a/azalea-buf/azalea-buf-macros/src/write.rs b/azalea-buf/azalea-buf-macros/src/write.rs
index 4d31f39e..df461d59 100644
--- a/azalea-buf/azalea-buf-macros/src/write.rs
+++ b/azalea-buf/azalea-buf-macros/src/write.rs
@@ -19,11 +19,11 @@ fn write_named_fields(
             syn::Type::Path(_) | syn::Type::Array(_) => {
                 if f.attrs.iter().any(|attr| attr.path().is_ident("var")) {
                     quote! {
-                        azalea_buf::McBufVarWritable::var_write_into(#ident_dot_field, buf)?;
+                        azalea_buf::AzaleaWriteVar::azalea_write_var(#ident_dot_field, buf)?;
                     }
                 } else {
                     quote! {
-                        azalea_buf::McBufWritable::write_into(#ident_dot_field, buf)?;
+                        azalea_buf::AzaleaWrite::azalea_write(#ident_dot_field, buf)?;
                     }
                 }
             }
@@ -37,7 +37,7 @@ fn write_named_fields(
     quote! { #(#write_fields)* }
 }
 
-pub fn create_impl_mcbufwritable(ident: &Ident, data: &Data) -> proc_macro2::TokenStream {
+pub fn create_impl_azaleawrite(ident: &Ident, data: &Data) -> proc_macro2::TokenStream {
     match data {
         syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
             syn::Fields::Named(FieldsNamed { named, .. }) => {
@@ -45,8 +45,8 @@ pub fn create_impl_mcbufwritable(ident: &Ident, data: &Data) -> proc_macro2::Tok
                     write_named_fields(named, Some(&Ident::new("self", Span::call_site())));
 
                 quote! {
-                    impl azalea_buf::McBufWritable for #ident {
-                        fn write_into(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
+                    impl azalea_buf::AzaleaWrite for #ident {
+                        fn azalea_write(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
                             #write_fields
                             Ok(())
                         }
@@ -55,15 +55,15 @@ pub fn create_impl_mcbufwritable(ident: &Ident, data: &Data) -> proc_macro2::Tok
             }
             syn::Fields::Unit => {
                 quote! {
-                    impl azalea_buf::McBufWritable for #ident {
-                        fn write_into(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
+                    impl azalea_buf::AzaleaWrite for #ident {
+                        fn azalea_write(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
                             Ok(())
                         }
                     }
                 }
             }
             _ => {
-                panic!("#[derive(McBuf)] can only be used on structs with named fields")
+                panic!("#[derive(AzBuf)] can only be used on structs with named fields")
             }
         },
         syn::Data::Enum(syn::DataEnum { variants, .. }) => {
@@ -103,7 +103,7 @@ pub fn create_impl_mcbufwritable(ident: &Ident, data: &Data) -> proc_macro2::Tok
 
                 // the variant number that we're going to write
                 let write_the_variant = quote! {
-                    azalea_buf::McBufVarWritable::var_write_into(&#variant_discrim, buf)?;
+                    azalea_buf::AzaleaWriteVar::azalea_write_var(&#variant_discrim, buf)?;
                 };
                 match &variant.fields {
                     syn::Fields::Named(f) => {
@@ -145,11 +145,11 @@ pub fn create_impl_mcbufwritable(ident: &Ident, data: &Data) -> proc_macro2::Tok
                             params_code.extend(quote! { #param_ident, });
                             if f.attrs.iter().any(|attr| attr.path().is_ident("var")) {
                                 writers_code.extend(quote! {
-                                    azalea_buf::McBufVarWritable::var_write_into(#param_ident, buf)?;
+                                    azalea_buf::AzaleaWriteVar::azalea_write_var(#param_ident, buf)?;
                                 });
                             } else {
                                 writers_code.extend(quote! {
-                                    azalea_buf::McBufWritable::write_into(#param_ident, buf)?;
+                                    azalea_buf::AzaleaWrite::azalea_write(#param_ident, buf)?;
                                 });
                             }
                         }
@@ -161,7 +161,7 @@ pub fn create_impl_mcbufwritable(ident: &Ident, data: &Data) -> proc_macro2::Tok
                         });
                         match_arms_without_id.extend(quote! {
                             Self::#variant_name(data) => {
-                                azalea_buf::McBufWritable::write_into(data, buf)?;
+                                azalea_buf::AzaleaWrite::azalea_write(data, buf)?;
                             }
                         });
                     }
@@ -169,8 +169,8 @@ pub fn create_impl_mcbufwritable(ident: &Ident, data: &Data) -> proc_macro2::Tok
             }
             if is_data_enum {
                 quote! {
-                    impl azalea_buf::McBufWritable for #ident {
-                        fn write_into(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
+                    impl azalea_buf::AzaleaWrite for #ident {
+                        fn azalea_write(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
                             match self {
                                 #match_arms
                             }
@@ -189,14 +189,14 @@ pub fn create_impl_mcbufwritable(ident: &Ident, data: &Data) -> proc_macro2::Tok
             } else {
                 // optimization: if it doesn't have data we can just do `as u32`
                 quote! {
-                    impl azalea_buf::McBufWritable for #ident {
-                        fn write_into(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
-                            azalea_buf::McBufVarWritable::var_write_into(&(*self as u32), buf)
+                    impl azalea_buf::AzaleaWrite for #ident {
+                        fn azalea_write(&self, buf: &mut impl std::io::Write) -> Result<(), std::io::Error> {
+                            azalea_buf::AzaleaWriteVar::azalea_write_var(&(*self as u32), buf)
                         }
                     }
                 }
             }
         }
-        _ => panic!("#[derive(McBuf)] can only be used on structs"),
+        _ => panic!("#[derive(AzBuf)] can only be used on structs"),
     }
 }
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)
     }
 }