work a bit more on 22w42a

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

@@ -1,41 +1,12 @@
-use azalea_buf::{McBuf, McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable};
+use super::clientbound_player_chat_packet::PackedMessageSignature;
+use azalea_buf::{
+    BufReadError, McBuf, McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable,
+};
 use azalea_crypto::MessageSignature;
 use azalea_protocol_macros::ClientboundGamePacket;
 use std::io::{Cursor, Write};
 
 #[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
 pub struct ClientboundDeleteChatPacket {
-    pub signature_or_id: SignatureOrId,
-}
-
-/// Messages can be deleted by either their signature or message id.
-pub enum SignatureOrId {
-    Signature(MessageSignature),
-    Id(u32),
-}
-
-impl McBufReadable for SignatureOrId {
-    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, azalea_buf::BufReadError> {
-        let id = u32::var_read_from(buf)?;
-        if id == 0 {
-            let full_signature = MessageSignature::read_from(buf)?;
-            Ok(SignatureOrId::Signature(full_signature))
-        } else {
-            Ok(SignatureOrId::Id(id - 1))
-        }
-    }
-}
-impl McBufWritable for SignatureOrId {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        match self {
-            SignatureOrId::Signature(full_signature) => {
-                0u32.var_write_into(buf);
-                full_signature.write_into(buf);
-            }
-            SignatureOrId::Id(id) => {
-                (id + 1).var_write_into(buf);
-            }
-        }
-        Ok(())
-    }
+    pub signature: PackedMessageSignature,
 }

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

@@ -1,17 +1,119 @@
-use azalea_buf::McBuf;
+use std::io::{Cursor, Write};
+
+use azalea_buf::{BufReadError, McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable};
+use azalea_core::BlockPos;
 use azalea_protocol_macros::ClientboundGamePacket;
 
-#[derive(Clone, Debug, McBuf, ClientboundGamePacket)]
+#[derive(Clone, Debug, PartialEq, ClientboundGamePacket)]
 pub struct ClientboundExplodePacket {
     pub x: f64,
     pub y: f64,
     pub z: f64,
     pub power: f32,
-    // TODO: {'operation': 'store', 'type': 'int', 'value': 'anp.b(this.a)', 'var': 'var2'}
-    // TODO: {'operation': 'store', 'type': 'int', 'value': 'anp.b(this.b)', 'var': 'var3'}
-    // TODO: {'operation': 'store', 'type': 'int', 'value': 'anp.b(this.c)', 'var': 'var4'}
-    pub to_blow: todo!(),
+    pub to_blow: Vec<BlockPos>,
     pub knockback_x: f32,
     pub knockback_y: f32,
     pub knockback_z: f32,
 }
