add serverbound packets

haya_collection/src/lib.rs

@@ -4,7 +4,7 @@ extern crate alloc;
 
 use alloc::boxed::Box;
 use alloc::vec::Vec;
-use mser::{Error, Read, Reader, V21, Write, Writer};
+use mser::{Error, Read, Reader, V21, Write, Writer, read_v21_len};
 
 pub enum List<'a, T: 'a, const MAX: usize = { usize::MAX }> {
     Borrowed(&'a [T]),
@@ -95,10 +95,7 @@ pub fn capacity_fix(len: usize) -> usize {
 
 impl<'a, T: Read<'a>, const MAX: usize> Read<'a> for List<'a, T, MAX> {
     fn read(buf: &mut Reader<'a>) -> Result<Self, Error> {
-        let len = V21::read(buf)?.0 as usize;
-        if len > MAX {
-            return Err(Error);
-        }
+        let len = read_v21_len(buf, MAX)?;
         let mut vec = Vec::with_capacity(capacity_fix(len));
         for _ in 0..len {
             vec.push(T::read(buf)?);
@@ -135,10 +132,7 @@ impl<'a, K: Write + 'a, V: Write + 'a, const MAX: usize> Write for Map<'a, K, V,
 
 impl<'a, K: Read<'a>, V: Read<'a>, const MAX: usize> Read<'a> for Map<'a, K, V, MAX> {
     fn read(buf: &mut Reader<'a>) -> Result<Self, Error> {
-        let len = V21::read(buf)?.0 as usize;
-        if len > MAX {
-            return Err(Error);
-        }
+        let len = read_v21_len(buf, MAX)?;
         let mut vec = Vec::with_capacity(capacity_fix(len));
         for _ in 0..len {
             let k = K::read(buf)?;
@@ -179,25 +173,3 @@ impl<'a, T: Read<'a>> Read<'a> for Cow<'a, T> {
         Ok(Self::Owned(Box::new(T::read(buf)?)))
     }
 }
-
-#[derive(Debug, Clone, Copy)]
-pub struct FixedByteArray<'a, const L: usize>(pub &'a [u8; L]);
-
-impl<'a, const L: usize> Read<'a> for FixedByteArray<'a, L> {
-    fn read(buf: &mut Reader<'a>) -> Result<Self, Error> {
-        match buf.read_array() {
-            Ok(x) => Ok(Self(x)),
-            Err(e) => Err(e),
-        }
-    }
-}
-
-impl<'a, const L: usize> Write for FixedByteArray<'a, L> {
-    unsafe fn write(&self, w: &mut Writer) {
-        unsafe { w.write(self.0) }
-    }
-
-    fn len_s(&self) -> usize {
-        self.0.len()
-    }
-}

haya_math/src/lib.rs

@@ -325,8 +325,8 @@ impl From<Vec3> for LpVec3 {
 pub struct ByteAngle(pub u8);
 
 impl ByteAngle {
-    pub fn new(f: f32) -> ByteAngle {
-        ByteAngle(libm::floorf(f * 256.0 / 360.0) as u8)
+    pub fn new(f: f32) -> Self {
+        Self(libm::floorf(f * 256.0 / 360.0) as u8)
     }
 
     pub fn to_degrees(self) -> f32 {
@@ -562,6 +562,32 @@ pub enum Direction {
     East,
 }
 
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct ByteDirection(pub Direction);
+
+impl<'a> Read<'a> for ByteDirection {
+    fn read(buf: &mut Reader<'a>) -> Result<Self, Error> {
+        Ok(Self(match buf.read_byte()? {
+            1 => Direction::Up,
+            2 => Direction::North,
+            3 => Direction::South,
+            4 => Direction::West,
+            5 => Direction::East,
+            _ => Direction::Down,
+        }))
+    }
+}
+
+impl Write for ByteDirection {
+    unsafe fn write(&self, w: &mut Writer) {
+        unsafe { w.write_byte(self.0 as u8) }
+    }
+
+    fn len_s(&self) -> usize {
+        1
+    }
+}
+
 impl<'a> Read<'a> for Direction {
     fn read(buf: &mut Reader<'a>) -> Result<Self, Error> {
         Ok(match V21::read(buf)?.0 {

haya_nbt/src/compound.rs

@@ -7,52 +7,31 @@ use haya_mutf8::{as_mutf8_ascii, decode_mutf8_len};
 use haya_str::HayaStr;
 use mser::{Error, Read, Reader, Write, Writer};
 
-enum CowVec {
-    Thin(HayaStr),
-    Heap(Vec<u8>),
-}
-
 impl<'a> Read<'a> for Name {
     fn read(buf: &mut Reader<'a>) -> Result<Self, Error> {
         let len = u16::read(buf)? as usize;
         let data = buf.read_slice(len)?;
         if let Some(x) = as_mutf8_ascii(data) {
-            Ok(Self::new(x))
+            unsafe { Ok(Self::new(x)) }
         } else {
             let len = decode_mutf8_len(data)?;
-            let mut ptr = if len <= haya_str::MAX {
-                CowVec::Thin(HayaStr::new())
-            } else {
-                CowVec::Heap(Vec::with_capacity(len))
-            };
+            let mut vec = Vec::with_capacity(len);
             unsafe {
-                mser::write_unchecked(
-                    match &mut ptr {
-                        CowVec::Thin(s) => s.as_mut_ptr(),
-                        CowVec::Heap(x) => x.as_mut_ptr(),
-                    },
-                    &(DecodeMutf8(data, len)),
-                );
-                match ptr {
-                    CowVec::Thin(mut s) => {
-                        s.set_len(len);
-                        Ok(Self::Thin(s))
-                    }
-                    CowVec::Heap(mut x) => {
-                        x.set_len(len);
-                        Ok(Self::Heap(String::from_utf8_unchecked(x).into_boxed_str()))
-                    }
-                }
+                mser::write_unchecked(vec.as_mut_ptr(), &(DecodeMutf8(data, len)));
+                vec.set_len(len);
+                Ok(Self(crate::Inner::Heap(
+                    String::from_utf8_unchecked(vec).into_boxed_str(),
+                )))
             }
         }
     }
 }
 
 impl AsRef<str> for Name {
     fn as_ref(&self) -> &str {
-        match self {
-            Self::Thin(x) => x,
-            Self::Heap(x) => x,
+        match &self.0 {
+            crate::Inner::Thin(x) => x,
+            crate::Inner::Heap(x) => x,
         }
     }
 }
@@ -66,10 +45,10 @@ impl core::ops::Deref for Name {
 }
 
 impl Name {
-    pub fn new(s: &str) -> Self {
+    pub(crate) unsafe fn new(s: &str) -> Self {
         match HayaStr::copy_from(s) {
-            Ok(x) => Self::Thin(x),
-            Err(_) => Self::Heap(s.to_owned().into_boxed_str()),
+            Ok(x) => Self(crate::Inner::Thin(x)),
+            Err(_) => Self(crate::Inner::Heap(s.to_owned().into_boxed_str())),
         }
     }
 }

haya_nbt/src/lib.rs

@@ -53,7 +53,10 @@ pub struct Compound(Vec<(Name, Tag)>);
 pub struct CompoundStringify(pub Compound);
 
 #[derive(Clone, Debug)]
-pub enum Name {
+pub struct Name(Inner);
+
+#[derive(Clone, Debug)]
+enum Inner {
     Thin(HayaStr),
     Heap(Box<str>),
 }

haya_nbt/src/string.rs

@@ -1,4 +1,4 @@
-use crate::{Error, Name, RawStringTag, Read, RefStringTag, StringTag, Write, Writer};
+use crate::{Error, Inner, Name, RawStringTag, Read, RefStringTag, StringTag, Write, Writer};
 use alloc::borrow::ToOwned;
 use alloc::vec::Vec;
 use haya_mutf8::{as_mutf8_ascii, decode_mutf8, decode_mutf8_len, encode_mutf8, encode_mutf8_len};
@@ -129,21 +129,27 @@ impl Write for Name {
     #[inline]
     unsafe fn write(&self, w: &mut Writer) {
         unsafe {
-            if let Some(x) = RawStringTag::new(self.as_bytes()) {
-                x.write(w);
-            } else {
-                (encode_mutf8_len(self) as u16).write(w);
-                encode_mutf8(self, w);
+            match &self.0 {
+                Inner::Thin(direct) => RawStringTag::new_unchecked(direct).write(w),
+                Inner::Heap(x) => match RawStringTag::new(x.as_bytes()) {
+                    Some(x) => x.write(w),
+                    None => {
+                        (encode_mutf8_len(self) as u16).write(w);
+                        encode_mutf8(self, w);
+                    }
+                },
             }
         }
     }
 
     #[inline]
     fn len_s(&self) -> usize {
-        if let Some(x) = RawStringTag::new(self.as_bytes()) {
-            x.len_s()
-        } else {
-            encode_mutf8_len(self) + 2
+        match &self.0 {
+            Inner::Thin(direct) => RawStringTag::new_unchecked(direct).len_s(),
+            Inner::Heap(x) => match RawStringTag::new(x.as_bytes()) {
+                Some(x) => x.len_s(),
+                None => encode_mutf8_len(self) + 2,
+            },
         }
     }
 }

haya_palette/Cargo.toml

@@ -10,3 +10,5 @@ edition.workspace = true
 [dependencies]
 mser = { workspace = true }
 minecraft_data = { workspace = true }
+
+hashbrown = { version = "0", default-features = false }