Merge branch 'main' into chunk-decoding

4 files changed, 544 insertions, 73 deletions

diff --git a/azalea-protocol/src/mc_buf/definitions.rs b/azalea-protocol/src/mc_buf/definitions.rs
new file mode 100644
index 00000000..a59fc574
--- /dev/null
+++ b/azalea-protocol/src/mc_buf/definitions.rs
@@ -0,0 +1,435 @@
+use crate::mc_buf::read::{McBufReadable, Readable};
+use crate::mc_buf::write::{McBufWritable, Writable};
+use azalea_chat::component::Component;
+use azalea_core::{BlockPos, Direction, Slot};
+use packet_macros::{McBufReadable, McBufWritable};
+use std::io::{Read, Write};
+use std::ops::Deref;
+use uuid::Uuid;
+
+/// A Vec<u8> that isn't prefixed by a VarInt with the size.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct UnsizedByteArray(Vec<u8>);
+
+impl Deref for UnsizedByteArray {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<Vec<u8>> for UnsizedByteArray {
+    fn from(vec: Vec<u8>) -> Self {
+        Self(vec)
+    }
+}
+
+impl From<&str> for UnsizedByteArray {
+    fn from(s: &str) -> Self {
+        Self(s.as_bytes().to_vec())
+    }
+}
+
+/// Represents Java's BitSet, a list of bits.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, McBufReadable, McBufWritable)]
+pub struct BitSet {
+    data: Vec<u64>,
+}
+
+// the Index trait requires us to return a reference, but we can't do that
+impl BitSet {
+    pub fn index(&self, index: usize) -> bool {
+        (self.data[index / 64] & (1u64 << (index % 64))) != 0
+    }
+}
+
+pub type EntityMetadata = Vec<EntityDataItem>;
+
+#[derive(Clone, Debug)]
+pub struct EntityDataItem {
+    // we can't identify what the index is for here because we don't know the
+    // entity type
+    pub index: u8,
+    pub value: EntityDataValue,
+}
+
+impl McBufReadable for Vec<EntityDataItem> {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let mut metadata = Vec::new();
+        loop {
+            let index = buf.read_byte()?;
+            if index == 0xff {
+                break;
+            }
+            let value = EntityDataValue::read_into(buf)?;
+            metadata.push(EntityDataItem { index, value });
+        }
+        Ok(metadata)
+    }
+}
+
+impl McBufWritable for Vec<EntityDataItem> {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        for item in self {
+            buf.write_byte(item.index)?;
+            item.value.write_into(buf)?;
+        }
+        buf.write_byte(0xff)?;
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum EntityDataValue {
+    Byte(u8),
+    // varint
+    Int(i32),
+    Float(f32),
+    String(String),
+    Component(Component),
+    OptionalComponent(Option<Component>),
+    ItemStack(Slot),
+    Boolean(bool),
+    Rotations { x: f32, y: f32, z: f32 },
+    BlockPos(BlockPos),
+    OptionalBlockPos(Option<BlockPos>),
+    Direction(Direction),
+    OptionalUuid(Option<Uuid>),
+    // 0 for absent (implies air); otherwise, a block state ID as per the global palette
+    // this is a varint
+    OptionalBlockState(Option<i32>),
+    CompoundTag(azalea_nbt::Tag),
+    Particle(Particle),
+    VillagerData(VillagerData),
+    // 0 for absent; 1 + actual value otherwise. Used for entity IDs.
+    OptionalUnsignedInt(Option<u32>),
+    Pose(Pose),
+}
+
+impl McBufReadable for EntityDataValue {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let type_ = buf.read_varint()?;
+        Ok(match type_ {
+            0 => EntityDataValue::Byte(buf.read_byte()?),
+            1 => EntityDataValue::Int(buf.read_varint()?),
+            2 => EntityDataValue::Float(buf.read_float()?),
+            3 => EntityDataValue::String(buf.read_utf()?),
+            4 => EntityDataValue::Component(Component::read_into(buf)?),
+            5 => EntityDataValue::OptionalComponent(Option::<Component>::read_into(buf)?),
+            6 => EntityDataValue::ItemStack(Slot::read_into(buf)?),
+            7 => EntityDataValue::Boolean(buf.read_boolean()?),
+            8 => EntityDataValue::Rotations {
+                x: buf.read_float()?,
+                y: buf.read_float()?,
+                z: buf.read_float()?,
+            },
+            9 => EntityDataValue::BlockPos(BlockPos::read_into(buf)?),
+            10 => EntityDataValue::OptionalBlockPos(Option::<BlockPos>::read_into(buf)?),
+            11 => EntityDataValue::Direction(Direction::read_into(buf)?),
+            12 => EntityDataValue::OptionalUuid(Option::<Uuid>::read_into(buf)?),
+            13 => EntityDataValue::OptionalBlockState({
+                let val = i32::read_into(buf)?;
+                if val == 0 {
+                    None
+                } else {
+                    Some(val)
+                }
+            }),
+            14 => EntityDataValue::CompoundTag(azalea_nbt::Tag::read_into(buf)?),
+            15 => EntityDataValue::Particle(Particle::read_into(buf)?),
+            16 => EntityDataValue::VillagerData(VillagerData::read_into(buf)?),
+            17 => EntityDataValue::OptionalUnsignedInt({
+                let val = buf.read_varint()?;
+                if val == 0 {
+                    None
+                } else {
+                    Some((val - 1) as u32)
+                }
+            }),
+            18 => EntityDataValue::Pose(Pose::read_into(buf)?),
+            _ => return Err(format!("Unknown entity data type: {}", type_)),
+        })
+    }
+}
+
+impl McBufWritable for EntityDataValue {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        todo!();
+    }
+}
+
+#[derive(Clone, Debug, Copy, McBufReadable, McBufWritable)]
+pub enum Pose {
+    Standing = 0,
+    FallFlying = 1,
+    Sleeping = 2,
+    Swimming = 3,
+    SpinAttack = 4,
+    Sneaking = 5,
+    LongJumping = 6,
+    Dying = 7,
+}
+
+#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+pub struct VillagerData {
+    #[var]
+    type_: u32,
+    #[var]
+    profession: u32,
+    #[var]
+    level: u32,
+}
+
+#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+pub struct Particle {
+    #[var]
+    pub id: i32,
+    pub data: ParticleData,
+}
+
+#[derive(Clone, Debug)]
+pub enum ParticleData {
+    AmbientEntityEffect,
+    AngryVillager,
+    Block(BlockParticle),
+    BlockMarker(BlockParticle),
+    Bubble,
+    Cloud,
+    Crit,
+    DamageIndicator,
+    DragonBreath,
+    DrippingLava,
+    FallingLava,
+    LandingLava,
+    DrippingWater,
+    FallingWater,
+    Dust(DustParticle),
+    DustColorTransition(DustColorTransitionParticle),
+    Effect,
+    ElderGuardian,
+    EnchantedHit,
+    Enchant,
+    EndRod,
+    EntityEffect,
+    ExplosionEmitter,
+    Explosion,
+    FallingDust(BlockParticle),
+    Firework,
+    Fishing,
+    Flame,
+    SoulFireFlame,
+    Soul,
+    Flash,
+    HappyVillager,
+    Composter,
+    Heart,
+    InstantEffect,
+    Item(ItemParticle),
+    Vibration(VibrationParticle),
+    ItemSlime,
+    ItemSnowball,
+    LargeSmoke,
+    Lava,
+    Mycelium,
+    Note,
+    Poof,
+    Portal,
+    Rain,
+    Smoke,
+    Sneeze,
+    Spit,
+    SquidInk,
+    SweepAttack,
+    TotemOfUndying,
+    Underwater,
+    Splash,
+    Witch,
+    BubblePop,
+    CurrentDown,
+    BubbleColumnUp,
+    Nautilus,
+    Dolphin,
+    CampfireCozySmoke,
+    CampfireSignalSmoke,
+    DrippingHoney,
+    FallingHoney,
+    LandingHoney,
+    FallingNectar,
+    FallingSporeBlossom,
+    Ash,
+    CrimsonSpore,
+    WarpedSpore,
+    SporeBlossomAir,
+    DrippingObsidianTear,
+    FallingObsidianTear,
+    LandingObsidianTear,
+    ReversePortal,
+    WhiteAsh,
+    SmallFlame,
+    Snowflake,
+    DrippingDripstoneLava,
+    FallingDripstoneLava,
+    DrippingDripstoneWater,
+    FallingDripstoneWater,
+    GlowSquidInk,
+    Glow,
+    WaxOn,
+    WaxOff,
+    ElectricSpark,
+    Scrape,
+}
+
+#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+pub struct BlockParticle {
+    #[var]
+    pub block_state: i32,
+}
+#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+pub struct DustParticle {
+    /// Red value, 0-1
+    pub red: f32,
+    /// Green value, 0-1
+    pub green: f32,
+    /// Blue value, 0-1
+    pub blue: f32,
+    /// The scale, will be clamped between 0.01 and 4.
+    pub scale: f32,
+}
+
+#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+pub struct DustColorTransitionParticle {
+    /// Red value, 0-1
+    pub from_red: f32,
+    /// Green value, 0-1
+    pub from_green: f32,
+    /// Blue value, 0-1
+    pub from_blue: f32,
+    /// The scale, will be clamped between 0.01 and 4.
+    pub scale: f32,
+    /// Red value, 0-1
+    pub to_red: f32,
+    /// Green value, 0-1
+    pub to_green: f32,
+    /// Blue value, 0-1
+    pub to_blue: f32,
+}
+
+#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+pub struct ItemParticle {
+    pub item: Slot,
+}
+
+#[derive(Debug, Clone, McBufReadable, McBufWritable)]
+pub struct VibrationParticle {
+    pub origin: BlockPos,
+    pub position_type: String,
+    pub block_position: BlockPos,
+    #[var]
+    pub entity_id: u32,
+    #[var]
+    pub ticks: u32,
+}
+
+impl McBufReadable for ParticleData {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let id = buf.read_varint()?;
+        Ok(match id {
+            0 => ParticleData::AmbientEntityEffect,
+            1 => ParticleData::AngryVillager,
+            2 => ParticleData::Block(BlockParticle::read_into(buf)?),
+            3 => ParticleData::BlockMarker(BlockParticle::read_into(buf)?),
+            4 => ParticleData::Bubble,
+            5 => ParticleData::Cloud,
+            6 => ParticleData::Crit,
+            7 => ParticleData::DamageIndicator,
+            8 => ParticleData::DragonBreath,
+            9 => ParticleData::DrippingLava,
+            10 => ParticleData::FallingLava,
+            11 => ParticleData::LandingLava,
+            12 => ParticleData::DrippingWater,
+            13 => ParticleData::FallingWater,
+            14 => ParticleData::Dust(DustParticle::read_into(buf)?),
+            15 => ParticleData::DustColorTransition(DustColorTransitionParticle::read_into(buf)?),
+            16 => ParticleData::Effect,
+            17 => ParticleData::ElderGuardian,
+            18 => ParticleData::EnchantedHit,
+            19 => ParticleData::Enchant,
+            20 => ParticleData::EndRod,
+            21 => ParticleData::EntityEffect,
+            22 => ParticleData::ExplosionEmitter,
+            23 => ParticleData::Explosion,
+            24 => ParticleData::FallingDust(BlockParticle::read_into(buf)?),
+            25 => ParticleData::Firework,
+            26 => ParticleData::Fishing,
+            27 => ParticleData::Flame,
+            28 => ParticleData::SoulFireFlame,
+            29 => ParticleData::Soul,
+            30 => ParticleData::Flash,
+            31 => ParticleData::HappyVillager,
+            32 => ParticleData::Composter,
+            33 => ParticleData::Heart,
+            34 => ParticleData::InstantEffect,
+            35 => ParticleData::Item(ItemParticle::read_into(buf)?),
+            36 => ParticleData::Vibration(VibrationParticle::read_into(buf)?),
+            37 => ParticleData::ItemSlime,
+            38 => ParticleData::ItemSnowball,
+            39 => ParticleData::LargeSmoke,
+            40 => ParticleData::Lava,
+            41 => ParticleData::Mycelium,
+            42 => ParticleData::Note,
+            43 => ParticleData::Poof,
+            44 => ParticleData::Portal,
+            45 => ParticleData::Rain,
+            46 => ParticleData::Smoke,
+            47 => ParticleData::Sneeze,
+            48 => ParticleData::Spit,
+            49 => ParticleData::SquidInk,
+            50 => ParticleData::SweepAttack,
+            51 => ParticleData::TotemOfUndying,
+            52 => ParticleData::Underwater,
+            53 => ParticleData::Splash,
+            54 => ParticleData::Witch,
+            55 => ParticleData::BubblePop,
+            56 => ParticleData::CurrentDown,
+            57 => ParticleData::BubbleColumnUp,
+            58 => ParticleData::Nautilus,
+            59 => ParticleData::Dolphin,
+            60 => ParticleData::CampfireCozySmoke,
+            61 => ParticleData::CampfireSignalSmoke,
+            62 => ParticleData::DrippingHoney,
+            63 => ParticleData::FallingHoney,
+            64 => ParticleData::LandingHoney,
+            65 => ParticleData::FallingNectar,
+            66 => ParticleData::FallingSporeBlossom,
+            67 => ParticleData::Ash,
+            68 => ParticleData::CrimsonSpore,
+            69 => ParticleData::WarpedSpore,
+            70 => ParticleData::SporeBlossomAir,
+            71 => ParticleData::DrippingObsidianTear,
+            72 => ParticleData::FallingObsidianTear,
+            73 => ParticleData::LandingObsidianTear,
+            74 => ParticleData::ReversePortal,
+            75 => ParticleData::WhiteAsh,
+            76 => ParticleData::SmallFlame,
+            77 => ParticleData::Snowflake,
+            78 => ParticleData::DrippingDripstoneLava,
+            79 => ParticleData::FallingDripstoneLava,
+            80 => ParticleData::DrippingDripstoneWater,
+            81 => ParticleData::FallingDripstoneWater,
+            82 => ParticleData::GlowSquidInk,
+            83 => ParticleData::Glow,
+            84 => ParticleData::WaxOn,
+            85 => ParticleData::WaxOff,
+            86 => ParticleData::ElectricSpark,
+            87 => ParticleData::Scrape,
+            _ => return Err(format!("Unknown particle id: {}", id)),
+        })
+    }
+}
+
+impl McBufWritable for ParticleData {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        todo!()
+    }
+}
diff --git a/azalea-protocol/src/mc_buf/mod.rs b/azalea-protocol/src/mc_buf/mod.rs
index debf2991..94e4af0b 100755..100644
--- a/azalea-protocol/src/mc_buf/mod.rs
+++ b/azalea-protocol/src/mc_buf/mod.rs
@@ -1,12 +1,14 @@
 //! Utilities for reading and writing for the Minecraft protocol
 
