Implement ALL packets (#16)

* add a couple more packets and improve codegen

* enums in packet codegen

* fix enums and MORE PACKETS

* make unsigned numbers the default

* codegen can make hashmaps

* UnsizedByteArray in codegen

* Vec and Option

* enum codgen works in more situations

* ServerboundInteractPacket

* Fix error with new error system

* More packets

* more packets

* more packets

* guess what was added

* yeah it's more packets

* add more packets

* packets

* start adding ClientboundBossEventPacket

* finish boss event packet

* improve codegen for linux

* start on command suggestions packet

* rename declare_commands to commands

* más paquetes

* fix generating custom payload packet

* more packets

* mehr Pakete

* improve codegen for movement packets

* rename move packets to have "packet" at the end

* fix some unused variable warns

* addere plus facis

* pli da pakoj

* plus de paquets

* più pacchetti

* make ChatFormatting a macro in azalea-chat

* change a match to matches! macro

* update SetPlayerTeam to use ChatFormatting

* ClientboundSetScorePacket & fix clippy warnings

* finish game state :tada:

* add remaining packets for other states

* fix error in ping.rs

1 files changed, 118 insertions, 0 deletions

diff --git a/azalea-protocol/src/packets/game/clientbound_explode_packet.rs b/azalea-protocol/src/packets/game/clientbound_explode_packet.rs
new file mode 100644
index 00000000..25731bcf
--- /dev/null
+++ b/azalea-protocol/src/packets/game/clientbound_explode_packet.rs
@@ -0,0 +1,118 @@
+use azalea_buf::{BufReadError, McBufReadable, McBufVarReadable, McBufVarWritable, McBufWritable};
+use azalea_core::BlockPos;
+use packet_macros::ClientboundGamePacket;
+use std::io::{Read, Write};
+
+#[derive(Clone, Debug, PartialEq, ClientboundGamePacket)]
+pub struct ClientboundExplodePacket {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub power: f32,
+    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 impl Read) -> Result<Self, BufReadError> {
+        let x = f32::read_from(buf)?;
+        let y = f32::read_from(buf)?;
+        let z = f32::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 buf.as_slice()).unwrap();
+        assert_eq!(packet, packet2);
+    }
+}