Added custom blocks API with initial oraxen integration

fix empty nbt

build.gradle.kts

@@ -22,6 +22,7 @@ dependencies {
     implementation(project(path = ":eco-core:core-plugin", configuration = "shadow"))
     implementation(project(":eco-core:core-proxy"))
     implementation(project(":eco-core:core-backend"))
+    implementation(project(":eco-core:core-backend-modern"))
     implementation(project(path = ":eco-core:core-nms:v1_17_R1", configuration = "reobf"))
     implementation(project(path = ":eco-core:core-nms:v1_18_R1", configuration = "reobf"))
     implementation(project(path = ":eco-core:core-nms:v1_18_R2", configuration = "reobf"))
@@ -31,7 +32,7 @@ dependencies {
     implementation(project(path = ":eco-core:core-nms:v1_20_R1", configuration = "reobf"))
     implementation(project(path = ":eco-core:core-nms:v1_20_R2", configuration = "reobf"))
     implementation(project(path = ":eco-core:core-nms:v1_20_R3", configuration = "reobf"))
-    implementation(project(path = ":eco-core:core-nms:v1_20_6", configuration = "reobf"))
+    implementation(project(path = ":eco-core:core-nms:v1_21", configuration = "reobf"))
 }
 
 allprojects {
@@ -44,9 +45,10 @@ allprojects {
 
     repositories {
         mavenCentral()
-        mavenLocal()
         maven("https://repo.auxilor.io/repository/maven-public/")
-        maven("https://jitpack.io")
+        maven("https://jitpack.io") {
+            content { includeGroupByRegex("com\\.github\\..*") }
+        }
 
         // SuperiorSkyblock2
         maven("https://repo.bg-software.com/repository/api/")
@@ -95,6 +97,9 @@ allprojects {
 
         // HuskPlugins
         maven("https://repo.william278.net/releases")
+
+        // FancyHolograms
+        maven("https://repo.fancyplugins.de/releases")
     }
 
     dependencies {
@@ -158,12 +163,6 @@ allprojects {
             options.encoding = "UTF-8"
         }
 
-        java {
-            sourceCompatibility = JavaVersion.VERSION_17
-            targetCompatibility = JavaVersion.VERSION_17
-            withSourcesJar()
-        }
-
         test {
             useJUnitPlatform()
 
@@ -176,6 +175,17 @@ allprojects {
         build {
             dependsOn(shadowJar)
         }
+
+        withType<JavaCompile>().configureEach {
+            options.release = 17
+        }
+    }
+
+    java {
+        withSourcesJar()
+        toolchain {
+            languageVersion = JavaLanguageVersion.of(21)
+        }
     }
 }
 
@@ -215,12 +225,5 @@ tasks {
     }
 }
 
-// Root is Java 21 to support 1.20.6+, rest use Java 17
-java {
-    sourceCompatibility = JavaVersion.VERSION_21
-    targetCompatibility = JavaVersion.VERSION_21
-    withSourcesJar()
-}
-
 group = "com.willfp"
 version = findProperty("version")!!

eco-api/src/main/java/com/willfp/eco/core/EcoPlugin.java

@@ -1,5 +1,6 @@
 package com.willfp.eco.core;
 
+import com.google.common.collect.ImmutableList;
 import com.willfp.eco.core.command.impl.PluginCommand;
 import com.willfp.eco.core.config.base.ConfigYml;
 import com.willfp.eco.core.config.base.LangYml;
@@ -36,6 +37,8 @@ import org.jetbrains.annotations.Nullable;
 import java.io.File;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
@@ -120,9 +123,17 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike, Regist
 
     /**
      * The display module for the plugin.
+     *
+     * @deprecated Plugins can now have multiple display modules.
      */
+    @Deprecated(since = "6.72.0")
     private DisplayModule displayModule;
 
+    /**
+     * The display modules for the plugin.
+     */
+    private List<DisplayModule> displayModules = new ArrayList<>();
+
     /**
      * The logger for the plugin.
      */
@@ -555,10 +566,15 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike, Regist
      * Default code to be executed after the server is up.
      */
     public final void afterLoad() {
-        this.displayModule = createDisplayModule();
+        DisplayModule module = createDisplayModule();
+        if (module != null) {
+            Display.registerDisplayModule(module);
+            this.displayModules.add(module);
+        }
 
-        if (this.getDisplayModule() != null) {
+        for (DisplayModule displayModule : this.loadDisplayModules()) {
-            Display.registerDisplayModule(this.getDisplayModule());
+            Display.registerDisplayModule(displayModule);
+            this.displayModules.add(displayModule);
         }
 
         if (Prerequisite.HAS_PROTOCOLLIB.isMet()) {
@@ -899,14 +915,25 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike, Regist
      * Create the display module for the plugin.
      *
      * @return The display module, or null.
+     * @deprecated Use {@link #loadDisplayModules()} instead.
      */
     @Nullable
+    @Deprecated(since = "6.72.0")
     protected DisplayModule createDisplayModule() {
         Validate.isTrue(this.getDisplayModule() == null, "Display module exists!");
 
         return null;
     }
 
+    /**
+     * Load display modules.
+     *
+     * @return The display modules.
+     */
+    protected List<DisplayModule> loadDisplayModules() {
+        return new ArrayList<>();
+    }
+
     /**
      * Get the minimum version of eco to use the plugin.
      *
@@ -1156,12 +1183,23 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike, Regist
      * Get the plugin's display module.
      *
      * @return The display module.
+     * @deprecated Use {@link #getDisplayModules()} instead.
      */
     @Nullable
+    @Deprecated(since = "6.72.0", forRemoval = true)
     public DisplayModule getDisplayModule() {
         return this.displayModule;
     }
 
+    /**
+     * Get the plugin's display modules.
+     *
+     * @return The display modules.
+     */
+    public List<DisplayModule> getDisplayModules() {
+        return ImmutableList.copyOf(this.displayModules);
+    }
+
     /**
      * Get if the plugin is outdated.
      *

eco-api/src/main/java/com/willfp/eco/core/Prerequisite.java

@@ -37,11 +37,20 @@ public class Prerequisite {
             "Requires server to have ProtocolLib"
     );
 
+    /**
+     * Requires the server to be running 1.21.
+     */
+    public static final Prerequisite HAS_1_21 = new Prerequisite(
+            () -> ProxyConstants.NMS_VERSION.contains("1_21"),
+            "Requires server to be running 1.21+"
+    );
+
     /**
      * Requires the server to be running 1.20.5.
      */
     public static final Prerequisite HAS_1_20_5 = new Prerequisite(
-            () -> ProxyConstants.NMS_VERSION.contains("1_20_") && !ProxyConstants.NMS_VERSION.contains("R"),
+            () -> (ProxyConstants.NMS_VERSION.contains("1_20_") && !ProxyConstants.NMS_VERSION.contains("R"))
+                    || HAS_1_21.isMet(),
             "Requires server to be running 1.20.5+"
     );
 

eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java

@@ -0,0 +1,149 @@
+package com.willfp.eco.core.blocks;
+
+import com.willfp.eco.core.blocks.impl.EmptyTestableBlock;
+import com.willfp.eco.core.blocks.impl.MaterialTestableBlock;
+import com.willfp.eco.core.blocks.impl.UnrestrictedMaterialTestableBlock;
+import com.willfp.eco.core.blocks.provider.BlockProvider;
+import com.willfp.eco.util.NamespacedKeyUtils;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.block.Block;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Class to manage all custom and vanilla blocks.
+ */
+public final class Blocks {
+    /**
+     * All entities.
+     */
+    private static final Map<NamespacedKey, TestableBlock> REGISTRY = new ConcurrentHashMap<>();
+
+    /**
+     * All block providers.
+     */
+    private static final Map<String, BlockProvider> PROVIDERS = new ConcurrentHashMap<>();
+
+    /**
+     * The lookup handler.
+     */
+    private static final BlocksLookupHandler BLOCKS_LOOKUP_HANDLER = new BlocksLookupHandler(Blocks::doParse);
+
+    /**
+     * Register a new custom block.
+     *
+     * @param key   The key of the block.
+     * @param block The block.
+     */
+    public static void registerCustomBlock(@NotNull final NamespacedKey key,
+                                           @NotNull final TestableBlock block) {
+        REGISTRY.put(key, block);
+    }
+
+    /**
+     * Register a new block provider.
+     *
+     * @param provider The provider.
+     */
+    public static void registerBlockProvider(@NotNull final BlockProvider provider) {
+        PROVIDERS.put(provider.getNamespace(), provider);
+    }
+
+    /**
+     * Remove a block.
+     *
+     * @param key The key of the block.
+     */
+    public static void removeCustomBlock(@NotNull final NamespacedKey key) {
+        REGISTRY.remove(key);
+    }
+
+    /**
+     * This is the backbone of the eco block system.
+     * <p>
+     * You can look up a TestableBlock for any material or custom block,
+     * and it will return it.
+     * <p>
+     * If you want to get a Block instance from this, then just call
+     * {@link TestableBlock#place(Location)}.
+     *
+     * @param key The lookup string.
+     * @return The testable block, or an empty testable block if not found.
+     */
+    @NotNull
+    public static TestableBlock lookup(@NotNull final String key) {
+        return BLOCKS_LOOKUP_HANDLER.parseKey(key);
+    }
+
+    @NotNull
+    private static TestableBlock doParse(@NotNull final String[] args) {
+        if (args.length == 0) {
+            return new EmptyTestableBlock();
+        }
+
+        String[] split = args[0].toLowerCase().split(":");
+        if (split.length == 1) {
+            if (args[0].startsWith("*")) {
+                Material type = Material.getMaterial(args[0].substring(1));
+                return (type == null) ? new EmptyTestableBlock() : new UnrestrictedMaterialTestableBlock(type);
+            } else {
+                Material type = Material.getMaterial(args[0].toUpperCase());
+                return (type == null) ? new EmptyTestableBlock() : new MaterialTestableBlock(type);
+            }
+        }
+
+        NamespacedKey namespacedKey = NamespacedKeyUtils.create(split[0], split[1]);
+        TestableBlock block = REGISTRY.get(namespacedKey);
+
+        if (block != null) {
+            return block;
+        }
+
+        BlockProvider provider = PROVIDERS.get(split[0]);
+        if (provider == null) {
+            return new EmptyTestableBlock();
+        }
+
+        block = provider.provideForKey(split[1]);
+        if (block == null) {
+            return new EmptyTestableBlock();
+        }
+
+        registerCustomBlock(namespacedKey, block);
+        return block;
+    }
+
+    /**
+     * Get if block is a custom block.
+     *
+     * @param block The block to check.
+     * @return If is custom.
+     */
+    public static boolean isCustomBlock(@NotNull final Block block) {
+        for (TestableBlock testable : REGISTRY.values()) {
+            if (testable.matches(block)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Get all registered custom blocks.
+     *
+     * @return A set of all blocks.
+     */
+    public static Set<TestableBlock> getCustomBlocks() {
+        return new HashSet<>(REGISTRY.values());
+    }
+
+    private Blocks() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/blocks/BlocksLookupHandler.java

@@ -0,0 +1,48 @@
+package com.willfp.eco.core.blocks;
+
+import com.willfp.eco.core.blocks.impl.EmptyTestableBlock;
+import com.willfp.eco.core.blocks.impl.GroupedTestableBlocks;
+import com.willfp.eco.core.lookup.LookupHandler;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.function.Function;
+
+/**
+ * Handle block lookup strings.
+ */
+public class BlocksLookupHandler implements LookupHandler<TestableBlock> {
+    /**
+     * The parser.
+     */
+    private final Function<String[], @NotNull TestableBlock> parser;
+
+    /**
+     * Create new lookup handler.
+     *
+     * @param parser The parser.
+     */
+    public BlocksLookupHandler(@NotNull final Function<String[], @NotNull TestableBlock> parser) {
+        this.parser = parser;
+    }
+
+    @Override
+    public @NotNull TestableBlock parse(@NotNull final String[] args) {
+        return parser.apply(args);
+    }
+
+    @Override
+    public boolean validate(@NotNull final TestableBlock object) {
+        return !(object instanceof EmptyTestableBlock);
+    }
+
+    @Override
+    public @NotNull TestableBlock getFailsafe() {
+        return new EmptyTestableBlock();
+    }
+
+    @Override
+    public @NotNull TestableBlock join(@NotNull final Collection<TestableBlock> options) {
+        return new GroupedTestableBlocks(options);
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/blocks/CustomBlock.java

@@ -0,0 +1,84 @@
+package com.willfp.eco.core.blocks;
+
+import org.apache.commons.lang.Validate;
+import org.bukkit.Location;
+import org.bukkit.NamespacedKey;
+import org.bukkit.block.Block;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+/**
+ * A custom block has 3 components.
+ *
+ * <ul>
+ *     <li>The key to identify it</li>
+ *     <li>The test to check if any block is this custom block</li>
+ *     <li>The supplier to spawn the custom {@link Block}</li>
+ * </ul>
+ */
+public class CustomBlock implements TestableBlock {
+    /**
+     * The key.
+     */
+    private final NamespacedKey key;
+
+    /**
+     * The test for block to pass.
+     */
+    private final Predicate<@NotNull Block> test;
+
+    /**
+     * The provider to spawn the block.
+     */
+    private final Function<Location, Block> provider;
+
+    /**
+     * Create a new custom block.
+     *
+     * @param key      The block key.
+     * @param test     The test.
+     * @param provider The provider to spawn the block.
+     */
+    public CustomBlock(@NotNull final NamespacedKey key,
+                       @NotNull final Predicate<@NotNull Block> test,
+                       @NotNull final Function<Location, Block> provider) {
+        this.key = key;
+        this.test = test;
+        this.provider = provider;
+    }
+
+    @Override
+    public boolean matches(@Nullable final Block other) {
+        if (other == null) {
+            return false;
+        }
+
+        return test.test(other);
+    }
+
+    @Override
+    public @NotNull Block place(@NotNull final Location location) {
+        Validate.notNull(location.getWorld());
+
+        return provider.apply(location);
+    }
+
+    /**
+     * Register the block.
+     */
+    public void register() {
+        Blocks.registerCustomBlock(this.getKey(), this);
+    }
+
+    /**
+     * Get the key.
+     *
+     * @return The key.
+     */
+    public NamespacedKey getKey() {
+        return this.key;
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/blocks/TestableBlock.java

@@ -0,0 +1,31 @@
+package com.willfp.eco.core.blocks;
+
+import com.willfp.eco.core.lookup.Testable;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A block with a test.
+ */
+public interface TestableBlock extends Testable<Block> {
+    /**
+     * If a Block matches the test.
+     *
+     * @param other The other block.
+     * @return If the block matches.
+     */
+    @Override
+    boolean matches(@Nullable Block other);
+
+    /**
+     * Place the block.
+     *
+     * @param location The location.
+     * @return The block.
+     */
+    @NotNull
+    Block place(@NotNull Location location);
+}

eco-api/src/main/java/com/willfp/eco/core/blocks/impl/EmptyTestableBlock.java

@@ -0,0 +1,29 @@
+package com.willfp.eco.core.blocks.impl;
+
+import com.willfp.eco.core.blocks.TestableBlock;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Empty block.
+ */
+public class EmptyTestableBlock implements TestableBlock {
+    /**
+     * Create a new empty testable block.
+     */
+    public EmptyTestableBlock() {
+
+    }
+
+    @Override
+    public boolean matches(@Nullable final Block other) {
+        return false;
+    }
+
+    @Override
+    public @NotNull Block place(@NotNull final Location location) {
+        return location.getBlock();
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/blocks/impl/GroupedTestableBlocks.java

@@ -0,0 +1,60 @@
+package com.willfp.eco.core.blocks.impl;
+
+import com.willfp.eco.core.blocks.TestableBlock;
+import com.willfp.eco.util.NumberUtils;
+import org.apache.commons.lang.Validate;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+/**
+ * A group of testable blocks.
+ */
+public class GroupedTestableBlocks implements TestableBlock {
+    /**
+     * The children.
+     */
+    private final Collection<TestableBlock> children;
+
+    /**
+     * Create a new group of testable blocks.
+     *
+     * @param children The children.
+     */
+    public GroupedTestableBlocks(@NotNull final Collection<TestableBlock> children) {
+        Validate.isTrue(!children.isEmpty(), "Group must have at least one child!");
+
+        this.children = children;
+    }
+
+    @Override
+    public boolean matches(@Nullable final Block other) {
+        for (TestableBlock child : children) {
+            if (child.matches(other)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public @NotNull Block place(@NotNull final Location location) {
+        return new ArrayList<>(children)
+                .get(NumberUtils.randInt(0, children.size() - 1))
+                .place(location);
+    }
+
+    /**
+     * Get the children.
+     *
+     * @return The children.
+     */
+    public Collection<TestableBlock> getChildren() {
+        return new ArrayList<>(children);
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/blocks/impl/MaterialTestableBlock.java

@@ -0,0 +1,59 @@
+package com.willfp.eco.core.blocks.impl;
+
+import com.willfp.eco.core.blocks.Blocks;
+import com.willfp.eco.core.blocks.TestableBlock;
+import org.apache.commons.lang.Validate;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A testable block for vanilla materials.
+ */
+public class MaterialTestableBlock implements TestableBlock {
+    /**
+     * The block type.
+     */
+    private final Material material;
+
+    /**
+     * Create a new unrestricted material testable block.
+     *
+     * @param material The material.
+     */
+    public MaterialTestableBlock(@NotNull final Material material) {
+        this.material = material;
+    }
+
+    @Override
+    public boolean matches(@Nullable final Block block) {
+        boolean simpleMatches = block != null && block.getType() == material;
+
+        if (!simpleMatches) {
+            return false;
+        }
+
+        return !Blocks.isCustomBlock(block);
+    }
+
+    @Override
+    public @NotNull Block place(@NotNull Location location) {
+        Validate.notNull(location.getWorld());
+
+        Block block = location.getWorld().getBlockAt(location);
+        block.setType(material);
+
+        return block;
+    }
+
+    /**
+     * Get the material.
+     *
+     * @return The material.
+     */
+    public Material getMaterial() {
+        return this.material;
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/blocks/impl/UnrestrictedMaterialTestableBlock.java

@@ -0,0 +1,52 @@
+package com.willfp.eco.core.blocks.impl;
+
+import com.willfp.eco.core.blocks.TestableBlock;
+import org.apache.commons.lang.Validate;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A testable block for materials regardless of data.
+ */
+public class UnrestrictedMaterialTestableBlock implements TestableBlock {
+    /**
+     * The block type.
+     */
+    private final Material material;
+
+    /**
+     * Create a new unrestricted material testable block.
+     *
+     * @param material The material.
+     */
+    public UnrestrictedMaterialTestableBlock(@NotNull final Material material) {
+        this.material = material;
+    }
+
+    @Override
+    public boolean matches(@Nullable final Block other) {
+        return other != null && other.getType() == material;
+    }
+
+    @Override
+    public @NotNull Block place(@NotNull Location location) {
+        Validate.notNull(location.getWorld());
+
+        Block block = location.getWorld().getBlockAt(location);
+        block.setType(material);
+
+        return block;
+    }
+
+    /**
+     * Get the material.
+     *
+     * @return The material.
+     */
+    public Material getMaterial() {
+        return this.material;
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/blocks/provider/BlockProvider.java

@@ -0,0 +1,49 @@
+package com.willfp.eco.core.blocks.provider;
+
+import com.willfp.eco.core.blocks.TestableBlock;
+import com.willfp.eco.core.registry.Registry;
+import org.apache.commons.lang.Validate;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Block providers are call-site registrations for blocks. In other words,
+ * they only register their blocks when a request is made. This is marginally
+ * slower, however it is required for certain plugins, and fixes bugs related to
+ * loading orders.
+ *
+ * @see TestableBlock
+ */
+public abstract class BlockProvider {
+    /**
+     * The namespace.
+     */
+    private final String namespace;
+
+    /**
+     * Create a new BlockProvider for a specific namespace.
+     *
+     * @param namespace The namespace.
+     */
+    protected BlockProvider(@NotNull final String namespace) {
+        this.namespace = namespace;
+    }
+
+    /**
+     * Provide a TestableBlock for a given key.
+     *
+     * @param key The block ID.
+     * @return The TestableBlock, or null if not found.
+     */
+    @Nullable
+    public abstract TestableBlock provideForKey(@NotNull String key);
+
+    /**
+     * Get the namespace.
+     *
+     * @return The namespace.
+     */
+    public String getNamespace() {
+        return this.namespace;
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/display/Display.java

@@ -211,12 +211,22 @@ public final class Display {
                 new ArrayList<>()
         );
 
-        modules.removeIf(it -> it.getPluginName().equalsIgnoreCase(module.getPluginName()));
         modules.add(module);
 
         REGISTERED_MODULES.put(module.getWeight(), modules);
     }
 
+    /**
+     * Unregister a display module.
+     *
+     * @param module The module.
+     */
+    public static void unregisterDisplayModule(@NotNull final DisplayModule module) {
+        for (List<DisplayModule> modules : REGISTERED_MODULES.values()) {
+            modules.remove(module);
+        }
+    }
+
     private Display() {
         throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
     }

eco-api/src/main/java/com/willfp/eco/core/integrations/customblocks/CustomBlocksIntegration.java

@@ -0,0 +1,24 @@
+package com.willfp.eco.core.integrations.customblocks;
+
+import com.willfp.eco.core.integrations.Integration;
+
+/**
+ * Wrapper class for custom block integrations.
+ */
+public interface CustomBlocksIntegration extends Integration {
+    /**
+     * Register all the custom block for a specific plugin into eco.
+     *
+     * @see com.willfp.eco.core.blocks.Blocks
+     */
+    default void registerAllBlocks() {
+        // Override when needed.
+    }
+
+    /**
+     * Register {@link com.willfp.eco.core.blocks.provider.BlockProvider}s.
+     */
+    default void registerProvider() {
+        // Override when needed.
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/integrations/customblocks/CustomBlocksManager.java

@@ -0,0 +1,45 @@
+package com.willfp.eco.core.integrations.customblocks;
+
+import com.willfp.eco.core.integrations.IntegrationRegistry;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Class to handle custom block integrations.
+ */
+public final class CustomBlocksManager {
+    /**
+     * A set of all registered integrations.
+     */
+    private static final IntegrationRegistry<CustomBlocksIntegration> REGISTRY = new IntegrationRegistry<>();
+
+    /**
+     * Register a new integration.
+     *
+     * @param integration The integration to register.
+     */
+    public static void register(@NotNull final CustomBlocksIntegration integration) {
+        REGISTRY.register(integration);
+    }
+
+    /**
+     * Register all the custom block for a specific plugin into eco.
+     *
+     * @see com.willfp.eco.core.blocks.Blocks
+     */
+    public static void registerAllBlocks() {
+        REGISTRY.forEachSafely(CustomBlocksIntegration::registerAllBlocks);
+    }
+
+    /**
+     * Register all the custom blocks for a specific plugin into eco.
+     *
+     * @see com.willfp.eco.core.blocks.Blocks
+     */
+    public static void registerProviders() {
+        REGISTRY.forEachSafely(CustomBlocksIntegration::registerProvider);
+    }
+
+    private CustomBlocksManager() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/items/Items.java

@@ -6,6 +6,7 @@ import com.willfp.eco.core.Eco;
 import com.willfp.eco.core.fast.FastItemStack;
 import com.willfp.eco.core.items.args.LookupArgParser;
 import com.willfp.eco.core.items.provider.ItemProvider;
+import com.willfp.eco.core.items.tag.ItemTag;
 import com.willfp.eco.core.recipe.parts.EmptyTestableItem;
 import com.willfp.eco.core.recipe.parts.MaterialTestableItem;
 import com.willfp.eco.core.recipe.parts.ModifiedTestableItem;
@@ -13,7 +14,6 @@ import com.willfp.eco.core.recipe.parts.TestableStack;
 import com.willfp.eco.core.recipe.parts.UnrestrictedMaterialTestableItem;
 import com.willfp.eco.util.NamespacedKeyUtils;
 import com.willfp.eco.util.NumberUtils;
-import kotlin.Suppress;
 import org.bukkit.Material;
 import org.bukkit.NamespacedKey;
 import org.bukkit.enchantments.Enchantment;
@@ -93,6 +93,11 @@ public final class Items {
      */
     private static final Map<String, Material> FRIENDLY_MATERIAL_NAMES = new HashMap<>();
 
+    /**
+     * All tags.
+     */
+    private static final Map<String, ItemTag> TAGS = new HashMap<>();
+
     /**
      * Register a new custom item.
      *
@@ -217,7 +222,20 @@ public final class Items {
 
         String[] split = args[0].toLowerCase().split(":");
 
-        if (split.length == 1) {
+        String base = split[0];
+        boolean isTag = base.startsWith("#");
+
+        if (isTag) {
+            String tag = base.substring(1);
+            ItemTag itemTag = TAGS.get(tag);
+
+            if (itemTag == null) {
+                return new EmptyTestableItem();
+            }
+            item = itemTag.toTestableItem();
+        }
+
+        if (split.length == 1 && !isTag) {
             String itemType = args[0];
             boolean isWildcard = itemType.startsWith("*");
             if (isWildcard) {
@@ -230,7 +248,7 @@ public final class Items {
             item = isWildcard ? new UnrestrictedMaterialTestableItem(material) : new MaterialTestableItem(material);
         }
 
-        if (split.length == 2) {
+        if (split.length == 2 && !isTag) {
             String namespace = split[0];
             String keyID = split[1];
             NamespacedKey namespacedKey = NamespacedKeyUtils.create(namespace, keyID);
@@ -274,7 +292,7 @@ public final class Items {
         Legacy namespace:id:amount format
         This has been superseded by namespace:id amount
          */
-        if (split.length == 3) {
+        if (split.length == 3 && !isTag) {
             TestableItem part = REGISTRY.get(NamespacedKeyUtils.create(split[0], split[1]));
             if (part == null) {
                 return new EmptyTestableItem();
@@ -306,7 +324,8 @@ public final class Items {
 
         List<Predicate<ItemStack>> predicates = new ArrayList<>();
 
-        for (LookupArgParser argParser : ARG_PARSERS) {
+        for (
+                LookupArgParser argParser : ARG_PARSERS) {
             Predicate<ItemStack> predicate = argParser.parseArguments(modifierArgs, meta);
             if (predicate != null) {
                 predicates.add(argParser.parseArguments(modifierArgs, meta));
@@ -611,6 +630,24 @@ public final class Items {
         return false;
     }
 
+    /**
+     * Register a new item tag.
+     *
+     * @param tag The tag.
+     */
+    public static void registerTag(@NotNull final ItemTag tag) {
+        TAGS.put(tag.getIdentifier(), tag);
+    }
+
+    /**
+     * Get all tags.
+     *
+     * @return All tags.
+     */
+    public static Collection<ItemTag> getTags() {
+        return TAGS.values();
+    }
+
     private Items() {
         throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
     }

eco-api/src/main/java/com/willfp/eco/core/items/tag/CustomItemTag.java

@@ -0,0 +1,29 @@
+package com.willfp.eco.core.items.tag;
+
+import org.bukkit.NamespacedKey;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A custom item tag.
+ */
+public abstract class CustomItemTag implements ItemTag {
+    /**
+     * The key.
+     */
+    private final NamespacedKey key;
+
+    /**
+     * Create a new custom item tag.
+     *
+     * @param key         The key.
+     */
+    public CustomItemTag(@NotNull final NamespacedKey key) {
+        this.key = key;
+    }
+
+    @Override
+    @NotNull
+    public String getIdentifier() {
+        return key.toString();
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/items/tag/ItemTag.java

@@ -0,0 +1,66 @@
+package com.willfp.eco.core.items.tag;
+
+import com.willfp.eco.core.items.TestableItem;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A group of items that share a common trait.
+ */
+public interface ItemTag {
+    /**
+     * Get the identifier of the tag.
+     *
+     * @return The identifier.
+     */
+    @NotNull
+    String getIdentifier();
+
+    /**
+     * Check if an item matches the tag.
+     *
+     * @param itemStack The item to check.
+     * @return If the item matches the tag.
+     */
+    boolean matches(@NotNull ItemStack itemStack);
+
+    /**
+     * Get an example item.
+     *
+     * @return The example item.
+     */
+    @Nullable
+    default ItemStack getExampleItem() {
+        return null;
+    }
+
+    /**
+     * Convert this tag to a testable item.
+     *
+     * @return The testable item.
+     */
+    @NotNull
+    default TestableItem toTestableItem() {
+        return new TestableItem() {
+            @Override
+            public boolean matches(@Nullable final ItemStack itemStack) {
+                return itemStack != null && ItemTag.this.matches(itemStack);
+            }
+
+            @Override
+            public @NotNull ItemStack getItem() {
+                ItemStack example = ItemTag.this.getExampleItem();
+                return example == null ? new ItemStack(Material.STONE) : example;
+            }
+
+            @Override
+            public String toString() {
+                return "ItemTagTestableItem{" +
+                        "tag=" + ItemTag.this.getIdentifier() +
+                        '}';
+            }
+        };
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/items/tag/VanillaItemTag.java

@@ -0,0 +1,58 @@
+package com.willfp.eco.core.items.tag;
+
+import org.bukkit.Material;
+import org.bukkit.Tag;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A vanilla item tag.
+ */
+public final class VanillaItemTag implements ItemTag {
+    /**
+     * The identifier.
+     */
+    private final String identifier;
+
+    /**
+     * The tag.
+     */
+    private final Tag<Material> tag;
+
+    /**
+     * Create a new vanilla item tag.
+     *
+     * @param identifier The identifier.
+     * @param tag        The tag.
+     */
+    public VanillaItemTag(@NotNull final String identifier,
+                          @NotNull final Tag<Material> tag) {
+        this.identifier = identifier;
+        this.tag = tag;
+    }
+
+    /**
+     * Get the tag.
+     *
+     * @return The tag.
+     */
+    public Tag<Material> getTag() {
+        return tag;
+    }
+
+    @Override
+    @NotNull
+    public String getIdentifier() {
+        return identifier;
+    }
+
+    @Override
+    public boolean matches(@NotNull final ItemStack itemStack) {
+        return tag.isTagged(itemStack.getType());
+    }
+
+    @Override
+    public @NotNull ItemStack getExampleItem() {
+        return new ItemStack(tag.getValues().stream().findFirst().orElse(Material.STONE));
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/proxy/ProxyConstants.java

@@ -28,7 +28,7 @@ public final class ProxyConstants {
             "v1_20_R1",
             "v1_20_R2",
             "v1_20_R3",
-            "v1_20_6"
+            "v1_21"
     );
 
     private ProxyConstants() {

eco-api/src/main/java/com/willfp/eco/util/DurabilityUtils.java

@@ -158,11 +158,8 @@ public final class DurabilityUtils {
         }
 
         if (item.getItemMeta() instanceof Damageable meta) {
-            meta.setDamage(meta.getDamage() - repair);
+            meta.setDamage(Math.max(0, meta.getDamage() - repair));
 
-            if (meta.getDamage() < 0) {
-                meta.setDamage(0);
-            }
             item.setItemMeta((ItemMeta) meta);
         }
     }

eco-core/core-backend-modern/build.gradle.kts

@@ -0,0 +1,19 @@
+group = "com.willfp"
+version = rootProject.version
+
+dependencies {
+    compileOnly(project(":eco-core:core-backend"))
+    compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT")
+}
+
+tasks {
+    compileJava {
+        options.release = 21
+    }
+
+    compileKotlin {
+        kotlinOptions {
+            jvmTarget = "21"
+        }
+    }
+}

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/entities/ModernEntityArgParsersImpl.kt

@@ -0,0 +1,13 @@
+package com.willfp.eco.internal.compat.modern.entities
+
+import com.willfp.eco.core.entities.Entities
+import com.willfp.eco.internal.compat.modern.entities.parsers.EntityArgParserJumpStrength
+import com.willfp.eco.internal.compat.modern.entities.parsers.EntityArgParserScale
+import com.willfp.eco.internal.entities.ModernEntityArgParsers
+
+class ModernEntityArgParsersImpl: ModernEntityArgParsers {
+    override fun registerAll() {
+        Entities.registerArgParser(EntityArgParserScale)
+        Entities.registerArgParser(EntityArgParserJumpStrength)
+    }
+}

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/entities/parsers/EntityArgParserJumpStrength.kt

@@ -1,4 +1,4 @@
-package com.willfp.eco.internal.entities
+package com.willfp.eco.internal.compat.modern.entities.parsers
 
 import com.willfp.eco.core.entities.args.EntityArgParseResult
 import com.willfp.eco.core.entities.args.EntityArgParser
@@ -28,7 +28,7 @@ object EntityArgParserJumpStrength : EntityArgParser {
                     return@EntityArgParseResult false
                 }
 
-                val inst = it.getAttribute(Attribute.HORSE_JUMP_STRENGTH) ?: return@EntityArgParseResult false
+                val inst = it.getAttribute(Attribute.GENERIC_JUMP_STRENGTH) ?: return@EntityArgParseResult false
                 inst.value >= attributeValue
             },
             {
@@ -36,7 +36,7 @@ object EntityArgParserJumpStrength : EntityArgParser {
                     return@EntityArgParseResult
                 }
 
-                it.getAttribute(Attribute.HORSE_JUMP_STRENGTH)?.baseValue = attributeValue
+                it.getAttribute(Attribute.GENERIC_JUMP_STRENGTH)?.baseValue = attributeValue
             }
         )
     }

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/entities/parsers/EntityArgParserScale.kt

@@ -0,0 +1,45 @@
+package com.willfp.eco.internal.compat.modern.entities.parsers
+
+import com.willfp.eco.core.entities.args.EntityArgParseResult
+import com.willfp.eco.core.entities.args.EntityArgParser
+import org.bukkit.attribute.Attribute
+import org.bukkit.entity.LivingEntity
+import org.bukkit.entity.Phantom
+import org.bukkit.entity.Slime
+
+object EntityArgParserScale : EntityArgParser {
+    override fun parseArguments(args: Array<out String>): EntityArgParseResult? {
+        var attributeValue: Double? = null
+
+        for (arg in args) {
+            val argSplit = arg.split(":")
+            if (!argSplit[0].equals("scale", ignoreCase = true)) {
+                continue
+            }
+            if (argSplit.size < 2) {
+                continue
+            }
+            attributeValue = argSplit[1].toDoubleOrNull()
+        }
+
+        attributeValue ?: return null
+
+        return EntityArgParseResult(
+            {
+                if (it !is LivingEntity) {
+                    return@EntityArgParseResult false
+                }
+
+                val inst = it.getAttribute(Attribute.GENERIC_SCALE) ?: return@EntityArgParseResult false
+                inst.value >= attributeValue
+            },
+            {
+                if (it !is LivingEntity) {
+                    return@EntityArgParseResult
+                }
+
+                it.getAttribute(Attribute.GENERIC_SCALE)?.baseValue = attributeValue
+            }
+        )
+    }
+}

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/items/ModernItemArgParsersImpl.kt

@@ -0,0 +1,21 @@
+package com.willfp.eco.internal.compat.modern.items
+
+import com.willfp.eco.core.items.Items
+import com.willfp.eco.internal.compat.modern.items.parsers.ArgParserFireResistant
+import com.willfp.eco.internal.compat.modern.items.parsers.ArgParserGlint
+import com.willfp.eco.internal.compat.modern.items.parsers.ArgParserItemName
+import com.willfp.eco.internal.compat.modern.items.parsers.ArgParserMaxDamage
+import com.willfp.eco.internal.compat.modern.items.parsers.ArgParserMaxStackSize
+import com.willfp.eco.internal.compat.modern.items.parsers.ArgParserTrim
+import com.willfp.eco.internal.items.ModernItemArgParsers
+
+class ModernItemArgParsersImpl : ModernItemArgParsers {
+    override fun registerAll() {
+        Items.registerArgParser(ArgParserTrim)
+        Items.registerArgParser(ArgParserFireResistant)
+        Items.registerArgParser(ArgParserGlint)
+        Items.registerArgParser(ArgParserItemName)
+        Items.registerArgParser(ArgParserMaxDamage)
+        Items.registerArgParser(ArgParserMaxStackSize)
+    }
+}

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/items/parsers/ArgParserFireResistant.kt

@@ -0,0 +1,14 @@
+package com.willfp.eco.internal.compat.modern.items.parsers
+
+import com.willfp.eco.internal.items.templates.FlagArgParser
+import org.bukkit.inventory.meta.ItemMeta
+
+object ArgParserFireResistant : FlagArgParser("fire_resistant") {
+    override fun apply(meta: ItemMeta) {
+        meta.isFireResistant = true
+    }
+
+    override fun test(meta: ItemMeta): Boolean {
+        return meta.isFireResistant
+    }
+}

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/items/parsers/ArgParserGlint.kt

@@ -0,0 +1,14 @@
+package com.willfp.eco.internal.compat.modern.items.parsers
+
+import com.willfp.eco.internal.items.templates.FlagArgParser
+import org.bukkit.inventory.meta.ItemMeta
+
+object ArgParserGlint : FlagArgParser("glint") {
+    override fun apply(meta: ItemMeta) {
+        meta.setEnchantmentGlintOverride(true)
+    }
+
+    override fun test(meta: ItemMeta): Boolean {
+        return meta.hasEnchantmentGlintOverride()
+    }
+}

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/items/parsers/ArgParserItemName.kt

@@ -0,0 +1,27 @@
+package com.willfp.eco.internal.compat.modern.items.parsers
+
+import com.willfp.eco.internal.items.templates.ValueArgParser
+import com.willfp.eco.util.StringUtils
+import net.kyori.adventure.text.Component
+import net.kyori.adventure.text.minimessage.MiniMessage
+import org.bukkit.inventory.meta.ItemMeta
+
+object ArgParserItemName : ValueArgParser<Component>("item_name") {
+    override fun parse(arg: String): Component {
+        return StringUtils.formatToComponent(arg)
+    }
+
+    override fun apply(meta: ItemMeta, value: Component) {
+        meta.itemName(value)
+    }
+
+    override fun test(meta: ItemMeta): String? {
+        if (!meta.hasItemName()) {
+            return null
+        }
+
+        val name = MiniMessage.miniMessage().serialize(meta.itemName())
+
+        return name
+    }
+}

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/items/parsers/ArgParserMaxDamage.kt

@@ -0,0 +1,31 @@
+package com.willfp.eco.internal.compat.modern.items.parsers
+
+import com.willfp.eco.internal.items.templates.ValueArgParser
+import org.bukkit.inventory.meta.Damageable
+import org.bukkit.inventory.meta.ItemMeta
+
+object ArgParserMaxDamage : ValueArgParser<Int>("max_damage") {
+    override fun parse(arg: String): Int? {
+        return arg.toIntOrNull()
+    }
+
+    override fun apply(meta: ItemMeta, value: Int) {
+        if (meta !is Damageable) {
+            return
+        }
+
+        meta.setMaxDamage(value)
+    }
+
+    override fun test(meta: ItemMeta): String? {
+        if (meta !is Damageable) {
+            return null
+        }
+
+        if (!meta.hasMaxDamage()) {
+            return null
+        }
+
+        return meta.maxDamage.toString()
+    }
+}

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/items/parsers/ArgParserMaxStackSize.kt

@@ -0,0 +1,22 @@
+package com.willfp.eco.internal.compat.modern.items.parsers
+
+import com.willfp.eco.internal.items.templates.ValueArgParser
+import org.bukkit.inventory.meta.ItemMeta
+
+object ArgParserMaxStackSize : ValueArgParser<Int>("max_stack_size") {
+    override fun parse(arg: String): Int? {
+        return arg.toIntOrNull()
+    }
+
+    override fun apply(meta: ItemMeta, value: Int) {
+        meta.setMaxStackSize(value)
+    }
+
+    override fun test(meta: ItemMeta): String? {
+        if (!meta.hasMaxStackSize()) {
+            return null
+        }
+
+        return meta.maxStackSize.toString()
+    }
+}

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/items/parsers/ArgParserTrim.kt

@@ -1,4 +1,4 @@
-package com.willfp.eco.internal.items
+package com.willfp.eco.internal.compat.modern.items.parsers
 
 import com.willfp.eco.core.items.args.LookupArgParser
 import org.bukkit.NamespacedKey
@@ -23,7 +23,11 @@ object ArgParserTrim : LookupArgParser {
             if (!argSplit[0].equals("trim", ignoreCase = true)) {
                 continue
             }
+
+            @Suppress("DEPRECATION")
             material = Registry.TRIM_MATERIAL.get(NamespacedKey.minecraft(argSplit.getOrElse(1) {""}))
+
+            @Suppress("DEPRECATION")
             pattern = Registry.TRIM_PATTERN.get(NamespacedKey.minecraft(argSplit.getOrElse(2) {""}))
         }
 
@@ -43,6 +47,11 @@ object ArgParserTrim : LookupArgParser {
     override fun serializeBack(meta: ItemMeta): String? {
         val trim = (meta as? ArmorMeta)?.trim ?: return null
 
-        return "trim:${trim.material.key.key.lowercase()}:${trim.pattern.key.key.lowercase()}"
+        @Suppress("DEPRECATION")
+        val materialKey = Registry.TRIM_MATERIAL.getKey(trim.material) ?: return null
+        @Suppress("DEPRECATION")
+        val patternKey = Registry.TRIM_PATTERN.getKey(trim.pattern) ?: return null
+
+        return "trim:${materialKey.key.lowercase()}:${patternKey.key.lowercase()}"
     }
 }

eco-core/core-backend-modern/src/main/kotlin/com/willfp/eco/internal/compat/modern/recipes/AutocrafterPatchImpl.kt

@@ -0,0 +1,19 @@
+@file:Suppress("UnstableApiUsage")
+
+package com.willfp.eco.internal.compat.modern.recipes
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.internal.recipes.AutocrafterPatch
+import org.bukkit.event.EventHandler
+import org.bukkit.event.block.CrafterCraftEvent
+
+class AutocrafterPatchImpl: AutocrafterPatch {
+    @EventHandler
+    fun preventEcoRecipes(event: CrafterCraftEvent) {
+        if (!EcoPlugin.getPluginNames().contains(event.recipe.key.namespace)) {
+            return
+        }
+
+        event.isCancelled = true
+    }
+}

eco-core/core-backend/build.gradle.kts

@@ -13,3 +13,15 @@ dependencies {
     compileOnly("org.yaml:snakeyaml:1.33")
     compileOnly("com.moandjiezana.toml:toml4j:0.7.2")
 }
+
+tasks {
+    compileJava {
+        options.release = 17
+    }
+
+    compileKotlin {
+        kotlinOptions {
+            jvmTarget = "17"
+        }
+    }
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/command/HandledCommand.kt

@@ -126,14 +126,19 @@ abstract class HandledCommand(
      * @return The tab completion results.
      */
     private fun CommandBase.handleTabComplete(sender: CommandSender, args: List<String>): List<String> {
-        if (!sender.hasPermission(permission)) return emptyList()
+        if (!sender.hasPermission(permission)) {
+            return emptyList()
+        }
 
         if (args.size == 1) {
-            val completions = subcommands.filter { sender.hasPermission(it.permission) }.map { it.name }
+            val completions = mutableListOf<String>()
 
-            val list = mutableListOf<String>()
+            StringUtil.copyPartialMatches(
+                args[0],
+                subcommands.filter { sender.hasPermission(it.permission) }.map { it.name },
+                completions
+            )
 
-            StringUtil.copyPartialMatches(args[0], completions, list)
             if (completions.isNotEmpty()) {
                 return completions
             }
@@ -156,9 +161,11 @@ abstract class HandledCommand(
         }
 
         val completions = tabComplete(sender, args).toMutableList()
+
         if (sender is Player) {
             completions.addAll(tabComplete(sender, args))
         }
+
         return completions.sorted()
     }
 }

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/compat/ModernCompatibility.kt

@@ -0,0 +1,68 @@
+package com.willfp.eco.internal.compat
+
+import com.willfp.eco.core.Prerequisite
+import com.willfp.eco.core.proxy.exceptions.ProxyError
+
+private const val BASE_PACKAGE = "com.willfp.eco.internal.compat.modern"
+private val isModern = Prerequisite.HAS_PAPER.isMet && Prerequisite.HAS_1_21.isMet
+
+internal annotation class ModernCompatibilityProxy(
+    val location: String
+)
+
+private val cache = mutableMapOf<Class<*>, Any>()
+
+object ModernCompatibilityScope {
+    inline fun <reified T> loadProxy(): T {
+        return loadCompatibilityProxy(T::class.java)
+    }
+
+    inline fun <reified T> useProxy(block: T.() -> Any?) {
+        val proxy = loadProxy<T>()
+
+        with(proxy) {
+            block()
+        }
+    }
+}
+
+fun <R> ifModern(block: ModernCompatibilityScope.() -> R) {
+    if (!isModern) {
+        return
+    }
+
+    block(ModernCompatibilityScope)
+}
+
+fun <T> loadCompatibilityProxy(clazz: Class<T>): T {
+    @Suppress("UNCHECKED_CAST")
+    return cache.getOrPut(clazz) {
+        loadProxyUncached(clazz)
+    } as T
+}
+
+private fun loadProxyUncached(clazz: Class<*>): Any {
+    val proxy = clazz.getAnnotation(ModernCompatibilityProxy::class.java)
+    val location = proxy?.location ?: throw IllegalArgumentException("Class ${clazz.name} is not a proxy")
+    val className = "$BASE_PACKAGE.$location"
+
+    try {
+        val found = Class.forName(className)
+
+        val constructor = found.getConstructor()
+        val instance = constructor.newInstance()
+
+        if (!clazz.isInstance(instance)) {
+            throw ProxyError(
+                "Modern compatibility proxy class $className does not implement ${clazz.name}",
+                ClassCastException()
+            )
+        }
+
+        return instance
+    } catch (e: ClassNotFoundException) {
+        throw ProxyError("Could not find modern compatibility proxy class $className", e)
+    } catch (e: NoSuchMethodException) {
+        throw ProxyError("Could not find no-args constructor for modern compatibility proxy class $className", e)
+    }
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/entities/ModernEntityArgParsers.kt

@@ -0,0 +1,8 @@
+package com.willfp.eco.internal.entities
+
+import com.willfp.eco.internal.compat.ModernCompatibilityProxy
+
+@ModernCompatibilityProxy("entities.ModernEntityArgParsersImpl")
+interface ModernEntityArgParsers {
+    fun registerAll()
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/gui/menu/RenderedInventory.kt

@@ -1,5 +1,7 @@
 package com.willfp.eco.internal.gui.menu
 
+import com.willfp.eco.core.Eco
+import com.willfp.eco.core.Prerequisite
 import com.willfp.eco.core.gui.menu.events.CaptiveItemChangeEvent
 import com.willfp.eco.core.items.isEcoEmpty
 import com.willfp.eco.core.recipe.parts.EmptyTestableItem
@@ -20,9 +22,23 @@ fun Player.forceRenderedInventory(menu: RenderedInventory) {
     trackedForceRendered[this.uniqueId] = menu
 }
 
+// Workaround because 1.21 has OpenInventory as an interface instead of an abstract class like in previous versions
+interface TopInventoryProxy {
+    fun getTopInventory(player: Player): Inventory
+}
+
+private val Player.topInventory: Inventory
+    get() {
+        return if (!Prerequisite.HAS_1_21.isMet) {
+            Eco.get().ecoPlugin.getProxy(TopInventoryProxy::class.java).getTopInventory(this)
+        } else {
+            this.openInventory.topInventory
+        }
+    }
+
 val Player.renderedInventory: RenderedInventory?
     get() = trackedForceRendered[this.uniqueId]
-        ?: this.openInventory.topInventory.asRenderedInventory()
+        ?: this.topInventory.asRenderedInventory()
 
 class RenderedInventory(
     val menu: EcoMenu,

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/items/ArgParserCustomModelData.kt

@@ -7,20 +7,12 @@ import java.util.function.Predicate
 
 object ArgParserCustomModelData : LookupArgParser {
     override fun parseArguments(args: Array<out String>, meta: ItemMeta): Predicate<ItemStack>? {
-        var modelData: Int? = null
+        val arg = args.firstOrNull {
+            it.startsWith("custom-model-data:", ignoreCase = true)
+                    || it.startsWith("custom_model_data:", ignoreCase = true)
+        } ?: return null
 
-        for (arg in args) {
+        val modelData = arg.split(":")[1].toIntOrNull() ?: return null
-            val argSplit = arg.split(":")
-            if (!argSplit[0].equals("custom-model-data", ignoreCase = true)) {
-                continue
-            }
-            if (argSplit.size < 2) {
-                continue
-            }
-            modelData = argSplit[1].toIntOrNull()
-        }
-
-        modelData ?: return null
 
         meta.setCustomModelData(modelData)
 
@@ -40,6 +32,6 @@ object ArgParserCustomModelData : LookupArgParser {
             return null
         }
 
-        return "custom-model-data:${meta.customModelData}"
+        return "custom_model_data:${meta.customModelData}"
     }
 }

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/items/ArgParserEnchantment.kt

@@ -2,7 +2,7 @@ package com.willfp.eco.internal.items
 
 import com.willfp.eco.core.fast.fast
 import com.willfp.eco.core.items.args.LookupArgParser
-import com.willfp.eco.util.NamespacedKeyUtils
+import org.bukkit.NamespacedKey
 import org.bukkit.enchantments.Enchantment
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.EnchantmentStorageMeta
@@ -16,16 +16,10 @@ object ArgParserEnchantment : LookupArgParser {
         for (arg in args) {
             val argSplit = arg.split(":")
 
-            if (argSplit.size < 2) {
+            val enchant = Enchantment.getByKey(NamespacedKey.minecraft(argSplit[0].lowercase())) ?: continue
-                continue
+            val level = argSplit.getOrNull(1)?.toIntOrNull() ?: enchant.maxLevel
-            }
 
-            val enchant = Enchantment.getByKey(NamespacedKeyUtils.create("minecraft", argSplit[0]))
+            enchants[enchant] = level
-            val level = argSplit[1].toIntOrNull()
-
-            if (enchant != null && level != null) {
-                enchants[enchant] = level
-            }
         }
 
         if (enchants.isEmpty()) {

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/items/ArgParserName.kt

@@ -1,44 +1,30 @@
 package com.willfp.eco.internal.items
 
-import com.willfp.eco.core.items.args.LookupArgParser
+import com.willfp.eco.internal.items.templates.ValueArgParser
 import com.willfp.eco.util.StringUtils
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.ItemMeta
 import java.util.function.Predicate
 
-object ArgParserName : LookupArgParser {
+object ArgParserName : ValueArgParser<String>("name") {
-    override fun parseArguments(args: Array<out String>, meta: ItemMeta): Predicate<ItemStack>? {
+    override fun parse(arg: String): String {
-        var name: String? = null
+        return arg
+    }
 
-        for (arg in args) {
+    override fun apply(meta: ItemMeta, value: String) {
-            if (!arg.lowercase().startsWith("name:")) {
+        val formatted = StringUtils.format(value)
-                continue
-            }
-            name = arg.substring(5, arg.length)
-        }
-
-        name ?: return null
-
-        val formatted = StringUtils.format(name)
 
         // I don't know why it says it's redundant, the compiler yells at me
         @Suppress("UsePropertyAccessSyntax", "RedundantSuppression", "DEPRECATION")
         meta.setDisplayName(formatted)
-
-        return Predicate {
-            val testMeta = it.itemMeta ?: return@Predicate false
-
-            @Suppress("DEPRECATION")
-            testMeta.displayName == formatted
-        }
     }
 
-    override fun serializeBack(meta: ItemMeta): String? {
+    override fun test(meta: ItemMeta): String? {
         if (!meta.hasDisplayName()) {
             return null
         }
 
         @Suppress("DEPRECATION")
-        return "name:\"${meta.displayName}\""
+        return meta.displayName
     }
 }

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/items/ArgParserUnbreakable.kt

@@ -1,38 +1,14 @@
 package com.willfp.eco.internal.items
 
-import com.willfp.eco.core.items.args.LookupArgParser
+import com.willfp.eco.internal.items.templates.FlagArgParser
-import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.ItemMeta
-import java.util.function.Predicate
-
-object ArgParserUnbreakable : LookupArgParser {
-    override fun parseArguments(args: Array<out String>, meta: ItemMeta): Predicate<ItemStack>? {
-        var unbreakable = false
-
-        for (arg in args) {
-            if (arg.equals("unbreakable", true)) {
-                unbreakable = true
-            }
-        }
-
-        if (!unbreakable) {
-            return null
-        }
 
+object ArgParserUnbreakable : FlagArgParser("unbreakable") {
+    override fun apply(meta: ItemMeta) {
         meta.isUnbreakable = true
-
-        return Predicate {
-            val testMeta = it.itemMeta ?: return@Predicate false
-
-            testMeta.isUnbreakable
-        }
     }
 
-    override fun serializeBack(meta: ItemMeta): String? {
+    override fun test(meta: ItemMeta): Boolean {
-        if (!meta.isUnbreakable) {
+        return meta.isUnbreakable
-            return null
-        }
-
-        return "unbreakable"
     }
 }

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/items/ModernItemArgParsers.kt

@@ -0,0 +1,8 @@
+package com.willfp.eco.internal.items
+
+import com.willfp.eco.internal.compat.ModernCompatibilityProxy
+
+@ModernCompatibilityProxy("items.ModernItemArgParsersImpl")
+interface ModernItemArgParsers {
+    fun registerAll()
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/items/tags/VanillaItemTags.kt

@@ -0,0 +1,39 @@
+package com.willfp.eco.internal.items.tags
+
+import com.willfp.eco.core.items.Items
+import com.willfp.eco.core.items.tag.VanillaItemTag
+import org.bukkit.Keyed
+import org.bukkit.Material
+import org.bukkit.Tag
+
+object VanillaItemTags {
+    fun register() {
+        // Get all tags
+        val allTags = Tag::class.java.declaredFields
+            .filter { it.type == Tag::class.java }
+            .mapNotNull {
+                val tag = it.get(null) as? Tag<*>
+                if (tag == null) {
+                    null
+                } else {
+                    NamedTag(it.name.lowercase(), tag)
+                }
+            }
+
+        // Register all tags
+        for (tag in allTags) {
+            if (tag.isMaterial) {
+                Items.registerTag(
+                    @Suppress("UNCHECKED_CAST")
+                    VanillaItemTag(tag.name, tag.tag as Tag<Material>)
+                )
+            }
+        }
+    }
+
+    private data class NamedTag<T : Keyed>(val name: String, val tag: Tag<T>) {
+        // Check if tag is material
+        val isMaterial: Boolean
+            get() = tag.values.firstOrNull() is Material
+    }
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/items/templates/FlagArgParser.kt

@@ -0,0 +1,44 @@
+package com.willfp.eco.internal.items.templates
+
+import com.willfp.eco.core.items.args.LookupArgParser
+import org.bukkit.inventory.ItemStack
+import org.bukkit.inventory.meta.ItemMeta
+import java.util.function.Predicate
+
+abstract class FlagArgParser(
+    protected val flag: String
+) : LookupArgParser {
+    abstract fun apply(meta: ItemMeta)
+
+    abstract fun test(meta: ItemMeta): Boolean
+
+    override fun parseArguments(args: Array<out String>, meta: ItemMeta): Predicate<ItemStack>? {
+        var has = false
+
+        for (arg in args) {
+            if (arg.equals(flag, true)) {
+                has = true
+            }
+        }
+
+        if (!has) {
+            return null
+        }
+
+        apply(meta)
+
+        return Predicate {
+            val testMeta = it.itemMeta ?: return@Predicate false
+
+            test(testMeta)
+        }
+    }
+
+    override fun serializeBack(meta: ItemMeta): String? {
+        if (!test(meta)) {
+            return null
+        }
+
+        return flag
+    }
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/items/templates/ValueArgParser.kt

@@ -0,0 +1,50 @@
+package com.willfp.eco.internal.items.templates
+
+import com.willfp.eco.core.items.args.LookupArgParser
+import com.willfp.eco.util.StringUtils
+import org.bukkit.inventory.ItemStack
+import org.bukkit.inventory.meta.ItemMeta
+import java.util.function.Predicate
+
+abstract class ValueArgParser<T: Any>(
+    protected val flag: String
+) : LookupArgParser {
+    abstract fun parse(arg: String): T?
+
+    abstract fun apply(meta: ItemMeta, value: T)
+
+    abstract fun test(meta: ItemMeta): String?
+
+    override fun parseArguments(args: Array<out String>, meta: ItemMeta): Predicate<ItemStack>? {
+        var argument: String? = null
+
+        for (arg in args) {
+            if (!arg.lowercase().startsWith("${flag}:")) {
+                continue
+            }
+            argument = arg.substring(flag.length + 1, arg.length)
+        }
+
+        argument ?: return null
+
+        val parsed = parse(argument) ?: return null
+
+        apply(meta, parsed)
+
+        return Predicate {
+            val testMeta = it.itemMeta ?: return@Predicate false
+
+            test(testMeta) == parsed
+        }
+    }
+
+    override fun serializeBack(meta: ItemMeta): String? {
+        val test = test(meta)
+
+        if (test.isNullOrBlank()) {
+            return null
+        }
+
+        return "${flag}:\"$test\""
+    }
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/particle/ParticleFactoryRGB.kt

@@ -1,5 +1,6 @@
 package com.willfp.eco.internal.particle
 
+import com.willfp.eco.core.Prerequisite
 import com.willfp.eco.core.particle.ParticleFactory
 import com.willfp.eco.core.particle.SpawnableParticle
 import org.bukkit.Color
@@ -7,6 +8,14 @@ import org.bukkit.Location
 import org.bukkit.Particle
 
 object ParticleFactoryRGB : ParticleFactory {
+    private val dustParticle = runCatching {
+        if (Prerequisite.HAS_1_20_5.isMet) {
+            Particle.valueOf("DUST")
+        } else {
+            Particle.valueOf("REDSTONE_DUST")
+        }
+    }.getOrNull()
+
     override fun getNames() = listOf(
         "color",
         "rgb",
@@ -30,7 +39,9 @@ object ParticleFactoryRGB : ParticleFactory {
         override fun spawn(location: Location, amount: Int) {
             val world = location.world ?: return
 
-            world.spawnParticle(Particle.REDSTONE, location, amount, 0.0, 0.0, 0.0, 0.0, options)
+            val particle = dustParticle ?: return
+
+            world.spawnParticle(particle, location, amount, 0.0, 0.0, 0.0, 0.0, options)
         }
     }
 }

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/price/PriceFactoryXP.kt

@@ -8,6 +8,11 @@ import org.bukkit.entity.Player
 import java.util.UUID
 import kotlin.math.roundToInt
 
+private fun getXPNeededForLevel(level: Int): Int {
+    // XP Formula from NMS Player
+    return if (level >= 30) 112 + (level - 30) * 9 else (if (level >= 15) 37 + (level - 15) * 5 else 7 + level * 2)
+}
+
 object PriceFactoryXP : PriceFactory {
     override fun getNames() = listOf(
         "xp",
@@ -25,15 +30,37 @@ object PriceFactoryXP : PriceFactory {
     ) : Price {
         private val multipliers = mutableMapOf<UUID, Double>()
 
-        override fun canAfford(player: Player, multiplier: Double): Boolean =
+        override fun canAfford(player: Player, multiplier: Double): Boolean {
-            player.totalExperience >= getValue(player, multiplier)
+            var totalExperience = 0
+            for (level in 0 until player.level) {
+                totalExperience += getXPNeededForLevel(level)
+            }
+
+            totalExperience += (player.exp * getXPNeededForLevel(player.level)).toInt()
+
+            return totalExperience >= getValue(player, multiplier).roundToInt()
+        }
 
         override fun pay(player: Player, multiplier: Double) {
-            player.totalExperience -= getValue(player, multiplier).roundToInt()
+            takeXP(player, getValue(player, multiplier).roundToInt())
+        }
+
+        private fun takeXP(player: Player, amount: Int) {
+            val currentLevel = player.level
+            val currentExp = player.exp * getXPNeededForLevel(currentLevel)
+
+            if (currentExp >= amount) {
+                player.exp = (currentExp - amount) / getXPNeededForLevel(currentLevel)
+            } else {
+                // Handle recursive level down
+                player.exp = 1f
+                player.level = (currentLevel - 1).coerceAtLeast(0)
+                takeXP(player, (amount - currentExp).toInt())
+            }
         }
 
         override fun giveTo(player: Player, multiplier: Double) {
-            player.totalExperience += getValue(player, multiplier).roundToInt()
+            player.giveExp(getValue(player, multiplier).roundToInt())
         }
 
         override fun getValue(player: Player, multiplier: Double): Double {

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/recipes/AutocrafterPatch.kt

@@ -0,0 +1,7 @@
+package com.willfp.eco.internal.recipes
+
+import com.willfp.eco.internal.compat.ModernCompatibilityProxy
+import org.bukkit.event.Listener
+
+@ModernCompatibilityProxy("recipes.AutocrafterPatchImpl")
+interface AutocrafterPatch: Listener

eco-core/core-nms/common/build.gradle.kts

@@ -7,4 +7,11 @@ version = rootProject.version
 
 dependencies {
     paperweight.paperDevBundle("1.17.1-R0.1-SNAPSHOT")
+    pluginRemapper("net.fabricmc:tiny-remapper:0.10.3:fat")
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
 }