From a24d00d99819166a147af77dc50ff61dff5cb04a Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Sun, 1 May 2022 23:35:30 -0500
Subject: impl Write instead of Vec<u8> for consistency

---
 azalea-protocol/src/mc_buf/mod.rs   |   2 +-
 azalea-protocol/src/mc_buf/write.rs | 128 +++++++++++++-----------------------
 2 files changed, 46 insertions(+), 84 deletions(-)

(limited to 'azalea-protocol/src/mc_buf')

diff --git a/azalea-protocol/src/mc_buf/mod.rs b/azalea-protocol/src/mc_buf/mod.rs
index a61ad3c3..a82334fb 100755
--- a/azalea-protocol/src/mc_buf/mod.rs
+++ b/azalea-protocol/src/mc_buf/mod.rs
@@ -5,7 +5,7 @@ mod write;
 
 use packet_macros::{McBufReadable, McBufWritable};
 pub use read::{read_varint_async, McBufReadable, McBufVarintReadable, Readable};
-use std::ops::{Deref, Index};
+use std::ops::Deref;
 pub use write::{McBufVarintWritable, McBufWritable, Writable};
 
 // const DEFAULT_NBT_QUOTA: u32 = 2097152;
diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
index 57ec3a48..34bcafeb 100755
--- a/azalea-protocol/src/mc_buf/write.rs
+++ b/azalea-protocol/src/mc_buf/write.rs
@@ -8,49 +8,10 @@ use byteorder::{BigEndian, WriteBytesExt};
 use std::io::Write;
 use uuid::Uuid;
 
