Enchantments (#286)

* start implementing enchants

* store parsed registries

* more work on enchants

* implement deserializer for some entity effects

* mostly working definitions for enchants

* fix tests

* detect equipment changes

* fix errors

* update changelog

* fix some imports

* remove outdated todo

* add basic test for enchants applying attributes

* use git simdnbt

1 files changed, 47 insertions, 33 deletions

diff --git a/azalea-core/src/data_registry.rs b/azalea-core/src/data_registry.rs
index d3fae125..cf82772a 100644
--- a/azalea-core/src/data_registry.rs
+++ b/azalea-core/src/data_registry.rs
@@ -1,47 +1,61 @@
-use std::{io::Cursor, str::FromStr};
-
 use azalea_registry::DataRegistry;
 use simdnbt::owned::NbtCompound;
 
-use crate::{identifier::Identifier, registry_holder::RegistryHolder};
+use crate::{
+    identifier::Identifier,
+    registry_holder::{self, RegistryDeserializesTo, RegistryHolder},
+};
 
 pub trait ResolvableDataRegistry: DataRegistry {
-    fn resolve_name(&self, registries: &RegistryHolder) -> Option<Identifier> {
-        self.resolve(registries).map(|(name, _)| name.clone())
+    type DeserializesTo: RegistryDeserializesTo;
+
+    fn resolve_name<'a>(&self, registries: &'a RegistryHolder) -> Option<&'a Identifier> {
+        // self.resolve(registries).map(|(name, _)| name.clone())
+        registries.protocol_id_to_identifier(Identifier::from(Self::NAME), self.protocol_id())
     }
+
     fn resolve<'a>(
         &self,
         registries: &'a RegistryHolder,
-    ) -> Option<(&'a Identifier, &'a NbtCompound)> {
-        let name_ident = Identifier::from_str(Self::NAME).unwrap_or_else(|_| {
-            panic!(
-                "Name for registry should be a valid Identifier: {}",
-                Self::NAME
-            )
-        });
-        let registry_values = registries.map.get(&name_ident)?;
-        let resolved = registry_values.get_index(self.protocol_id() as usize)?;
-        Some(resolved)
+    ) -> Option<(&'a Identifier, &'a Self::DeserializesTo)> {
+        Self::DeserializesTo::get_for_registry(registries, Self::NAME, self.protocol_id())
     }
+}
 
-    fn resolve_and_deserialize<T: simdnbt::Deserialize>(
-        &self,
-        registries: &RegistryHolder,
-    ) -> Option<Result<(Identifier, T), simdnbt::DeserializeError>> {
-        let (name, value) = self.resolve(registries)?;
-
-        let mut nbt_bytes = Vec::new();
-        value.write(&mut nbt_bytes);
-        let nbt_borrow_compound =
-            simdnbt::borrow::read_compound(&mut Cursor::new(&nbt_bytes)).ok()?;
-        let value = match T::from_compound((&nbt_borrow_compound).into()) {
-            Ok(value) => value,
-            Err(err) => {
-                return Some(Err(err));
+macro_rules! define_deserializes_to {
+    ($($t:ty => $deserializes_to:ty),* $(,)?) => {
+        $(
+            impl ResolvableDataRegistry for $t {
+                type DeserializesTo = $deserializes_to;
             }
-        };
+        )*
+    };
+}
+macro_rules! define_default_deserializes_to {
+    ($($t:ty),* $(,)?) => {
+        $(
+            impl ResolvableDataRegistry for $t {
+                type DeserializesTo = NbtCompound;
+            }
+        )*
+    };
+}
 
-        Some(Ok((name.clone(), value)))
-    }
+define_deserializes_to! {
+    azalea_registry::DimensionType => registry_holder::dimension_type::DimensionTypeElement,
+    azalea_registry::Enchantment => registry_holder::enchantment::EnchantmentData,
+}
+
+define_default_deserializes_to! {
+    azalea_registry::DamageKind,
+    azalea_registry::Dialog,
+    azalea_registry::WolfSoundVariant,
+    azalea_registry::CowVariant,
+    azalea_registry::ChickenVariant,
+    azalea_registry::FrogVariant,
+    azalea_registry::CatVariant,
+    azalea_registry::PigVariant,
+    azalea_registry::PaintingVariant,
+    azalea_registry::WolfVariant,
+    azalea_registry::Biome,
 }
-impl<T: DataRegistry> ResolvableDataRegistry for T {}