From 7b3e2e4bf793466a351510c7fbbd08234e93bb0e Mon Sep 17 00:00:00 2001
From: mat <27899617+mat-1@users.noreply.github.com>
Date: Thu, 21 Sep 2023 11:16:29 -0500
Subject: 1.20.2 (#99)

* add configuration state

* start updating to 23w31a

* implement a bit more of 23w31a

* chunk batching

* start adding configuration state

* ioasfhjgsd

* almost works

* configuration state mostly implemented

* handle other packets in configuration state and fix keepalive

* cleanup, fix warnings

* 23w32a

* fix some doctests

* 23w33a

* 23w35a

* 1.20.2-pre2

* fix system conflicts

* 1.20.2-pre4

* make tests compile

* tests pass

* 1.20.2-rc2

* 1.20.2

* Revert "1.20.2"

This reverts commit dd152fd265332ead333c919e585ded6d609d7468.

* didn't mean to commit that code

---------

Co-authored-by: mat <git@matdoes.dev>
---
 azalea-nbt/src/encode.rs | 91 +++++++++++++++++++++++++++---------------------
 1 file changed, 51 insertions(+), 40 deletions(-)

(limited to 'azalea-nbt/src/encode.rs')

diff --git a/azalea-nbt/src/encode.rs b/azalea-nbt/src/encode.rs
index 76b70b6e..34c451d2 100755
--- a/azalea-nbt/src/encode.rs
+++ b/azalea-nbt/src/encode.rs
@@ -16,51 +16,55 @@ fn write_compound(writer: &mut impl Write, value: &NbtCompound, end_tag: bool) {
     for (key, tag) in value.iter() {
         writer.write_u8(tag.id()).unwrap();
         write_string(writer, key);
-        match tag {
-            Nbt::End => {}
-            Nbt::Byte(value) => {
-                writer.write_i8(*value).unwrap();
-            }
-            Nbt::Short(value) => {
-                writer.write_i16::<BE>(*value).unwrap();
-            }
-            Nbt::Int(value) => {
-                writer.write_i32::<BE>(*value).unwrap();
-            }
-            Nbt::Long(value) => {
-                writer.write_i64::<BE>(*value).unwrap();
-            }
-            Nbt::Float(value) => {
-                writer.write_f32::<BE>(*value).unwrap();
-            }
-            Nbt::Double(value) => {
-                writer.write_f64::<BE>(*value).unwrap();
-            }
-            Nbt::ByteArray(value) => {
-                write_byte_array(writer, value);
-            }
-            Nbt::String(value) => {
-                write_string(writer, value);
-            }
-            Nbt::List(value) => {
-                write_list(writer, value);
-            }
-            Nbt::Compound(value) => {
-                write_compound(writer, value, true);
-            }
-            Nbt::IntArray(value) => {
-                write_int_array(writer, value);
-            }
-            Nbt::LongArray(value) => {
-                write_long_array(writer, value);
-            }
-        }
+        write_known(writer, tag);
     }
     if end_tag {
         writer.write_u8(END_ID).unwrap();
     }
 }
 
+fn write_known(writer: &mut impl Write, tag: &Nbt) {
+    match tag {
+        Nbt::End => {}
+        Nbt::Byte(value) => {
+            writer.write_i8(*value).unwrap();
+        }
+        Nbt::Short(value) => {
+            writer.write_i16::<BE>(*value).unwrap();
+        }
+        Nbt::Int(value) => {
+            writer.write_i32::<BE>(*value).unwrap();
+        }
+        Nbt::Long(value) => {
+            writer.write_i64::<BE>(*value).unwrap();
+        }
+        Nbt::Float(value) => {
+            writer.write_f32::<BE>(*value).unwrap();
+        }
+        Nbt::Double(value) => {
+            writer.write_f64::<BE>(*value).unwrap();
+        }
+        Nbt::ByteArray(value) => {
+            write_byte_array(writer, value);
+        }
+        Nbt::String(value) => {
+            write_string(writer, value);
+        }
+        Nbt::List(value) => {
+            write_list(writer, value);
+        }
+        Nbt::Compound(value) => {
+            write_compound(writer, value, true);
+        }
+        Nbt::IntArray(value) => {
+            write_int_array(writer, value);
+        }
+        Nbt::LongArray(value) => {
+            write_long_array(writer, value);
+        }
+    }
+}
+
 #[inline]
 fn write_list(writer: &mut impl Write, value: &NbtList) {
     writer.write_u8(value.id()).unwrap();
@@ -256,6 +260,13 @@ impl Nbt {
         }
     }
 
+    /// Write any tag as NBT data. This is used by Minecraft when writing to the
+    /// network, otherwise [`Nbt::write`] is usually used instead.
+    pub fn write_any(&self, writer: &mut impl Write) {
+        writer.write_u8(self.id()).unwrap();
+        write_known(writer, self);
+    }
+
     /// Write the compound tag as NBT data compressed wtih zlib.
     ///
     /// # Errors
@@ -279,7 +290,7 @@ impl Nbt {
 
 impl McBufWritable for Nbt {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        self.write(buf);
+        self.write_any(buf);
         Ok(())
     }
 }
-- 
cgit v1.2.3