-pub trait Writable {
+pub trait Writable: Write {
     fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
     where
         F: FnOnce(&mut Self, &T) -> Result<(), std::io::Error> + Copy,
-        T: Sized,
-        Self: Sized;
-    fn write_int_id_list(&mut self, list: &Vec<i32>) -> Result<(), std::io::Error>;
-    fn write_map<KF, VF, KT, VT>(
-        &mut self,
-        map: Vec<(KT, VT)>,
-        key_writer: KF,
-        value_writer: VF,
-    ) -> Result<(), std::io::Error>
-    where
-        KF: Fn(&mut Self, KT) -> Result<(), std::io::Error> + Copy,
-        VF: Fn(&mut Self, VT) -> Result<(), std::io::Error> + Copy,
-        Self: Sized;
-
-    fn write_byte(&mut self, n: u8) -> Result<(), std::io::Error>;
-    fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
-    fn write_varint(&mut self, value: i32) -> Result<(), std::io::Error>;
-    fn write_utf_with_len(&mut self, string: &str, len: usize) -> Result<(), std::io::Error>;
-    fn write_utf(&mut self, string: &str) -> Result<(), std::io::Error>;
-    fn write_short(&mut self, n: i16) -> Result<(), std::io::Error>;
-    fn write_byte_array(&mut self, bytes: &[u8]) -> Result<(), std::io::Error>;
-    fn write_int(&mut self, n: i32) -> Result<(), std::io::Error>;
-    fn write_boolean(&mut self, b: bool) -> Result<(), std::io::Error>;
-    fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error>;
-    fn write_long(&mut self, n: i64) -> Result<(), std::io::Error>;
-    fn write_resource_location(
-        &mut self,
-        location: &ResourceLocation,
-    ) -> Result<(), std::io::Error>;
-    fn write_float(&mut self, n: f32) -> Result<(), std::io::Error>;
-    fn write_double(&mut self, n: f64) -> Result<(), std::io::Error>;
-    fn write_uuid(&mut self, uuid: &Uuid) -> Result<(), std::io::Error>;
-}
-
-impl Writable for Vec<u8> {
-    fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
-    where
-        F: FnOnce(&mut Self, &T) -> Result<(), std::io::Error> + Copy,
-        Self: Sized,
     {
         self.write_varint(list.len() as i32)?;
         for item in list {
@@ -72,7 +33,6 @@ impl Writable for Vec<u8> {
     where
         KF: Fn(&mut Self, KT) -> Result<(), std::io::Error> + Copy,
         VF: Fn(&mut Self, VT) -> Result<(), std::io::Error> + Copy,
-        Self: Sized,
     {
         self.write_varint(map.len() as i32)?;
         for (key, value) in map {
@@ -87,7 +47,7 @@ impl Writable for Vec<u8> {
     }
 
     fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
-        self.extend_from_slice(bytes);
+        self.write_all(bytes);
         Ok(())
     }
 
@@ -140,7 +100,10 @@ impl Writable for Vec<u8> {
         self.write_byte(if b { 1 } else { 0 })
     }
 
-    fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error> {
+    fn write_nbt(&mut self, nbt: &azalea_nbt::Tag) -> Result<(), std::io::Error>
+    where
+        Self: Sized,
+    {
         nbt.write(self)
             .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
     }
@@ -164,7 +127,10 @@ impl Writable for Vec<u8> {
         self.write_utf(&location.to_string())
     }
 
-    fn write_uuid(&mut self, uuid: &Uuid) -> Result<(), std::io::Error> {
+    fn write_uuid(&mut self, uuid: &Uuid) -> Result<(), std::io::Error>
+    where
+        Self: Sized,
+    {
         let [a, b, c, d] = uuid.to_int_array();
         a.write_into(self)?;
         b.write_into(self)?;
@@ -174,34 +140,30 @@ impl Writable for Vec<u8> {
     }
 }
 
-pub trait McBufWritable
-where
-    Self: Sized,
-{
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error>;
+impl<W: Write + ?Sized> Writable for W {}
+
+pub trait McBufWritable {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }
 
-pub trait McBufVarintWritable
-where
-    Self: Sized,
-{
-    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error>;
+pub trait McBufVarintWritable {
+    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }
 
 impl McBufWritable for i32 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         Writable::write_int(buf, *self)
     }
 }
 
 impl McBufVarintWritable for i32 {
-    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_varint(*self)
     }
 }
 
 impl McBufWritable for UnsizedByteArray {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_bytes(self)
     }
 }
@@ -209,132 +171,132 @@ impl McBufWritable for UnsizedByteArray {
 // TODO: use specialization when that gets stabilized into rust
 // to optimize for Vec<u8> byte arrays
 impl<T: McBufWritable> McBufWritable for Vec<T> {
-    default fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    default fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_list(self, |buf, i| T::write_into(i, buf))
     }
 }
 
 impl McBufWritable for Vec<u8> {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte_array(self)
     }
 }
 
 // string
 impl McBufWritable for String {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_utf(self)
     }
 }
 
 // ResourceLocation
 impl McBufWritable for ResourceLocation {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_resource_location(self)
     }
 }
 
 // u32
 impl McBufWritable for u32 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i16::write_into(&(*self as i16), buf)
     }
 }
 
 // u32 varint
 impl McBufVarintWritable for u32 {
-    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i32::varint_write_into(&(*self as i32), buf)
     }
 }
 
 // u16
 impl McBufWritable for u16 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i16::write_into(&(*self as i16), buf)
     }
 }
 
 // u16 varint
 impl McBufVarintWritable for u16 {
-    fn varint_write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i32::varint_write_into(&(*self as i32), buf)
     }
 }
 
 // u8
 impl McBufWritable for u8 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte(*self)
     }
 }
 
 // i16
 impl McBufWritable for i16 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         Writable::write_short(buf, *self)
     }
 }
 
 // i64
 impl McBufWritable for i64 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         Writable::write_long(buf, *self)
     }
 }
 
 // u64
 impl McBufWritable for u64 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i64::write_into(&(*self as i64), buf)
     }
 }
 
 // bool
 impl McBufWritable for bool {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_boolean(*self)
     }
 }
 
 // i8
 impl McBufWritable for i8 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte(*self as u8)
     }
 }
 
 // f32
 impl McBufWritable for f32 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_float(*self)
     }
 }
 
 // f64
 impl McBufWritable for f64 {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_double(*self)
     }
 }
 
 // GameType
 impl McBufWritable for GameType {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         u8::write_into(&self.to_id(), buf)
     }
 }
 
 // Option<GameType>
 impl McBufWritable for Option<GameType> {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte(GameType::to_optional_id(self) as u8)
     }
 }
 
 // Option<String>
 impl<T: McBufWritable> McBufWritable for Option<T> {
-    default fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    default fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         if let Some(s) = self {
             buf.write_boolean(true)?;
             s.write_into(buf)?;
@@ -347,14 +309,14 @@ impl<T: McBufWritable> McBufWritable for Option<T> {
 
 // azalea_nbt::Tag
 impl McBufWritable for azalea_nbt::Tag {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_nbt(self)
     }
 }
 
 // Difficulty
 impl McBufWritable for Difficulty {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         u8::write_into(&self.id(), buf)
     }
 }
@@ -371,7 +333,7 @@ impl McBufWritable for Component {
     //     let component = Component::deserialize(json).map_err(|e| e.to_string())?;
     //     Ok(component)
     // }
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         // component doesn't have serialize implemented yet
         todo!()
     }
@@ -379,7 +341,7 @@ impl McBufWritable for Component {
 
 // Slot
 impl McBufWritable for Slot {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         match self {
             Slot::Empty => buf.write_byte(0)?,
             Slot::Present(i) => {
@@ -395,7 +357,7 @@ impl McBufWritable for Slot {
 
 // Slot
 impl McBufWritable for Uuid {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_uuid(self)?;
 
         Ok(())
@@ -404,7 +366,7 @@ impl McBufWritable for Uuid {
 
 // BlockPos
 impl McBufWritable for BlockPos {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_long(
             (((self.x & 0x3FFFFFF) as i64) << 38)
                 | (((self.z & 0x3FFFFFF) as i64) << 12)
@@ -415,7 +377,7 @@ impl McBufWritable for BlockPos {
 
 // Direction
 impl McBufWritable for Direction {
-    fn write_into(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_varint(*self as i32)
     }
 }
-- 
cgit v1.2.3


From 1e2ec611003770ce889d69545604f164e2ea8fff Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Mon, 2 May 2022 00:24:29 -0500
Subject: write some more azalea-world code

---
 Cargo.lock                                         |   3 +
 azalea-protocol/src/mc_buf/mod.rs                  |   6 ++
 .../clientbound_level_chunk_with_light_packet.rs   |   6 --
 azalea-world/Cargo.toml                            |   3 +-
 azalea-world/src/lib.rs                            | 118 ++++++++++++++++++---
 5 files changed, 117 insertions(+), 19 deletions(-)

(limited to 'azalea-protocol/src/mc_buf')

diff --git a/Cargo.lock b/Cargo.lock
index 7f6ef343..b0fe3c05 100755
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -164,6 +164,9 @@ dependencies = [
 [[package]]
 name = "azalea-world"
 version = "0.1.0"
+dependencies = [
+ "azalea-protocol",
+]
 
 [[package]]
 name = "bitflags"
diff --git a/azalea-protocol/src/mc_buf/mod.rs b/azalea-protocol/src/mc_buf/mod.rs
index a82334fb..74d69441 100755
--- a/azalea-protocol/src/mc_buf/mod.rs
+++ b/azalea-protocol/src/mc_buf/mod.rs
@@ -1,5 +1,11 @@
 //! Utilities for reading and writing for the Minecraft protocol
 
+// TODO: have a separate azalea-protocol-definitions crate to house everything in mc_buf
+// We need to do this to prevent cyclic dependencies.
+// For example with azalea-protocol depending on azalea-world,
+// it could be changed to azalea-protocol depending on azalea-world
+// and azalea-world depending on azalea-protocol-definitions.
+
 mod read;
 mod write;
 
diff --git a/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs b/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs
index abd936dc..0ab581ec 100644
--- a/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs
@@ -28,9 +28,3 @@ pub struct BlockEntity {
 }
 
 pub struct ChunkSection {}
-
-impl ClientboundLevelChunkPacketData {
-    pub fn read(world_height: u32) {
-        // let section_count
-    }
-}
diff --git a/azalea-world/Cargo.toml b/azalea-world/Cargo.toml
index afae93a7..54326fb7 100644
--- a/azalea-world/Cargo.toml
+++ b/azalea-world/Cargo.toml
@@ -1,8 +1,9 @@
 [package]
+edition = "2021"
 name = "azalea-world"
 version = "0.1.0"
-edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+azalea-protocol = {path = "../azalea-protocol"}
diff --git a/azalea-world/src/lib.rs b/azalea-world/src/lib.rs
index 20043bbf..e6b90ad5 100644
--- a/azalea-world/src/lib.rs
+++ b/azalea-world/src/lib.rs
@@ -1,3 +1,6 @@
+use azalea_protocol::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
+use std::io::{Read, Write};
+
 #[cfg(test)]
 mod tests {
     #[test]
@@ -7,22 +10,92 @@ mod tests {
     }
 }
 
+const SECTION_HEIGHT: u32 = 16;
+
 pub struct Chunk {
-    sections: Vec<Section>,
+    pub sections: Vec<Section>,
+}
+
+impl Chunk {
+    fn read_with_world_height(buf: &mut impl Read, world_height: u32) -> Result<Self, String> {
+        let section_count = world_height / SECTION_HEIGHT;
+        let mut sections = Vec::with_capacity(section_count as usize);
+        for _ in 0..section_count {
+            let section = Section::read_into(buf)?;
+            sections.push(section);
+        }
+        Ok(Chunk { sections })
+    }
 }
 
+impl McBufWritable for Chunk {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        for section in &self.sections {
+            section.write_into(buf)?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
 pub struct Section {
-    states: PalettedContainer,
-    biomes: PalettedContainer,
+    pub block_count: u16,
+    pub states: PalettedContainer,
+    pub biomes: PalettedContainer,
+}
+
+impl McBufReadable for Section {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let block_count = u16::read_into(buf)?;
+        let states = PalettedContainer::read_into(buf)?;
+        let biomes = PalettedContainer::read_into(buf)?;
+        Ok(Section {
+            block_count,
+            states,
+            biomes,
+        })
+    }
+}
+
+impl McBufWritable for Section {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        self.block_count.write_into(buf)?;
+        self.states.write_into(buf)?;
+        self.biomes.write_into(buf)?;
+        Ok(())
+    }
 }
 
+#[derive(Clone, Debug)]
 pub struct PalettedContainer {
-    bits_per_entry: u8,
-    palette: Palette,
+    pub bits_per_entry: u8,
+    pub palette: Palette,
     /// Compacted list of indices pointing to entry IDs in the Palette.
-    data: Vec<i64>,
+    pub data: Vec<i64>,
+}
+
+impl McBufReadable for PalettedContainer {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let bits_per_entry = buf.read_byte()?;
+        let palette = Palette::read_with_bits_per_entry(buf, bits_per_entry)?;
+        let data = Vec::<i64>::read_into(buf)?;
+        Ok(PalettedContainer {
+            bits_per_entry,
+            palette,
+            data,
+        })
+    }
+}
+impl McBufWritable for PalettedContainer {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        buf.write_byte(self.bits_per_entry)?;
+        self.palette.write_into(buf)?;
+        self.data.write_into(buf)?;
+        Ok(())
+    }
 }
 
+#[derive(Clone, Debug)]
 pub enum Palette {
     /// ID of the corresponding entry in its global palette
     SingleValue(u32),
@@ -32,12 +105,33 @@ pub enum Palette {
 }
 
 impl Palette {
-    fn choose_palette_for_states(bits_per_entry: u8) -> &'static Palette {
-        match bits_per_entry {
-            0 => &Palette::SingleValue,
-            1..=4 => &Palette::LinearPalette,
-            5..=8 => &Palette::HashmapPalette,
-            _ => &Palette::GlobalPalette,
+    pub fn read_with_bits_per_entry(
+        buf: &mut impl Read,
+        bits_per_entry: u8,
+    ) -> Result<Palette, String> {
+        Ok(match bits_per_entry {
+            0 => Palette::SingleValue(u32::read_into(buf)?),
+            1..=4 => Palette::LinearPalette(Vec::<u32>::read_into(buf)?),
+            5..=8 => Palette::HashmapPalette(Vec::<u32>::read_into(buf)?),
+            _ => Palette::GlobalPalette,
+        })
+    }
+}
+
+impl McBufWritable for Palette {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        match self {
+            Palette::SingleValue(value) => {
+                value.write_into(buf)?;
+            }
+            Palette::LinearPalette(values) => {
+                values.write_into(buf)?;
+            }
+            Palette::HashmapPalette(values) => {
+                values.write_into(buf)?;
+            }
+            Palette::GlobalPalette => {}
         }
+        Ok(())
     }
 }
-- 
cgit v1.2.3


From 8e42e1c5dfc54314585b564696044780e0407c2f Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Mon, 2 May 2022 23:07:06 +0000
Subject: more chunk and readme stuff

---
 Cargo.lock                                                     |  1 +
 README.md                                                      | 10 +++++++---
 azalea-client/Cargo.toml                                       |  1 +
 azalea-client/src/connect.rs                                   |  3 ++-
 azalea-protocol/src/mc_buf/mod.rs                              |  6 ------
 .../packets/game/clientbound_level_chunk_with_light_packet.rs  |  1 -
 azalea-world/src/lib.rs                                        |  6 +++++-
 7 files changed, 16 insertions(+), 12 deletions(-)

(limited to 'azalea-protocol/src/mc_buf')

diff --git a/Cargo.lock b/Cargo.lock
index b0fe3c05..3633a1af 100755
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -99,6 +99,7 @@ dependencies = [
  "azalea-core",
  "azalea-crypto",
  "azalea-protocol",
+ "azalea-world",
  "tokio",
 ]
 
diff --git a/README.md b/README.md
index 909ae47e..4c90ba42 100755
--- a/README.md
+++ b/README.md
@@ -1,20 +1,24 @@
 # Azalea
 
-A Rust crate for creating Minecraft bots.
-
 <p align="center">
     <img src="https://cdn.matdoes.dev/images/flowering_azalea.webp" alt="Azalea" height="200">
 </p>
 
+A Rust crate for creating Minecraft bots.
+
 I named this Azalea because it sounds like a cool word and this is a cool library. This project was heavily inspired by PrismarineJS.
 
+## Why
+
+I wanted a fun excuse to do something cool with Rust, and I also felt like I could do better than [Mineflayer](https://github.com/prismarinejs/mineflayer) in some areas.
+
 ## Goals
 
 - Do everything a vanilla client can do
 - Be easy to use
 - Bypass most/all anticheats
 - Support the latest Minecraft version
-- Be fast
+- Be fast and memory efficient
 
 ## Example code
 
diff --git a/azalea-client/Cargo.toml b/azalea-client/Cargo.toml
index 55caadeb..1156f8de 100755
--- a/azalea-client/Cargo.toml
+++ b/azalea-client/Cargo.toml
@@ -10,4 +10,5 @@ azalea-auth = {path = "../azalea-auth"}
 azalea-core = {path = "../azalea-core"}
 azalea-crypto = {path = "../azalea-crypto"}
 azalea-protocol = {path = "../azalea-protocol"}
+azalea-world = {path = "../azalea-world"}
 tokio = {version = "1.18.0", features = ["sync"]}
diff --git a/azalea-client/src/connect.rs b/azalea-client/src/connect.rs
index b628051a..be268eee 100755
--- a/azalea-client/src/connect.rs
+++ b/azalea-client/src/connect.rs
@@ -13,6 +13,7 @@ use azalea_protocol::{
     },
     resolver, ServerAddress,
 };
+use azalea_world::Chunk;
 use std::sync::Arc;
 use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
 use tokio::sync::Mutex;
@@ -233,7 +234,7 @@ impl Client {
             }
             GamePacket::ClientboundLevelChunkWithLightPacket(p) => {
                 println!("Got chunk with light packet {} {}", p.x, p.z);
-                // p.chunk_data
+                // let chunk = Chunk::read_with_world_height(&mut p.chunk_data);
             }
             GamePacket::ClientboundLightUpdatePacket(p) => {
                 println!("Got light update packet {:?}", p);
diff --git a/azalea-protocol/src/mc_buf/mod.rs b/azalea-protocol/src/mc_buf/mod.rs
index 74d69441..a82334fb 100755
--- a/azalea-protocol/src/mc_buf/mod.rs
+++ b/azalea-protocol/src/mc_buf/mod.rs
@@ -1,11 +1,5 @@
 //! Utilities for reading and writing for the Minecraft protocol
 
-// TODO: have a separate azalea-protocol-definitions crate to house everything in mc_buf
-// We need to do this to prevent cyclic dependencies.
-// For example with azalea-protocol depending on azalea-world,
-// it could be changed to azalea-protocol depending on azalea-world
-// and azalea-world depending on azalea-protocol-definitions.
-
 mod read;
 mod write;
 
diff --git a/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs b/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs
index 0ab581ec..6810ceb2 100644
--- a/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs
@@ -27,4 +27,3 @@ pub struct BlockEntity {
     data: azalea_nbt::Tag,
 }
 
-pub struct ChunkSection {}
diff --git a/azalea-world/src/lib.rs b/azalea-world/src/lib.rs
index e6b90ad5..8e60a6d6 100644
--- a/azalea-world/src/lib.rs
+++ b/azalea-world/src/lib.rs
@@ -12,12 +12,16 @@ mod tests {
 
 const SECTION_HEIGHT: u32 = 16;
 
+pub struct World {
+    
+}
+
 pub struct Chunk {
     pub sections: Vec<Section>,
 }
 
 impl Chunk {
-    fn read_with_world_height(buf: &mut impl Read, world_height: u32) -> Result<Self, String> {
+    pub fn read_with_world_height(buf: &mut impl Read, world_height: u32) -> Result<Self, String> {
         let section_count = world_height / SECTION_HEIGHT;
         let mut sections = Vec::with_capacity(section_count as usize);
         for _ in 0..section_count {
-- 
cgit v1.2.3


From c9878129274258a30dc3ee0ecbd064b4fcf9bc6e Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Tue, 3 May 2022 18:20:24 +0000
Subject: clippy

---
 azalea-client/src/connect.rs                          | 19 +++++++++----------
 azalea-client/src/player.rs                           |  1 -
 azalea-crypto/src/lib.rs                              | 14 +++++---------
 azalea-nbt/src/encode.rs                              |  2 +-
 azalea-protocol/packet-macros/src/lib.rs              | 13 ++++++-------
 azalea-protocol/src/mc_buf/read.rs                    |  6 +++---
 azalea-protocol/src/mc_buf/write.rs                   |  8 ++++----
 .../game/clientbound_declare_commands_packet.rs       | 18 ++++++++----------
 .../packets/game/clientbound_light_update_packet.rs   |  1 -
 .../game/clientbound_player_abilities_packet.rs       |  8 ++++----
 .../game/clientbound_player_position_packet.rs        | 10 +++++-----
 .../src/packets/game/clientbound_recipe_packet.rs     |  4 ++--
 .../game/clientbound_set_entity_data_packet.rs        |  4 ++--
 .../packets/game/clientbound_update_recipes_packet.rs |  2 +-
 .../src/packets/login/serverbound_key_packet.rs       |  2 --
 azalea-protocol/src/write.rs                          |  5 +----
 azalea-world/src/palette.rs                           | 18 +++++++++---------
 17 files changed, 60 insertions(+), 75 deletions(-)

(limited to 'azalea-protocol/src/mc_buf')

diff --git a/azalea-client/src/connect.rs b/azalea-client/src/connect.rs
index 984c5d86..3b880ea3 100755
--- a/azalea-client/src/connect.rs
+++ b/azalea-client/src/connect.rs
@@ -13,8 +13,8 @@ use azalea_protocol::{
     },
     resolver, ServerAddress,
 };
-use azalea_world::{Chunk, ChunkStorage, World};
-use std::{fmt::Debug, ops::Deref, sync::Arc};
+use azalea_world::{ChunkStorage, World};
+use std::{fmt::Debug, sync::Arc};
 use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
 use tokio::sync::Mutex;
 
@@ -34,8 +34,8 @@ pub struct ClientState {
 /// A player that you can control that is currently in a Minecraft server.
 pub struct Client {
     event_receiver: UnboundedReceiver<Event>,
-    conn: Arc<Mutex<GameConnection>>,
-    state: Arc<Mutex<ClientState>>,
+    pub conn: Arc<Mutex<GameConnection>>,
+    pub state: Arc<Mutex<ClientState>>,
     // game_loop
 }
 
@@ -133,10 +133,9 @@ impl Client {
         // just start up the game loop and we're ready!
         // tokio::spawn(Self::game_loop(conn, tx, handler, state))
 
-        let game_loop_conn = conn.clone();
         let game_loop_state = client.state.clone();
 
-        tokio::spawn(Self::game_loop(game_loop_conn, tx, game_loop_state));
+        tokio::spawn(Self::game_loop(conn, tx, game_loop_state));
 
         Ok(client)
     }
@@ -221,7 +220,7 @@ impl Client {
             GamePacket::ClientboundChangeDifficultyPacket(p) => {
                 println!("Got difficulty packet {:?}", p);
             }
-            GamePacket::ClientboundDeclareCommandsPacket(p) => {
+            GamePacket::ClientboundDeclareCommandsPacket(_p) => {
                 println!("Got declare commands packet");
             }
             GamePacket::ClientboundPlayerAbilitiesPacket(p) => {
@@ -230,19 +229,19 @@ impl Client {
             GamePacket::ClientboundSetCarriedItemPacket(p) => {
                 println!("Got set carried item packet {:?}", p);
             }
-            GamePacket::ClientboundUpdateTagsPacket(p) => {
+            GamePacket::ClientboundUpdateTagsPacket(_p) => {
                 println!("Got update tags packet");
             }
             GamePacket::ClientboundDisconnectPacket(p) => {
                 println!("Got disconnect packet {:?}", p);
             }
-            GamePacket::ClientboundUpdateRecipesPacket(p) => {
+            GamePacket::ClientboundUpdateRecipesPacket(_p) => {
                 println!("Got update recipes packet");
             }
             GamePacket::ClientboundEntityEventPacket(p) => {
                 println!("Got entity event packet {:?}", p);
             }
-            GamePacket::ClientboundRecipePacket(p) => {
+            GamePacket::ClientboundRecipePacket(_p) => {
                 println!("Got recipe packet");
             }
             GamePacket::ClientboundPlayerPositionPacket(p) => {
diff --git a/azalea-client/src/player.rs b/azalea-client/src/player.rs
index 70ac1c76..fc54ff93 100644
--- a/azalea-client/src/player.rs
+++ b/azalea-client/src/player.rs
@@ -1,5 +1,4 @@
 use crate::Entity;
-use azalea_world::World;
 
 #[derive(Default)]
 pub struct Player {
diff --git a/azalea-crypto/src/lib.rs b/azalea-crypto/src/lib.rs
index dc2620cc..62a81de3 100644
--- a/azalea-crypto/src/lib.rs
+++ b/azalea-crypto/src/lib.rs
@@ -1,9 +1,6 @@
 use aes::cipher::inout::InOutBuf;
-use aes::cipher::BlockEncrypt;
 use aes::{
-    cipher::{
-        generic_array::GenericArray, AsyncStreamCipher, BlockDecryptMut, BlockEncryptMut, KeyIvInit,
-    },
+    cipher::{BlockDecryptMut, BlockEncryptMut, KeyIvInit},
     Aes128,
 };
 use rand::{rngs::OsRng, RngCore};
@@ -15,7 +12,7 @@ fn generate_secret_key() -> [u8; 16] {
     key
 }
 
-fn digest_data(server_id: &[u8], public_key: &[u8], private_key: &[u8]) -> Vec<u8> {
+pub fn digest_data(server_id: &[u8], public_key: &[u8], private_key: &[u8]) -> Vec<u8> {
     let mut digest = Sha1::new();
     digest.update(server_id);
     digest.update(public_key);
@@ -23,7 +20,7 @@ fn digest_data(server_id: &[u8], public_key: &[u8], private_key: &[u8]) -> Vec<u
     digest.finalize().to_vec()
 }
 
-fn hex_digest(digest: &[u8]) -> String {
+pub fn hex_digest(digest: &[u8]) -> String {
     // Note that the Sha1.hexdigest() method used by minecraft is non standard.
     // It doesn't match the digest method found in most programming languages
     // and libraries. It works by treating the sha1 output bytes as one large
@@ -48,9 +45,8 @@ pub fn encrypt(public_key: &[u8], nonce: &[u8]) -> Result<EncryptResult, String>
 
     // this.keybytes = Crypt.encryptUsingKey(publicKey, secretKey.getEncoded());
     // this.nonce = Crypt.encryptUsingKey(publicKey, arrby);
-    let encrypted_public_key: Vec<u8> =
-        rsa_public_encrypt_pkcs1::encrypt(&public_key, &secret_key)?;
-    let encrypted_nonce: Vec<u8> = rsa_public_encrypt_pkcs1::encrypt(&public_key, &nonce)?;
+    let encrypted_public_key: Vec<u8> = rsa_public_encrypt_pkcs1::encrypt(public_key, &secret_key)?;
+    let encrypted_nonce: Vec<u8> = rsa_public_encrypt_pkcs1::encrypt(public_key, nonce)?;
 
     Ok(EncryptResult {
         secret_key,
diff --git a/azalea-nbt/src/encode.rs b/azalea-nbt/src/encode.rs
index 20d13793..fb5585b3 100755
--- a/azalea-nbt/src/encode.rs
+++ b/azalea-nbt/src/encode.rs
@@ -98,7 +98,7 @@ fn write_compound(
     if end_tag {
         writer.write_u8(Tag::End.id())?;
     }
-    return Ok(());
+    Ok(())
 }
 
 #[inline]
diff --git a/azalea-protocol/packet-macros/src/lib.rs b/azalea-protocol/packet-macros/src/lib.rs
index 35abf642..dec153ec 100755
--- a/azalea-protocol/packet-macros/src/lib.rs
+++ b/azalea-protocol/packet-macros/src/lib.rs
@@ -232,13 +232,12 @@ struct PacketIdMap {
 impl Parse for PacketIdMap {
     fn parse(input: ParseStream) -> Result<Self> {
         let mut packets = vec![];
-        loop {
-            // 0x0e: clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
-            // 0x0e
-            let packet_id: LitInt = match input.parse() {
-                Ok(i) => i,
-                Err(_) => break,
-            };
+
+        // example:
+        // 0x0e: clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
+
+        // 0x0e
+        while let Ok(packet_id) = input.parse::<LitInt>() {
             let packet_id = packet_id.base10_parse::<u32>()?;
             // :
             input.parse::<Token![:]>()?;
diff --git a/azalea-protocol/src/mc_buf/read.rs b/azalea-protocol/src/mc_buf/read.rs
index 68c9cb3f..e1ae321c 100755
--- a/azalea-protocol/src/mc_buf/read.rs
+++ b/azalea-protocol/src/mc_buf/read.rs
@@ -1,10 +1,10 @@
-use super::{BitSet, UnsizedByteArray, MAX_STRING_LENGTH};
+use super::{UnsizedByteArray, MAX_STRING_LENGTH};
 use azalea_chat::component::Component;
 use azalea_core::{
     difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
     serializable_uuid::SerializableUuid, BlockPos, Direction, Slot, SlotData,
 };
-use byteorder::{ReadBytesExt, WriteBytesExt, BE};
+use byteorder::{ReadBytesExt, BE};
 use serde::Deserialize;
 use std::io::Read;
 use tokio::io::{AsyncRead, AsyncReadExt};
@@ -421,7 +421,7 @@ impl McBufReadable for Component {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
         let string = buf.read_utf()?;
         let json: serde_json::Value = serde_json::from_str(string.as_str())
-            .map_err(|e| "Component isn't valid JSON".to_string())?;
+            .map_err(|_| "Component isn't valid JSON".to_string())?;
         let component = Component::deserialize(json).map_err(|e| e.to_string())?;
         Ok(component)
     }
diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
index 34bcafeb..3a4a02f8 100755
--- a/azalea-protocol/src/mc_buf/write.rs
+++ b/azalea-protocol/src/mc_buf/write.rs
@@ -20,8 +20,8 @@ pub trait Writable: Write {
         Ok(())
     }
 
-    fn write_int_id_list(&mut self, list: &Vec<i32>) -> Result<(), std::io::Error> {
-        self.write_list(&list, |buf, n| buf.write_varint(*n))
+    fn write_int_id_list(&mut self, list: &[i32]) -> Result<(), std::io::Error> {
+        self.write_list(list, |buf, n| buf.write_varint(*n))
     }
 
     fn write_map<KF, VF, KT, VT>(
@@ -47,7 +47,7 @@ pub trait Writable: Write {
     }
 
     fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
-        self.write_all(bytes);
+        self.write_all(bytes)?;
         Ok(())
     }
 
@@ -333,7 +333,7 @@ impl McBufWritable for Component {
     //     let component = Component::deserialize(json).map_err(|e| e.to_string())?;
     //     Ok(component)
     // }
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn write_into(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
         // component doesn't have serialize implemented yet
         todo!()
     }
diff --git a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
index 27f4fb16..6743c3af 100755
--- a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
@@ -281,7 +281,7 @@ impl McBufReadable for BrigadierParser {
     }
 }
 
-// azalea_brigadier::tree::CommandNode
+// TODO: BrigadierNodeStub should have more stuff
 impl McBufReadable for BrigadierNodeStub {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
         let flags = u8::read_into(buf)?;
@@ -292,20 +292,18 @@ impl McBufReadable for BrigadierNodeStub {
         }
 
         let node_type = flags & 0x03;
-        let is_executable = flags & 0x04 != 0;
+        let _is_executable = flags & 0x04 != 0;
         let has_redirect = flags & 0x08 != 0;
         let has_suggestions_type = flags & 0x10 != 0;
 
-        let children = buf.read_int_id_list()?;
-        let redirect_node = if has_redirect { buf.read_varint()? } else { 0 };
+        let _children = buf.read_int_id_list()?;
+        let _redirect_node = if has_redirect { buf.read_varint()? } else { 0 };
 
         // argument node
         if node_type == 2 {
-            let name = buf.read_utf()?;
-
-            let parser = BrigadierParser::read_into(buf)?;
-
-            let suggestions_type = if has_suggestions_type {
+            let _name = buf.read_utf()?;
+            let _parser = BrigadierParser::read_into(buf)?;
+            let _suggestions_type = if has_suggestions_type {
                 Some(buf.read_resource_location()?)
             } else {
                 None
@@ -314,7 +312,7 @@ impl McBufReadable for BrigadierNodeStub {
         }
         // literal node
         if node_type == 1 {
-            let name = buf.read_utf()?;
+            let _name = buf.read_utf()?;
             return Ok(BrigadierNodeStub {});
         }
         Ok(BrigadierNodeStub {})
diff --git a/azalea-protocol/src/packets/game/clientbound_light_update_packet.rs b/azalea-protocol/src/packets/game/clientbound_light_update_packet.rs
index c97eacff..e83d1e87 100644
--- a/azalea-protocol/src/packets/game/clientbound_light_update_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_light_update_packet.rs
@@ -1,5 +1,4 @@
 use crate::mc_buf::BitSet;
-use azalea_core::{game_type::GameType, resource_location::ResourceLocation};
 use packet_macros::{GamePacket, McBufReadable, McBufWritable};
 
 #[derive(Clone, Debug, GamePacket)]
diff --git a/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs
index cd645fe6..ed27ecf3 100755
--- a/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs
@@ -34,16 +34,16 @@ impl McBufWritable for PlayerAbilitiesFlags {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let mut byte = 0;
         if self.invulnerable {
-            byte = byte | 1;
+            byte |= 0b1;
         }
         if self.flying {
-            byte = byte | 2;
+            byte |= 0b10;
         }
         if self.can_fly {
-            byte = byte | 4;
+            byte |= 0b100;
         }
         if self.instant_break {
-            byte = byte | 8;
+            byte |= 0b1000;
         }
         u8::write_into(&byte, buf)
     }
diff --git a/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs
index cac4665d..c2bef8fa 100644
--- a/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs
@@ -43,19 +43,19 @@ impl McBufWritable for RelativeArguments {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let mut byte = 0;
         if self.x {
-            byte = byte | 0b1;
+            byte |= 0b1;
         }
         if self.y {
-            byte = byte | 0b10;
+            byte |= 0b10;
         }
         if self.z {
-            byte = byte | 0b100;
+            byte |= 0b100;
         }
         if self.y_rot {
-            byte = byte | 0b1000;
+            byte |= 0b1000;
         }
         if self.x_rot {
-            byte = byte | 0b10000;
+            byte |= 0b10000;
         }
         u8::write_into(&byte, buf)
     }
diff --git a/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs b/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
index 543fb64c..fa0d58f0 100644
--- a/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
@@ -1,5 +1,5 @@
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
-use azalea_core::{resource_location::ResourceLocation, Slot};
+use azalea_core::resource_location::ResourceLocation;
 use packet_macros::{GamePacket, McBufReadable, McBufWritable};
 use std::io::{Read, Write};
 
@@ -41,7 +41,7 @@ impl McBufWritable for State {
 }
 impl McBufReadable for State {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
-        let state = buf.read_varint()?.try_into().unwrap();
+        let state = buf.read_varint()?;
         Ok(match state {
             0 => State::Init,
             1 => State::Add,
diff --git a/azalea-protocol/src/packets/game/clientbound_set_entity_data_packet.rs b/azalea-protocol/src/packets/game/clientbound_set_entity_data_packet.rs
index 5d288518..ca726c39 100644
--- a/azalea-protocol/src/packets/game/clientbound_set_entity_data_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_set_entity_data_packet.rs
@@ -123,7 +123,7 @@ impl McBufReadable for EntityDataValue {
 }
 
 impl McBufWritable for EntityDataValue {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn write_into(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
         todo!();
     }
 }
@@ -398,7 +398,7 @@ impl McBufReadable for ParticleData {
 }
 
 impl McBufWritable for ParticleData {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn write_into(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
         todo!()
     }
 }
diff --git a/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
index d15e10c3..9bdea26e 100644
--- a/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
@@ -122,7 +122,7 @@ pub struct Ingredient {
 }
 
 impl McBufWritable for Recipe {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn write_into(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
         todo!()
     }
 }
diff --git a/azalea-protocol/src/packets/login/serverbound_key_packet.rs b/azalea-protocol/src/packets/login/serverbound_key_packet.rs
index f402d357..2ff8dda6 100644
--- a/azalea-protocol/src/packets/login/serverbound_key_packet.rs
+++ b/azalea-protocol/src/packets/login/serverbound_key_packet.rs
@@ -1,5 +1,3 @@
-use super::LoginPacket;
-use crate::mc_buf::Writable;
 use packet_macros::LoginPacket;
 use std::hash::Hash;
 
diff --git a/azalea-protocol/src/write.rs b/azalea-protocol/src/write.rs
index 345829c5..9291681c 100755
--- a/azalea-protocol/src/write.rs
+++ b/azalea-protocol/src/write.rs
@@ -2,10 +2,7 @@ use crate::{mc_buf::Writable, packets::ProtocolPacket, read::MAXIMUM_UNCOMPRESSE
 use async_compression::tokio::bufread::ZlibEncoder;
 use azalea_crypto::Aes128CfbEnc;
 use std::fmt::Debug;
-use tokio::{
-    io::{AsyncReadExt, AsyncWrite, AsyncWriteExt},
-    net::TcpStream,
-};
+use tokio::io::{AsyncReadExt, AsyncWrite, AsyncWriteExt};
 
 fn frame_prepender(data: &mut Vec<u8>) -> Result<Vec<u8>, String> {
     let mut buf = Vec::new();
diff --git a/azalea-world/src/palette.rs b/azalea-world/src/palette.rs
index a8ec50c9..69900fe6 100644
--- a/azalea-world/src/palette.rs
+++ b/azalea-world/src/palette.rs
@@ -35,9 +35,9 @@ impl McBufWritable for PalettedContainer {
 pub enum Palette {
     /// ID of the corresponding entry in its global palette
     SingleValue(u32),
-    LinearPalette(Vec<u32>),
-    HashmapPalette(Vec<u32>),
-    GlobalPalette,
+    Linear(Vec<u32>),
+    Hashmap(Vec<u32>),
+    Global,
 }
 
 impl Palette {
@@ -47,9 +47,9 @@ impl Palette {
     ) -> Result<Palette, String> {
         Ok(match bits_per_entry {
             0 => Palette::SingleValue(u32::read_into(buf)?),
-            1..=4 => Palette::LinearPalette(Vec::<u32>::read_into(buf)?),
-            5..=8 => Palette::HashmapPalette(Vec::<u32>::read_into(buf)?),
-            _ => Palette::GlobalPalette,
+            1..=4 => Palette::Linear(Vec::<u32>::read_into(buf)?),
+            5..=8 => Palette::Hashmap(Vec::<u32>::read_into(buf)?),
+            _ => Palette::Global,
         })
     }
 }
@@ -60,13 +60,13 @@ impl McBufWritable for Palette {
             Palette::SingleValue(value) => {
                 value.write_into(buf)?;
             }
-            Palette::LinearPalette(values) => {
+            Palette::Linear(values) => {
                 values.write_into(buf)?;
             }
-            Palette::HashmapPalette(values) => {
+            Palette::Hashmap(values) => {
                 values.write_into(buf)?;
             }
-            Palette::GlobalPalette => {}
+            Palette::Global => {}
         }
         Ok(())
     }
-- 
cgit v1.2.3


From 4dac004635e50682d9ebe8812fdf654a0c1808f1 Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Thu, 5 May 2022 22:12:54 -0500
Subject: Fix chunk decoding

---
 azalea-protocol/src/mc_buf/mod.rs   |  2 ++
 azalea-protocol/src/mc_buf/read.rs  | 11 ++++++++
 azalea-protocol/src/mc_buf/write.rs |  7 +++++
 azalea-world/src/bit_storage.rs     |  9 ++++---
 azalea-world/src/lib.rs             | 19 ++++++++++---
 azalea-world/src/palette.rs         | 54 ++++++++++++++++++++++++++++++-------
 bot/src/main.rs                     |  2 +-
 7 files changed, 85 insertions(+), 19 deletions(-)

(limited to 'azalea-protocol/src/mc_buf')

diff --git a/azalea-protocol/src/mc_buf/mod.rs b/azalea-protocol/src/mc_buf/mod.rs
index a82334fb..debf2991 100755
--- a/azalea-protocol/src/mc_buf/mod.rs
+++ b/azalea-protocol/src/mc_buf/mod.rs
@@ -12,6 +12,8 @@ pub use write::{McBufVarintWritable, McBufWritable, Writable};
 const MAX_STRING_LENGTH: u16 = 32767;
 // const MAX_COMPONENT_STRING_LENGTH: u32 = 262144;
 
+// TODO: maybe get rid of the readable/writable traits so there's not two ways to do the same thing and improve McBufReadable/McBufWritable
+
 // TODO: have a definitions.rs in mc_buf that contains UnsizedByteArray and BitSet
 
 /// A Vec<u8> that isn't prefixed by a VarInt with the size.
diff --git a/azalea-protocol/src/mc_buf/read.rs b/azalea-protocol/src/mc_buf/read.rs
index e1ae321c..a8c44bdf 100755
--- a/azalea-protocol/src/mc_buf/read.rs
+++ b/azalea-protocol/src/mc_buf/read.rs
@@ -255,6 +255,17 @@ impl McBufVarintReadable for i32 {
     }
 }
 
+impl<T: McBufVarintReadable> McBufVarintReadable for Vec<T> {
+    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let length = u32::varint_read_into(buf)?;
+        let mut vec = Vec::with_capacity(length as usize);
+        for _ in 0..length {
+            vec.push(T::varint_read_into(buf)?);
+        }
+        Ok(vec)
+    }
+}
+
 impl McBufReadable for UnsizedByteArray {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
         Ok(UnsizedByteArray(buf.read_bytes()?))
diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
index 3a4a02f8..cc5f2284 100755
--- a/azalea-protocol/src/mc_buf/write.rs
+++ b/azalea-protocol/src/mc_buf/write.rs
@@ -210,6 +210,13 @@ impl McBufVarintWritable for u32 {
     }
 }
 
+// Vec<T> varint
+impl<T: McBufVarintWritable> McBufVarintWritable for Vec<T> {
+    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        buf.write_list(self, |buf, i| i.varint_write_into(buf))
+    }
+}
+
 // u16
 impl McBufWritable for u16 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
diff --git a/azalea-world/src/bit_storage.rs b/azalea-world/src/bit_storage.rs
index 5ced67fe..9cc3a053 100644
--- a/azalea-world/src/bit_storage.rs
+++ b/azalea-world/src/bit_storage.rs
@@ -1,4 +1,4 @@
-use std::{error::Error, fmt, ops::Index};
+use std::{error::Error, fmt};
 
 // this is from minecraft's code
 // yeah idk either
@@ -70,6 +70,7 @@ const MAGIC: [(i32, i32, i32); 64] = [
 ];
 
 /// A compact list of integers with the given number of bits per entry.
+#[derive(Clone)]
 pub struct BitStorage {
     data: Vec<u64>,
     bits: usize,
@@ -135,7 +136,7 @@ impl BitStorage {
 
     pub fn cell_index(&self, index: u64) -> usize {
         let first = self.divide_mul as u64;
-        let second = self.divide_mul as u64;
+        let second = self.divide_add as u64;
 
         (index * first + second >> 32 >> self.divide_shift)
             .try_into()
@@ -182,8 +183,8 @@ mod tests {
         let data = [
             1, 2, 2, 3, 4, 4, 5, 6, 6, 4, 8, 0, 7, 4, 3, 13, 15, 16, 9, 14, 10, 12, 0, 2,
         ];
-        let expected_compact: [u64; 2] = [0x0020863148418841, 0x01018A7260F68C87];
-        let storage = BitStorage::new(5, data.len(), Some(expected_compact.to_vec())).unwrap();
+        let compact_data: [u64; 2] = [0x0020863148418841, 0x01018A7260F68C87];
+        let storage = BitStorage::new(5, data.len(), Some(compact_data.to_vec())).unwrap();
 
         for (i, expected) in data.iter().enumerate() {
             assert_eq!(storage.get(i), *expected);
diff --git a/azalea-world/src/lib.rs b/azalea-world/src/lib.rs
index 54961401..abeac181 100644
--- a/azalea-world/src/lib.rs
+++ b/azalea-world/src/lib.rs
@@ -11,6 +11,8 @@ use std::{
     sync::{Arc, Mutex},
 };
 
+use crate::palette::PalettedContainerType;
+
 #[cfg(test)]
 mod tests {
     #[test]
@@ -43,7 +45,7 @@ impl World {
         // let existing_chunk = &self.storage[pos];
 
         let chunk = Arc::new(Mutex::new(Chunk::read_with_world(data, self)?));
-        println!("Loaded chunk {:?}", chunk);
+        println!("Loaded chunk {:?}", pos);
         self.storage[pos] = Some(chunk);
 
         Ok(())
@@ -121,7 +123,9 @@ impl Chunk {
     pub fn read_with_world_height(buf: &mut impl Read, world_height: u32) -> Result<Self, String> {
         let section_count = world_height / SECTION_HEIGHT;
         let mut sections = Vec::with_capacity(section_count as usize);
-        for _ in 0..section_count {
+        println!("\n\nreading {} sections", section_count);
+        for i in 0..section_count {
+            println!("reading section #{}", i);
             let section = Section::read_into(buf)?;
             sections.push(section);
         }
@@ -148,8 +152,15 @@ pub struct Section {
 impl McBufReadable for Section {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
         let block_count = u16::read_into(buf)?;
-        let states = PalettedContainer::read_into(buf)?;
-        let biomes = PalettedContainer::read_into(buf)?;
+        println!("block count: {}\n", block_count);
+        // assert!(
+        //     block_count <= 16 * 16 * 16,
+        //     "A section has more blocks than what should be possible. This is a bug!"
+        // );
+        let states = PalettedContainer::read_with_type(buf, &PalettedContainerType::BlockStates)?;
+        println!("! read states, reading biomes next");
+        let biomes = PalettedContainer::read_with_type(buf, &PalettedContainerType::Biomes)?;
+        println!();
         Ok(Section {
             block_count,
             states,
diff --git a/azalea-world/src/palette.rs b/azalea-world/src/palette.rs
index 69900fe6..47354c94 100644
--- a/azalea-world/src/palette.rs
+++ b/azalea-world/src/palette.rs
@@ -1,20 +1,43 @@
+use azalea_protocol::mc_buf::{
+    McBufReadable, McBufVarintReadable, McBufWritable, Readable, Writable,
+};
 use std::io::{Read, Write};
 
-use azalea_protocol::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
+#[derive(Clone, Debug, Copy)]
+pub enum PalettedContainerType {
+    Biomes,
+    BlockStates,
+}
 
 #[derive(Clone, Debug)]
 pub struct PalettedContainer {
     pub bits_per_entry: u8,
     pub palette: Palette,
     /// Compacted list of indices pointing to entry IDs in the Palette.
-    pub data: Vec<i64>,
+    pub data: Vec<u64>,
 }
 
-impl McBufReadable for PalettedContainer {
-    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+impl PalettedContainer {
+    pub fn read_with_type(
+        buf: &mut impl Read,
+        type_: &'static PalettedContainerType,
+    ) -> Result<Self, String> {
         let bits_per_entry = buf.read_byte()?;
-        let palette = Palette::read_with_bits_per_entry(buf, bits_per_entry)?;
-        let data = Vec::<i64>::read_into(buf)?;
+        let palette = match type_ {
+            PalettedContainerType::BlockStates => {
+                Palette::block_states_read_with_bits_per_entry(buf, bits_per_entry)?
+            }
+            PalettedContainerType::Biomes => {
+                Palette::biomes_read_with_bits_per_entry(buf, bits_per_entry)?
+            }
+        };
+
+        let data = Vec::<u64>::read_into(buf)?;
+        debug_assert!(
+            bits_per_entry != 0 || data.is_empty(),
+            "Bits per entry is 0 but data is not empty."
+        );
+
         Ok(PalettedContainer {
             bits_per_entry,
             palette,
@@ -41,14 +64,25 @@ pub enum Palette {
 }
 
 impl Palette {
-    pub fn read_with_bits_per_entry(
+    pub fn block_states_read_with_bits_per_entry(
+        buf: &mut impl Read,
+        bits_per_entry: u8,
+    ) -> Result<Palette, String> {
+        Ok(match bits_per_entry {
+            0 => Palette::SingleValue(u32::varint_read_into(buf)?),
+            1..=4 => Palette::Linear(Vec::<u32>::varint_read_into(buf)?),
+            5..=8 => Palette::Hashmap(Vec::<u32>::varint_read_into(buf)?),
+            _ => Palette::Global,
+        })
+    }
+
+    pub fn biomes_read_with_bits_per_entry(
         buf: &mut impl Read,
         bits_per_entry: u8,
     ) -> Result<Palette, String> {
         Ok(match bits_per_entry {
-            0 => Palette::SingleValue(u32::read_into(buf)?),
-            1..=4 => Palette::Linear(Vec::<u32>::read_into(buf)?),
-            5..=8 => Palette::Hashmap(Vec::<u32>::read_into(buf)?),
+            0 => Palette::SingleValue(u32::varint_read_into(buf)?),
+            1..=3 => Palette::Linear(Vec::<u32>::varint_read_into(buf)?),
             _ => Palette::Global,
         })
     }
diff --git a/bot/src/main.rs b/bot/src/main.rs
index 167f4edc..7cf056bf 100644
--- a/bot/src/main.rs
+++ b/bot/src/main.rs
@@ -5,7 +5,7 @@ async fn main() {
     println!("Hello, world!");
 
     // let address = "95.111.249.143:10000";
-    let address = "172.23.192.1:65111";
+    let address = "172.23.192.1:62522";
     // let response = azalea_client::ping::ping_server(&address.try_into().unwrap())
     //     .await
     //     .unwrap();
-- 
cgit v1.2.3


From 42f86f73f256c0219a923c5ff67a509e7a8a898d Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Sat, 14 May 2022 19:14:34 -0500
Subject: add unhandled ClientboundSectionBlocksUpdatePacket

---
 azalea-client/src/connect.rs                               |  3 +++
 azalea-protocol/src/mc_buf/read.rs                         | 14 +++++++++++++-
 azalea-protocol/src/mc_buf/write.rs                        | 13 ++++++++++++-
 .../game/clientbound_section_blocks_update_packet.rs       | 10 ++++++++++
 azalea-protocol/src/packets/game/mod.rs                    |  2 ++
 bot/src/main.rs                                            |  4 ++--
 6 files changed, 42 insertions(+), 4 deletions(-)
 create mode 100644 azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs

(limited to 'azalea-protocol/src/mc_buf')

diff --git a/azalea-client/src/connect.rs b/azalea-client/src/connect.rs
index 8d2e9dc1..48fd16f2 100755
--- a/azalea-client/src/connect.rs
+++ b/azalea-client/src/connect.rs
@@ -373,6 +373,9 @@ impl Client {
             GamePacket::ClientboundAnimatePacket(p) => {
                 println!("Got animate packet {:?}", p);
             }
+            GamePacket::ClientboundSectionBlocksUpdatePacket(p) => {
+                println!("Got section blocks update packet {:?}", p);
+            }
             _ => panic!("Unexpected packet {:?}", packet),
         }
     }
diff --git a/azalea-protocol/src/mc_buf/read.rs b/azalea-protocol/src/mc_buf/read.rs
index ebafad92..1c4fbd6f 100644
--- a/azalea-protocol/src/mc_buf/read.rs
+++ b/azalea-protocol/src/mc_buf/read.rs
@@ -2,7 +2,7 @@ use super::{UnsizedByteArray, MAX_STRING_LENGTH};
 use azalea_chat::component::Component;
 use azalea_core::{
     difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
-    serializable_uuid::SerializableUuid, BlockPos, Direction, Slot, SlotData,
+    serializable_uuid::SerializableUuid, BlockPos, ChunkSectionPos, Direction, Slot, SlotData,
 };
 use byteorder::{ReadBytesExt, BE};
 use serde::Deserialize;
@@ -518,3 +518,15 @@ impl McBufReadable for Direction {
         }
     }
 }
+
+// ChunkSectionPos
+impl McBufReadable for ChunkSectionPos {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let long = i64::read_into(buf)?;
+        Ok(ChunkSectionPos {
+            x: (long >> 42) as i32,
+            y: (long << 44 >> 44) as i32,
+            z: (long << 22 >> 42) as i32,
+        })
+    }
+}
diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
index 7fe61752..c46297a6 100644
--- a/azalea-protocol/src/mc_buf/write.rs
+++ b/azalea-protocol/src/mc_buf/write.rs
@@ -2,7 +2,7 @@ use super::{UnsizedByteArray, MAX_STRING_LENGTH};
 use azalea_chat::component::Component;
 use azalea_core::{
     difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
-    serializable_uuid::SerializableUuid, BlockPos, Direction, Slot,
+    serializable_uuid::SerializableUuid, BlockPos, ChunkSectionPos, Direction, Slot,
 };
 use byteorder::{BigEndian, WriteBytesExt};
 use std::{collections::HashMap, io::Write};
@@ -425,3 +425,14 @@ impl McBufWritable for Direction {
         buf.write_varint(*self as i32)
     }
 }
+
+// ChunkSectionPos
+impl McBufWritable for ChunkSectionPos {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        let long = (((self.x & 0x3FFFFF) as i64) << 42)
+            | (self.y & 0xFFFFF) as i64
+            | (((self.z & 0x3FFFFF) as i64) << 20);
+        long.write_into(buf)?;
+        Ok(())
+    }
+}
diff --git a/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs b/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs
new file mode 100644
index 00000000..f220b07f
--- /dev/null
+++ b/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs
@@ -0,0 +1,10 @@
+use azalea_core::ChunkSectionPos;
+use packet_macros::GamePacket;
+
+#[derive(Clone, Debug, GamePacket)]
+pub struct ClientboundSectionBlocksUpdatePacket {
+    pub section_pos: ChunkSectionPos,
+    pub suppress_light_updates: bool,
+    #[var]
+    pub states: Vec<u64>,
+}
diff --git a/azalea-protocol/src/packets/game/mod.rs b/azalea-protocol/src/packets/game/mod.rs
index 0391ee10..66c55cd2 100755
--- a/azalea-protocol/src/packets/game/mod.rs
+++ b/azalea-protocol/src/packets/game/mod.rs
@@ -26,6 +26,7 @@ pub mod clientbound_player_position_packet;
 pub mod clientbound_recipe_packet;
 pub mod clientbound_remove_entities_packet;
 pub mod clientbound_rotate_head_packet;
+pub mod clientbound_section_blocks_update_packet;
 pub mod clientbound_set_carried_item_packet;
 pub mod clientbound_set_chunk_cache_center;
 pub mod clientbound_set_default_spawn_position_packet;
@@ -80,6 +81,7 @@ declare_state_packets!(
         0x39: clientbound_recipe_packet::ClientboundRecipePacket,
         0x3a: clientbound_remove_entities_packet::ClientboundRemoveEntitiesPacket,
         0x3e: clientbound_rotate_head_packet::ClientboundRotateHeadPacket,
+        0x3f: clientbound_section_blocks_update_packet::ClientboundSectionBlocksUpdatePacket,
         0x48: clientbound_set_carried_item_packet::ClientboundSetCarriedItemPacket,
         0x49: clientbound_set_chunk_cache_center::ClientboundSetChunkCacheCenterPacket,
         0x4a: clientbound_update_view_distance_packet::ClientboundUpdateViewDistancePacket,
diff --git a/bot/src/main.rs b/bot/src/main.rs
index 1f2cb6e1..76a5a15d 100644
--- a/bot/src/main.rs
+++ b/bot/src/main.rs
@@ -1,12 +1,12 @@
 use azalea_client::{Account, Event};
-use azalea_core::{BlockPos, ChunkPos};
+use azalea_core::BlockPos;
 
 #[tokio::main]
 async fn main() {
     println!("Hello, world!");
 
     // let address = "95.111.249.143:10000";
-    let address = "192.168.2.234:62840";
+    let address = "192.168.2.234:50736";
     // let response = azalea_client::ping::ping_server(&address.try_into().unwrap())
     //     .await
     //     .unwrap();
-- 
cgit v1.2.3


From 93730a550aed964d122bc08f5353e8eb0c5c9f31 Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Sat, 14 May 2022 19:55:33 -0500
Subject: start adding ClientboundLevelParticlesPacket

---
 azalea-protocol/packet-macros/src/lib.rs           | 13 +++++++++
 azalea-protocol/src/mc_buf/definitions.rs          | 33 +++++++++++++---------
 azalea-protocol/src/mc_buf/mod.rs                  |  4 +--
 .../src/packets/game/clientbound_animate_packet.rs |  4 +--
 .../src/packets/game/clientbound_chat_packet.rs    |  4 +--
 .../packets/game/clientbound_game_event_packet.rs  |  4 +--
 .../clientbound_level_chunk_with_light_packet.rs   |  6 ++--
 .../game/clientbound_level_particles_packet.rs     | 17 +++++++++++
 .../game/clientbound_light_update_packet.rs        |  4 +--
 .../packets/game/clientbound_player_info_packet.rs | 14 ++++-----
 .../src/packets/game/clientbound_recipe_packet.rs  |  4 +--
 .../clientbound_section_blocks_update_packet.rs    |  2 +-
 .../src/packets/game/clientbound_sound_packet.rs   |  4 +--
 .../game/clientbound_update_advancements_packet.rs | 12 ++++----
 .../game/clientbound_update_attributes_packet.rs   |  6 ++--
 .../game/clientbound_update_recipes_packet.rs      | 12 ++++----
 azalea-protocol/src/packets/game/mod.rs            |  8 ++++--
 azalea-protocol/src/packets/mod.rs                 |  2 +-
 18 files changed, 95 insertions(+), 58 deletions(-)
 create mode 100644 azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs

(limited to 'azalea-protocol/src/mc_buf')

diff --git a/azalea-protocol/packet-macros/src/lib.rs b/azalea-protocol/packet-macros/src/lib.rs
index 87b216c0..59fb91eb 100755
--- a/azalea-protocol/packet-macros/src/lib.rs
+++ b/azalea-protocol/packet-macros/src/lib.rs
@@ -157,6 +157,19 @@ pub fn derive_mcbufwritable(input: TokenStream) -> TokenStream {
     create_impl_mcbufwritable(&ident, &data).into()
 }
 
+#[proc_macro_derive(McBuf, attributes(var))]
+pub fn derive_mcbuf(input: TokenStream) -> TokenStream {
+    let DeriveInput { ident, data, .. } = parse_macro_input!(input);
+
+    let writable = create_impl_mcbufwritable(&ident, &data);
+    let readable = create_impl_mcbufreadable(&ident, &data);
+    quote! {
+        #writable
+        #readable
+    }
+    .into()
+}
+
 fn as_packet_derive(input: TokenStream, state: proc_macro2::TokenStream) -> TokenStream {
     let DeriveInput { ident, data, .. } = parse_macro_input!(input);
 
diff --git a/azalea-protocol/src/mc_buf/definitions.rs b/azalea-protocol/src/mc_buf/definitions.rs
index a59fc574..3867b3fc 100644
--- a/azalea-protocol/src/mc_buf/definitions.rs
+++ b/azalea-protocol/src/mc_buf/definitions.rs
@@ -1,8 +1,9 @@
 use crate::mc_buf::read::{McBufReadable, Readable};
 use crate::mc_buf::write::{McBufWritable, Writable};
+use crate::mc_buf::McBufVarReadable;
 use azalea_chat::component::Component;
 use azalea_core::{BlockPos, Direction, Slot};
-use packet_macros::{McBufReadable, McBufWritable};
+use packet_macros::McBuf;
 use std::io::{Read, Write};
 use std::ops::Deref;
 use uuid::Uuid;
@@ -32,7 +33,7 @@ impl From<&str> for UnsizedByteArray {
 }
 
 /// Represents Java's BitSet, a list of bits.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, McBufReadable, McBufWritable)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, McBuf)]
 pub struct BitSet {
     data: Vec<u64>,
 }
@@ -159,7 +160,7 @@ impl McBufWritable for EntityDataValue {
     }
 }
 
-#[derive(Clone, Debug, Copy, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, Copy, McBuf)]
 pub enum Pose {
     Standing = 0,
     FallFlying = 1,
@@ -171,7 +172,7 @@ pub enum Pose {
     Dying = 7,
 }
 
-#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+#[derive(Debug, Clone, McBuf)]
 pub struct VillagerData {
     #[var]
     type_: u32,
@@ -181,7 +182,7 @@ pub struct VillagerData {
     level: u32,
 }
 
-#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+#[derive(Debug, Clone, McBuf)]
 pub struct Particle {
     #[var]
     pub id: i32,
@@ -280,12 +281,12 @@ pub enum ParticleData {
     Scrape,
 }
 
-#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+#[derive(Debug, Clone, McBuf)]
 pub struct BlockParticle {
     #[var]
     pub block_state: i32,
 }
-#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+#[derive(Debug, Clone, McBuf)]
 pub struct DustParticle {
     /// Red value, 0-1
     pub red: f32,
@@ -297,7 +298,7 @@ pub struct DustParticle {
     pub scale: f32,
 }
 
-#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+#[derive(Debug, Clone, McBuf)]
 pub struct DustColorTransitionParticle {
     /// Red value, 0-1
     pub from_red: f32,
@@ -315,12 +316,12 @@ pub struct DustColorTransitionParticle {
     pub to_blue: f32,
 }
 
-#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+#[derive(Debug, Clone, McBuf)]
 pub struct ItemParticle {
     pub item: Slot,
 }
 
-#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+#[derive(Debug, Clone, McBuf)]
 pub struct VibrationParticle {
     pub origin: BlockPos,
     pub position_type: String,
@@ -331,9 +332,8 @@ pub struct VibrationParticle {
     pub ticks: u32,
 }
 
-impl McBufReadable for ParticleData {
-    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
-        let id = buf.read_varint()?;
+impl ParticleData {
+    pub fn read_from_particle_id(buf: &mut impl Read, id: u32) -> Result<Self, String> {
         Ok(match id {
             0 => ParticleData::AmbientEntityEffect,
             1 => ParticleData::AngryVillager,
@@ -428,6 +428,13 @@ impl McBufReadable for ParticleData {
     }
 }
 
+impl McBufReadable for ParticleData {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let id = u32::var_read_into(buf)?;
+        ParticleData::read_from_particle_id(buf, id)
+    }
+}
+
 impl McBufWritable for ParticleData {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         todo!()
diff --git a/azalea-protocol/src/mc_buf/mod.rs b/azalea-protocol/src/mc_buf/mod.rs
index 94e4af0b..548ba7c2 100644
--- a/azalea-protocol/src/mc_buf/mod.rs
+++ b/azalea-protocol/src/mc_buf/mod.rs
@@ -4,10 +4,8 @@ mod definitions;
 mod read;
 mod write;
 
-pub use definitions::{BitSet, EntityMetadata, UnsizedByteArray};
-use packet_macros::{McBufReadable, McBufWritable};
+pub use definitions::{BitSet, EntityMetadata, ParticleData, UnsizedByteArray};
 pub use read::{read_varint_async, McBufReadable, McBufVarReadable, Readable};
-use std::ops::Deref;
 pub use write::{McBufVarWritable, McBufWritable, Writable};
 
 // const DEFAULT_NBT_QUOTA: u32 = 2097152;
diff --git a/azalea-protocol/src/packets/game/clientbound_animate_packet.rs b/azalea-protocol/src/packets/game/clientbound_animate_packet.rs
index 84a20381..6ac4bd99 100644
--- a/azalea-protocol/src/packets/game/clientbound_animate_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_animate_packet.rs
@@ -1,4 +1,4 @@
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 
 #[derive(Clone, Debug, GamePacket)]
 pub struct ClientboundAnimatePacket {
@@ -9,7 +9,7 @@ pub struct ClientboundAnimatePacket {
 
 // minecraft actually uses a u8 for this, but a varint still works and makes it
 // so i don't have to add a special handler
-#[derive(Clone, Debug, Copy, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, Copy, McBuf)]
 pub enum AnimationAction {
     SwingMainHand = 0,
     Hurt = 1,
diff --git a/azalea-protocol/src/packets/game/clientbound_chat_packet.rs b/azalea-protocol/src/packets/game/clientbound_chat_packet.rs
index 3786993a..7a52337e 100644
--- a/azalea-protocol/src/packets/game/clientbound_chat_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_chat_packet.rs
@@ -1,5 +1,5 @@
 use azalea_chat::component::Component;
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 use uuid::Uuid;
 
 #[derive(Clone, Debug, GamePacket)]
@@ -9,7 +9,7 @@ pub struct ClientboundChatPacket {
     pub sender: Uuid,
 }
 
-#[derive(Clone, Debug, Copy, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, Copy, McBuf)]
 pub enum ChatType {
     Chat = 0,
     System = 1,
diff --git a/azalea-protocol/src/packets/game/clientbound_game_event_packet.rs b/azalea-protocol/src/packets/game/clientbound_game_event_packet.rs
index c3ae2299..faba0a6e 100644
--- a/azalea-protocol/src/packets/game/clientbound_game_event_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_game_event_packet.rs
@@ -1,4 +1,4 @@
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 
 #[derive(Clone, Debug, GamePacket)]
 pub struct ClientboundGameEventPacket {
@@ -6,7 +6,7 @@ pub struct ClientboundGameEventPacket {
     pub param: f32,
 }
 
-#[derive(Clone, Debug, Copy, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, Copy, McBuf)]
 pub enum EventType {
     NoRespawnBlockAvailable = 0,
     StartRaining = 1,
diff --git a/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs b/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs
index edcb5777..dab36050 100644
--- a/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_level_chunk_with_light_packet.rs
@@ -1,4 +1,4 @@
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 
 use super::clientbound_light_update_packet::ClientboundLightUpdatePacketData;
 
@@ -10,7 +10,7 @@ pub struct ClientboundLevelChunkWithLightPacket {
     pub light_data: ClientboundLightUpdatePacketData,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct ClientboundLevelChunkPacketData {
     pub heightmaps: azalea_nbt::Tag,
     // we can't parse the data in azalea-protocol because it dependso on context from other packets
@@ -18,7 +18,7 @@ pub struct ClientboundLevelChunkPacketData {
     pub block_entities: Vec<BlockEntity>,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct BlockEntity {
     pub packed_xz: u8,
     pub y: u16,
diff --git a/azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs b/azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs
new file mode 100644
index 00000000..0194d08d
--- /dev/null
+++ b/azalea-protocol/src/packets/game/clientbound_level_particles_packet.rs
@@ -0,0 +1,17 @@
+use crate::mc_buf::ParticleData;
+use packet_macros::GamePacket;
+
+#[derive(Clone, Debug, GamePacket)]
+pub struct ClientboundLevelParticlesPacket {
+    pub particle_id: u32,
+    pub override_limiter: bool,
+    pub x: f64,
+    pub y: f64,
+    pub z: f64,
+    pub x_dist: f32,
+    pub y_dist: f32,
+    pub z_dist: f32,
+    pub max_speed: f32,
+    pub count: i32,
+    pub data: ParticleData,
+}
diff --git a/azalea-protocol/src/packets/game/clientbound_light_update_packet.rs b/azalea-protocol/src/packets/game/clientbound_light_update_packet.rs
index e83d1e87..0c75b356 100644
--- a/azalea-protocol/src/packets/game/clientbound_light_update_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_light_update_packet.rs
@@ -1,5 +1,5 @@
 use crate::mc_buf::BitSet;
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 
 #[derive(Clone, Debug, GamePacket)]
 pub struct ClientboundLightUpdatePacket {
@@ -8,7 +8,7 @@ pub struct ClientboundLightUpdatePacket {
     pub light_data: ClientboundLightUpdatePacketData,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct ClientboundLightUpdatePacketData {
     trust_edges: bool,
     sky_y_mask: BitSet,
diff --git a/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs
index 8e7ce4fd..db306ade 100644
--- a/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs
@@ -1,6 +1,6 @@
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_chat::component::Component;
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 use std::io::{Read, Write};
 use uuid::Uuid;
 
@@ -18,14 +18,14 @@ pub enum Action {
     RemovePlayer(Vec<RemovePlayer>),
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct PlayerProperty {
     name: String,
     value: String,
     signature: Option<String>,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct AddPlayer {
     uuid: Uuid,
     name: String,
@@ -37,26 +37,26 @@ pub struct AddPlayer {
     display_name: Option<Component>,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct UpdateGameMode {
     uuid: Uuid,
     #[var]
     gamemode: u32,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct UpdateLatency {
     uuid: Uuid,
     #[var]
     ping: i32,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct UpdateDisplayName {
     uuid: Uuid,
     display_name: Option<Component>,
 }
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct RemovePlayer {
     uuid: Uuid,
 }
diff --git a/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs b/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
index fa0d58f0..9a9623ad 100644
--- a/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
@@ -1,6 +1,6 @@
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_core::resource_location::ResourceLocation;
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 use std::io::{Read, Write};
 
 #[derive(Clone, Debug, GamePacket)]
@@ -11,7 +11,7 @@ pub struct ClientboundRecipePacket {
     pub to_highlight: Vec<ResourceLocation>,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct RecipeBookSettings {
     pub gui_open: bool,
     pub filtering_craftable: bool,
diff --git a/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs b/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs
index 7f57a126..91d579a8 100644
--- a/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs
@@ -37,7 +37,7 @@ impl McBufWritable for BlockStateWithPosition {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let data = (self.state as u64) << 12
             | ((self.pos.x as u64) << 8 | (self.pos.z as u64) << 4 | (self.pos.y as u64));
-        u64::var_write_into(&data, buf);
+        u64::var_write_into(&data, buf)?;
         Ok(())
     }
 }
diff --git a/azalea-protocol/src/packets/game/clientbound_sound_packet.rs b/azalea-protocol/src/packets/game/clientbound_sound_packet.rs
index 67e832fe..8094227b 100644
--- a/azalea-protocol/src/packets/game/clientbound_sound_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_sound_packet.rs
@@ -1,4 +1,4 @@
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 
 #[derive(Clone, Debug, GamePacket)]
 pub struct ClientboundSoundPacket {
@@ -13,7 +13,7 @@ pub struct ClientboundSoundPacket {
     pub pitch: f32,
 }
 
-#[derive(Clone, Debug, Copy, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, Copy, McBuf)]
 pub enum SoundSource {
     Master = 0,
     Music = 1,
diff --git a/azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs
index fe2c226d..0bd18319 100644
--- a/azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_update_advancements_packet.rs
@@ -1,7 +1,7 @@
 use crate::packets::{McBufReadable, McBufWritable};
 use azalea_chat::component::Component;
 use azalea_core::{resource_location::ResourceLocation, Slot};
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 use std::{
     collections::HashMap,
     io::{Read, Write},
@@ -15,7 +15,7 @@ pub struct ClientboundUpdateAdvancementsPacket {
     pub progress: HashMap<ResourceLocation, AdvancementProgress>,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct Advancement {
     parent_id: Option<ResourceLocation>,
     display: Option<DisplayInfo>,
@@ -25,7 +25,7 @@ pub struct Advancement {
     // requirements_strategy: RequirementsStrategy.AND
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct DisplayInfo {
     pub title: Component,
     pub description: Component,
@@ -71,7 +71,7 @@ impl McBufWritable for DisplayFlags {
     }
 }
 
-#[derive(Clone, Debug, Copy, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, Copy, McBuf)]
 pub enum FrameType {
     Task = 0,
     Challenge = 1,
@@ -79,12 +79,12 @@ pub enum FrameType {
 }
 
 // nothing is written here
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct Criterion {}
 
 pub type AdvancementProgress = HashMap<ResourceLocation, CriterionProgress>;
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct CriterionProgress {
     date: Option<u64>,
 }
diff --git a/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs
index 3d83e6fb..2b382c9f 100644
--- a/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs
@@ -1,6 +1,6 @@
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_core::resource_location::ResourceLocation;
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 use std::io::{Read, Write};
 use uuid::Uuid;
 
@@ -11,14 +11,14 @@ pub struct ClientboundUpdateAttributesPacket {
     pub attributes: Vec<AttributeSnapshot>,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct AttributeSnapshot {
     pub attribute: ResourceLocation,
     pub base: f64,
     pub modifiers: Vec<Modifier>,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct Modifier {
     pub uuid: Uuid,
     pub amount: f64,
diff --git a/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
index 5b4c5cd9..e7756248 100644
--- a/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
@@ -1,7 +1,7 @@
 use std::io::{Read, Write};
 
 use azalea_core::{resource_location::ResourceLocation, Slot};
-use packet_macros::{GamePacket, McBufReadable, McBufWritable};
+use packet_macros::{GamePacket, McBuf};
 
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
 
@@ -16,7 +16,7 @@ pub struct Recipe {
     pub data: RecipeData,
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct ShapelessRecipe {
     /// Used to group similar recipes together in the recipe book.
     /// Tag is present in recipe JSON
@@ -68,7 +68,7 @@ impl McBufReadable for ShapedRecipe {
     }
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct CookingRecipe {
     group: String,
     ingredient: Ingredient,
@@ -77,13 +77,13 @@ pub struct CookingRecipe {
     #[var]
     cooking_time: u32,
 }
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct StoneCuttingRecipe {
     group: String,
     ingredient: Ingredient,
     result: Slot,
 }
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct SmithingRecipe {
     base: Ingredient,
     addition: Ingredient,
@@ -116,7 +116,7 @@ pub enum RecipeData {
     Smithing(SmithingRecipe),
 }
 
-#[derive(Clone, Debug, McBufReadable, McBufWritable)]
+#[derive(Clone, Debug, McBuf)]
 pub struct Ingredient {
     pub allowed: Vec<Slot>,
 }
diff --git a/azalea-protocol/src/packets/game/mod.rs b/azalea-protocol/src/packets/game/mod.rs
index f8ead9d6..883e03aa 100755
--- a/azalea-protocol/src/packets/game/mod.rs
+++ b/azalea-protocol/src/packets/game/mod.rs
@@ -16,6 +16,7 @@ pub mod clientbound_initialize_border_packet;
 pub mod clientbound_keep_alive_packet;
 pub mod clientbound_level_chunk_with_light_packet;
 pub mod clientbound_level_event_packet;
+pub mod clientbound_level_particles_packet;
 pub mod clientbound_light_update_packet;
 pub mod clientbound_login_packet;
 pub mod clientbound_move_entity_pos_packet;
@@ -58,10 +59,10 @@ declare_state_packets!(
         0x00: clientbound_add_entity_packet::ClientboundAddEntityPacket,
         0x02: clientbound_add_mob_packet::ClientboundAddMobPacket,
         0x04: clientbound_add_player_packet::ClientboundAddPlayerPacket,
-        0x6: clientbound_animate_packet::ClientboundAnimatePacket,
-        0xc: clientbound_block_update_packet::ClientboundBlockUpdatePacket,
+        0x06: clientbound_animate_packet::ClientboundAnimatePacket,
+        0x0c: clientbound_block_update_packet::ClientboundBlockUpdatePacket,
         0x0e: clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
-        0xf: clientbound_chat_packet::ClientboundChatPacket,
+        0x0f: clientbound_chat_packet::ClientboundChatPacket,
         0x12: clientbound_declare_commands_packet::ClientboundDeclareCommandsPacket,
         0x14: clientbound_container_set_content_packet::ClientboundContainerSetContentPacket,
         0x1a: clientbound_disconnect_packet::ClientboundDisconnectPacket,
@@ -72,6 +73,7 @@ declare_state_packets!(
         0x21: clientbound_keep_alive_packet::ClientboundKeepAlivePacket,
         0x22: clientbound_level_chunk_with_light_packet::ClientboundLevelChunkWithLightPacket,
         0x23: clientbound_level_event_packet::ClientboundLevelEventPacket,
+        0x24: clientbound_level_particles_packet::ClientboundLevelParticlesPacket,
         0x25: clientbound_light_update_packet::ClientboundLightUpdatePacket,
         0x26: clientbound_login_packet::ClientboundLoginPacket,
         0x29: clientbound_move_entity_pos_packet::ClientboundMoveEntityPosPacket,
diff --git a/azalea-protocol/src/packets/mod.rs b/azalea-protocol/src/packets/mod.rs
index a706646d..16e97068 100755
--- a/azalea-protocol/src/packets/mod.rs
+++ b/azalea-protocol/src/packets/mod.rs
@@ -43,7 +43,7 @@ where
     fn write(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }
 
-impl McBufReadable for ConnectionProtocol {
+impl crate::mc_buf::McBufReadable for ConnectionProtocol {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
         ConnectionProtocol::from_i32(buf.read_varint()?)
             .ok_or_else(|| "Invalid intention".to_string())
-- 
cgit v1.2.3