Change brigadier numbers

1 files changed, 64 insertions, 162 deletions

diff --git a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
index 5617b0c4..648ca9e0 100755
--- a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
@@ -1,44 +1,20 @@
 use super::GamePacket;
+use crate::mc_buf::McBufVarReadable;
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_core::resource_location::ResourceLocation;
-use packet_macros::McBuf;
+use packet_macros::{GamePacket, McBuf};
 use std::{
     hash::Hash,
     io::{Read, Write},
 };
 
-#[derive(Hash, Clone, Debug)]
+#[derive(Clone, Debug, McBuf, GamePacket)]
 pub struct ClientboundDeclareCommandsPacket {
     pub entries: Vec<BrigadierNodeStub>,
+    #[var]
     pub root_index: i32,
 }
 
-impl ClientboundDeclareCommandsPacket {
-    pub fn get(self) -> GamePacket {
-        GamePacket::ClientboundDeclareCommandsPacket(self)
-    }
-
-    pub fn write(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
-        panic!("ClientboundDeclareCommandsPacket::write not implemented")
-    }
-
-    pub fn read<T: Read>(buf: &mut T) -> Result<GamePacket, String> {
-        let node_count = buf.read_varint()?;
-        let mut nodes = Vec::with_capacity(node_count as usize);
-        for _ in 0..node_count {
-            let node = BrigadierNodeStub::read_into(buf)?;
-            nodes.push(node);
-        }
-        let root_index = buf.read_varint()?;
-        Ok(GamePacket::ClientboundDeclareCommandsPacket(
-            ClientboundDeclareCommandsPacket {
-                entries: nodes,
-                root_index,
-            },
-        ))
-    }
-}
-
 #[derive(Hash, Debug, Clone)]
 pub struct BrigadierNodeStub {}
 
