actually do ClientboundSectionBlocksUpdatePacket

azalea-client/src/connect.rs

@@ -369,12 +369,14 @@ impl Client {
             }
             GamePacket::ClientboundBlockUpdatePacket(p) => {
                 println!("Got block update packet {:?}", p);
+                // TODO: update world
             }
             GamePacket::ClientboundAnimatePacket(p) => {
                 println!("Got animate packet {:?}", p);
             }
             GamePacket::ClientboundSectionBlocksUpdatePacket(p) => {
                 println!("Got section blocks update packet {:?}", p);
+                // TODO: update world
             }
             _ => panic!("Unexpected packet {:?}", packet),
         }

azalea-protocol/src/packets/game/clientbound_section_blocks_update_packet.rs

@@ -1,10 +1,43 @@
-use azalea_core::ChunkSectionPos;
+use crate::mc_buf::{McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable};
+use azalea_core::{ChunkSectionBlockPos, ChunkSectionPos};
 use packet_macros::GamePacket;
+use std::io::{Read, Write};
 
 #[derive(Clone, Debug, GamePacket)]
 pub struct ClientboundSectionBlocksUpdatePacket {
     pub section_pos: ChunkSectionPos,
     pub suppress_light_updates: bool,
-    #[var]
+    pub states: Vec<BlockStateWithPosition>,
-    pub states: Vec<u64>,
+}
+
+#[derive(Clone, Debug)]
+pub struct BlockStateWithPosition {
+    pub pos: ChunkSectionBlockPos,
+    pub state: u32,
+}
+
+impl McBufReadable for BlockStateWithPosition {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let data = u64::var_read_into(buf)?;
+        let position_part = data & 4095;
+        let state = (data >> 12) as u32;
+        let position = ChunkSectionBlockPos {
+            x: (position_part >> 8 & 15) as u8,
+            y: (position_part >> 0 & 15) as u8,
+            z: (position_part >> 4 & 15) as u8,
+        };
+        Ok(BlockStateWithPosition {
+            pos: position,
+            state: state,
+        })
+    }
+}
+
+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);
+        Ok(())
+    }
 }