+mod definitions;
 mod read;
 mod write;
 
+pub use definitions::{BitSet, EntityMetadata, UnsizedByteArray};
 use packet_macros::{McBufReadable, McBufWritable};
-pub use read::{read_varint_async, McBufReadable, McBufVarintReadable, Readable};
+pub use read::{read_varint_async, McBufReadable, McBufVarReadable, Readable};
 use std::ops::Deref;
-pub use write::{McBufVarintWritable, McBufWritable, Writable};
+pub use write::{McBufVarWritable, McBufWritable, Writable};
 
 // const DEFAULT_NBT_QUOTA: u32 = 2097152;
 const MAX_STRING_LENGTH: u16 = 32767;
@@ -16,43 +18,6 @@ const MAX_STRING_LENGTH: u16 = 32767;
 
 // TODO: have a definitions.rs in mc_buf that contains UnsizedByteArray and BitSet
 
-/// A Vec<u8> that isn't prefixed by a VarInt with the size.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UnsizedByteArray(Vec<u8>);
-
-impl Deref for UnsizedByteArray {
-    type Target = Vec<u8>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl From<Vec<u8>> for UnsizedByteArray {
-    fn from(vec: Vec<u8>) -> Self {
-        Self(vec)
-    }
-}
-
-impl From<&str> for UnsizedByteArray {
-    fn from(s: &str) -> Self {
-        Self(s.as_bytes().to_vec())
-    }
-}
-
-/// Represents Java's BitSet, a list of bits.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, McBufReadable, McBufWritable)]
-pub struct BitSet {
-    data: Vec<u64>,
-}
-
-// the Index trait requires us to return a reference, but we can't do that
-impl BitSet {
-    pub fn index(&self, index: usize) -> bool {
-        (self.data[index / 64] & (1u64 << (index % 64))) != 0
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/azalea-protocol/src/mc_buf/read.rs b/azalea-protocol/src/mc_buf/read.rs
index a8c44bdf..ebafad92 100755..100644
--- a/azalea-protocol/src/mc_buf/read.rs
+++ b/azalea-protocol/src/mc_buf/read.rs
@@ -6,7 +6,7 @@ use azalea_core::{
 };
 use byteorder::{ReadBytesExt, BE};
 use serde::Deserialize;
-use std::io::Read;
+use std::{collections::HashMap, hash::Hash, io::Read};
 use tokio::io::{AsyncRead, AsyncReadExt};
 use uuid::Uuid;
 
@@ -236,11 +236,11 @@ where
     fn read_into(buf: &mut impl Read) -> Result<Self, String>;
 }
 
-pub trait McBufVarintReadable
+pub trait McBufVarReadable
 where
     Self: Sized,
 {
-    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String>;
+    fn var_read_into(buf: &mut impl Read) -> Result<Self, String>;
 }
 
 impl McBufReadable for i32 {
@@ -249,26 +249,37 @@ impl McBufReadable for i32 {
     }
 }
 
-impl McBufVarintReadable for i32 {
-    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String> {
+impl McBufVarReadable for i32 {
+    fn var_read_into(buf: &mut impl Read) -> Result<Self, String> {
         buf.read_varint()
     }
 }
 
-impl<T: McBufVarintReadable> McBufVarintReadable for Vec<T> {
-    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String> {
-        let length = u32::varint_read_into(buf)?;
-        let mut vec = Vec::with_capacity(length as usize);
-        for _ in 0..length {
-            vec.push(T::varint_read_into(buf)?);
+impl McBufVarReadable for i64 {
+    // fast varints modified from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L54
+    fn var_read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let mut buffer = [0];
+        let mut ans = 0;
+        for i in 0..8 {
+            buf.read_exact(&mut buffer)
+                .map_err(|_| "Invalid VarLong".to_string())?;
+            ans |= ((buffer[0] & 0b0111_1111) as i64) << 7 * i;
+            if buffer[0] & 0b1000_0000 == 0 {
+                break;
+            }
         }
-        Ok(vec)
+        Ok(ans)
+    }
+}
+impl McBufVarReadable for u64 {
+    fn var_read_into(buf: &mut impl Read) -> Result<Self, String> {
+        i64::var_read_into(buf).map(|i| i as u64)
     }
 }
 
 impl McBufReadable for UnsizedByteArray {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
-        Ok(UnsizedByteArray(buf.read_bytes()?))
+        Ok(buf.read_bytes()?.into())
     }
 }
 
@@ -283,6 +294,17 @@ impl<T: McBufReadable + Send> McBufReadable for Vec<T> {
     }
 }
 
+impl<K: McBufReadable + Send + Eq + Hash, V: McBufReadable + Send> McBufReadable for HashMap<K, V> {
+    default fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let length = buf.read_varint()? as usize;
+        let mut contents = HashMap::with_capacity(length);
+        for _ in 0..length {
+            contents.insert(K::read_into(buf)?, V::read_into(buf)?);
+        }
+        Ok(contents)
+    }
+}
+
 impl McBufReadable for Vec<u8> {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
         buf.read_byte_array()
@@ -311,8 +333,8 @@ impl McBufReadable for u32 {
 }
 
 // u32 varint
-impl McBufVarintReadable for u32 {
-    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String> {
+impl McBufVarReadable for u32 {
+    fn var_read_into(buf: &mut impl Read) -> Result<Self, String> {
         buf.read_varint().map(|i| i as u32)
     }
 }
@@ -332,12 +354,24 @@ impl McBufReadable for i16 {
 }
 
 // u16 varint
-impl McBufVarintReadable for u16 {
-    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String> {
+impl McBufVarReadable for u16 {
+    fn var_read_into(buf: &mut impl Read) -> Result<Self, String> {
         buf.read_varint().map(|i| i as u16)
     }
 }
 
+// Vec<T> varint
+impl<T: McBufVarReadable> McBufVarReadable for Vec<T> {
+    fn var_read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let length = buf.read_varint()? as usize;
+        let mut contents = Vec::with_capacity(length);
+        for _ in 0..length {
+            contents.push(T::var_read_into(buf)?);
+        }
+        Ok(contents)
+    }
+}
+
 // i64
 impl McBufReadable for i64 {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
index cc5f2284..7fe61752 100755..100644
--- a/azalea-protocol/src/mc_buf/write.rs
+++ b/azalea-protocol/src/mc_buf/write.rs
@@ -5,7 +5,7 @@ use azalea_core::{
     serializable_uuid::SerializableUuid, BlockPos, Direction, Slot,
 };
 use byteorder::{BigEndian, WriteBytesExt};
-use std::io::Write;
+use std::{collections::HashMap, io::Write};
 use uuid::Uuid;
 
 pub trait Writable: Write {
@@ -146,8 +146,8 @@ pub trait McBufWritable {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }
 
-pub trait McBufVarintWritable {
-    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
+pub trait McBufVarWritable {
+    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
 }
 
 impl McBufWritable for i32 {
@@ -156,8 +156,8 @@ impl McBufWritable for i32 {
     }
 }
 
-impl McBufVarintWritable for i32 {
-    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+impl McBufVarWritable for i32 {
+    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_varint(*self)
     }
 }
@@ -168,14 +168,24 @@ impl McBufWritable for UnsizedByteArray {
     }
 }
 
-// TODO: use specialization when that gets stabilized into rust
-// to optimize for Vec<u8> byte arrays
 impl<T: McBufWritable> McBufWritable for Vec<T> {
     default fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_list(self, |buf, i| T::write_into(i, buf))
     }
 }
 
+impl<K: McBufWritable, V: McBufWritable> McBufWritable for HashMap<K, V> {
+    default fn 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.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)
@@ -204,16 +214,32 @@ impl McBufWritable for u32 {
 }
 
 // u32 varint
-impl McBufVarintWritable for u32 {
-    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        i32::varint_write_into(&(*self as i32), buf)
+impl McBufVarWritable for u32 {
+    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        i32::var_write_into(&(*self as i32), buf)
     }
 }
 
-// Vec<T> varint
-impl<T: McBufVarintWritable> McBufVarintWritable for Vec<T> {
-    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        buf.write_list(self, |buf, i| i.varint_write_into(buf))
+impl McBufVarWritable for i64 {
+    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        let mut buffer = [0];
+        let mut cnt = 0;
+        let mut value = *self;
+        while value != 0 {
+            buffer[0] = (value & 0b0111_1111) as u8;
+            value = (value >> 7) & (i64::max_value() >> 6);
+            if value != 0 {
+                buffer[0] |= 0b1000_0000;
+            }
+            cnt += buf.write(&mut buffer)?;
+        }
+        Ok(())
+    }
+}
+
+impl McBufVarWritable for u64 {
+    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        i64::var_write_into(&(*self as i64), buf)
     }
 }
 
@@ -225,9 +251,20 @@ impl McBufWritable for u16 {
 }
 
 // u16 varint
-impl McBufVarintWritable for u16 {
-    fn varint_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
-        i32::varint_write_into(&(*self as i32), buf)
+impl McBufVarWritable for u16 {
+    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        i32::var_write_into(&(*self as i32), buf)
+    }
+}
+
+// Vec<T> varint
+impl<T: McBufVarWritable> McBufVarWritable for Vec<T> {
+    fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        u32::var_write_into(&(self.len() as u32), buf)?;
+        for i in self {
+            i.var_write_into(buf)?;
+        }
+        Ok(())
     }
 }