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, 85 insertions, 0 deletions

diff --git a/azalea-protocol/src/packets/game/serverbound_interact_packet.rs b/azalea-protocol/src/packets/game/serverbound_interact_packet.rs
new file mode 100644
index 00000000..47843d47
--- /dev/null
+++ b/azalea-protocol/src/packets/game/serverbound_interact_packet.rs
@@ -0,0 +1,85 @@
+use crate::packets::BufReadError;
+use azalea_buf::McBufVarReadable;
+use azalea_buf::{McBuf, McBufReadable, McBufVarWritable, McBufWritable};
+use azalea_core::EntityPos;
+use packet_macros::ServerboundGamePacket;
+use std::io::{Read, Write};
+
+#[derive(Clone, Debug, McBuf, ServerboundGamePacket)]
+pub struct ServerboundInteractPacket {
+    #[var]
+    pub entity_id: u32,
+    pub action: ActionType,
+    /// Whether the player is sneaking
+    pub using_secondary_action: bool,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum ActionType {
+    Interact {
+        hand: InteractionHand,
+    },
+    Attack,
+    InteractAt {
+        location: EntityPos,
+        hand: InteractionHand,
+    },
+}
+
+impl McBufWritable for ActionType {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        match self {
+            ActionType::Interact { hand } => {
+                0u32.var_write_into(buf)?;
+                hand.write_into(buf)?;
+            }
+            ActionType::Attack => {
+                1u32.var_write_into(buf)?;
+            }
+            ActionType::InteractAt { location, hand } => {
+                2u32.var_write_into(buf)?;
+                (location.x as f32).write_into(buf)?;
+                (location.y as f32).write_into(buf)?;
+                (location.z as f32).write_into(buf)?;
+                hand.write_into(buf)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl McBufReadable for ActionType {
+    fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+        let action_type = u32::var_read_from(buf)?;
+        match action_type {
+            0 => {
+                let hand = InteractionHand::read_from(buf)?;
+                Ok(ActionType::Interact { hand })
+            }
+            1 => Ok(ActionType::Attack),
+            2 => {
+                let x = f32::read_from(buf)?;
+                let y = f32::read_from(buf)?;
+                let z = f32::read_from(buf)?;
+                let hand = InteractionHand::read_from(buf)?;
+                Ok(ActionType::InteractAt {
+                    location: EntityPos {
+                        x: x as f64,
+                        y: y as f64,
+                        z: z as f64,
+                    },
+                    hand,
+                })
+            }
+            _ => Err(BufReadError::UnexpectedEnumVariant {
+                id: action_type as i32,
+            }),
+        }
+    }
+}
+
+#[derive(McBuf, Clone, Copy, Debug)]
+pub enum InteractionHand {
+    MainHand = 0,
+    OffHand = 1,
+}