+
+impl McBufReadable for ClientboundExplodePacket {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let x = f64::read_from(buf)?;
+        let y = f64::read_from(buf)?;
+        let z = f64::read_from(buf)?;
+        let power = f32::read_from(buf)?;
+
+        let x_floor = x.floor() as i32;
+        let y_floor = y.floor() as i32;
+        let z_floor = z.floor() as i32;
+
+        let to_blow_len = u32::var_read_from(buf)?;
+        let mut to_blow = Vec::with_capacity(to_blow_len as usize);
+        for _ in 0..to_blow_len {
+            // the bytes are offsets from the main x y z
+            let x = x_floor + i8::read_from(buf)? as i32;
+            let y = y_floor + i8::read_from(buf)? as i32;
+            let z = z_floor + i8::read_from(buf)? as i32;
+            to_blow.push(BlockPos { x, y, z });
+        }
+
+        let knockback_x = f32::read_from(buf)?;
+        let knockback_y = f32::read_from(buf)?;
+        let knockback_z = f32::read_from(buf)?;
+
+        Ok(Self {
+            x,
+            y,
+            z,
+            power,
+            to_blow,
+            knockback_x,
+            knockback_y,
+            knockback_z,
+        })
+    }
+}
+
+impl McBufWritable for ClientboundExplodePacket {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        self.x.write_into(buf)?;
+        self.y.write_into(buf)?;
+        self.z.write_into(buf)?;
+        self.power.write_into(buf)?;
+
+        let to_blow_len = self.to_blow.len() as u32;
+        to_blow_len.var_write_into(buf)?;
+
+        let x_floor = self.x.floor() as i32;
+        let y_floor = self.y.floor() as i32;
+        let z_floor = self.z.floor() as i32;
+
+        for pos in &self.to_blow {
+            let x = (pos.x - x_floor) as i8;
+            let y = (pos.y - y_floor) as i8;
+            let z = (pos.z - z_floor) as i8;
+            x.write_into(buf)?;
+            y.write_into(buf)?;
+            z.write_into(buf)?;
+        }
+
+        self.knockback_x.write_into(buf)?;
+        self.knockback_y.write_into(buf)?;
+        self.knockback_z.write_into(buf)?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_read_write() {
+        let packet = ClientboundExplodePacket {
+            x: 123_456.0,
+            y: 789_012.0,
+            z: 345_678.0,
+            power: 1_000.0,
+            to_blow: vec![
+                BlockPos {
+                    x: 123_456 + 1,
+                    y: 789_012 + 2,
+                    z: 345_678 - 127,
+                },
+                BlockPos {
+                    x: 123_456 + 4,
+                    y: 789_012 - 5,
+                    z: 345_678 + 6,
+                },
+            ],
+            knockback_x: 1_000.0,
+            knockback_y: 2_000.0,
+            knockback_z: 3_000.0,
+        };
+        let mut buf = Vec::new();
+        packet.write_into(&mut buf).unwrap();
+        let packet2 = ClientboundExplodePacket::read_from(&mut Cursor::new(&buf)).unwrap();
+        assert_eq!(packet, packet2);
+    }
+}

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

@@ -1,5 +1,8 @@
-use azalea_buf::McBuf;
+use std::io::{Cursor, Write};
+
+use azalea_buf::{BufReadError, McBuf, McBufReadable, McBufWritable};
 use azalea_chat::component::Component;
+use azalea_crypto::MessageSignature;
 use azalea_protocol_macros::ClientboundGamePacket;
 use uuid::Uuid;
 
@@ -8,10 +11,7 @@ pub struct ClientboundPlayerChatPacket {
     pub sender: Uuid,
     #[var]
     pub index: u32,
-    pub signature: Option<Vec<u8>>,
-    // TODO: {'field': 'd.a', 'operation': 'write', 'type': 'string'}
-    // TODO: {'field': 'd.b.toEpochMilli()', 'operation': 'write', 'type': 'long'}
-    // TODO: {'field': 'd.c', 'operation': 'write', 'type': 'long'}
+    pub signature: Option<MessageSignature>,
     pub body: todo!(),
     pub unsigned_content: Option<Component>,
     // TODO: {'field': 'f.f', 'operation': 'write', 'type': 'enum'}
@@ -20,3 +20,48 @@ pub struct ClientboundPlayerChatPacket {
     // TODO: {'field': 'g.b', 'operation': 'write', 'type': 'chatcomponent'}
     pub chat_type: Option<Component>,
 }
+
+#[derive(McBuf)]
+pub struct PackedSignedMessageBody {
+    pub content: String,
+    pub timestamp: u64,
+    pub salt: u64,
+    pub last_seen: PackedLastSeenMessages,
+}
+
+pub struct PackedLastSeenMessages {
+    pub entries: PackedMessageSignature,
+}
+
+/// Messages can be deleted by either their signature or message id.
+#[derive(Clone, Debug)]
+pub enum PackedMessageSignature {
+    Signature(MessageSignature),
+    Id(u32),
+}
+
+impl McBufReadable for PackedMessageSignature {
+    fn read_from(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        let id = u32::var_read_from(buf)?;
+        if id == 0 {
+            let full_signature = MessageSignature::read_from(buf)?;
+            Ok(PackedMessageSignature::Signature(full_signature))
+        } else {
+            Ok(PackedMessageSignature::Id(id - 1))
+        }
+    }
+}
+impl McBufWritable for PackedMessageSignature {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        match self {
+            PackedMessageSignature::Signature(full_signature) => {
+                0u32.var_write_into(buf);
+                full_signature.write_into(buf);
+            }
+            PackedMessageSignature::Id(id) => {
+                (id + 1).var_write_into(buf);
+            }
+        }
+        Ok(())
+    }
+}