start implementing data driven registries

Author: mat-1

Cargo.lock

@@ -386,3 +386,9 @@ where
         Ok(Box::new(T::azalea_read(buf)?))
     }
 }
+
+impl<A: AzaleaRead, B: AzaleaRead> AzaleaRead for (A, B) {
+    fn azalea_read(buf: &mut Cursor<&[u8]>) -> Result<Self, BufReadError> {
+        Ok((A::azalea_read(buf)?, B::azalea_read(buf)?))
+    }
+}

azalea-buf/src/read.rs

@@ -1,14 +1,13 @@
-use std::{collections::HashMap, io::Write};
+use std::{
+    collections::HashMap,
+    io::{self, Write},
+};
 
 use byteorder::{BigEndian, WriteBytesExt};
 
 use super::{UnsizedByteArray, MAX_STRING_LENGTH};
 
-fn write_utf_with_len(
-    buf: &mut impl Write,
-    string: &str,
-    len: usize,
-) -> Result<(), std::io::Error> {
+fn write_utf_with_len(buf: &mut impl Write, string: &str, len: usize) -> Result<(), io::Error> {
     if string.len() > len {
         panic!(
             "String too big (was {} bytes encoded, max {})",
@@ -21,21 +20,21 @@ fn write_utf_with_len(
 }
 
 pub trait AzaleaWrite {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error>;
 }
 
 pub trait AzaleaWriteVar {
-    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error>;
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), io::Error>;
 }
 
 impl AzaleaWrite for i32 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         WriteBytesExt::write_i32::<BigEndian>(buf, *self)
     }
 }
 
 impl AzaleaWriteVar for i32 {
-    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         let mut buffer = [0];
         let mut value = *self;
         if value == 0 {
@@ -54,19 +53,19 @@ impl AzaleaWriteVar for i32 {
 }
 
 impl AzaleaWrite for UnsizedByteArray {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         buf.write_all(self)
     }
 }
 
 impl<T: AzaleaWrite> AzaleaWrite for Vec<T> {
-    default fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    default fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         self[..].azalea_write(buf)
     }
 }
 
 impl<T: AzaleaWrite> AzaleaWrite for [T] {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         (self.len() as u32).azalea_write_var(buf)?;
         for item in self {
             T::azalea_write(item, buf)?;
@@ -76,7 +75,7 @@ impl<T: AzaleaWrite> AzaleaWrite for [T] {
 }
 
 impl<K: AzaleaWrite, V: AzaleaWrite> AzaleaWrite for HashMap<K, V> {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         u32::azalea_write_var(&(self.len() as u32), buf)?;
         for (key, value) in self {
             key.azalea_write(buf)?;
@@ -88,7 +87,7 @@ impl<K: AzaleaWrite, V: AzaleaWrite> AzaleaWrite for HashMap<K, V> {
 }
 
 impl<K: AzaleaWrite, V: AzaleaWriteVar> AzaleaWriteVar for HashMap<K, V> {
-    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         u32::azalea_write_var(&(self.len() as u32), buf)?;
         for (key, value) in self {
             key.azalea_write(buf)?;
@@ -100,38 +99,38 @@ impl<K: AzaleaWrite, V: AzaleaWriteVar> AzaleaWriteVar for HashMap<K, V> {
 }
 
 impl AzaleaWrite for Vec<u8> {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         (self.len() as u32).azalea_write_var(buf)?;
         buf.write_all(self)
     }
 }
 
 impl AzaleaWrite for String {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         write_utf_with_len(buf, self, MAX_STRING_LENGTH.into())
     }
 }
 
 impl AzaleaWrite for &str {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         write_utf_with_len(buf, self, MAX_STRING_LENGTH.into())
     }
 }
 
 impl AzaleaWrite for u32 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         i32::azalea_write(&(*self as i32), buf)
     }
 }
 
 impl AzaleaWriteVar for u32 {
-    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         i32::azalea_write_var(&(*self as i32), buf)
     }
 }
 
 impl AzaleaWriteVar for i64 {
-    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         let mut buffer = [0];
         let mut value = *self;
         if value == 0 {
@@ -150,25 +149,25 @@ impl AzaleaWriteVar for i64 {
 }
 
 impl AzaleaWriteVar for u64 {
-    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         i64::azalea_write_var(&(*self as i64), buf)
     }
 }
 
 impl AzaleaWrite for u16 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         i16::azalea_write(&(*self as i16), buf)
     }
 }
 
 impl AzaleaWriteVar for u16 {
-    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         i32::azalea_write_var(&(*self as i32), buf)
     }
 }
 
 impl<T: AzaleaWriteVar> AzaleaWriteVar for Vec<T> {
-    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         u32::azalea_write_var(&(self.len() as u32), buf)?;
         for i in self {
             i.azalea_write_var(buf)?;
@@ -178,56 +177,56 @@ impl<T: AzaleaWriteVar> AzaleaWriteVar for Vec<T> {
 }
 
 impl AzaleaWrite for u8 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         WriteBytesExt::write_u8(buf, *self)
     }
 }
 
 impl AzaleaWrite for i16 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         WriteBytesExt::write_i16::<BigEndian>(buf, *self)
     }
 }
 
 impl AzaleaWrite for i64 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         WriteBytesExt::write_i64::<BigEndian>(buf, *self)
     }
 }
 
 impl AzaleaWrite for u64 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         i64::azalea_write(&(*self as i64), buf)
     }
 }
 
 impl AzaleaWrite for bool {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         let byte = u8::from(*self);
         byte.azalea_write(buf)
     }
 }
 
 impl AzaleaWrite for i8 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         (*self as u8).azalea_write(buf)
     }
 }
 
 impl AzaleaWrite for f32 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         WriteBytesExt::write_f32::<BigEndian>(buf, *self)
     }
 }
 
 impl AzaleaWrite for f64 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         WriteBytesExt::write_f64::<BigEndian>(buf, *self)
     }
 }
 
 impl<T: AzaleaWrite> AzaleaWrite for Option<T> {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         if let Some(s) = self {
             true.azalea_write(buf)?;
             s.azalea_write(buf)?;
@@ -239,7 +238,7 @@ impl<T: AzaleaWrite> AzaleaWrite for Option<T> {
 }
 
 impl<T: AzaleaWriteVar> AzaleaWriteVar for Option<T> {
-    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write_var(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         if let Some(s) = self {
             true.azalea_write(buf)?;
             s.azalea_write_var(buf)?;
@@ -252,7 +251,7 @@ impl<T: AzaleaWriteVar> AzaleaWriteVar for Option<T> {
 
 // [T; N]
 impl<T: AzaleaWrite, const N: usize> AzaleaWrite for [T; N] {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         for i in self {
             i.azalea_write(buf)?;
         }
@@ -261,23 +260,23 @@ impl<T: AzaleaWrite, const N: usize> AzaleaWrite for [T; N] {
 }
 
 impl AzaleaWrite for simdnbt::owned::NbtTag {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         let mut data = Vec::new();
         self.write(&mut data);
         buf.write_all(&data)
     }
 }
 
 impl AzaleaWrite for simdnbt::owned::NbtCompound {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         let mut data = Vec::new();
         simdnbt::owned::NbtTag::Compound(self.clone()).write(&mut data);
         buf.write_all(&data)
     }
 }
 
 impl AzaleaWrite for simdnbt::owned::Nbt {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         let mut data = Vec::new();
         self.write_unnamed(&mut data);
         buf.write_all(&data)
@@ -288,7 +287,14 @@ impl<T> AzaleaWrite for Box<T>
 where
     T: AzaleaWrite,
 {
-    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
         T::azalea_write(&**self, buf)
     }
 }
+
+impl<A: AzaleaWrite, B: AzaleaWrite> AzaleaWrite for (A, B) {
+    fn azalea_write(&self, buf: &mut impl Write) -> Result<(), io::Error> {
+        self.0.azalea_write(buf)?;
+        self.1.azalea_write(buf)
+    }
+}

azalea-buf/src/write.rs

@@ -9,7 +9,10 @@ use std::{
 
 use azalea_auth::{game_profile::GameProfile, sessionserver::ClientSessionServerError};
 use azalea_chat::FormattedText;
-use azalea_core::{position::Vec3, tick::GameTick};
+use azalea_core::{
+    data_registry::ResolvableDataRegistry, position::Vec3, resource_location::ResourceLocation,
+    tick::GameTick,
+};
 use azalea_entity::{
     indexing::{EntityIdIndex, EntityUuidIndex},
     metadata::Health,
@@ -48,6 +51,7 @@ use bevy_ecs::{
 use bevy_time::TimePlugin;
 use derive_more::Deref;
 use parking_lot::{Mutex, RwLock};
+use simdnbt::owned::NbtCompound;
 use thiserror::Error;
 use tokio::{
     sync::{broadcast, mpsc},
@@ -715,6 +719,52 @@ impl Client {
     pub fn tab_list(&self) -> HashMap<Uuid, PlayerInfo> {
         self.component::<TabList>().deref().clone()
     }
+
+    /// Call the given function with the client's [`RegistryHolder`].
+    ///
+    /// The player's instance (aka world) will be locked during this time, which
+    /// may result in a deadlock if you try to access the instance again while
+    /// in the function.
+    pub fn with_registry_holder<R>(
+        &self,
+        f: impl FnOnce(&azalea_core::registry_holder::RegistryHolder) -> R,
+    ) -> R {
+        let instance = self.world();
+        let registries = &instance.read().registries;
+        f(registries)
+    }
+
+    /// Resolve the given registry to its name.
+    ///
+    /// This is necessary for data-driven registries like [`Enchantment`].
+    ///
+    /// [`Enchantment`]: azalea_registry::Enchantment
+    pub fn resolve_registry_name(
+        &self,
+        registry: &impl ResolvableDataRegistry,
+    ) -> Option<ResourceLocation> {
+        self.with_registry_holder(|registries| registry.resolve_name(registries))
+    }
+    /// Resolve the given registry to its name and data and call the given
+    /// function with it.
+    ///
+    /// This is necessary for data-driven registries like [`Enchantment`].
+    ///
+    /// If you just want the value name, use [`Self::resolve_registry_name`]
+    /// instead.
+    ///
+    /// [`Enchantment`]: azalea_registry::Enchantment
+    pub fn with_resolved_registry<R>(
+        &self,
+        registry: impl ResolvableDataRegistry,
+        f: impl FnOnce(&ResourceLocation, &NbtCompound) -> R,
+    ) -> Option<R> {
+        self.with_registry_holder(|registries| {
+            registry
+                .resolve(registries)
+                .map(|(name, data)| f(name, data))
+        })
+    }
 }
 
 /// The bundle of components that's shared when we're either in the

azalea-client/src/client.rs

@@ -16,6 +16,7 @@ serde = { workspace = true, optional = true }
 simdnbt = { workspace = true }
 tracing = { workspace = true }
 azalea-chat = { path = "../azalea-chat", version = "0.11.0" }
+indexmap = { workspace = true }
 
 [features]
 bevy_ecs = ["dep:bevy_ecs"]