From dbb2092ac002790c07ad21cf7d12aabb477a2e74 Mon Sep 17 00:00:00 2001
From: mat <27899617+mat-1@users.noreply.github.com>
Date: Sat, 20 Aug 2022 15:17:07 -0500
Subject: Implement ALL packets (#16)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* 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
---
 azalea-buf/src/read.rs  | 39 +++++++++++++++++++++++++++++++++++++++
 azalea-buf/src/write.rs | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 73 insertions(+)

(limited to 'azalea-buf/src')

diff --git a/azalea-buf/src/read.rs b/azalea-buf/src/read.rs
index 8518d637..7372018e 100644
--- a/azalea-buf/src/read.rs
+++ b/azalea-buf/src/read.rs
@@ -24,6 +24,8 @@ pub enum BufReadError {
     InvalidUtf8,
     #[error("Unexpected enum variant {id}")]
     UnexpectedEnumVariant { id: i32 },
+    #[error("Unexpected enum variant {id}")]
+    UnexpectedStringEnumVariant { id: String },
     #[error("{0}")]
     Custom(String),
     #[cfg(feature = "serde_json")]
@@ -281,6 +283,19 @@ impl<K: McBufReadable + Send + Eq + Hash, V: McBufReadable + Send> McBufReadable
     }
 }
 
+impl<K: McBufReadable + Send + Eq + Hash, V: McBufVarReadable + Send> McBufVarReadable
+    for HashMap<K, V>
+{
+    default fn var_read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+        let length = buf.read_varint()? as usize;
+        let mut contents = HashMap::with_capacity(length);
+        for _ in 0..length {
+            contents.insert(K::read_from(buf)?, V::var_read_from(buf)?);
+        }
+        Ok(contents)
+    }
+}
+
 impl McBufReadable for Vec<u8> {
     fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
         buf.read_byte_array()
@@ -386,3 +401,27 @@ impl<T: McBufReadable> McBufReadable for Option<T> {
         })
     }
 }
+
+impl<T: McBufVarReadable> McBufVarReadable for Option<T> {
+    default fn var_read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+        let present = buf.read_boolean()?;
+        Ok(if present {
+            Some(T::var_read_from(buf)?)
+        } else {
+            None
+        })
+    }
+}
+
+// [String; 4]
+impl<T: McBufReadable, const N: usize> McBufReadable for [T; N] {
+    default fn read_from(buf: &mut impl Read) -> Result<Self, BufReadError> {
+        let mut contents = Vec::with_capacity(N);
+        for _ in 0..N {
+            contents.push(T::read_from(buf)?);
+        }
+        contents.try_into().map_err(|_| {
+            panic!("Panic is not possible since the Vec is the same size as the array")
+        })
+    }
+}
diff --git a/azalea-buf/src/write.rs b/azalea-buf/src/write.rs
index df7f56e0..8def52b3 100644
--- a/azalea-buf/src/write.rs
+++ b/azalea-buf/src/write.rs
@@ -155,6 +155,18 @@ impl<K: McBufWritable, V: McBufWritable> McBufWritable for HashMap<K, V> {
     }
 }
 
+impl<K: McBufWritable, V: McBufVarWritable> McBufVarWritable for HashMap<K, V> {
+    default fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        u32::var_write_into(&(self.len() as u32), buf)?;
+        for (key, value) in self {
+            key.write_into(buf)?;
+            value.var_write_into(buf)?;
+        }
+
+        Ok(())
+    }
+}
+
 impl McBufWritable for Vec<u8> {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte_array(self)
@@ -284,3 +296,25 @@ impl<T: McBufWritable> McBufWritable for Option<T> {
         Ok(())
     }
 }
+
+impl<T: McBufVarWritable> McBufVarWritable for Option<T> {
+    default fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        if let Some(s) = self {
+            buf.write_boolean(true)?;
+            s.var_write_into(buf)?;
+        } else {
+            buf.write_boolean(false)?;
+        };
+        Ok(())
+    }
+}
+
+// [T; N]
+impl<T: McBufWritable, const N: usize> McBufWritable for [T; N] {
+    default fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        for i in self {
+            i.write_into(buf)?;
+        }
+        Ok(())
+    }
+}
-- 
cgit v1.2.3