From 925c3b9d2b4a4a1c0a6ea4dc2b06f4009cde02aa Mon Sep 17 00:00:00 2001 From: Jake Potrebic Date: Sat, 7 Sep 2024 13:35:11 -0700 Subject: [PATCH] Add FeatureFlag API (#8952) * Add FeatureFlag API * switch to index & move method * fix test --- patches/api/0270-Add-basic-Datapack-API.patch | 40 +- patches/api/0488-Add-FeatureFlag-API.patch | 333 +++++++++++++++ ...vanilla-BiomeProvider-from-WorldInfo.patch | 4 +- patches/server/1058-Add-FeatureFlag-API.patch | 395 ++++++++++++++++++ 4 files changed, 762 insertions(+), 10 deletions(-) create mode 100644 patches/api/0488-Add-FeatureFlag-API.patch create mode 100644 patches/server/1058-Add-FeatureFlag-API.patch diff --git a/patches/api/0270-Add-basic-Datapack-API.patch b/patches/api/0270-Add-basic-Datapack-API.patch index 2250ed92f6..8a3ae9cf95 100644 --- a/patches/api/0270-Add-basic-Datapack-API.patch +++ b/patches/api/0270-Add-basic-Datapack-API.patch @@ -70,7 +70,7 @@ index 0000000000000000000000000000000000000000..58f78d5e91beacaf710f62461cf869f7 + +} diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java -index b558fa73dbcf3747690933e6aadf7061a0de2630..8a22c242a93b0e16e0bca583d0918bab695248b1 100644 +index b558fa73dbcf3747690933e6aadf7061a0de2630..be68351555bde59a4e55bf1bad261e9f6bc9f704 100644 --- a/src/main/java/org/bukkit/Bukkit.java +++ b/src/main/java/org/bukkit/Bukkit.java @@ -328,9 +328,11 @@ public final class Bukkit { @@ -81,7 +81,7 @@ index b558fa73dbcf3747690933e6aadf7061a0de2630..8a22c242a93b0e16e0bca583d0918bab * @return the manager */ @NotNull -+ @Deprecated(forRemoval = true) ++ @Deprecated(forRemoval = true, since = "1.20") public static DataPackManager getDataPackManager() { return server.getDataPackManager(); } @@ -100,8 +100,20 @@ index b558fa73dbcf3747690933e6aadf7061a0de2630..8a22c242a93b0e16e0bca583d0918bab // Paper end @NotNull +diff --git a/src/main/java/org/bukkit/Material.java b/src/main/java/org/bukkit/Material.java +index cc25734f3dcf6075eb44e39da01ed2f1b59b618e..2721ad40d6ba025caad16455f74f2350dcb7a4ff 100644 +--- a/src/main/java/org/bukkit/Material.java ++++ b/src/main/java/org/bukkit/Material.java +@@ -5497,6 +5497,7 @@ public enum Material implements Keyed, Translatable, net.kyori.adventure.transla + * @param world the world to check + * @return true if this material can be used in this World. + */ ++ @Deprecated(forRemoval = true, since = "1.20") // Paper + public boolean isEnabledByFeature(@NotNull World world) { + if (isItem()) { + return Bukkit.getDataPackManager().isEnabledByFeature(asItemType(), world); diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java -index 42930006b6425b5d82233e4ffe7025ce5397b277..67b5cb7635c4251c259b1fb1ef50f99a0b2647e5 100644 +index 42930006b6425b5d82233e4ffe7025ce5397b277..45693e6c02eac37eb609cd3c59253a949a6ca4c0 100644 --- a/src/main/java/org/bukkit/Server.java +++ b/src/main/java/org/bukkit/Server.java @@ -267,9 +267,11 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi @@ -112,7 +124,7 @@ index 42930006b6425b5d82233e4ffe7025ce5397b277..67b5cb7635c4251c259b1fb1ef50f99a * @return the manager */ @NotNull -+ @Deprecated(forRemoval = true) // Paper ++ @Deprecated(forRemoval = true, since = "1.20") // Paper public DataPackManager getDataPackManager(); /** @@ -128,8 +140,20 @@ index 42930006b6425b5d82233e4ffe7025ce5397b277..67b5cb7635c4251c259b1fb1ef50f99a + io.papermc.paper.datapack.DatapackManager getDatapackManager(); // Paper end } +diff --git a/src/main/java/org/bukkit/entity/EntityType.java b/src/main/java/org/bukkit/entity/EntityType.java +index 976f701ed9b9873945a5628173c580e2e6873864..eea0351559a2835280713f5d5d1d430c7cf857a0 100644 +--- a/src/main/java/org/bukkit/entity/EntityType.java ++++ b/src/main/java/org/bukkit/entity/EntityType.java +@@ -449,6 +449,7 @@ public enum EntityType implements Keyed, Translatable, net.kyori.adventure.trans + * @param world the world to check + * @return true if this EntityType can be used to spawn an Entity for this World. + */ ++ @Deprecated(forRemoval = true, since = "1.20") // Paper + public boolean isEnabledByFeature(@NotNull World world) { + return Bukkit.getDataPackManager().isEnabledByFeature(this, world); + } diff --git a/src/main/java/org/bukkit/packs/DataPack.java b/src/main/java/org/bukkit/packs/DataPack.java -index ea03c51d51e015e69d3aaa795547033ceabff9e0..419f6bdbec5dc1c731fb0f93816a90f58a329021 100644 +index ea03c51d51e015e69d3aaa795547033ceabff9e0..f51d59e6369c76e333fd9e58e711c2b6f245882d 100644 --- a/src/main/java/org/bukkit/packs/DataPack.java +++ b/src/main/java/org/bukkit/packs/DataPack.java @@ -9,7 +9,9 @@ import org.jetbrains.annotations.NotNull; @@ -138,12 +162,12 @@ index ea03c51d51e015e69d3aaa795547033ceabff9e0..419f6bdbec5dc1c731fb0f93816a90f5 * @see Minecraft wiki + * @deprecated use {@link io.papermc.paper.datapack.Datapack} */ -+@Deprecated(forRemoval = true) // Paper ++@Deprecated(forRemoval = true, since = "1.20") // Paper public interface DataPack extends Keyed { /** diff --git a/src/main/java/org/bukkit/packs/DataPackManager.java b/src/main/java/org/bukkit/packs/DataPackManager.java -index aee6e828c6fac9b010356af1239a58b4579c1773..7d3694efc21c7bc3784207735bdd9fb27e69988a 100644 +index aee6e828c6fac9b010356af1239a58b4579c1773..1b850e76a885f0da653d4b48db72e5f85ae72805 100644 --- a/src/main/java/org/bukkit/packs/DataPackManager.java +++ b/src/main/java/org/bukkit/packs/DataPackManager.java @@ -13,7 +13,9 @@ import org.jetbrains.annotations.Nullable; @@ -152,7 +176,7 @@ index aee6e828c6fac9b010356af1239a58b4579c1773..7d3694efc21c7bc3784207735bdd9fb2 * Manager of data packs. + * @deprecated use {@link io.papermc.paper.datapack.DatapackManager} */ -+@Deprecated(forRemoval = true) // Paper ++@Deprecated(forRemoval = true, since = "1.20") // Paper public interface DataPackManager { /** diff --git a/patches/api/0488-Add-FeatureFlag-API.patch b/patches/api/0488-Add-FeatureFlag-API.patch new file mode 100644 index 0000000000..18ba9226e2 --- /dev/null +++ b/patches/api/0488-Add-FeatureFlag-API.patch @@ -0,0 +1,333 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Jake Potrebic +Date: Thu, 9 Mar 2023 11:24:43 -0800 +Subject: [PATCH] Add FeatureFlag API + + +diff --git a/src/main/java/io/papermc/paper/world/flag/FeatureDependant.java b/src/main/java/io/papermc/paper/world/flag/FeatureDependant.java +new file mode 100644 +index 0000000000000000000000000000000000000000..914dc0b655630dd835bb115a144206d7e3a02337 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/world/flag/FeatureDependant.java +@@ -0,0 +1,26 @@ ++package io.papermc.paper.world.flag; ++ ++import java.util.Set; ++import org.bukkit.FeatureFlag; ++import org.checkerframework.checker.nullness.qual.NonNull; ++import org.jetbrains.annotations.ApiStatus; ++import org.jetbrains.annotations.Unmodifiable; ++ ++/** ++ * Implemented by types in built-in registries that are controlled by {@link FeatureFlag FeatureFlags}. ++ * Types in data-driven registries that are controlled by feature flags just will not exist in that registry. ++ */ ++@ApiStatus.Experimental ++@ApiStatus.NonExtendable ++public interface FeatureDependant { ++ ++ /** ++ * Gets the set of required feature flags for this ++ * to be enabled. ++ * ++ * @return the immutable set of feature flags ++ */ ++ default @Unmodifiable @NonNull Set requiredFeatures() { ++ return FeatureFlagProvider.provider().requiredFeatures(this); ++ } ++} +diff --git a/src/main/java/io/papermc/paper/world/flag/FeatureFlagProvider.java b/src/main/java/io/papermc/paper/world/flag/FeatureFlagProvider.java +new file mode 100644 +index 0000000000000000000000000000000000000000..f64cbee35fd3c6fe7b5f7391f6d118166d26dc18 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/world/flag/FeatureFlagProvider.java +@@ -0,0 +1,19 @@ ++package io.papermc.paper.world.flag; ++ ++import java.util.Optional; ++import java.util.ServiceLoader; ++import java.util.Set; ++import org.bukkit.FeatureFlag; ++import org.jetbrains.annotations.ApiStatus; ++ ++@ApiStatus.Internal ++interface FeatureFlagProvider { ++ ++ Optional PROVIDER = ServiceLoader.load(FeatureFlagProvider.class).findFirst(); ++ ++ static FeatureFlagProvider provider() { ++ return PROVIDER.orElseThrow(); ++ } ++ ++ Set requiredFeatures(FeatureDependant dependant); ++} +diff --git a/src/main/java/io/papermc/paper/world/flag/FeatureFlagSetHolder.java b/src/main/java/io/papermc/paper/world/flag/FeatureFlagSetHolder.java +new file mode 100644 +index 0000000000000000000000000000000000000000..2d7bbc9b157ccbb02731ecf3ec6680681c9c0da8 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/world/flag/FeatureFlagSetHolder.java +@@ -0,0 +1,32 @@ ++package io.papermc.paper.world.flag; ++ ++import java.util.Set; ++import org.bukkit.FeatureFlag; ++import org.checkerframework.checker.nullness.qual.NonNull; ++import org.jetbrains.annotations.ApiStatus; ++import org.jetbrains.annotations.Unmodifiable; ++ ++/** ++ * Implemented by types that hold {@link FeatureFlag FeatureFlags} like ++ * {@link org.bukkit.generator.WorldInfo} and {@link org.bukkit.RegionAccessor}. ++ */ ++@ApiStatus.Experimental ++@ApiStatus.NonExtendable ++public interface FeatureFlagSetHolder { ++ ++ /** ++ * Checks if this is enabled based on the loaded feature flags. ++ * ++ * @return true if enabled ++ */ ++ default boolean isEnabled(final @NonNull FeatureDependant featureDependant) { ++ return this.getFeatureFlags().containsAll(featureDependant.requiredFeatures()); ++ } ++ ++ /** ++ * Get all {@link FeatureFlag FeatureFlags} enabled in this world. ++ * ++ * @return all enabled {@link FeatureFlag FeatureFlags} ++ */ ++ @Unmodifiable @NonNull Set getFeatureFlags(); ++} +diff --git a/src/main/java/org/bukkit/FeatureFlag.java b/src/main/java/org/bukkit/FeatureFlag.java +index 026b1832bcd163ab89668c991bf002e608e36aef..d690ecf6eac753fab9d09514cfadae4c6a73e146 100644 +--- a/src/main/java/org/bukkit/FeatureFlag.java ++++ b/src/main/java/org/bukkit/FeatureFlag.java +@@ -1,37 +1,57 @@ + package org.bukkit; + ++// Paper start - overhaul FeatureFlag API ++import com.google.common.base.Preconditions; ++import java.util.List; ++import net.kyori.adventure.key.Key; ++import net.kyori.adventure.util.Index; ++import org.intellij.lang.annotations.Subst; ++// Paper end - overhaul FeatureFlag API + import org.jetbrains.annotations.ApiStatus; + + /** + * This represents a Feature Flag for a World. +- *
+- * Flags which are unavailable in the current version will be null and/or +- * removed. + */ + @ApiStatus.Experimental + public interface FeatureFlag extends Keyed { + +- public static final FeatureFlag VANILLA = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("vanilla")); ++ // Paper start - overhaul FeatureFlag API ++ /** ++ * The {@code vanilla} feature flag. ++ */ ++ FeatureFlag VANILLA = create("vanilla"); + ++ /** ++ * The {@code bundle} feature flag. ++ */ + @ApiStatus.Experimental // Paper - add missing annotation +- public static final FeatureFlag BUNDLE = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("bundle")); ++ FeatureFlag BUNDLE = create("bundle"); + + /** +- * AVAILABLE BETWEEN VERSIONS: 1.19 - 1.19.4 +- * +- * @deprecated not available since 1.20 ++ * The {@code trade_rebalance} feature flag. + */ +- @Deprecated +- public static final FeatureFlag UPDATE_1_20 = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("update_1_20")); +- + @ApiStatus.Experimental // Paper - add missing annotation +- public static final FeatureFlag TRADE_REBALANCE = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("trade_rebalance")); ++ FeatureFlag TRADE_REBALANCE = create("trade_rebalance"); ++ ++ @Deprecated(since = "1.20") ++ FeatureFlag UPDATE_1_20 = deprecated("update_1_20"); ++ ++ @Deprecated(since = "1.21") ++ FeatureFlag UPDATE_121 = deprecated("update_1_21"); + + /** +- * AVAILABLE BETWEEN VERSIONS: 1.20.5 - 1.20.6 +- * +- * @deprecated not available since 1.21 ++ * An index of all feature flags. + */ +- @Deprecated +- public static final FeatureFlag UPDATE_121 = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("update_1_21")); ++ Index ALL_FLAGS = Index.create(FeatureFlag::key, List.copyOf(FeatureFlagImpl.ALL_FLAGS)); ++ ++ private static FeatureFlag create(@Subst("vanilla") final String name) { ++ final FeatureFlag flag = new FeatureFlagImpl(NamespacedKey.minecraft(name)); ++ Preconditions.checkState(FeatureFlagImpl.ALL_FLAGS.add(flag), "Tried to add duplicate feature flag: " + name); ++ return flag; ++ } ++ ++ private static FeatureFlag deprecated(@Subst("vanilla") final String name) { ++ return new FeatureFlagImpl.Deprecated(NamespacedKey.minecraft(name)); ++ } ++ // Paper end - overhaul FeatureFlag API + } +diff --git a/src/main/java/org/bukkit/FeatureFlagImpl.java b/src/main/java/org/bukkit/FeatureFlagImpl.java +new file mode 100644 +index 0000000000000000000000000000000000000000..a33517dbd69021fde8246836720b6247800ee43c +--- /dev/null ++++ b/src/main/java/org/bukkit/FeatureFlagImpl.java +@@ -0,0 +1,29 @@ ++package org.bukkit; ++ ++import java.util.HashSet; ++import java.util.Set; ++import org.checkerframework.checker.nullness.qual.NonNull; ++import org.checkerframework.framework.qual.DefaultQualifier; ++import org.jetbrains.annotations.ApiStatus; ++ ++@ApiStatus.Internal ++@DefaultQualifier(NonNull.class) ++record FeatureFlagImpl(NamespacedKey key) implements FeatureFlag { ++ ++ static final Set ALL_FLAGS = new HashSet<>(); ++ ++ @Override ++ public NamespacedKey getKey() { ++ return this.key; ++ } ++ ++ @ApiStatus.Internal ++ @DefaultQualifier(NonNull.class) ++ record Deprecated(NamespacedKey key) implements FeatureFlag { ++ ++ @Override ++ public NamespacedKey getKey() { ++ return this.key; ++ } ++ } ++} +diff --git a/src/main/java/org/bukkit/RegionAccessor.java b/src/main/java/org/bukkit/RegionAccessor.java +index eb33e8e671972aa308ad75a7ce9aa9ac526f470f..05ecf3cb38ff42c8b52405d900197e6bf47dd1e6 100644 +--- a/src/main/java/org/bukkit/RegionAccessor.java ++++ b/src/main/java/org/bukkit/RegionAccessor.java +@@ -18,7 +18,7 @@ import org.jetbrains.annotations.Nullable; + * A RegionAccessor gives access to getting, modifying and spawning {@link Biome}, {@link BlockState} and {@link Entity}, + * as well as generating some basic structures. + */ +-public interface RegionAccessor extends Keyed { // Paper ++public interface RegionAccessor extends Keyed, io.papermc.paper.world.flag.FeatureFlagSetHolder { // Paper - feature flag API + + /** + * Gets the {@link Biome} at the given {@link Location}. +diff --git a/src/main/java/org/bukkit/UnsafeValues.java b/src/main/java/org/bukkit/UnsafeValues.java +index 330e3013eda204aa9b33d5e1c3104e0b595abdbc..c80e0ef587a001ee6de3f5c182cc9696d58bafeb 100644 +--- a/src/main/java/org/bukkit/UnsafeValues.java ++++ b/src/main/java/org/bukkit/UnsafeValues.java +@@ -114,8 +114,7 @@ public interface UnsafeValues { + + String getTranslationKey(Attribute attribute); + +- @Nullable +- FeatureFlag getFeatureFlag(@NotNull NamespacedKey key); ++ // Paper - replace with better system + + /** + * Do not use, method will get removed, and the plugin won't run +diff --git a/src/main/java/org/bukkit/block/BlockType.java b/src/main/java/org/bukkit/block/BlockType.java +index 8f430a4067fc722ebfbca846cccded4fb0a3a4e5..4aa79016eb5f7edf930c82d30ff25078fdb88436 100644 +--- a/src/main/java/org/bukkit/block/BlockType.java ++++ b/src/main/java/org/bukkit/block/BlockType.java +@@ -123,7 +123,7 @@ import org.jetbrains.annotations.Nullable; + * changes may occur. Do not use this API in plugins. + */ + @ApiStatus.Internal +-public interface BlockType extends Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - add translatable ++public interface BlockType extends Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - add translatable & feature flag API + + /** + * Typed represents a subtype of {@link BlockType}s that have a known block +diff --git a/src/main/java/org/bukkit/enchantments/Enchantment.java b/src/main/java/org/bukkit/enchantments/Enchantment.java +index f38321c437b19125d57d25419e3cb564e3928d89..daf4eeed2881858f734c19471ad5dbc4e1f42def 100644 +--- a/src/main/java/org/bukkit/enchantments/Enchantment.java ++++ b/src/main/java/org/bukkit/enchantments/Enchantment.java +@@ -15,7 +15,7 @@ import org.jetbrains.annotations.Nullable; + /** + * The various type of enchantments that may be added to armour or weapons + */ +-public abstract class Enchantment implements Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - Adventure translations ++public abstract class Enchantment implements Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - Adventure translations & feature flag API + /** + * Provides protection against environmental damage + */ +diff --git a/src/main/java/org/bukkit/entity/EntityType.java b/src/main/java/org/bukkit/entity/EntityType.java +index ba605ad75d4ed920c0dc4527529998041a58676b..a78e1c431a6ea46ba7c44880e25a871f473bef41 100644 +--- a/src/main/java/org/bukkit/entity/EntityType.java ++++ b/src/main/java/org/bukkit/entity/EntityType.java +@@ -23,7 +23,7 @@ import org.jetbrains.annotations.Contract; + import org.jetbrains.annotations.NotNull; + import org.jetbrains.annotations.Nullable; + +-public enum EntityType implements Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - translatable ++public enum EntityType implements Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - translatable + + // These strings MUST match the strings in nms.EntityTypes and are case sensitive. + /** +diff --git a/src/main/java/org/bukkit/generator/WorldInfo.java b/src/main/java/org/bukkit/generator/WorldInfo.java +index 5067f1371433cccd3287af7f03e152f2c3c1ece3..e0cb282541548ac3bd24cce86b3413f5748ea8bc 100644 +--- a/src/main/java/org/bukkit/generator/WorldInfo.java ++++ b/src/main/java/org/bukkit/generator/WorldInfo.java +@@ -7,7 +7,7 @@ import org.jetbrains.annotations.NotNull; + /** + * Holds various information of a World + */ +-public interface WorldInfo { ++public interface WorldInfo extends io.papermc.paper.world.flag.FeatureFlagSetHolder { // Paper - feature flag API + + /** + * Gets the unique name of this world +diff --git a/src/main/java/org/bukkit/inventory/ItemType.java b/src/main/java/org/bukkit/inventory/ItemType.java +index 0168f0a14a3e899e84c5e36963ff79950ab580fb..86887e8b20288b8204adcc64993b39f94269a0eb 100644 +--- a/src/main/java/org/bukkit/inventory/ItemType.java ++++ b/src/main/java/org/bukkit/inventory/ItemType.java +@@ -48,7 +48,7 @@ import org.jetbrains.annotations.Nullable; + * changes may occur. Do not use this API in plugins. + */ + @ApiStatus.Experimental // Paper - already required for registry builders +-public interface ItemType extends Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - add Translatable ++public interface ItemType extends Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - add Translatable & feature flag API + + /** + * Typed represents a subtype of {@link ItemType}s that have a known item meta type +diff --git a/src/main/java/org/bukkit/potion/PotionEffectType.java b/src/main/java/org/bukkit/potion/PotionEffectType.java +index 10fa51d116b40450b51af9110d5637f3505ebf65..647452f16e4bf7e5a61520123e62d9408ec9adfb 100644 +--- a/src/main/java/org/bukkit/potion/PotionEffectType.java ++++ b/src/main/java/org/bukkit/potion/PotionEffectType.java +@@ -17,7 +17,7 @@ import org.jetbrains.annotations.Nullable; + /** + * Represents a type of potion and its effect on an entity. + */ +-public abstract class PotionEffectType implements Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - implement Translatable ++public abstract class PotionEffectType implements Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - implement Translatable & feature flag API + private static final BiMap ID_MAP = HashBiMap.create(); + + /** +diff --git a/src/main/java/org/bukkit/potion/PotionType.java b/src/main/java/org/bukkit/potion/PotionType.java +index 453c626092caa734a0af5800699f299fc6fd0e43..c82cc9d9db5cb0e0e3c02f6a9564fc935ee594aa 100644 +--- a/src/main/java/org/bukkit/potion/PotionType.java ++++ b/src/main/java/org/bukkit/potion/PotionType.java +@@ -14,7 +14,7 @@ import org.jetbrains.annotations.Nullable; + * This enum reflects and matches each potion state that can be obtained from + * the Creative mode inventory + */ +-public enum PotionType implements Keyed { ++public enum PotionType implements Keyed, io.papermc.paper.world.flag.FeatureDependant { // Paper - feature flag API + WATER("water"), + MUNDANE("mundane"), + THICK("thick"), diff --git a/patches/server/0648-Expose-vanilla-BiomeProvider-from-WorldInfo.patch b/patches/server/0648-Expose-vanilla-BiomeProvider-from-WorldInfo.patch index 84ec6ee0bd..e1ea6b3b1b 100644 --- a/patches/server/0648-Expose-vanilla-BiomeProvider-from-WorldInfo.patch +++ b/patches/server/0648-Expose-vanilla-BiomeProvider-from-WorldInfo.patch @@ -88,7 +88,7 @@ index 0c2734c1d06b6c5dff383f9c6139c0389f220a76..110a5d92d6154bc39c1916006a5cb747 private static final Random rand = new Random(); diff --git a/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java b/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java -index 5d655d6cd3e23e0287069f8bdf77601487e862fd..cf57c6e9ce63f7b1d95d91ead2453409a31a5c52 100644 +index 5d655d6cd3e23e0287069f8bdf77601487e862fd..c81455a4ee9a3185f125ebf8cec325f4ed2e501d 100644 --- a/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java +++ b/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java @@ -17,8 +17,14 @@ public class CraftWorldInfo implements WorldInfo { @@ -100,7 +100,7 @@ index 5d655d6cd3e23e0287069f8bdf77601487e862fd..cf57c6e9ce63f7b1d95d91ead2453409 + private final net.minecraft.core.RegistryAccess.Frozen registryAccess; - public CraftWorldInfo(ServerLevelData worldDataServer, LevelStorageSource.LevelStorageAccess session, World.Environment environment, DimensionType dimensionManager) { -+ public CraftWorldInfo(ServerLevelData worldDataServer, LevelStorageSource.LevelStorageAccess session, World.Environment environment, DimensionType dimensionManager, net.minecraft.world.level.chunk.ChunkGenerator chunkGenerator, net.minecraft.core.RegistryAccess.Frozen registryAccess) { ++ public CraftWorldInfo(PrimaryLevelData worldDataServer, LevelStorageSource.LevelStorageAccess session, World.Environment environment, DimensionType dimensionManager, net.minecraft.world.level.chunk.ChunkGenerator chunkGenerator, net.minecraft.core.RegistryAccess.Frozen registryAccess) { + this.registryAccess = registryAccess; + this.vanillaChunkGenerator = chunkGenerator; + // Paper end diff --git a/patches/server/1058-Add-FeatureFlag-API.patch b/patches/server/1058-Add-FeatureFlag-API.patch new file mode 100644 index 0000000000..c47a84009b --- /dev/null +++ b/patches/server/1058-Add-FeatureFlag-API.patch @@ -0,0 +1,395 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Jake Potrebic +Date: Wed, 29 May 2024 19:50:21 -0700 +Subject: [PATCH] Add FeatureFlag API + + +diff --git a/src/main/java/io/papermc/paper/world/flag/PaperFeatureDependent.java b/src/main/java/io/papermc/paper/world/flag/PaperFeatureDependent.java +new file mode 100644 +index 0000000000000000000000000000000000000000..c6fd2e8a570ac474dd1751929137280c52d79e78 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/world/flag/PaperFeatureDependent.java +@@ -0,0 +1,17 @@ ++package io.papermc.paper.world.flag; ++ ++import java.util.Set; ++import net.minecraft.world.flag.FeatureElement; ++import org.bukkit.FeatureFlag; ++import org.checkerframework.checker.nullness.qual.NonNull; ++import org.jetbrains.annotations.Unmodifiable; ++ ++public interface PaperFeatureDependent extends FeatureDependant { ++ ++ M getHandle(); ++ ++ @Override ++ default @Unmodifiable @NonNull Set requiredFeatures() { ++ return PaperFeatureFlagProviderImpl.fromNms(this.getHandle().requiredFeatures()); ++ } ++} +diff --git a/src/main/java/io/papermc/paper/world/flag/PaperFeatureFlagProviderImpl.java b/src/main/java/io/papermc/paper/world/flag/PaperFeatureFlagProviderImpl.java +new file mode 100644 +index 0000000000000000000000000000000000000000..d58b650fcafd04d00a92005ca8576d314535ce32 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/world/flag/PaperFeatureFlagProviderImpl.java +@@ -0,0 +1,53 @@ ++package io.papermc.paper.world.flag; ++ ++import com.google.common.collect.BiMap; ++import com.google.common.collect.ImmutableBiMap; ++import java.util.Collections; ++import java.util.HashSet; ++import java.util.Set; ++import net.minecraft.world.flag.FeatureElement; ++import net.minecraft.world.flag.FeatureFlagSet; ++import net.minecraft.world.flag.FeatureFlags; ++import org.bukkit.FeatureFlag; ++import org.bukkit.craftbukkit.entity.CraftEntityType; ++import org.bukkit.craftbukkit.entity.CraftEntityTypes; ++import org.bukkit.craftbukkit.potion.CraftPotionType; ++import org.bukkit.craftbukkit.util.CraftMagicNumbers; ++import org.bukkit.entity.EntityType; ++import org.bukkit.potion.PotionType; ++ ++public class PaperFeatureFlagProviderImpl implements FeatureFlagProvider { ++ ++ public static final BiMap FLAGS = ImmutableBiMap.of( ++ FeatureFlag.VANILLA, FeatureFlags.VANILLA, ++ FeatureFlag.BUNDLE, FeatureFlags.BUNDLE, ++ FeatureFlag.TRADE_REBALANCE, FeatureFlags.TRADE_REBALANCE ++ ); ++ ++ @Override ++ public Set requiredFeatures(final FeatureDependant dependant) { ++ final FeatureFlagSet requiredFeatures = getFeatureElement(dependant).requiredFeatures(); ++ return fromNms(requiredFeatures); ++ } ++ ++ public static Set fromNms(final FeatureFlagSet flagSet) { ++ final Set flags = new HashSet<>(); ++ for (final net.minecraft.world.flag.FeatureFlag nmsFlag : FeatureFlags.REGISTRY.names.values()) { ++ if (flagSet.contains(nmsFlag)) { ++ flags.add(FLAGS.inverse().get(nmsFlag)); ++ } ++ } ++ return Collections.unmodifiableSet(flags); ++ } ++ ++ static FeatureElement getFeatureElement(final FeatureDependant dependant) { ++ if (dependant instanceof final EntityType entityType) { ++ // TODO remove when EntityType is server-backed ++ return CraftEntityType.bukkitToMinecraft(entityType); ++ } else if (dependant instanceof final PotionType potionType) { ++ return CraftPotionType.bukkitToMinecraft(potionType); ++ } else { ++ throw new IllegalArgumentException(dependant + " is not a valid feature dependant"); ++ } ++ } ++} +diff --git a/src/main/java/org/bukkit/craftbukkit/CraftFeatureFlag.java b/src/main/java/org/bukkit/craftbukkit/CraftFeatureFlag.java +deleted file mode 100644 +index da90e5c84a0cc4505a5fff0ed278a905978c6ce2..0000000000000000000000000000000000000000 +--- a/src/main/java/org/bukkit/craftbukkit/CraftFeatureFlag.java ++++ /dev/null +@@ -1,51 +0,0 @@ +-package org.bukkit.craftbukkit; +- +-import java.util.HashSet; +-import java.util.Set; +-import net.minecraft.resources.ResourceLocation; +-import net.minecraft.world.flag.FeatureFlagSet; +-import net.minecraft.world.flag.FeatureFlags; +-import org.bukkit.FeatureFlag; +-import org.bukkit.NamespacedKey; +-import org.bukkit.craftbukkit.util.CraftNamespacedKey; +-import org.jetbrains.annotations.NotNull; +- +-public class CraftFeatureFlag implements FeatureFlag { +- +- private final NamespacedKey namespacedKey; +- private final net.minecraft.world.flag.FeatureFlag featureFlag; +- +- public CraftFeatureFlag(ResourceLocation minecraftKey, net.minecraft.world.flag.FeatureFlag featureFlag) { +- this.namespacedKey = CraftNamespacedKey.fromMinecraft(minecraftKey); +- this.featureFlag = featureFlag; +- } +- +- public net.minecraft.world.flag.FeatureFlag getHandle() { +- return this.featureFlag; +- } +- +- @NotNull +- @Override +- public NamespacedKey getKey() { +- return this.namespacedKey; +- } +- +- @Override +- public String toString() { +- return "CraftFeatureFlag{key=" + this.getKey() + ",keyUniverse=" + this.getHandle().universe.toString() + "}"; +- } +- +- public static Set getFromNMS(FeatureFlagSet featureFlagSet) { +- Set set = new HashSet<>(); +- FeatureFlags.REGISTRY.names.forEach((minecraftkey, featureflag) -> { +- if (featureFlagSet.contains(featureflag)) { +- set.add(new CraftFeatureFlag(minecraftkey, featureflag)); +- } +- }); +- return set; +- } +- +- public static CraftFeatureFlag getFromNMS(NamespacedKey namespacedKey) { +- return FeatureFlags.REGISTRY.names.entrySet().stream().filter(entry -> CraftNamespacedKey.fromMinecraft(entry.getKey()).equals(namespacedKey)).findFirst().map(entry -> new CraftFeatureFlag(entry.getKey(), entry.getValue())).orElse(null); +- } +-} +diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java +index 284234fcdd15c4c7a4567c7c887d47bf0b7967f4..c9ecec5da937bc5458f69736b68ff6ae50aa5ebc 100644 +--- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java ++++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java +@@ -558,4 +558,11 @@ public abstract class CraftRegionAccessor implements RegionAccessor { + return !this.getHandle().noCollision(aabb); + } + // Paper end ++ ++ // Paper start - feature flag API ++ @Override ++ public java.util.Set getFeatureFlags() { ++ return io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl.fromNms(this.getHandle().enabledFeatures()); ++ } ++ // Paper end - feature flag API + } +diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java +index 90d4834f97d3ba996d46493246b1947511553424..cd3381d8225e0322b3e285b3c4aa0a1265a91cc0 100644 +--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java ++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java +@@ -2372,10 +2372,7 @@ public class CraftWorld extends CraftRegionAccessor implements World { + return this.persistentDataContainer; + } + +- @Override +- public Set getFeatureFlags() { +- return CraftFeatureFlag.getFromNMS(this.getHandle().enabledFeatures()).stream().map(FeatureFlag.class::cast).collect(Collectors.toUnmodifiableSet()); +- } ++ // Paper - replace feature flag API + + public void storeBukkitValues(CompoundTag c) { + if (!this.persistentDataContainer.isEmpty()) { +diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockType.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockType.java +index 785d3fe4929e008d4150f3ecab258fd5b6d7cdaf..978e602c38d66c1ac219ffdfe82f9fc777a6ad26 100644 +--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockType.java ++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockType.java +@@ -33,7 +33,7 @@ import org.bukkit.craftbukkit.util.Handleable; + import org.bukkit.inventory.ItemType; + import org.jetbrains.annotations.NotNull; + +-public class CraftBlockType implements BlockType.Typed, Handleable { ++public class CraftBlockType implements BlockType.Typed, Handleable, io.papermc.paper.world.flag.PaperFeatureDependent { // Paper - feature flag API + + private final NamespacedKey key; + private final Block block; +diff --git a/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java b/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java +index c81455a4ee9a3185f125ebf8cec325f4ed2e501d..8d962b055bd6574df7eb5510dd0efd67f579d84a 100644 +--- a/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java ++++ b/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java +@@ -17,6 +17,7 @@ public class CraftWorldInfo implements WorldInfo { + private final long seed; + private final int minHeight; + private final int maxHeight; ++ private final net.minecraft.world.flag.FeatureFlagSet enabledFeatures; // Paper - feature flag API + // Paper start + private final net.minecraft.world.level.chunk.ChunkGenerator vanillaChunkGenerator; + private final net.minecraft.core.RegistryAccess.Frozen registryAccess; +@@ -31,6 +32,7 @@ public class CraftWorldInfo implements WorldInfo { + this.seed = ((PrimaryLevelData) worldDataServer).worldGenOptions().seed(); + this.minHeight = dimensionManager.minY(); + this.maxHeight = dimensionManager.minY() + dimensionManager.height(); ++ this.enabledFeatures = worldDataServer.enabledFeatures(); // Paper - feature flag API + } + + @Override +@@ -92,4 +94,11 @@ public class CraftWorldInfo implements WorldInfo { + }; + } + // Paper end ++ ++ // Paper start - feature flag API ++ @Override ++ public java.util.Set getFeatureFlags() { ++ return io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl.fromNms(this.enabledFeatures); ++ } ++ // Paper end - feature flag API + } +diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java +index 450c63c31d2f5d056d989aa00452231f50c8224d..b9d9f1df2720c301915c8b07c0bdc12970128324 100644 +--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java ++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java +@@ -36,7 +36,7 @@ import org.bukkit.inventory.meta.ItemMeta; + import org.jetbrains.annotations.NotNull; + import org.jetbrains.annotations.Nullable; + +-public class CraftItemType implements ItemType.Typed, Handleable { ++public class CraftItemType implements ItemType.Typed, Handleable, io.papermc.paper.world.flag.PaperFeatureDependent { // Paper - feature flag API + + private final NamespacedKey key; + private final Item item; +diff --git a/src/main/java/org/bukkit/craftbukkit/packs/CraftDataPack.java b/src/main/java/org/bukkit/craftbukkit/packs/CraftDataPack.java +index 9525a7d4602b9b98dcc5e5e60dbcb628a656ae53..a0c0ad832726dcf9c8c25c1cfce2a6ddf770bf0f 100644 +--- a/src/main/java/org/bukkit/craftbukkit/packs/CraftDataPack.java ++++ b/src/main/java/org/bukkit/craftbukkit/packs/CraftDataPack.java +@@ -11,7 +11,7 @@ import net.minecraft.util.InclusiveRange; + import org.bukkit.Bukkit; + import org.bukkit.FeatureFlag; + import org.bukkit.NamespacedKey; +-import org.bukkit.craftbukkit.CraftFeatureFlag; ++// import org.bukkit.craftbukkit.CraftFeatureFlag; // Paper - replace feature flag API + import org.bukkit.craftbukkit.CraftServer; + import org.bukkit.craftbukkit.util.CraftChatMessage; + import org.bukkit.packs.DataPack; +@@ -98,7 +98,7 @@ public class CraftDataPack implements DataPack { + + @Override + public Set getRequestedFeatures() { +- return CraftFeatureFlag.getFromNMS(this.getHandle().getRequestedFeatures()).stream().map(FeatureFlag.class::cast).collect(Collectors.toUnmodifiableSet()); ++ return io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl.fromNms(this.getHandle().getRequestedFeatures()); // Paper - replace feature flag API + } + + @Override +diff --git a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionEffectType.java b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionEffectType.java +index 6cf790c9fa23ea313423fdaeb7c181bf530828c6..0bcb9df1103050441f8922a688b163dc97c04591 100644 +--- a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionEffectType.java ++++ b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionEffectType.java +@@ -13,7 +13,7 @@ import org.bukkit.potion.PotionEffectType; + import org.bukkit.potion.PotionEffectTypeCategory; + import org.jetbrains.annotations.NotNull; + +-public class CraftPotionEffectType extends PotionEffectType implements Handleable { ++public class CraftPotionEffectType extends PotionEffectType implements Handleable, io.papermc.paper.world.flag.PaperFeatureDependent { // Paper - feature flag API + + public static PotionEffectType minecraftHolderToBukkit(Holder minecraft) { + return CraftPotionEffectType.minecraftToBukkit(minecraft.value()); +diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java +index 28dbe30a98a6730839949bc9a6a90b78619ff84d..7d32c032b63b9c4674489b30c845fe2de8275808 100644 +--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java ++++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java +@@ -47,7 +47,7 @@ import org.bukkit.advancement.Advancement; + import org.bukkit.attribute.Attribute; + import org.bukkit.attribute.AttributeModifier; + import org.bukkit.block.data.BlockData; +-import org.bukkit.craftbukkit.CraftFeatureFlag; ++// import org.bukkit.craftbukkit.CraftFeatureFlag; // Paper + import org.bukkit.craftbukkit.CraftRegistry; + import org.bukkit.craftbukkit.CraftServer; + import org.bukkit.craftbukkit.attribute.CraftAttribute; +@@ -455,11 +455,7 @@ public final class CraftMagicNumbers implements UnsafeValues { + return CraftAttribute.bukkitToMinecraft(attribute).getDescriptionId(); + } + +- @Override +- public FeatureFlag getFeatureFlag(NamespacedKey namespacedKey) { +- Preconditions.checkArgument(namespacedKey != null, "NamespaceKey cannot be null"); +- return CraftFeatureFlag.getFromNMS(namespacedKey); +- } ++ // Paper - replace feature flag API + + @Override + public PotionType.InternalPotionData getInternalPotionData(NamespacedKey namespacedKey) { +diff --git a/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlagProvider b/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlagProvider +new file mode 100644 +index 0000000000000000000000000000000000000000..c3e6b96013f6dd0b784bd867196552d97f3d8685 +--- /dev/null ++++ b/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlagProvider +@@ -0,0 +1 @@ ++io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl +diff --git a/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlags$FeatureFlagProvider b/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlags$FeatureFlagProvider +new file mode 100644 +index 0000000000000000000000000000000000000000..c3e6b96013f6dd0b784bd867196552d97f3d8685 +--- /dev/null ++++ b/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlags$FeatureFlagProvider +@@ -0,0 +1 @@ ++io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl +diff --git a/src/test/java/io/papermc/paper/world/flag/FeatureFlagTest.java b/src/test/java/io/papermc/paper/world/flag/FeatureFlagTest.java +new file mode 100644 +index 0000000000000000000000000000000000000000..174efed9d0352066a146acb4ec0554d46f81df21 +--- /dev/null ++++ b/src/test/java/io/papermc/paper/world/flag/FeatureFlagTest.java +@@ -0,0 +1,79 @@ ++package io.papermc.paper.world.flag; ++ ++import io.papermc.paper.adventure.PaperAdventure; ++import io.papermc.paper.registry.PaperRegistries; ++import io.papermc.paper.registry.RegistryAccess; ++import io.papermc.paper.registry.RegistryKey; ++import java.util.HashSet; ++import java.util.Set; ++import net.kyori.adventure.key.Key; ++import net.minecraft.core.registries.Registries; ++import net.minecraft.resources.ResourceKey; ++import net.minecraft.resources.ResourceLocation; ++import net.minecraft.world.flag.FeatureElement; ++import net.minecraft.world.flag.FeatureFlagSet; ++import net.minecraft.world.flag.FeatureFlags; ++import org.bukkit.FeatureFlag; ++import org.bukkit.Keyed; ++import org.bukkit.support.AbstractTestingBase; ++import org.junit.jupiter.api.Test; ++import org.junit.jupiter.params.ParameterizedTest; ++import org.junit.jupiter.params.provider.MethodSource; ++ ++import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; ++import static org.junit.jupiter.api.Assertions.assertEquals; ++import static org.junit.jupiter.api.Assertions.assertInstanceOf; ++import static org.junit.jupiter.api.Assertions.assertNotNull; ++import static org.junit.jupiter.api.Assertions.fail; ++ ++class FeatureFlagTest extends AbstractTestingBase { ++ ++ @Test ++ void testFeatureFlagParity() { ++ final Set locations = new HashSet<>(); ++ for (final FeatureFlag flag : FeatureFlag.ALL_FLAGS.values()) { ++ locations.add(PaperAdventure.asVanilla(flag.getKey())); ++ } ++ FeatureFlags.REGISTRY.fromNames(locations, unknown -> { ++ fail("Unknown api feature flag: " + unknown); ++ }); ++ ++ for (final ResourceLocation nmsFlag : allNames()) { ++ assertNotNull(FeatureFlag.ALL_FLAGS.value(Key.key(nmsFlag.toString())), "can't find api flag for " + nmsFlag); ++ } ++ } ++ ++ @Test ++ void testFeatureFlagConversion() { ++ assertEquals(allNames().size(), PaperFeatureFlagProviderImpl.FLAGS.size()); ++ for (final FeatureFlag featureFlag : PaperFeatureFlagProviderImpl.FLAGS.keySet()) { ++ final net.minecraft.world.flag.FeatureFlag nmsFlag = PaperFeatureFlagProviderImpl.FLAGS.get(featureFlag); ++ final ResourceLocation nmsFlagName = FeatureFlags.REGISTRY.toNames(FeatureFlagSet.of(nmsFlag)).iterator().next(); ++ assertEquals(nmsFlagName.toString(), featureFlag.key().asString()); ++ } ++ } ++ ++ static Set allNames() { ++ return FeatureFlags.REGISTRY.toNames(FeatureFlags.REGISTRY.allFlags()); ++ } ++ ++ @SuppressWarnings({"rawtypes", "unchecked"}) ++ static Set> featureFilteredRegistries() { ++ final Set> registryKeys = new HashSet<>(); ++ for (final ResourceKey filteredRegistry : FeatureElement.FILTERED_REGISTRIES) { ++ if (filteredRegistry == Registries.MENU) continue; // not applicable atm ++ registryKeys.add(PaperRegistries.registryFromNms(filteredRegistry)); ++ } ++ return registryKeys; ++ } ++ ++ @MethodSource("featureFilteredRegistries") ++ @ParameterizedTest ++ void testFeatureDependent(final RegistryKey registryKey) { ++ final org.bukkit.Registry registry = RegistryAccess.registryAccess().getRegistry(registryKey); ++ final T anyElement = registry.iterator().next(); ++ assertInstanceOf(FeatureDependant.class, anyElement, "Registry " + registryKey + " doesn't have feature dependent elements"); ++ final FeatureDependant dependant = ((FeatureDependant) anyElement); ++ assertDoesNotThrow(dependant::requiredFeatures, "Failed to get required features for " + anyElement + " in " + registryKey); ++ } ++}