tag registry (#350)

- add Tags extractor
- add tags.json to extracted
- send `SynchronizeTagsS2c` packet on join
- fix encode

## Description

Adds a `TagsRegistry` resource that contains all the information needed
to build and send `SynchronizeTagsS2c` on join.

closes #349

Author: dyc3

crates/valence_client/src/lib.rs

@@ -67,7 +67,7 @@ use valence_instance::packet::{
     ChunkLoadDistanceS2c, ChunkRenderDistanceCenterS2c, UnloadChunkS2c,
 };
 use valence_instance::{ClearInstanceChangesSet, Instance, WriteUpdatePacketsToInstancesSet};
-use valence_registry::{RegistryCodec, RegistryCodecSet};
+use valence_registry::{RegistryCodec, RegistryCodecSet, TagsRegistry};
 
 pub mod action;
 pub mod chat;
@@ -678,6 +678,7 @@ struct ClientJoinQuery {
 
 fn initial_join(
     codec: Res<RegistryCodec>,
+    tags: Res<TagsRegistry>,
     mut clients: Query<ClientJoinQuery, Added<Client>>,
     instances: Query<&Instance>,
     mut commands: Commands,
@@ -724,6 +725,8 @@ fn initial_join(
             last_death_location,
         });
 
+        q.client.enc.append_bytes(tags.sync_tags_packet());
+
         /*
         // TODO: enable all the features?
         q.client.write_packet(&FeatureFlags {

crates/valence_core/src/lib.rs

@@ -142,7 +142,7 @@ impl Default for CoreSettings {
 }
 
 /// Contains global server state accessible as a [`Resource`].
-#[derive(Resource)]
+#[derive(Resource, Default)]
 pub struct Server {
     /// Incremented on every tick.
     current_tick: i64,

crates/valence_core/src/protocol/packet.rs

@@ -1372,26 +1372,3 @@ pub mod map {
         }
     }
 }
-
-// TODO: Move this to valence_registry?
-pub mod synchronize_tags {
-    use super::*;
-
-    #[derive(Clone, Debug, Encode, Decode, Packet)]
-    #[packet(id = packet_id::SYNCHRONIZE_TAGS_S2C)]
-    pub struct SynchronizeTagsS2c<'a> {
-        pub tags: Vec<TagGroup<'a>>,
-    }
-
-    #[derive(Clone, PartialEq, Eq, Debug, Encode, Decode)]
-    pub struct TagGroup<'a> {
-        pub kind: Ident<Cow<'a, str>>,
-        pub tags: Vec<Tag<'a>>,
-    }
-
-    #[derive(Clone, PartialEq, Eq, Debug, Encode, Decode)]
-    pub struct Tag<'a> {
-        pub name: Ident<Cow<'a, str>>,
-        pub entries: Vec<VarInt>,
-    }
-}

crates/valence_core/src/protocol/var_int.rs

@@ -2,12 +2,13 @@ use std::io::{Read, Write};
 
 use anyhow::bail;
 use byteorder::ReadBytesExt;
+use serde::Deserialize;
 use thiserror::Error;
 
 use crate::protocol::{Decode, Encode};
 
 /// An `i32` encoded with variable length.
-#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Deserialize)]
 #[repr(transparent)]
 pub struct VarInt(pub i32);
 

crates/valence_registry/Cargo.toml

@@ -8,4 +8,6 @@ tracing.workspace = true
 valence_core.workspace = true
 valence_nbt.workspace = true
 bevy_ecs.workspace = true
-bevy_app.workspace = true
+bevy_app.workspace = true
+serde.workspace = true
+serde_json.workspace = true

crates/valence_registry/src/lib.rs

@@ -25,6 +25,10 @@ use tracing::error;
 use valence_core::ident::Ident;
 use valence_nbt::{compound, Compound, List, Value};
 
+mod tags;
+
+pub use tags::*;
+
 pub struct RegistryPlugin;
 
 /// The [`SystemSet`] where the [`RegistryCodec`] cache is rebuilt. Systems that
@@ -35,8 +39,11 @@ pub struct RegistryCodecSet;
 impl Plugin for RegistryPlugin {
     fn build(&self, app: &mut bevy_app::App) {
         app.init_resource::<RegistryCodec>()
+            .init_resource::<TagsRegistry>()
             .configure_set(RegistryCodecSet.in_base_set(CoreSet::PostUpdate))
-            .add_system(cache_registry_codec.in_set(RegistryCodecSet));
+            .add_startup_system(init_tags_registry.in_set(RegistryCodecSet))
+            .add_system(cache_registry_codec.in_set(RegistryCodecSet))
+            .add_system(cache_tags_packet.in_set(RegistryCodecSet));
     }
 }
 

crates/valence_registry/src/tags.rs

@@ -0,0 +1,84 @@
+use std::borrow::Cow;
+
+use bevy_ecs::prelude::*;
+use serde::Deserialize;
+use valence_core::ident::Ident;
+use valence_core::protocol::encode::{PacketWriter, WritePacket};
+use valence_core::protocol::var_int::VarInt;
+use valence_core::protocol::{packet_id, Decode, Encode, Packet};
+use valence_core::Server;
+
+#[derive(Clone, Debug, Encode, Decode, Packet)]
+#[packet(id = packet_id::SYNCHRONIZE_TAGS_S2C)]
+pub struct SynchronizeTagsS2c<'a> {
+    pub registries: Cow<'a, [Registry]>,
+}
+
+#[derive(Debug, Resource, Default)]
+pub struct TagsRegistry {
+    pub registries: Vec<Registry>,
+    cached_packet: Vec<u8>,
+}
+
+#[derive(Debug, Deserialize, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct Registry {
+    pub registry: Ident<String>,
+    pub tags: Vec<TagEntry>,
+}
+
+#[derive(Debug, Deserialize, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct TagEntry {
+    pub name: Ident<String>,
+    pub entries: Vec<VarInt>,
+}
+
+impl<'a> TagsRegistry {
+    pub(crate) fn build_synchronize_tags(&'a self) -> SynchronizeTagsS2c<'a> {
+        SynchronizeTagsS2c {
+            registries: Cow::Borrowed(&self.registries),
+        }
+    }
+
+    pub fn sync_tags_packet(&self) -> &Vec<u8> {
+        &self.cached_packet
+    }
+}
+
+pub(crate) fn init_tags_registry(mut tags: ResMut<TagsRegistry>) {
+    let registries =
+        serde_json::from_str::<Vec<Registry>>(include_str!("../../../extracted/tags.json"))
+            .expect("tags.json is invalid");
+    tags.registries = registries;
+}
+
+pub(crate) fn cache_tags_packet(server: Res<Server>, tags: ResMut<TagsRegistry>) {
+    if tags.is_changed() {
+        let tags = tags.into_inner();
+        let packet = tags.build_synchronize_tags();
+        let mut bytes = vec![];
+        let mut scratch = vec![];
+        let mut writer =
+            PacketWriter::new(&mut bytes, server.compression_threshold(), &mut scratch);
+        writer.write_packet(&packet);
+        tags.cached_packet = bytes;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::RegistryPlugin;
+
+    #[test]
+    fn smoke_test() {
+        let mut app = bevy_app::App::new();
+        app.add_plugin(RegistryPlugin);
+        app.insert_resource(Server::default());
+        app.update();
+
+        let tags_registry = app.world.get_resource::<TagsRegistry>().unwrap();
+        let packet = tags_registry.build_synchronize_tags();
+        assert!(!packet.registries.is_empty());
+        assert!(!tags_registry.cached_packet.is_empty());
+    }
+}