@@ -83,7 +59,7 @@ impl<T: McBufWritable> McBufWritable for BrigadierNumber<T> {
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, McBuf)]
 pub enum BrigadierString {
     /// Reads a single word
     SingleWord = 0,
@@ -93,76 +69,6 @@ pub enum BrigadierString {
     GreedyPhrase = 2,
 }
 
-impl McBufReadable for BrigadierString {
-    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
-        let id = buf.read_byte()?;
-        Ok(match id {
-            0 => BrigadierString::SingleWord,
-            1 => BrigadierString::QuotablePhrase,
-            2 => BrigadierString::GreedyPhrase,
-            _ => panic!("Unknown BrigadierString id: {}", id),
-        })
-    }
-}
-impl McBufWritable for BrigadierString {
-    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        buf.write_byte(*self as u8)?;
-        Ok(())
-    }
-}
-
-#[derive(Debug, Clone, Copy, McBuf)]
-pub enum BrigadierParserType {
-    Bool = 0,
-    Double,
-    Float,
-    Integer,
-    Long,
-    String,
-    Entity,
-    GameProfile,
-    BlockPos,
-    ColumnPos,
-    Vec3,
-    Vec2,
-    BlockState,
-    BlockPredicate,
-    ItemStack,
-    ItemPredicate,
-    Color,
-    Component,
-    Message,
-    Nbt,
-    NbtPath,
-    Objective,
-    ObjectiveCriteira,
-    Operation,
-    Particle,
-    Rotation,
-    Angle,
-    ScoreboardSlot,
-    ScoreHolder,
-    Swizzle,
-    Team,
-    ItemSlot,
-    ResourceLocation,
-    MobEffect,
-    Function,
-    EntityAnchor,
-    Range,
-    IntRange,
-    FloatRange,
-    ItemEnchantment,
-    EntitySummon,
-    Dimension,
-    Uuid,
-    NbtTag,
-    NbtCompoundTag,
-    Time,
-    ResourceOrTag,
-    Resource,
-}
-
 #[derive(Debug, Clone)]
 pub enum BrigadierParser {
     Bool,
@@ -201,7 +107,6 @@ pub enum BrigadierParser {
     MobEffect,
     Function,
     EntityAnchor,
-    Range { decimals_allowed: bool },
     IntRange,
     FloatRange,
     ItemEnchantment,
@@ -213,88 +118,79 @@ pub enum BrigadierParser {
     Time,
     ResourceOrTag { registry_key: ResourceLocation },
     Resource { registry_key: ResourceLocation },
+    TemplateMirror,
+    TemplateRotation,
 }
 
 impl McBufReadable for BrigadierParser {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
-        let parser_type = BrigadierParserType::read_into(buf)?;
+        let parser_type = u32::var_read_into(buf)?;
 
         match parser_type {
-            BrigadierParserType::Bool => Ok(BrigadierParser::Bool),
-            BrigadierParserType::Double => {
-                Ok(BrigadierParser::Double(BrigadierNumber::read_into(buf)?))
-            }
-            BrigadierParserType::Float => {
-                Ok(BrigadierParser::Float(BrigadierNumber::read_into(buf)?))
-            }
-            BrigadierParserType::Integer => {
-                Ok(BrigadierParser::Integer(BrigadierNumber::read_into(buf)?))
-            }
-            BrigadierParserType::Long => {
-                Ok(BrigadierParser::Long(BrigadierNumber::read_into(buf)?))
-            }
-            BrigadierParserType::String => {
-                Ok(BrigadierParser::String(BrigadierString::read_into(buf)?))
-            }
-            BrigadierParserType::Entity => {
+            0 => Ok(BrigadierParser::Bool),
+            1 => Ok(BrigadierParser::Float(BrigadierNumber::read_into(buf)?)),
+            2 => Ok(BrigadierParser::Double(BrigadierNumber::read_into(buf)?)),
+            3 => Ok(BrigadierParser::Integer(BrigadierNumber::read_into(buf)?)),
+            4 => Ok(BrigadierParser::Long(BrigadierNumber::read_into(buf)?)),
+            5 => Ok(BrigadierParser::String(BrigadierString::read_into(buf)?)),
+            6 => {
                 let flags = buf.read_byte()?;
                 Ok(BrigadierParser::Entity {
                     single: flags & 0x01 != 0,
                     players_only: flags & 0x02 != 0,
                 })
             }
-            BrigadierParserType::GameProfile => Ok(BrigadierParser::GameProfile),
-            BrigadierParserType::BlockPos => Ok(BrigadierParser::BlockPos),
-            BrigadierParserType::ColumnPos => Ok(BrigadierParser::ColumnPos),
-            BrigadierParserType::Vec3 => Ok(BrigadierParser::Vec3),
-            BrigadierParserType::Vec2 => Ok(BrigadierParser::Vec2),
-            BrigadierParserType::BlockState => Ok(BrigadierParser::BlockState),
-            BrigadierParserType::BlockPredicate => Ok(BrigadierParser::BlockPredicate),
-            BrigadierParserType::ItemStack => Ok(BrigadierParser::ItemStack),
-            BrigadierParserType::ItemPredicate => Ok(BrigadierParser::ItemPredicate),
-            BrigadierParserType::Color => Ok(BrigadierParser::Color),
-            BrigadierParserType::Component => Ok(BrigadierParser::Component),
-            BrigadierParserType::Message => Ok(BrigadierParser::Message),
-            BrigadierParserType::Nbt => Ok(BrigadierParser::Nbt),
-            BrigadierParserType::NbtPath => Ok(BrigadierParser::NbtPath),
-            BrigadierParserType::Objective => Ok(BrigadierParser::Objective),
-            BrigadierParserType::ObjectiveCriteira => Ok(BrigadierParser::ObjectiveCriteira),
-            BrigadierParserType::Operation => Ok(BrigadierParser::Operation),
-            BrigadierParserType::Particle => Ok(BrigadierParser::Particle),
-            BrigadierParserType::Rotation => Ok(BrigadierParser::Rotation),
-            BrigadierParserType::Angle => Ok(BrigadierParser::Angle),
-            BrigadierParserType::ScoreboardSlot => Ok(BrigadierParser::ScoreboardSlot),
-            BrigadierParserType::ScoreHolder => {
+            7 => Ok(BrigadierParser::GameProfile),
+            8 => Ok(BrigadierParser::BlockPos),
+            9 => Ok(BrigadierParser::ColumnPos),
+            10 => Ok(BrigadierParser::Vec3),
+            11 => Ok(BrigadierParser::Vec2),
+            12 => Ok(BrigadierParser::BlockState),
+            13 => Ok(BrigadierParser::BlockPredicate),
+            14 => Ok(BrigadierParser::ItemStack),
+            15 => Ok(BrigadierParser::ItemPredicate),
+            16 => Ok(BrigadierParser::Color),
+            17 => Ok(BrigadierParser::Component),
+            18 => Ok(BrigadierParser::Message),
+            19 => Ok(BrigadierParser::NbtCompoundTag),
+            20 => Ok(BrigadierParser::NbtTag),
+            21 => Ok(BrigadierParser::NbtPath),
+            22 => Ok(BrigadierParser::Objective),
+            23 => Ok(BrigadierParser::ObjectiveCriteira),
+            24 => Ok(BrigadierParser::Operation),
+            25 => Ok(BrigadierParser::Particle),
+            26 => Ok(BrigadierParser::Angle),
+            27 => Ok(BrigadierParser::Rotation),
+            28 => Ok(BrigadierParser::ScoreboardSlot),
+            29 => {
                 let flags = buf.read_byte()?;
                 Ok(BrigadierParser::ScoreHolder {
                     allows_multiple: flags & 0x01 != 0,
                 })
             }
-            BrigadierParserType::Swizzle => Ok(BrigadierParser::Swizzle),
-            BrigadierParserType::Team => Ok(BrigadierParser::Team),
-            BrigadierParserType::ItemSlot => Ok(BrigadierParser::ItemSlot),
-            BrigadierParserType::ResourceLocation => Ok(BrigadierParser::ResourceLocation),
-            BrigadierParserType::MobEffect => Ok(BrigadierParser::MobEffect),
-            BrigadierParserType::Function => Ok(BrigadierParser::Function),
-            BrigadierParserType::EntityAnchor => Ok(BrigadierParser::EntityAnchor),
-            BrigadierParserType::Range => Ok(BrigadierParser::Range {
-                decimals_allowed: buf.read_boolean()?,
-            }),
-            BrigadierParserType::IntRange => Ok(BrigadierParser::IntRange),
-            BrigadierParserType::FloatRange => Ok(BrigadierParser::FloatRange),
-            BrigadierParserType::ItemEnchantment => Ok(BrigadierParser::ItemEnchantment),
-            BrigadierParserType::EntitySummon => Ok(BrigadierParser::EntitySummon),
-            BrigadierParserType::Dimension => Ok(BrigadierParser::Dimension),
-            BrigadierParserType::Uuid => Ok(BrigadierParser::Uuid),
-            BrigadierParserType::NbtTag => Ok(BrigadierParser::NbtTag),
-            BrigadierParserType::NbtCompoundTag => Ok(BrigadierParser::NbtCompoundTag),
-            BrigadierParserType::Time => Ok(BrigadierParser::Time),
-            BrigadierParserType::ResourceOrTag => Ok(BrigadierParser::ResourceOrTag {
+            30 => Ok(BrigadierParser::Swizzle),
+            31 => Ok(BrigadierParser::Team),
+            32 => Ok(BrigadierParser::ItemSlot),
+            33 => Ok(BrigadierParser::ResourceLocation),
+            34 => Ok(BrigadierParser::MobEffect),
+            35 => Ok(BrigadierParser::Function),
+            36 => Ok(BrigadierParser::EntityAnchor),
+            37 => Ok(BrigadierParser::IntRange),
+            38 => Ok(BrigadierParser::FloatRange),
+            39 => Ok(BrigadierParser::ItemEnchantment),
+            40 => Ok(BrigadierParser::EntitySummon),
+            41 => Ok(BrigadierParser::Dimension),
+            42 => Ok(BrigadierParser::Time),
+            43 => Ok(BrigadierParser::ResourceOrTag {
                 registry_key: buf.read_resource_location()?,
             }),
-            BrigadierParserType::Resource => Ok(BrigadierParser::Resource {
+            44 => Ok(BrigadierParser::Resource {
                 registry_key: buf.read_resource_location()?,
             }),
+            45 => Ok(BrigadierParser::TemplateMirror),
+            46 => Ok(BrigadierParser::TemplateRotation),
+            47 => Ok(BrigadierParser::Uuid),
+            _ => Err(format!("Unknown BrigadierParser type: {}", parser_type)),
         }
     }
 }
@@ -305,7 +201,7 @@ impl McBufReadable for BrigadierNodeStub {
         let flags = u8::read_into(buf)?;
         if flags > 31 {
             println!(
-                "Warning: The flags from a Brigadier node are over 31. This is probably a bug."
+                "Warning: The flags from a Brigadier node are over 31 ({flags}; {flags:#b}). This is probably a bug.",
             );
         }
 
@@ -337,3 +233,9 @@ impl McBufReadable for BrigadierNodeStub {
         // return Err("Unknown node type".to_string());
     }
 }
+
+impl McBufWritable for BrigadierNodeStub {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        todo!()
+    }
+}