[#39] Implement new game tag logic

src/main/java/net/minestom/server/gametag/BlockTag.java

@@ -0,0 +1,55 @@
+package net.minestom.server.gametag;
+
+import net.minestom.server.instance.block.Block;
+import net.minestom.server.registry.Registry;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+public record BlockTag(Registry.TagEntry registry, int id, List<String> stringValue) implements Tag, BlockTags {
+    private static final AtomicInteger INDEX = new AtomicInteger();
+    private static final Function<NamespaceID, Integer> TAG_TO_ID = namespaceID -> Block.fromNamespaceId(namespaceID).id();
+    private static final Registry.Container<Tag> CONTAINER = Registry.createStaticContainer(Registry.Resource.BLOCK_TAGS, BlockTag::createImpl);
+
+    public static final String IDENTIFIER = "minecraft:block";
+
+    public BlockTag(Registry.TagEntry registry) {
+        this(registry, INDEX.getAndIncrement(), registry.values());
+    }
+
+    private static Tag createImpl(String namespace, Registry.Properties properties) {
+        return new BlockTag(Registry.tag(namespace, properties));
+    }
+
+    static Tag get(String namespace) {
+        return CONTAINER.get(namespace);
+    }
+
+    public static @NotNull Collection<Tag> values() {
+        return CONTAINER.values();
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull NamespaceID> tagValues() {
+        var concatinatedTags = stringValue.stream().filter(s -> s.startsWith("#")).toList();
+        var result = new ArrayList<>(stringValue.stream().filter(s -> !s.startsWith("#")).map(NamespaceID::from).toList());
+        concatinatedTags.stream().map(BlockTag::getSafe).filter(Objects::nonNull).map(Tag::tagValues).forEach(result::addAll);
+        return result;
+    }
+
+    @Override
+    public @NotNull Function<NamespaceID, Integer> getMapper() {
+        return TAG_TO_ID;
+    }
+
+    static Tag getSafe(@NotNull String namespace) {
+        return CONTAINER.getSafe(namespace);
+    }
+
+}

src/main/java/net/minestom/server/gametag/EntityTag.java

@@ -0,0 +1,53 @@
+package net.minestom.server.gametag;
+
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.registry.Registry;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+public record EntityTag(Registry.TagEntry registry, int id, List<String> stringValue) implements Tag, EntityTags {
+    private static final AtomicInteger INDEX = new AtomicInteger();
+    private static final Registry.Container<Tag> CONTAINER = Registry.createStaticContainer(Registry.Resource.ENTITY_TYPE_TAGS, EntityTag::createImpl);
+    private static final Function<NamespaceID, Integer> TAG_TO_ID = namespaceID -> Objects.requireNonNull(EntityType.fromNamespaceId(namespaceID)).id();
+
+    public static final String IDENTIFIER = "minecraft:entity_type";
+
+    public EntityTag(Registry.TagEntry registry) {
+        this(registry, INDEX.getAndIncrement(), registry.values());
+    }
+
+    private static Tag createImpl(String namespace, Registry.Properties properties) {
+        return new EntityTag(Registry.tag(namespace, properties));
+    }
+
+    public static Tag get(String namespace) {
+        return CONTAINER.get(namespace);
+    }
+
+    public static @NotNull Collection<Tag> values() {
+        return CONTAINER.values();
+    }
+
+    static Tag getSafe(@NotNull String namespace) {
+        return CONTAINER.getSafe(namespace);
+    }
+    @Override
+    public @NotNull Collection<@NotNull NamespaceID> tagValues() {
+        var concatinatedTags = stringValue.stream().filter(s -> s.startsWith("#")).toList();
+        var result = new ArrayList<>(stringValue.stream().filter(s -> !s.startsWith("#")).map(NamespaceID::from).toList());
+        concatinatedTags.stream().map(EntityTag::getSafe).filter(Objects::nonNull).map(Tag::tagValues).forEach(result::addAll);
+        return result;
+    }
+
+    @Override
+    public @NotNull Function<NamespaceID, Integer> getMapper() {
+        return TAG_TO_ID;
+    }
+}

src/main/java/net/minestom/server/gametag/FluidTag.java

@@ -0,0 +1,54 @@
+package net.minestom.server.gametag;
+
+import net.minestom.server.fluid.Fluid;
+import net.minestom.server.registry.Registry;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+public record FluidTag(Registry.TagEntry registry, int id, List<String> stringValue) implements Tag, FluidTags {
+    private static final AtomicInteger INDEX = new AtomicInteger();
+    private static final Registry.Container<Tag> CONTAINER = Registry.createStaticContainer(Registry.Resource.FLUID_TAGS, FluidTag::createImpl);
+    private static final Function<NamespaceID, Integer> TAG_TO_ID = namespaceID -> Objects.requireNonNull(Fluid.fromNamespaceId(namespaceID)).id();
+
+    public static final String IDENTIFIER = "minecraft:fluid";
+
+    public FluidTag(Registry.TagEntry registry) {
+        this(registry, INDEX.getAndIncrement(), registry.values());
+    }
+
+    private static Tag createImpl(String namespace, Registry.Properties properties) {
+        return new FluidTag(Registry.tag(namespace, properties));
+    }
+
+    public static Tag get(String namespace) {
+        return CONTAINER.get(namespace);
+    }
+
+    public static @NotNull Collection<Tag> values() {
+        return CONTAINER.values();
+    }
+
+    static Tag getSafe(@NotNull String namespace) {
+        return CONTAINER.getSafe(namespace);
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull NamespaceID> tagValues() {
+        var concatinatedTags = stringValue.stream().filter(s -> s.startsWith("#")).toList();
+        var result = new ArrayList<>(stringValue.stream().filter(s -> !s.startsWith("#")).map(NamespaceID::from).toList());
+        concatinatedTags.stream().map(FluidTag::getSafe).filter(Objects::nonNull).map(Tag::tagValues).forEach(result::addAll);
+        return result;
+    }
+
+    @Override
+    public @NotNull Function<NamespaceID, Integer> getMapper() {
+        return TAG_TO_ID;
+    }
+}

src/main/java/net/minestom/server/gametag/GameEventTag.java

@@ -0,0 +1,53 @@
+package net.minestom.server.gametag;
+
+import net.minestom.server.registry.Registry;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+public record GameEventTag(Registry.TagEntry registry, int id, List<String> stringValue) implements Tag, GameEventTags {
+    private static final AtomicInteger INDEX = new AtomicInteger();
+    private static final Registry.Container<Tag> CONTAINER = Registry.createStaticContainer(Registry.Resource.GAMEPLAY_TAGS, GameEventTag::createImpl);
+    private static final Function<NamespaceID, Integer> TAG_TO_ID = namespaceID -> Objects.requireNonNull(GameEventTag.getSafe(namespaceID.asString())).id();
+
+    public static final String IDENTIFIER = "minecraft:game_event";
+
+    public GameEventTag(Registry.TagEntry registry) {
+        this(registry, INDEX.getAndIncrement(), registry.values());
+    }
+
+    private static Tag createImpl(String namespace, Registry.Properties properties) {
+        return new GameEventTag(Registry.tag(namespace, properties));
+    }
+
+    public static Tag get(String namespace) {
+        return CONTAINER.get(namespace);
+    }
+
+    public static @NotNull Collection<Tag> values() {
+        return CONTAINER.values();
+    }
+
+    static Tag getSafe(@NotNull String namespace) {
+        return CONTAINER.getSafe(namespace);
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull NamespaceID> tagValues() {
+        var concatinatedTags = stringValue.stream().filter(s -> s.startsWith("#")).toList();
+        var result = new ArrayList<>(stringValue.stream().filter(s -> !s.startsWith("#")).map(NamespaceID::from).toList());
+        concatinatedTags.stream().map(GameEventTag::getSafe).filter(Objects::nonNull).map(Tag::tagValues).forEach(result::addAll);
+        return result;
+    }
+
+    @Override
+    public @NotNull Function<NamespaceID, Integer> getMapper() {
+        return TAG_TO_ID;
+    }
+}

src/main/java/net/minestom/server/gametag/ItemTag.java

@@ -0,0 +1,53 @@
+package net.minestom.server.gametag;
+
+import net.minestom.server.item.Material;
+import net.minestom.server.registry.Registry;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+public record ItemTag(Registry.TagEntry registry, int id, List<String> stringValue) implements Tag, ItemTags {
+    private static final AtomicInteger INDEX = new AtomicInteger();
+    private static final Registry.Container<Tag> CONTAINER = Registry.createStaticContainer(Registry.Resource.ITEM_TAGS, ItemTag::createImpl);
+    public static final Function<NamespaceID, Integer> TAG_TO_ID = namespaceID -> Objects.requireNonNull(Material.fromNamespaceId(namespaceID)).id();
+
+    public static final String IDENTIFIER = "minecraft:item";
+
+    public ItemTag(Registry.TagEntry registry) {
+        this(registry, INDEX.getAndIncrement(), registry.values());
+    }
+
+    private static Tag createImpl(String namespace, Registry.Properties properties) {
+        return new ItemTag(Registry.tag(namespace, properties));
+    }
+
+    public static Tag get(String namespace) {
+        return CONTAINER.get(namespace);
+    }
+
+    public static @NotNull Collection<Tag> values() {
+        return CONTAINER.values();
+    }
+
+    static Tag getSafe(@NotNull String namespace) {
+        return CONTAINER.getSafe(namespace);
+    }
+    @Override
+    public @NotNull Collection<@NotNull NamespaceID> tagValues() {
+        var concatinatedTags = stringValue.stream().filter(s -> s.startsWith("#")).toList();
+        var result = new ArrayList<>(stringValue.stream().filter(s -> !s.startsWith("#")).map(NamespaceID::from).toList());
+        concatinatedTags.stream().map(ItemTag::getSafe).filter(Objects::nonNull).map(Tag::tagValues).forEach(result::addAll);
+        return result;
+    }
+
+    @Override
+    public @NotNull Function<NamespaceID, Integer> getMapper() {
+        return TAG_TO_ID;
+    }
+}

src/main/java/net/minestom/server/gametag/Tag.java

@@ -0,0 +1,25 @@
+package net.minestom.server.gametag;
+
+import net.minestom.server.registry.Registry;
+import net.minestom.server.registry.StaticProtocolObject;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.function.Function;
+
+public sealed interface Tag extends StaticProtocolObject permits BlockTag, EntityTag, FluidTag, GameEventTag, ItemTag {
+
+    @Contract(pure = true)
+    @NotNull Registry.TagEntry registry();
+
+    @Override
+    default @NotNull NamespaceID namespace() {
+        return registry().namespace();
+    }
+
+    @NotNull Collection<@NotNull NamespaceID> tagValues();
+
+    @NotNull Function<NamespaceID, Integer> getMapper();
+}

src/main/java/net/minestom/server/network/ConnectionManager.java

@@ -13,6 +13,7 @@
 import net.minestom.server.listener.preplay.LoginListener;
 import net.minestom.server.message.Messenger;
 import net.minestom.server.network.packet.client.login.ClientLoginStartPacket;
+import net.minestom.server.network.packet.server.CachedPacket;
 import net.minestom.server.network.packet.server.common.KeepAlivePacket;
 import net.minestom.server.network.packet.server.common.PluginMessagePacket;
 import net.minestom.server.network.packet.server.common.TagsPacket;
@@ -59,6 +60,7 @@ public final class ConnectionManager {
     private final Set<Player> configurationPlayers = new CopyOnWriteArraySet<>();
     // Players in play state
     private final Set<Player> playPlayers = new CopyOnWriteArraySet<>();
+    public static final CachedPacket DEFAULT_TAGS = new CachedPacket(new TagsPacket(TagsPacket.createDefaultTags()));
 
     // The players who need keep alive ticks. This was added because we may not send a keep alive in
     // the time after sending finish configuration but before receiving configuration end (to swap to play).
@@ -293,7 +295,7 @@ public void doConfiguration(@NotNull Player player, boolean isFirstConfig) {
                 registry.put("minecraft:trim_pattern", MinecraftServer.getTrimManager().getTrimPatternNBT());
                 player.sendPacket(new RegistryDataPacket(NBT.Compound(registry)));
 
-                player.sendPacket(TagsPacket.DEFAULT_TAGS);
+                player.sendPacket(DEFAULT_TAGS);
             }
             player.sendPacket(new UpdateEnabledFeaturesPacket(event.getEnabledFeatures()));