Moved supported versions into ProxyConstants

This reverts commit 6361c0e8e9.

.github/workflows/checkstyle.yml

@@ -0,0 +1,15 @@
+name: Check PR Codestyle
+on: [ pull_request ]
+
+jobs:
+  checkstyle:
+    name: Checkstyle
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dbelyaev/action-checkstyle@v0.5.1
+        with:
+          github_token: ${{ secrets.github_token }}
+          reporter: github-pr-review
+          level: warning
+          checkstyle_config: ../../config/checkstyle/checkstyle.xml

.github/workflows/java-ci.yml

@@ -1,6 +1,6 @@
 name: Java CI
 
-on: [push]
+on: [ push, pull_request ]
 
 jobs:
   build:

.github/workflows/test-publish.yml

@@ -0,0 +1,42 @@
+name: Publish API (Dev)
+
+on: [ push, pull_request ]
+
+jobs:
+  publish-release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout latest code
+        uses: actions/checkout@v2
+
+      - name: Set outputs
+        id: vars
+        run: echo "::set-output name=sha_short::$(git rev-parse --short HEAD)"
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v2
+        with:
+          distribution: 'temurin'
+          java-version: 17
+
+      - name: Setup build cache
+        uses: actions/cache@v2.1.6
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+
+      - name: Publish artifact
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+        # The GITHUB_REF tag comes in the format 'refs/tags/xxx'.
+        # So if we split on '/' and take the 3rd value, we can get the release name.
+        run: |
+          NEW_VERSION=$(echo "${GITHUB_REF}" | cut -d "/" -f3)
+          echo "New version: ${{ steps.vars.outputs.sha_short }}"
+          echo "Github username: ${GITHUB_ACTOR}"
+          ./gradlew -Pversion=dev-${{ steps.vars.outputs.sha_short }} publish

CONTRIBUTING.md

@@ -1,24 +1,38 @@
 # How to contribute to eco
 
 ## Codestyle
+
 1. The eco checkstyle is in /config/checkstyle.xml
+
 - The pull request must not have any checkstyle issues.
 - Every method and field must have a javadoc attached.
 
 2. Use JetBrains annotations
+
 - Every parameter should be annotated with @NotNull or @Nullable
-- Use @NotNull over lombok @NonNull
 
 3. Imports
+
 - No group (*) imports.
 - No static imports.
 
+4. Kotlin
+
+- Kotlin should be the only language used in the backend, java should be the only language used in the frontend.
+- Kotlin API extensions should only be for creating extension functions and extra niceties that aren't possible in java.
+  Do not write API components in kotlin.
+- Kotlin code should never be called directly from the frontend Java API. Kotlin API extensions should always rely on
+  java, not the other way round.
+
 ## Dependency Injection
+
 - eco uses Dependency Injection
 - Any calls to Eco#getHandler#getEcoPlugin are code smells and should never be used unless **absolutely necessary**.
 - NamespacedKeys, FixedMetadataValues, Runnables, and Schedules should be managed using AbstractEcoPlugin through DI.
-- Any DI class should extend PluginDependent where possible. If the class extends another, then you **must** store the plugin instance in a private final variable called **plugin** with a private or protected getter.
+- Any DI class should extend PluginDependent where possible. If the class extends another, then you **must** store the
+  plugin instance in a private final variable called **plugin** with a private or protected getter.
 
 ## Other
+
 - All drops **must** be sent through a DropQueue - calls to World#dropItem will get your PR rejected.
 - eco is built with java 17.

README.md

@@ -29,7 +29,7 @@ and many more.
 
 # For server owners
 - Requires ProtocolLib to be installed: get the latest version [here](https://www.spigotmc.org/resources/protocollib.1997/)
-- Supports 1.16.5+
+- Supports 1.17+
 
 ## Downloads
 

build.gradle.kts

@@ -1,8 +1,19 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.6.10")
+    }
+}
+
 plugins {
     id("java-library")
-    id("com.github.johnrengelman.shadow") version "7.1.0"
+    id("com.github.johnrengelman.shadow") version "7.1.2"
     id("maven-publish")
     id("java")
+    kotlin("jvm") version "1.6.10"
 }
 
 dependencies {
@@ -10,7 +21,6 @@ dependencies {
     implementation(project(":eco-core:core-plugin"))
     implementation(project(":eco-core:core-proxy"))
     implementation(project(":eco-core:core-backend"))
-    implementation(project(":eco-core:core-nms:v1_16_R3"))
     implementation(project(path = ":eco-core:core-nms:v1_17_R1", configuration = "reobf"))
     implementation(project(path = ":eco-core:core-nms:v1_18_R1", configuration = "reobf"))
 }
@@ -20,6 +30,7 @@ allprojects {
     apply(plugin = "java-library")
     apply(plugin = "maven-publish")
     apply(plugin = "com.github.johnrengelman.shadow")
+    apply(plugin = "kotlin")
 
     repositories {
         mavenCentral()
@@ -73,10 +84,11 @@ allprojects {
     }
 
     dependencies {
+        compileOnly(kotlin("stdlib", version = "1.6.10"))
         compileOnly("org.jetbrains:annotations:23.0.0")
 
         // Test
-        testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1")
+        testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.2")
         testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.2")
         
         // Adventure
@@ -103,7 +115,19 @@ allprojects {
         exclude(group = "com.github.cryptomorin", module = "XSeries")
     }
 
+    configurations.testImplementation {
+        setExtendsFrom(listOf(configurations.compileOnly.get()))
+    }
+
     tasks {
+        compileKotlin {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+            targetCompatibility = "17"
+            sourceCompatibility = "17"
+        }
+
         shadowJar {
             relocate("org.bstats", "com.willfp.eco.shaded.bstats")
             relocate("net.kyori.adventure.text.minimessage", "com.willfp.eco.shaded.minimessage")

config/checkstyle/checkstyle.xml

@@ -32,10 +32,6 @@
 -->
 
 <module name="Checker">
-    <module name="SuppressionFilter">
-        <property name="file" value="config/checkstyle/suppression.xml"/>
-    </module>
-
     <!--
         If you set the basedir property below, then all reported file
         names will be relative to the specified directory. See

config/checkstyle/suppression.xml

@@ -1,24 +0,0 @@
-<?xml version="1.0"?>
-
-<!DOCTYPE suppressions PUBLIC
-        "-//Puppy Crawl//DTD Suppressions 1.1//EN"
-        "http://www.puppycrawl.com/dtds/suppressions_1_1.dtd">
-
-<suppressions>
-    <!-- Internals don't need javadoc. -->
-    <suppress files="[\\/]internal[\\/]" checks="MissingJavadocMethod"/>
-    <suppress files="[\\/]internal[\\/]" checks="JavadocVariable"/>
-    <suppress files="[\\/]eco[\\/]spigot[\\/]" checks="MissingJavadocMethod"/>
-    <suppress files="[\\/]eco[\\/]spigot[\\/]" checks="JavadocVariable"/>
-    <suppress files="[\\/]eco[\\/]proxy[\\/]" checks="MissingJavadocMethod"/>
-    <suppress files="[\\/]eco[\\/]proxy[\\/]" checks="JavadocVariable"/>
-
-    <!-- Modified version of library -->
-    <suppress files="ArmorEquipEvent.java" checks="JavadocVariable"/>
-    <suppress files="ArmorEquipEvent.java" checks="MissingJavadocMethod"/>
-    <suppress files="ArmorEquipEvent.java" checks="JavadocStyle"/>
-    <suppress files="ArmorListener.java" checks="JavadocVariable"/>
-    <suppress files="ArmorListener.java" checks="MissingJavadocMethod"/>
-    <suppress files="ArmorType.java" checks="JavadocVariable"/>
-    <suppress files="ArmorType.java" checks="MissingJavadocMethod"/>
-</suppressions>

eco-api/build.gradle

@@ -1,10 +1,3 @@
-plugins {
-    id 'com.github.johnrengelman.shadow'
-}
-
-group 'com.willfp'
-version rootProject.version
-
 dependencies {
     // Adventure
     compileOnly 'net.kyori:adventure-platform-bukkit:4.0.0'
@@ -17,10 +10,8 @@ dependencies {
     compileOnly 'com.google.code.gson:gson:2.8.8'
 }
 
-java {
-    withJavadocJar()
-}
-
+group 'com.willfp'
+version rootProject.version
 
 build.dependsOn publishToMavenLocal
 

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

@@ -152,10 +152,14 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
     private final ProxyFactory proxyFactory;
 
     /**
-     * Create a new plugin without a specified color, proxy support, polymart, or bStats.
+     * Create a new plugin.
+     * <p>
+     * Will read from eco.yml (like plugin.yml) to fetch values that would otherwise be passed
+     * into the constructor. If no eco.yml is present, the plugin will load without extension
+     * support, without proxy support, with no update-checker or bStats, and with the color white.
      */
     protected EcoPlugin() {
-        this("&f");
+        this((PluginProps) null);
     }
 
     /**
@@ -236,6 +240,23 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
                         @NotNull final String proxyPackage,
                         @NotNull final String color,
                         final boolean supportingExtensions) {
+        this(
+                PluginProps.createSimple(
+                        resourceId,
+                        bStatsId,
+                        proxyPackage,
+                        color,
+                        supportingExtensions
+                )
+        );
+    }
+
+    /**
+     * Create a new plugin.
+     *
+     * @param pluginProps The props. If left null, it will read from eco.yml.
+     */
+    protected EcoPlugin(@Nullable final PluginProps pluginProps) {
         /*
         The handler must be initialized before any plugin's constructors
         are called, as the constructors call Eco#getHandler().
@@ -253,15 +274,15 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         a standalone handler class, but then there would be an interface
         left in the API that doesn't really help anything.
 
-        The other alternative would be do use reflection to get a 'createHandler'
-        method that only exists in EcoSpigotPlugin - but that feels really dirty
+        The other alternative would be to use reflection to get a 'createHandler'
+        method that only exists in EcoSpigotPlugin - but that feels filthy,
         and I'd rather only use reflection where necessary.
         */
 
         if (Eco.getHandler() == null && this instanceof Handler) {
             /*
             This code is only ever called by EcoSpigotPlugin (EcoHandler)
-            as it's the first plugin to load and it is a handler.
+            as it's the first plugin to load, and it is a handler.
 
             Any other plugins will never call this code as the handler
             will have already been initialized.
@@ -272,11 +293,16 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
 
         assert Eco.getHandler() != null;
 
-        this.resourceId = resourceId;
-        this.bStatsId = bStatsId;
-        this.proxyPackage = proxyPackage;
-        this.color = color;
-        this.supportingExtensions = supportingExtensions;
+        PluginProps generatedProps = Eco.getHandler().getProps(pluginProps, this.getClass());
+        generatedProps.validate();
+        PluginProps props = this.mutateProps(generatedProps);
+        props.validate();
+
+        this.resourceId = props.getResourceId();
+        this.bStatsId = props.getBStatsId();
+        this.proxyPackage = props.getProxyPackage();
+        this.color = props.getColor();
+        this.supportingExtensions = props.isSupportingExtensions();
 
         this.scheduler = Eco.getHandler().createScheduler(this);
         this.eventManager = Eco.getHandler().createEventManager(this);
@@ -296,8 +322,8 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         /*
         The minimum eco version check was moved here because it's very common
         to add a lot of code in the constructor of plugins; meaning that the plugin
-        can throw errors without it being obvious to the user that the reason is
-        because they have an outdated version of eco installed.
+        can throw errors without it being obvious to the user that the reason is that
+        they have an outdated version of eco installed.
          */
 
         DefaultArtifactVersion runningVersion = new DefaultArtifactVersion(Eco.getHandler().getEcoPlugin().getDescription().getVersion());
@@ -534,6 +560,21 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
 
     }
 
+    /**
+     * Mutate the plugin props.
+     * <p>
+     * Useful for eco-based plugin libraries to enforce certain properties, such as
+     * forcing extensions to be enabled.
+     * <p>
+     * Props are validated both before and after calling this method.
+     *
+     * @param props The props.
+     * @return The mutated props.
+     */
+    protected PluginProps mutateProps(@NotNull final PluginProps props) {
+        return props;
+    }
+
     /**
      * The plugin-specific integrations to be tested and loaded.
      *
@@ -635,7 +676,7 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
      * @return The proxy.
      */
     public final <T> T getProxy(@NotNull final Class<T> proxyClass) {
-        Validate.notNull(proxyFactory, "Plugin does not support proxy!");
+        Validate.notNull(proxyFactory, "Plugin does not support proxies!");
 
         return proxyFactory.getProxy(proxyClass);
     }

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

@@ -15,7 +15,6 @@ import com.willfp.eco.core.gui.GUIFactory;
 import com.willfp.eco.core.integrations.placeholder.PlaceholderIntegration;
 import com.willfp.eco.core.proxy.Cleaner;
 import com.willfp.eco.core.proxy.ProxyFactory;
-import com.willfp.eco.core.requirement.RequirementFactory;
 import com.willfp.eco.core.scheduling.Scheduler;
 import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.bukkit.Location;
@@ -33,6 +32,7 @@ import java.util.logging.Logger;
  * @see Eco#getHandler()
  */
 @ApiStatus.Internal
+@SuppressWarnings("removal")
 public interface Handler {
     /**
      * Create a scheduler.
@@ -204,14 +204,6 @@ public interface Handler {
      */
     void registerBStats(@NotNull EcoPlugin plugin);
 
-    /**
-     * Get the requirement factory.
-     *
-     * @return The factory.
-     */
-    @NotNull
-    RequirementFactory getRequirementFactory();
-
     /**
      * Get Adventure audiences.
      *
@@ -259,4 +251,15 @@ public interface Handler {
     @NotNull
     NamespacedKey createNamespacedKey(@NotNull String namespace,
                                       @NotNull String key);
+
+    /**
+     * Return or get props for a plugin.
+     *
+     * @param existing The existing constructor props.
+     * @param plugin   The plugin.
+     * @return The props.
+     */
+    @NotNull
+    PluginProps getProps(@Nullable PluginProps existing,
+                         @NotNull Class<? extends EcoPlugin> plugin);
 }

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

@@ -0,0 +1,275 @@
+package com.willfp.eco.core;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Plugin props are the arguments related to the plugin that are required on start-up.
+ * <p>
+ * This class is complex in how it works intentionally. This is done so that fields can be
+ * added to the props without breaking API backwards compatibility. Thus, there is no public
+ * constructor and no way to instantiate props without creating a parser.
+ */
+public final class PluginProps {
+    /**
+     * All registered parsers.
+     */
+    private static final Map<Class<?>, PropsParser<?>> REGISTERED_PARSERS = new HashMap<>();
+
+    /**
+     * The polymart resource ID.
+     */
+    @Nullable
+    private Integer resourceId;
+
+    /**
+     * The bStats ID.
+     */
+    @Nullable
+    private Integer bStatsId;
+
+    /**
+     * The proxy package.
+     */
+    @Nullable
+    private String proxyPackage;
+
+    /**
+     * The color.
+     */
+    @Nullable
+    private String color;
+
+    /**
+     * If extensions are supported.
+     */
+    @Nullable
+    private Boolean supportingExtensions;
+
+    /**
+     * Create new blank props.
+     */
+    private PluginProps() {
+
+    }
+
+    /**
+     * Get resource ID.
+     *
+     * @return The resource ID.
+     */
+    public int getResourceId() {
+        assert resourceId != null;
+        return resourceId;
+    }
+
+    /**
+     * Set resource ID.
+     *
+     * @param resourceId The resource ID.
+     */
+    public void setResourceId(final int resourceId) {
+        this.resourceId = resourceId;
+    }
+
+    /**
+     * Get bStats ID.
+     *
+     * @return The bStats ID.
+     */
+    public int getBStatsId() {
+        assert bStatsId != null;
+        return bStatsId;
+    }
+
+    /**
+     * Set bStats ID.
+     *
+     * @param bStatsId The bStats ID.
+     */
+    public void setBStatsId(final int bStatsId) {
+        this.bStatsId = bStatsId;
+    }
+
+    /**
+     * Get the proxy package.
+     *
+     * @return The package.
+     */
+    @NotNull
+    public String getProxyPackage() {
+        assert proxyPackage != null;
+        return proxyPackage;
+    }
+
+    /**
+     * Set the proxy package.
+     *
+     * @param proxyPackage The proxy package.
+     */
+    public void setProxyPackage(@NotNull final String proxyPackage) {
+        this.proxyPackage = proxyPackage;
+    }
+
+    /**
+     * Get color.
+     *
+     * @return The color.
+     */
+    @NotNull
+    public String getColor() {
+        assert color != null;
+        return color;
+    }
+
+    /**
+     * Set the color.
+     *
+     * @param color The color.
+     */
+    public void setColor(@NotNull final String color) {
+        this.color = color;
+    }
+
+    /**
+     * Get if extensions are supported.
+     *
+     * @return If supported.
+     */
+    public boolean isSupportingExtensions() {
+        assert supportingExtensions != null;
+        return supportingExtensions;
+    }
+
+    /**
+     * Set if extensions are supported.
+     *
+     * @param supportingExtensions If supported.
+     */
+    public void setSupportingExtensions(final boolean supportingExtensions) {
+        this.supportingExtensions = supportingExtensions;
+    }
+
+    /**
+     * Ensure that all required props have been set.
+     */
+    public void validate() {
+        if (
+                supportingExtensions == null
+                        || proxyPackage == null
+                        || color == null
+                        || bStatsId == null
+                        || resourceId == null
+        ) {
+            throw new IllegalStateException("Missing required props!");
+        }
+    }
+
+    /**
+     * Parse props from source.
+     *
+     * @param source      The source.
+     * @param sourceClass The source class.
+     * @param <T>         The source type.
+     * @return The props.
+     */
+    public static <T> PluginProps parse(@NotNull final T source,
+                                        @NotNull final Class<? extends T> sourceClass) {
+        for (Map.Entry<Class<?>, PropsParser<?>> entry : REGISTERED_PARSERS.entrySet()) {
+            Class<?> clazz = entry.getKey();
+
+            if (clazz.equals(sourceClass)) {
+                @SuppressWarnings("unchecked")
+                PropsParser<T> parser = (PropsParser<T>) entry.getValue();
+                return parser.parseFrom(source);
+            }
+        }
+
+        throw new IllegalArgumentException("No parser exists for class " + sourceClass);
+    }
+
+    /**
+     * Register a parser for a type.
+     *
+     * @param clazz  The class.
+     * @param parser The parser.
+     * @param <T>    The source type.
+     */
+    public static <T> void registerParser(@NotNull final Class<T> clazz,
+                                          @NotNull final PropsParser<T> parser) {
+        REGISTERED_PARSERS.put(clazz, parser);
+    }
+
+    /**
+     * Get if there is a registered parser for a class.
+     *
+     * @param clazz The class.
+     * @return If there is a parser registered.
+     */
+    public static boolean hasParserFor(@NotNull final Class<?> clazz) {
+        for (Class<?> test : REGISTERED_PARSERS.keySet()) {
+            if (test.equals(clazz)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Create new props from known values.
+     *
+     * Marked as internal as this method will break whenever the properties themselves
+     * are updated (e.g. if a new property is added) - so to prevent any potential
+     * backwards-compatibility bugs, this method cannot be invoked outside eco itself.
+     *
+     * @param resourceId         The ID of the plugin on polymart.
+     * @param bStatsId           The ID of the plugin on bStats.
+     * @param proxyPackage       The package where proxies can be found.
+     * @param color              The primary color of the plugin.
+     * @param supportsExtensions If the plugin should attempt to look for extensions.
+     * @return The props.
+     */
+    @ApiStatus.Internal
+    static PluginProps createSimple(final int resourceId,
+                                    final int bStatsId,
+                                    @NotNull final String proxyPackage,
+                                    @NotNull final String color,
+                                    final boolean supportsExtensions) {
+        PluginProps props = new PluginProps();
+        props.setResourceId(resourceId);
+        props.setBStatsId(bStatsId);
+        props.setProxyPackage(proxyPackage);
+        props.setColor(color);
+        props.setSupportingExtensions(supportsExtensions);
+        return props;
+    }
+
+    /**
+     * Parse arguments into props for a plugin.
+     *
+     * @param <T> The type of source.
+     */
+    public interface PropsParser<T> {
+        /**
+         * Parse props from a given source.
+         *
+         * @param source The source.
+         * @return The props.
+         */
+        PluginProps parseFrom(@NotNull T source);
+
+        /**
+         * Get a new, blank props instance.
+         *
+         * @return Blank props.
+         */
+        default PluginProps getBlankProps() {
+            return new PluginProps();
+        }
+    }
+}

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

@@ -51,7 +51,10 @@ public class Prerequisite {
 
     /**
      * Requires the server to be running 1.17.
+     *
+     * @deprecated eco no longer supports versions before 1.17.
      */
+    @Deprecated(since = "6.25.2")
     public static final Prerequisite HAS_1_17 = new Prerequisite(
             () -> ProxyConstants.NMS_VERSION.contains("17") || HAS_1_18.isMet(),
             "Requires server to be running 1.17+"

eco-api/src/main/java/com/willfp/eco/core/command/CommandBase.java

@@ -1,5 +1,6 @@
 package com.willfp.eco.core.command;
 
+import com.willfp.eco.core.EcoPlugin;
 import org.bukkit.command.CommandSender;
 import org.jetbrains.annotations.NotNull;
 
@@ -66,6 +67,13 @@ public interface CommandBase {
         return new ArrayList<>();
     }
 
+    /**
+     * Get the plugin.
+     *
+     * @return The plugin.
+     */
+    EcoPlugin getPlugin();
+
     /**
      * Get the handler.
      *

eco-api/src/main/java/com/willfp/eco/core/command/impl/HandledCommand.java

@@ -1,7 +1,6 @@
 package com.willfp.eco.core.command.impl;
 
 import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.PluginDependent;
 import com.willfp.eco.core.command.CommandBase;
 import com.willfp.eco.core.command.CommandHandler;
 import com.willfp.eco.core.command.TabCompleteHandler;
@@ -25,7 +24,12 @@ import java.util.stream.Collectors;
  * layer, hence why it's a package-private class.
  */
 @SuppressWarnings({"DeprecatedIsStillUsed"})
-abstract class HandledCommand extends PluginDependent<EcoPlugin> implements CommandBase {
+abstract class HandledCommand implements CommandBase {
+    /**
+     * The plugin.
+     */
+    private final EcoPlugin plugin;
+
     /**
      * The name of the command.
      */
@@ -78,7 +82,7 @@ abstract class HandledCommand extends PluginDependent<EcoPlugin> implements Comm
                    @NotNull final String name,
                    @NotNull final String permission,
                    final boolean playersOnly) {
-        super(plugin);
+        this.plugin = plugin;
         this.name = name;
         this.permission = permission;
         this.playersOnly = playersOnly;
@@ -98,6 +102,16 @@ abstract class HandledCommand extends PluginDependent<EcoPlugin> implements Comm
         return this;
     }
 
+    /**
+     * Get the plugin.
+     *
+     * @return The plugin.
+     */
+    @Override
+    public EcoPlugin getPlugin() {
+        return this.plugin;
+    }
+
     /**
      * Handle the command.
      *
@@ -124,6 +138,11 @@ abstract class HandledCommand extends PluginDependent<EcoPlugin> implements Comm
             }
         }
 
+        if (this.isPlayersOnly() && !(sender instanceof Player)) {
+            sender.sendMessage(this.getPlugin().getLangYml().getMessage("not-player"));
+            return;
+        }
+
         if (this.getHandler() != null) {
             this.getHandler().onExecute(sender, Arrays.asList(args));
         } else {
@@ -193,11 +212,6 @@ abstract class HandledCommand extends PluginDependent<EcoPlugin> implements Comm
     public static boolean canExecute(@NotNull final CommandSender sender,
                                      @NotNull final CommandBase command,
                                      @NotNull final EcoPlugin plugin) {
-        if (command.isPlayersOnly() && !(sender instanceof Player)) {
-            sender.sendMessage(plugin.getLangYml().getMessage("not-player"));
-            return false;
-        }
-
         if (!sender.hasPermission(command.getPermission()) && sender instanceof Player) {
             sender.sendMessage(plugin.getLangYml().getNoPermission());
             return false;

eco-api/src/main/java/com/willfp/eco/core/config/TransientConfig.java

@@ -5,7 +5,10 @@ import com.willfp.eco.core.config.interfaces.Config;
 import com.willfp.eco.core.config.wrapper.ConfigWrapper;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
+import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.util.Map;
 
 /**
@@ -21,6 +24,15 @@ public class TransientConfig extends ConfigWrapper<Config> {
         super(Eco.getHandler().getConfigFactory().createConfig(config));
     }
 
+    /**
+     * @param stream The InputStream.
+     */
+    public TransientConfig(@Nullable final InputStream stream) {
+        super(stream != null ? Eco.getHandler().getConfigFactory().createConfig(YamlConfiguration.loadConfiguration(
+                new InputStreamReader(stream)
+        )) : new TransientConfig());
+    }
+
     /**
      * Create a new empty transient config.
      *

eco-api/src/main/java/com/willfp/eco/core/config/interfaces/Config.java

@@ -235,7 +235,7 @@ public interface Config extends Cloneable {
      */
     @NotNull
     default String getString(@NotNull String path) {
-        return getString(path, false);
+        return getString(path, false, StringUtils.FormatOption.WITHOUT_PLACEHOLDERS);
     }
 
     /**

eco-api/src/main/java/com/willfp/eco/core/data/keys/KeyRegistry.java

@@ -1,12 +1,18 @@
 package com.willfp.eco.core.data.keys;
 
+import com.willfp.eco.core.Eco;
+import org.bukkit.NamespacedKey;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Set;
 
 /**
  * API to register persistent data keys.
  */
+@ApiStatus.Internal
+@Eco.HandlerComponent
 public interface KeyRegistry {
     /**
      * Register a persistent data key to be stored.
@@ -21,4 +27,37 @@ public interface KeyRegistry {
      * @return The keys.
      */
     Set<PersistentDataKey<?>> getRegisteredKeys();
+
+    /**
+     * Mark key as category.
+     *
+     * @param key      The key.
+     * @param category The category.
+     */
+    void markKeyAs(@NotNull PersistentDataKey<?> key,
+                   @NotNull KeyRegistry.KeyCategory category);
+
+    /**
+     * Get persistent data key from namespaced key.
+     *
+     * @param namespacedKey The key.
+     * @return The key, or null if not found.
+     */
+    @Nullable
+    PersistentDataKey<?> getKeyFrom(@NotNull NamespacedKey namespacedKey);
+
+    /**
+     * Locations for key categorization.
+     */
+    enum KeyCategory {
+        /**
+         * Player keys.
+         */
+        PLAYER,
+
+        /**
+         * Server keys.
+         */
+        SERVER
+    }
 }

eco-api/src/main/java/com/willfp/eco/core/data/keys/PersistentDataKey.java

@@ -3,7 +3,9 @@ package com.willfp.eco.core.data.keys;
 import com.willfp.eco.core.Eco;
 import org.bukkit.NamespacedKey;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
+import java.util.Objects;
 import java.util.Set;
 
 /**
@@ -11,7 +13,7 @@ import java.util.Set;
  *
  * @param <T> The type of the data.
  */
-public class PersistentDataKey<T> {
+public final class PersistentDataKey<T> {
     /**
      * The key of the persistent data value.
      */
@@ -80,6 +82,32 @@ public class PersistentDataKey<T> {
         return this.type;
     }
 
+    /**
+     * Categorize key as a server key, will register new column to MySQL
+     * database immediately rather than waiting for auto-categorization.
+     * <p>
+     * This will improve performance.
+     *
+     * @return The key.
+     */
+    public PersistentDataKey<T> server() {
+        Eco.getHandler().getKeyRegistry().markKeyAs(this, KeyRegistry.KeyCategory.SERVER);
+        return this;
+    }
+
+    /**
+     * Categorize key as a player key, will register new column to MySQL
+     * database immediately rather than waiting for auto-categorization.
+     * <p>
+     * This will improve performance.
+     *
+     * @return The key.
+     */
+    public PersistentDataKey<T> player() {
+        Eco.getHandler().getKeyRegistry().markKeyAs(this, KeyRegistry.KeyCategory.PLAYER);
+        return this;
+    }
+
     /**
      * Get all persistent data keys.
      *
@@ -88,4 +116,20 @@ public class PersistentDataKey<T> {
     public static Set<PersistentDataKey<?>> values() {
         return Eco.getHandler().getKeyRegistry().getRegisteredKeys();
     }
+
+    @Override
+    public boolean equals(@Nullable final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof PersistentDataKey that)) {
+            return false;
+        }
+        return Objects.equals(this.getKey(), that.getKey());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.getKey());
+    }
 }

eco-api/src/main/java/com/willfp/eco/core/entities/DummyEntity.java

@@ -0,0 +1,10 @@
+package com.willfp.eco.core.entities;
+
+import org.bukkit.entity.Entity;
+
+/**
+ * Interface for Dummy Entities in order to filter them using instanceof.
+ */
+public interface DummyEntity extends Entity {
+
+}

eco-api/src/main/java/com/willfp/eco/core/entities/Entities.java

@@ -6,7 +6,6 @@ import com.willfp.eco.core.entities.impl.EmptyTestableEntity;
 import com.willfp.eco.core.entities.impl.ModifiedTestableEntity;
 import com.willfp.eco.core.entities.impl.SimpleTestableEntity;
 import com.willfp.eco.util.NamespacedKeyUtils;
-import com.willfp.eco.util.StringUtils;
 import org.bukkit.Location;
 import org.bukkit.NamespacedKey;
 import org.bukkit.entity.Entity;
@@ -37,6 +36,11 @@ public final class Entities {
      */
     private static final List<EntityArgParser> ARG_PARSERS = new ArrayList<>();
 
+    /**
+     * The lookup handler.
+     */
+    private static final EntitiesLookupHandler ENTITIES_LOOKUP_HANDLER = new EntitiesLookupHandler(Entities::doParse);
+
     /**
      * Register a new custom item.
      *
@@ -87,20 +91,11 @@ public final class Entities {
      */
     @NotNull
     public static TestableEntity lookup(@NotNull final String key) {
-        if (key.contains("?")) {
-            String[] options = key.split("\\?");
-            for (String option : options) {
-                TestableEntity lookup = lookup(option);
-                if (!(lookup instanceof EmptyTestableEntity)) {
-                    return lookup;
-                }
-            }
-
-            return new EmptyTestableEntity();
-        }
-
-        String[] args = StringUtils.parseTokens(key);
+        return ENTITIES_LOOKUP_HANDLER.parseKey(key);
+    }
 
+    @NotNull
+    private static TestableEntity doParse(@NotNull final String[] args) {
         if (args.length == 0) {
             return new EmptyTestableEntity();
         }
@@ -131,7 +126,6 @@ public final class Entities {
             entity = part;
         }
 
-
         String[] modifierArgs = Arrays.copyOfRange(args, 1, args.length);
 
         List<EntityArgParseResult> parseResults = new ArrayList<>();
@@ -172,7 +166,6 @@ public final class Entities {
         return entity;
     }
 
-
     /**
      * Get a Testable Entity from an ItemStack.
      * <p>

eco-api/src/main/java/com/willfp/eco/core/entities/EntitiesLookupHandler.java

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

eco-api/src/main/java/com/willfp/eco/core/entities/TestableEntity.java

@@ -1,5 +1,6 @@
 package com.willfp.eco.core.entities;
 
+import com.willfp.eco.core.lookup.Testable;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
 import org.jetbrains.annotations.NotNull;
@@ -8,13 +9,14 @@ import org.jetbrains.annotations.Nullable;
 /**
  * An item with a test to see if any item is that item.
  */
-public interface TestableEntity {
+public interface TestableEntity extends Testable<Entity> {
     /**
      * If an Entity matches the test.
      *
      * @param entity The entity to test.
      * @return If the entity matches.
      */
+    @Override
     boolean matches(@Nullable Entity entity);
 
     /**

eco-api/src/main/java/com/willfp/eco/core/entities/impl/GroupedTestableEntities.java

@@ -0,0 +1,68 @@
+package com.willfp.eco.core.entities.impl;
+
+import com.willfp.eco.core.entities.TestableEntity;
+import com.willfp.eco.util.NumberUtils;
+import org.apache.commons.lang.Validate;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+/**
+ * A group of testable entities.
+ *
+ * @see com.willfp.eco.core.entities.CustomEntity
+ */
+public class GroupedTestableEntities implements TestableEntity {
+    /**
+     * The children.
+     */
+    private final Collection<TestableEntity> children;
+
+    /**
+     * Create a new group of testable entities.
+     *
+     * @param children The children.
+     */
+    public GroupedTestableEntities(@NotNull final Collection<TestableEntity> children) {
+        Validate.isTrue(!children.isEmpty(), "Group must have at least one child!");
+
+        this.children = children;
+    }
+
+    /**
+     * If the item matches any children.
+     *
+     * @param entity The entity to test.
+     * @return If the entity matches the test of any children.
+     */
+    @Override
+    public boolean matches(@Nullable final Entity entity) {
+        for (TestableEntity child : children) {
+            if (child.matches(entity)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public Entity spawn(@NotNull final Location location) {
+        return new ArrayList<>(children)
+                .get(NumberUtils.randInt(0, children.size() - 1))
+                .spawn(location);
+    }
+
+    /**
+     * Get the children.
+     *
+     * @return The children.
+     */
+    public Collection<TestableEntity> getChildren() {
+        return new ArrayList<>(children);
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/fast/FastItemStack.java

@@ -22,8 +22,30 @@ public interface FastItemStack {
      *
      * @param checkStored If stored NBT should also be checked.
      * @return A map of all enchantments.
+     * @deprecated Poorly named method. Use getEnchants instead.
      */
-    Map<Enchantment, Integer> getEnchantmentsOnItem(boolean checkStored);
+    @Deprecated(since = "6.24.0")
+    default Map<Enchantment, Integer> getEnchantmentsOnItem(boolean checkStored) {
+        return getEnchants(checkStored);
+    }
+
+    /**
+     * Get all enchantments on an item.
+     * Does not account for stored enchants.
+     *
+     * @return A map of all enchantments.
+     */
+    default Map<Enchantment, Integer> getEnchants() {
+        return getEnchants(false);
+    }
+
+    /**
+     * Get all enchantments on an item.
+     *
+     * @param checkStored If stored enchantments should be accounted for.
+     * @return A map of all enchantments.
+     */
+    Map<Enchantment, Integer> getEnchants(boolean checkStored);
 
     /**
      * Get the level of an enchantment on an item.

eco-api/src/main/java/com/willfp/eco/core/gui/slot/FillerMask.java

@@ -1,6 +1,8 @@
 package com.willfp.eco.core.gui.slot;
 
 import com.willfp.eco.core.items.builder.ItemStackBuilder;
+import com.willfp.eco.core.recipe.parts.EmptyTestableItem;
+import com.willfp.eco.core.recipe.parts.MaterialTestableItem;
 import com.willfp.eco.util.ListUtils;
 import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
@@ -38,7 +40,7 @@ public class FillerMask {
      */
     public FillerMask(@NotNull final Material material,
                       @NotNull final String... pattern) {
-        this(new MaskMaterials(material), pattern);
+        this(new MaskItems(new MaterialTestableItem(material)), pattern);
     }
 
     /**
@@ -46,17 +48,33 @@ public class FillerMask {
      *
      * @param materials The mask materials.
      * @param pattern   The pattern.
+     * @deprecated Use {@link MaskItems} instead.
      */
+    @Deprecated(since = "6.24.0")
     public FillerMask(@NotNull final MaskMaterials materials,
                       @NotNull final String... pattern) {
-        if (Arrays.stream(materials.materials()).anyMatch(material -> material == Material.AIR)) {
-            throw new IllegalArgumentException("Materials cannot be air!");
+        this(
+                materials.toMaskItems(),
+                pattern
+        );
+    }
+
+    /**
+     * Create a new filler mask.
+     *
+     * @param items   The mask items.
+     * @param pattern The pattern.
+     */
+    public FillerMask(@NotNull final MaskItems items,
+                      @NotNull final String... pattern) {
+        if (Arrays.stream(items.items()).anyMatch(item -> item instanceof EmptyTestableItem)) {
+            throw new IllegalArgumentException("Items cannot be empty!");
         }
 
         mask = ListUtils.create2DList(6, 9);
 
-        for (int i = 0; i < materials.materials().length; i++) {
-            ItemStack itemStack = new ItemStackBuilder(materials.materials()[i])
+        for (int i = 0; i < items.items().length; i++) {
+            ItemStack itemStack = new ItemStackBuilder(items.items()[i])
                     .setDisplayName("&r")
                     .build();
 

eco-api/src/main/java/com/willfp/eco/core/gui/slot/MaskItems.java

@@ -0,0 +1,45 @@
+package com.willfp.eco.core.gui.slot;
+
+import com.willfp.eco.core.items.Items;
+import com.willfp.eco.core.items.TestableItem;
+import com.willfp.eco.core.recipe.parts.EmptyTestableItem;
+import com.willfp.eco.core.recipe.parts.MaterialTestableItem;
+import org.bukkit.Material;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Mask materials store a set of items which can be accessed by
+ * a filler mask.
+ *
+ * @param items The items.
+ */
+public record MaskItems(@NotNull TestableItem... items) {
+    /**
+     * Create MaskItems from a list of item names.
+     *
+     * @param names The names.
+     * @return The mask items.
+     */
+    public static MaskItems fromItemNames(@NotNull final Iterable<String> names) {
+        List<TestableItem> items = new ArrayList<>();
+
+        for (String name : names) {
+            TestableItem item = Items.lookup(name);
+
+            if (item instanceof EmptyTestableItem) {
+                continue;
+            }
+
+            items.add(item);
+        }
+
+        if (items.isEmpty()) {
+            return new MaskItems(new MaterialTestableItem(Material.BLACK_STAINED_GLASS_PANE));
+        }
+
+        return new MaskItems(items.toArray(new TestableItem[0]));
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/gui/slot/MaskMaterials.java

@@ -1,5 +1,6 @@
 package com.willfp.eco.core.gui.slot;
 
+import com.willfp.eco.core.items.Items;
 import org.bukkit.Material;
 import org.jetbrains.annotations.NotNull;
 
@@ -8,7 +9,16 @@ import org.jetbrains.annotations.NotNull;
  * a filler mask.
  *
  * @param materials The materials.
+ * @deprecated Use {@link MaskItems} instead.
  */
+@Deprecated(since = "6.24.0")
 public record MaskMaterials(@NotNull Material... materials) {
-
+    /**
+     * Convert MaskMaterials to MaskItems.
+     *
+     * @return The MaskItems.
+     */
+    public MaskItems toMaskItems() {
+        return new MaskItems(Items.fromMaterials(this.materials()));
+    }
 }

eco-api/src/main/java/com/willfp/eco/core/gui/slot/SlotBuilder.java

@@ -2,6 +2,7 @@ package com.willfp.eco.core.gui.slot;
 
 import com.willfp.eco.core.gui.slot.functional.SlotHandler;
 import com.willfp.eco.core.gui.slot.functional.SlotModifier;
+import com.willfp.eco.core.gui.slot.functional.SlotUpdater;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.jetbrains.annotations.NotNull;
 
@@ -106,8 +107,23 @@ public interface SlotBuilder {
      *
      * @param modifier The modifier.
      * @return The builder.
+     * @deprecated Use {@link SlotBuilder#setUpdater(SlotUpdater)} instead.
      */
-    SlotBuilder setModifier(@NotNull SlotModifier modifier);
+    @Deprecated
+    default SlotBuilder setModifier(@NotNull SlotModifier modifier) {
+        return setUpdater((player, menu, previous) -> {
+            modifier.modify(player, menu, previous);
+            return previous;
+        });
+    }
+
+    /**
+     * Set the ItemStack updater.
+     *
+     * @param updater The updater.
+     * @return The builder.
+     */
+    SlotBuilder setUpdater(@NotNull SlotUpdater updater);
 
     /**
      * Set slot to be a captive slot.

eco-api/src/main/java/com/willfp/eco/core/gui/slot/functional/SlotModifier.java

@@ -7,8 +7,11 @@ import org.jetbrains.annotations.NotNull;
 
 /**
  * Interface to run on slot modify.
+ *
+ * @deprecated Use {@link SlotUpdater} instead.
  */
 @FunctionalInterface
+@Deprecated
 public interface SlotModifier {
     /**
      * Performs this operation on the given arguments.

eco-api/src/main/java/com/willfp/eco/core/gui/slot/functional/SlotUpdater.java

@@ -0,0 +1,24 @@
+package com.willfp.eco.core.gui.slot.functional;
+
+import com.willfp.eco.core.gui.menu.Menu;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Interface to run on slot update.
+ */
+@FunctionalInterface
+public interface SlotUpdater {
+    /**
+     * Performs this operation on the given arguments.
+     *
+     * @param player   The player.
+     * @param menu     The menu.
+     * @param previous The previous ItemStack.
+     * @return The new ItemStack.
+     */
+    ItemStack update(@NotNull Player player,
+                     @NotNull Menu menu,
+                     @NotNull ItemStack previous);
+}

eco-api/src/main/java/com/willfp/eco/core/integrations/antigrief/AntigriefManager.java

@@ -44,7 +44,8 @@ public final class AntigriefManager {
      * @param location The location.
      * @return If player can pick up item.
      */
-    public static boolean canPickupItem(@NotNull final Player player, @NotNull final Location location) {
+    public static boolean canPickupItem(@NotNull final Player player,
+                                        @NotNull final Location location) {
         return REGISTERED.stream().allMatch(antigriefWrapper -> antigriefWrapper.canPickupItem(player, location));
     }
 

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

@@ -10,7 +10,6 @@ import com.willfp.eco.core.recipe.parts.ModifiedTestableItem;
 import com.willfp.eco.core.recipe.parts.TestableStack;
 import com.willfp.eco.util.NamespacedKeyUtils;
 import com.willfp.eco.util.NumberUtils;
-import com.willfp.eco.util.StringUtils;
 import org.bukkit.Material;
 import org.bukkit.NamespacedKey;
 import org.bukkit.inventory.ItemStack;
@@ -20,6 +19,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -67,6 +67,11 @@ public final class Items {
      */
     private static final List<LookupArgParser> ARG_PARSERS = new ArrayList<>();
 
+    /**
+     * The handler.
+     */
+    private static final ItemsLookupHandler ITEMS_LOOKUP_HANDLER = new ItemsLookupHandler(Items::doParse);
+
     /**
      * Register a new custom item.
      *
@@ -130,20 +135,11 @@ public final class Items {
      */
     @NotNull
     public static TestableItem lookup(@NotNull final String key) {
-        if (key.contains("?")) {
-            String[] options = key.split("\\?");
-            for (String option : options) {
-                TestableItem lookup = lookup(option);
-                if (!(lookup instanceof EmptyTestableItem)) {
-                    return lookup;
-                }
-            }
-
-            return new EmptyTestableItem();
-        }
-
-        String[] args = StringUtils.parseTokens(key);
+        return ITEMS_LOOKUP_HANDLER.parseKey(key);
+    }
 
+    @NotNull
+    private static TestableItem doParse(@NotNull final String[] args) {
         if (args.length == 0) {
             return new EmptyTestableItem();
         }
@@ -344,6 +340,35 @@ public final class Items {
         }
     }
 
+    /**
+     * Convert an array of materials to an array of testable items.
+     *
+     * @param materials The materials.
+     * @return An array of functionally identical testable items.
+     */
+    @NotNull
+    public static TestableItem[] fromMaterials(@NotNull final Material... materials) {
+        return Arrays.stream(materials)
+                .map(MaterialTestableItem::new)
+                .toArray(MaterialTestableItem[]::new);
+    }
+
+    /**
+     * Convert a collection of materials into a collection of testable items.
+     *
+     * @param materials The materials.
+     * @return A collection of functionally identical testable items.
+     */
+    @NotNull
+    public static Collection<TestableItem> fromMaterials(@NotNull final Iterable<Material> materials) {
+        List<TestableItem> items = new ArrayList<>();
+        for (Material material : materials) {
+            items.add(new MaterialTestableItem(material));
+        }
+
+        return items;
+    }
+
     private Items() {
         throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
     }

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

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

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

@@ -1,18 +1,20 @@
 package com.willfp.eco.core.items;
 
+import com.willfp.eco.core.lookup.Testable;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.Nullable;
 
 /**
  * An item with a test to see if any item is that item.
  */
-public interface TestableItem {
+public interface TestableItem extends Testable<ItemStack> {
     /**
      * If an ItemStack matches the recipe part.
      *
      * @param itemStack The item to test.
      * @return If the item matches.
      */
+    @Override
     boolean matches(@Nullable ItemStack itemStack);
 
     /**

eco-api/src/main/java/com/willfp/eco/core/lookup/LookupHandler.java

@@ -0,0 +1,76 @@
+package com.willfp.eco.core.lookup;
+
+import com.willfp.eco.util.StringUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+
+/**
+ * Handle lookups, used in {@link com.willfp.eco.core.entities.Entities} and {@link com.willfp.eco.core.items.Items}.
+ *
+ * @param <T> The type of testable object, eg {@link com.willfp.eco.core.items.TestableItem}.
+ */
+public interface LookupHandler<T extends Testable<?>> {
+    /**
+     * Parse lookup string completely.
+     * <p>
+     * You shouldn't override this method unless you're doing something
+     * technically interesting or weird. This is the entry point for all
+     * lookup parsers, {@link this#parse(String[])} is to specify implementation-specific
+     * parsing.
+     *
+     * @param key The key.
+     * @return The object.
+     */
+    default T parseKey(@NotNull String key) {
+        for (SegmentParser parser : SegmentParser.values()) {
+            T generated = parser.parse(key, this);
+
+            if (generated != null) {
+                return generated;
+            }
+        }
+
+        String[] args = StringUtils.parseTokens(key);
+
+        return this.parse(args);
+    }
+
+    /**
+     * Parse arguments to an object.
+     *
+     * @param args The arguments.
+     * @return The object.
+     */
+    @NotNull
+    T parse(@NotNull String[] args);
+
+    /**
+     * Validate an object.
+     *
+     * @param object The object.
+     * @return If validated.
+     */
+    boolean validate(@NotNull T object);
+
+    /**
+     * Get the failsafe object.
+     * <p>
+     * A failsafe object should never pass {@link this#validate(Testable)}, as this will
+     * cause issues with segment parsers. See {@link com.willfp.eco.core.items.ItemsLookupHandler} and
+     * {@link com.willfp.eco.core.recipe.parts.EmptyTestableItem} for examples.
+     *
+     * @return The failsafe.
+     */
+    @NotNull
+    T getFailsafe();
+
+    /**
+     * Join several options together.
+     *
+     * @param options The options.
+     * @return The joined object.
+     */
+    @NotNull
+    T join(@NotNull Collection<T> options);
+}

eco-api/src/main/java/com/willfp/eco/core/lookup/SegmentParser.java

@@ -0,0 +1,83 @@
+package com.willfp.eco.core.lookup;
+
+import com.willfp.eco.util.StringUtils;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Parse a key into segments.
+ */
+public abstract class SegmentParser {
+    /**
+     * All segment parsers.
+     */
+    private static final List<SegmentParser> REGISTERED = new ArrayList<>();
+
+    /**
+     * The pattern to split keys on.
+     */
+    private final String pattern;
+
+    /**
+     * Create new lookup segment parser.
+     *
+     * @param pattern The pattern.
+     */
+    protected SegmentParser(@NotNull final String pattern) {
+        this.pattern = pattern;
+    }
+
+    /**
+     * Register the parser.
+     *
+     * @return The parser.
+     */
+    public SegmentParser register() {
+        REGISTERED.add(this);
+        return this;
+    }
+
+    /**
+     * Try parse segments from key.
+     *
+     * @param key     The key.
+     * @param handler The handler.
+     * @param <T>     The object type.
+     * @return Null if no segments were found, or the object generated from the segments.
+     */
+    @Nullable
+    public <T extends Testable<?>> T parse(@NotNull final String key,
+                                           @NotNull final LookupHandler<T> handler) {
+        if (!key.contains(" " + pattern + " ")) {
+            return null;
+        }
+
+        String[] segments = StringUtils.splitAround(key, pattern);
+
+        return handleSegments(segments, handler);
+    }
+
+    /**
+     * Handle segments from key.
+     *
+     * @param segments The key segments.
+     * @param handler  The handler.
+     * @param <T>      The object type.
+     * @return The returned object.
+     */
+    protected abstract <T extends Testable<?>> T handleSegments(@NotNull String[] segments,
+                                                                @NotNull LookupHandler<T> handler);
+
+    /**
+     * Get all segment parsers.
+     *
+     * @return All parsers.
+     */
+    public static Collection<SegmentParser> values() {
+        return new ArrayList<>(REGISTERED);
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/lookup/Testable.java

@@ -0,0 +1,18 @@
+package com.willfp.eco.core.lookup;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface for testing if any object matches another object.
+ *
+ * @param <T> The type of object.
+ */
+public interface Testable<T> {
+    /**
+     * If object matches the test.
+     *
+     * @param other The other object.
+     * @return If matches.
+     */
+    boolean matches(@Nullable T other);
+}

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

@@ -2,6 +2,9 @@ package com.willfp.eco.core.proxy;
 
 import org.bukkit.Bukkit;
 
+import java.util.Arrays;
+import java.util.List;
+
 /**
  * Proxy / NMS constants.
  */
@@ -11,6 +14,14 @@ public final class ProxyConstants {
      */
     public static final String NMS_VERSION = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
 
+    /**
+     * All supported NMS versions.
+     */
+    public static final List<String> SUPPORTED_VERSIONS = Arrays.asList(
+            "v1_17_R1",
+            "v1_18_R1"
+    );
+
     private ProxyConstants() {
         throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
     }

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

@@ -5,12 +5,25 @@ import org.jetbrains.annotations.NotNull;
 /**
  * Generic error with proxy loading.
  */
-public class ProxyError extends RuntimeException {
+public class ProxyError extends Error {
     /**
      * Thrown if there is an error getting a proxy.
      *
      * @param message The message to send.
+     * @param cause   The cause.
      */
+    public ProxyError(@NotNull final String message,
+                      @NotNull final Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Thrown if there is an error getting a proxy.
+     *
+     * @param message The message to send.
+     * @deprecated Proxy Errors should include a cause.
+     */
+    @Deprecated
     public ProxyError(@NotNull final String message) {
         super(message);
     }

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

@@ -0,0 +1,15 @@
+package com.willfp.eco.core.proxy.exceptions;
+
+import com.willfp.eco.core.proxy.ProxyConstants;
+
+/**
+ * Server running an unsupported version.
+ */
+public class UnsupportedVersionError extends Error {
+    /**
+     * Thrown if the server is running an unsupported version.
+     */
+    public UnsupportedVersionError() {
+        super("You're running an unsupported server version: " + ProxyConstants.NMS_VERSION);
+    }
+}

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

@@ -1,17 +1,30 @@
 package com.willfp.eco.core.proxy.exceptions;
 
+import com.willfp.eco.core.proxy.ProxyConstants;
 import org.jetbrains.annotations.NotNull;
 
 /**
  * Error if the server is running an unsupported version.
+ *
+ * @deprecated Poorly named, exception when it's actually an error, contains doubly nested errors.
  */
+@Deprecated(since = "6.24.0", forRemoval = true)
 public class UnsupportedVersionException extends ProxyError {
     /**
      * Thrown if the server is running an unsupported NMS version.
      *
      * @param message The message to send.
+     * @deprecated Use the default constructor.
      */
+    @Deprecated(since = "6.24.0")
     public UnsupportedVersionException(@NotNull final String message) {
         super(message);
     }
+
+    /**
+     * Thrown if the server is running an unsupported NMS version.
+     */
+    public UnsupportedVersionException() {
+        super("You're running an unsupported server version: " + ProxyConstants.NMS_VERSION, new IllegalStateException());
+    }
 }

eco-api/src/main/java/com/willfp/eco/core/recipe/Recipes.java

@@ -18,7 +18,6 @@ import java.util.List;
 /**
  * Utility class to manage and register crafting recipes.
  */
-@SuppressWarnings("deprecation")
 public final class Recipes {
     /**
      * Registry of all recipes.

eco-api/src/main/java/com/willfp/eco/core/recipe/parts/GroupedTestableItems.java

@@ -0,0 +1,68 @@
+package com.willfp.eco.core.recipe.parts;
+
+import com.willfp.eco.core.items.TestableItem;
+import org.apache.commons.lang.Validate;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+/**
+ * A group of testable items.
+ *
+ * @see com.willfp.eco.core.items.CustomItem
+ */
+public class GroupedTestableItems implements TestableItem {
+    /**
+     * The children.
+     */
+    private final Collection<TestableItem> children;
+
+    /**
+     * Create a new group of testable items.
+     *
+     * @param children The children.
+     */
+    public GroupedTestableItems(@NotNull final Collection<TestableItem> children) {
+        Validate.isTrue(!children.isEmpty(), "Group must have at least one child!");
+
+        this.children = children;
+    }
+
+    /**
+     * If the item matches any children.
+     *
+     * @param itemStack The item to test.
+     * @return If the item matches the test of any children..
+     */
+    @Override
+    public boolean matches(@Nullable final ItemStack itemStack) {
+        for (TestableItem child : children) {
+            if (child.matches(itemStack)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public ItemStack getItem() {
+        for (TestableItem child : children) {
+            return child.getItem();
+        }
+
+        throw new IllegalStateException("Empty group of children!");
+    }
+
+    /**
+     * Get the children.
+     *
+     * @return The children.
+     */
+    public Collection<TestableItem> getChildren() {
+        return new ArrayList<>(children);
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/recipe/recipes/ShapedCraftingRecipe.java

@@ -294,7 +294,7 @@ public final class ShapedCraftingRecipe extends PluginDependent<EcoPlugin> imple
          */
         public boolean isAir() {
             for (TestableItem recipePart : this.recipeParts) {
-                if (recipePart!= null && !(recipePart instanceof EmptyTestableItem)) {
+                if (recipePart != null && !(recipePart instanceof EmptyTestableItem)) {
                     return false;
                 }
             }

eco-api/src/main/java/com/willfp/eco/core/requirement/Requirement.java

@@ -1,13 +1,19 @@
 package com.willfp.eco.core.requirement;
 
+import com.willfp.eco.core.Eco;
 import org.bukkit.entity.Player;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
 /**
  * A requirement is a defined goal that a player must meet.
+ *
+ * @deprecated No typing, weak definitions, and not an API component. Shouldn't be in eco.
  */
+@ApiStatus.ScheduledForRemoval(inVersion = "6.27.0")
+@Deprecated(since = "6.24.0", forRemoval = true)
 public abstract class Requirement {
     /**
      * Create a new requirement.
@@ -25,4 +31,9 @@ public abstract class Requirement {
      */
     public abstract boolean doesPlayerMeet(@NotNull Player player,
                                            @NotNull List<String> args);
+
+    static {
+        Eco.getHandler().getEcoPlugin().getLogger().severe("Loading for-removal Requirements system! This will throw an error once 6.27.0 is released."
+                + "Make sure you're running the latest version of all your plugins!");
+    }
 }

eco-api/src/main/java/com/willfp/eco/core/requirement/RequirementFactory.java

@@ -1,21 +0,0 @@
-package com.willfp.eco.core.requirement;
-
-import com.willfp.eco.core.Eco;
-import org.jetbrains.annotations.ApiStatus;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * Interface for internal requirement factory implementations.
- */
-@ApiStatus.Internal
-@Eco.HandlerComponent
-public interface RequirementFactory {
-    /**
-     * Create a requirement.
-     *
-     * @param name The name.
-     * @return The requirement returned for the name.
-     * Will return a requirement that is always true if not found.
-     */
-    Requirement create(@NotNull String name);
-}

eco-api/src/main/java/com/willfp/eco/core/requirement/Requirements.java

@@ -1,31 +1,40 @@
 package com.willfp.eco.core.requirement;
 
 import com.willfp.eco.core.Eco;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.List;
+
 /**
  * Contains methods and fields pertaining to requirements.
+ *
+ * @deprecated See {@link Requirement}.
  */
+@ApiStatus.ScheduledForRemoval(inVersion = "6.27.0")
+@Deprecated(since = "6.24.0", forRemoval = true)
+@SuppressWarnings("removal")
 public final class Requirements {
     /**
      * Requires a player to have a permission.
      */
-    public static final Requirement HAS_PERMISSION = Eco.getHandler().getRequirementFactory().create("has-permission");
+    public static final Requirement HAS_PERMISSION = new com.willfp.eco.core.requirement.impl.RequirementHasPermission();
 
     /**
      * Placeholder equals value.
      */
-    public static final Requirement PLACEHOLDER_EQUALS = Eco.getHandler().getRequirementFactory().create("placeholder-equals");
+    public static final Requirement PLACEHOLDER_EQUALS = new com.willfp.eco.core.requirement.impl.RequirementPlaceholderEquals();
 
     /**
      * Numeric placeholder greater than value.
      */
-    public static final Requirement PLACEHOLDER_GREATER_THAN = Eco.getHandler().getRequirementFactory().create("placeholder-greater-than");
+    public static final Requirement PLACEHOLDER_GREATER_THAN = new com.willfp.eco.core.requirement.impl.RequirementPlaceholderGreaterThan();
 
     /**
      * Numeric placeholder less than value.
      */
-    public static final Requirement PLACEHOLDER_LESS_THAN = Eco.getHandler().getRequirementFactory().create("placeholder-less-than");
+    public static final Requirement PLACEHOLDER_LESS_THAN = new com.willfp.eco.core.requirement.impl.RequirementPlaceholderLessThan();
 
     /**
      * Get Requirements matching ID.
@@ -34,10 +43,27 @@ public final class Requirements {
      * @return The matching Requirements.
      */
     public static Requirement getByID(@NotNull final String name) {
-        return Eco.getHandler().getRequirementFactory().create(name);
+        return switch (name.toLowerCase()) {
+            case "has-permission" -> HAS_PERMISSION;
+            case "placeholder-equals" -> PLACEHOLDER_EQUALS;
+            case "placeholder-greater-than" -> PLACEHOLDER_GREATER_THAN;
+            case "placeholder-less-than" -> PLACEHOLDER_LESS_THAN;
+            default -> new Requirement() {
+                @Override
+                public boolean doesPlayerMeet(@NotNull final Player player,
+                                              @NotNull final List<String> args) {
+                    return true;
+                }
+            };
+        };
     }
 
     private Requirements() {
         throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
     }
+
+    static {
+        Eco.getHandler().getEcoPlugin().getLogger().severe("Loading for-removal Requirements system! This will throw an error once 6.27.0 is released."
+                + "Make sure you're running the latest version of all your plugins!");
+    }
 }

eco-api/src/main/java/com/willfp/eco/core/requirement/impl/RequirementHasPermission.java

@@ -0,0 +1,34 @@
+package com.willfp.eco.core.requirement.impl;
+
+import com.willfp.eco.core.Eco;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * Moved to API in 6.26.0 after being marked for removal. This class should never be referenced, it
+ * was moved back to the API in order to remove backend components related to Requirements.
+ *
+ * @deprecated No typing, weak definitions, and not an API component. Shouldn't be in eco.
+ */
+@SuppressWarnings("removal")
+@ApiStatus.ScheduledForRemoval(inVersion = "6.27.0")
+@Deprecated(since = "6.26.0", forRemoval = true)
+public class RequirementHasPermission extends com.willfp.eco.core.requirement.Requirement {
+    @Override
+    public boolean doesPlayerMeet(@NotNull final Player player,
+                                  @NotNull final List<String> args) {
+        if (args.isEmpty()) {
+            return false;
+        }
+
+        return player.hasPermission(args.get(0));
+    }
+
+    static {
+        Eco.getHandler().getEcoPlugin().getLogger().severe("Loading for-removal Requirements system! This will throw an error once 6.27.0 is released."
+                + "Make sure you're running the latest version of all your plugins!");
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/requirement/impl/RequirementPlaceholderEquals.java

@@ -0,0 +1,35 @@
+package com.willfp.eco.core.requirement.impl;
+
+import com.willfp.eco.core.Eco;
+import com.willfp.eco.core.integrations.placeholder.PlaceholderManager;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * Moved to API in 6.26.0 after being marked for removal. This class should never be referenced, it
+ * was moved back to the API in order to remove backend components related to Requirements.
+ *
+ * @deprecated No typing, weak definitions, and not an API component. Shouldn't be in eco.
+ */
+@SuppressWarnings("removal")
+@ApiStatus.ScheduledForRemoval(inVersion = "6.27.0")
+@Deprecated(since = "6.26.0", forRemoval = true)
+public class RequirementPlaceholderEquals extends com.willfp.eco.core.requirement.Requirement {
+    @Override
+    public boolean doesPlayerMeet(@NotNull final Player player,
+                                  @NotNull final List<String> args) {
+        if (args.size() < 2) {
+            return false;
+        }
+
+        return PlaceholderManager.translatePlaceholders(args.get(0), player).equalsIgnoreCase(args.get(1));
+    }
+
+    static {
+        Eco.getHandler().getEcoPlugin().getLogger().severe("Loading for-removal Requirements system! This will throw an error once 6.27.0 is released."
+                + "Make sure you're running the latest version of all your plugins!");
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/requirement/impl/RequirementPlaceholderGreaterThan.java

@@ -0,0 +1,49 @@
+package com.willfp.eco.core.requirement.impl;
+
+import com.willfp.eco.core.Eco;
+import com.willfp.eco.core.integrations.placeholder.PlaceholderManager;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * Moved to API in 6.26.0 after being marked for removal. This class should never be referenced, it
+ * was moved back to the API in order to remove backend components related to Requirements.
+ *
+ * @deprecated No typing, weak definitions, and not an API component. Shouldn't be in eco.
+ */
+@SuppressWarnings("removal")
+@ApiStatus.ScheduledForRemoval(inVersion = "6.27.0")
+@Deprecated(since = "6.26.0", forRemoval = true)
+public class RequirementPlaceholderGreaterThan extends com.willfp.eco.core.requirement.Requirement {
+    @Override
+    public boolean doesPlayerMeet(@NotNull final Player player,
+                                  @NotNull final List<String> args) {
+        if (args.size() < 2) {
+            return false;
+        }
+
+        double actual;
+        try {
+            actual = Double.parseDouble(PlaceholderManager.translatePlaceholders(args.get(0), player));
+        } catch (NumberFormatException e) {
+            return false;
+        }
+
+        double expected;
+        try {
+            expected = Double.parseDouble(args.get(1));
+        } catch (NumberFormatException e) {
+            return false;
+        }
+
+        return actual >= expected;
+    }
+
+    static {
+        Eco.getHandler().getEcoPlugin().getLogger().severe("Loading for-removal Requirements system! This will throw an error once 6.27.0 is released."
+                + "Make sure you're running the latest version of all your plugins!");
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/requirement/impl/RequirementPlaceholderLessThan.java

@@ -0,0 +1,49 @@
+package com.willfp.eco.core.requirement.impl;
+
+import com.willfp.eco.core.Eco;
+import com.willfp.eco.core.integrations.placeholder.PlaceholderManager;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * Moved to API in 6.26.0 after being marked for removal. This class should never be referenced, it
+ * was moved back to the API in order to remove backend components related to Requirements.
+ *
+ * @deprecated No typing, weak definitions, and not an API component. Shouldn't be in eco.
+ */
+@SuppressWarnings("removal")
+@ApiStatus.ScheduledForRemoval(inVersion = "6.27.0")
+@Deprecated(since = "6.26.0", forRemoval = true)
+public class RequirementPlaceholderLessThan extends com.willfp.eco.core.requirement.Requirement {
+    @Override
+    public boolean doesPlayerMeet(@NotNull final Player player,
+                                  @NotNull final List<String> args) {
+        if (args.size() < 2) {
+            return false;
+        }
+
+        double actual;
+        try {
+            actual = Double.parseDouble(PlaceholderManager.translatePlaceholders(args.get(0), player));
+        } catch (NumberFormatException e) {
+            return false;
+        }
+
+        double expected;
+        try {
+            expected = Double.parseDouble(args.get(1));
+        } catch (NumberFormatException e) {
+            return false;
+        }
+
+        return actual < expected;
+    }
+
+    static {
+        Eco.getHandler().getEcoPlugin().getLogger().severe("Loading for-removal Requirements system! This will throw an error once 6.27.0 is released."
+                + "Make sure you're running the latest version of all your plugins!");
+    }
+}

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

@@ -26,11 +26,26 @@ public final class DurabilityUtils {
      * @param item   The item to damage.
      * @param damage The amount of damage to deal.
      * @param slot   The slot in the inventory of the item.
+     * @deprecated The slot is not required.
      */
+    @Deprecated(since = "6.24.0")
     public static void damageItem(@NotNull final Player player,
                                   @NotNull final ItemStack item,
                                   final int damage,
                                   final int slot) {
+        damageItem(player, item, damage);
+    }
+
+    /**
+     * Damage an item in a player's inventory.
+     *
+     * @param player The player.
+     * @param item   The item to damage.
+     * @param damage The amount of damage to deal.
+     */
+    public static void damageItem(@NotNull final Player player,
+                                  @NotNull final ItemStack item,
+                                  final int damage) {
         if (item.getItemMeta() == null) {
             return;
         }
@@ -61,7 +76,7 @@ public final class DurabilityUtils {
                 item.setItemMeta((ItemMeta) meta);
                 PlayerItemBreakEvent event = new PlayerItemBreakEvent(player, item);
                 Bukkit.getPluginManager().callEvent(event);
-                player.getInventory().clear(slot);
+                item.setType(Material.AIR);
                 player.playSound(player.getLocation(), Sound.ENTITY_ITEM_BREAK, SoundCategory.BLOCKS, 1, 1);
             } else {
                 item.setItemMeta((ItemMeta) meta);
@@ -69,6 +84,44 @@ public final class DurabilityUtils {
         }
     }
 
+    /**
+     * Damage an item.
+     *
+     * @param item   The item to damage.
+     * @param damage The amount of damage to deal.
+     */
+    public static void damageItem(@NotNull final ItemStack item,
+                                  final int damage) {
+        if (item.getItemMeta() == null) {
+            return;
+        }
+
+        if (item.getItemMeta().isUnbreakable()) {
+            return;
+        }
+
+        if (!(item.getItemMeta() instanceof Damageable)) {
+            return;
+        }
+
+        // Special edge case
+        if (item.getType() == Material.CARVED_PUMPKIN || item.getType() == Material.PLAYER_HEAD) {
+            return;
+        }
+
+
+        Damageable meta = (Damageable) item.getItemMeta();
+        meta.setDamage(meta.getDamage() + damage);
+
+        if (meta.getDamage() >= item.getType().getMaxDurability()) {
+            meta.setDamage(item.getType().getMaxDurability());
+            item.setItemMeta((ItemMeta) meta);
+            item.setType(Material.AIR);
+        } else {
+            item.setItemMeta((ItemMeta) meta);
+        }
+    }
+
     /**
      * Damage an item in a player's inventory without breaking it.
      *

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

@@ -3,6 +3,9 @@ package com.willfp.eco.util;
 import com.willfp.eco.core.Eco;
 import org.bukkit.NamespacedKey;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
 
 /**
  * Utilities / API methods for {@link NamespacedKey}s.
@@ -45,8 +48,25 @@ public final class NamespacedKeyUtils {
      */
     @NotNull
     public static NamespacedKey fromString(@NotNull final String string) {
+        return Objects.requireNonNull(NamespacedKeyUtils.fromStringOrNull(string));
+    }
+
+    /**
+     * Create a NamespacedKey from a string.
+     * <p>
+     * Preferred over {@link NamespacedKey#fromString(String)} for performance reasons.
+     *
+     * @param string The string.
+     * @return The key, or null if not a key.
+     */
+    @Nullable
+    public static NamespacedKey fromStringOrNull(@NotNull final String string) {
         int index = string.indexOf(":");
 
+        if (index < 0) {
+            return null;
+        }
+
         return NamespacedKeyUtils.create(
                 string.substring(0, index),
                 string.substring(index + 1)

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

@@ -5,6 +5,7 @@ import com.willfp.eco.core.Prerequisite;
 import com.willfp.eco.core.data.PlayerProfile;
 import com.willfp.eco.core.data.keys.PersistentDataKey;
 import com.willfp.eco.core.data.keys.PersistentDataKeyType;
+import com.willfp.eco.core.integrations.anticheat.AnticheatManager;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.bukkit.OfflinePlayer;
@@ -12,6 +13,8 @@ import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.function.Consumer;
+
 /**
  * Utilities / API methods for players.
  */
@@ -107,6 +110,38 @@ public final class PlayerUtils {
         profile.write(PLAYER_NAME_KEY, player.getDisplayName());
     }
 
+    /**
+     * Run something with the player exempted.
+     *
+     * @param player The player.
+     * @param action The action.
+     */
+    public static void runExempted(@NotNull final Player player,
+                                   @NotNull final Consumer<Player> action) {
+        try {
+            AnticheatManager.exemptPlayer(player);
+            action.accept(player);
+        } finally {
+            AnticheatManager.unexemptPlayer(player);
+        }
+    }
+
+    /**
+     * Run something with the player exempted.
+     *
+     * @param player The player.
+     * @param action The action.
+     */
+    public static void runExempted(@NotNull final Player player,
+                                   @NotNull final Runnable action) {
+        try {
+            AnticheatManager.exemptPlayer(player);
+            action.run();
+        } finally {
+            AnticheatManager.unexemptPlayer(player);
+        }
+    }
+
     private PlayerUtils() {
         throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
     }

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

@@ -121,6 +121,14 @@ public final class StringUtils {
             .put("§k", ChatColor.MAGIC)
             .build();
 
+    /**
+     * Regex map for splitting values.
+     */
+    private static final LoadingCache<String, Pattern> SPACE_AROUND_CHARACTER = Caffeine.newBuilder()
+            .build(
+                    character -> Pattern.compile("( " + Pattern.quote(character) + " )")
+            );
+
     /**
      * Format a list of strings.
      * <p>
@@ -419,9 +427,23 @@ public final class StringUtils {
      *
      * @param object The object to convert to string.
      * @return The object stringified.
+     * @deprecated Poorly named method. Use {@link StringUtils#toNiceString(Object)} instead.
      */
     @NotNull
+    @Deprecated(since = "6.26.0", forRemoval = true)
     public static String internalToString(@Nullable final Object object) {
+        return toNiceString(object);
+    }
+
+    /**
+     * Internal implementation of {@link String#valueOf}.
+     * Formats collections and doubles better.
+     *
+     * @param object The object to convert to string.
+     * @return The object stringified.
+     */
+    @NotNull
+    public static String toNiceString(@Nullable final Object object) {
         if (object == null) {
             return "null";
         }
@@ -433,7 +455,7 @@ public final class StringUtils {
         } else if (object instanceof Double) {
             return NumberUtils.format((Double) object);
         } else if (object instanceof Collection<?> c) {
-            return c.stream().map(StringUtils::internalToString).collect(Collectors.joining(", "));
+            return c.stream().map(StringUtils::toNiceString).collect(Collectors.joining(", "));
         } else {
             return String.valueOf(object);
         }
@@ -560,6 +582,22 @@ public final class StringUtils {
         return tokens.toArray(new String[0]);
     }
 
+    /**
+     * Split input string around separator surrounded by spaces.
+     * <p>
+     * e.g. {@code splitAround("hello ? how are you", "?")} will split, but
+     * {@code splitAround("hello? how are you", "?")} will not.
+     *
+     * @param input     Input string.
+     * @param separator Separator.
+     * @return The split string.
+     */
+    @NotNull
+    public static String[] splitAround(@NotNull final String input,
+                                       @NotNull final String separator) {
+        return SPACE_AROUND_CHARACTER.get(separator).split(input);
+    }
+
     /**
      * Options for formatting.
      */

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

@@ -2,7 +2,6 @@ package com.willfp.eco.util;
 
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
-import com.willfp.eco.core.Prerequisite;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.Material;
@@ -69,8 +68,10 @@ public final class TeamUtils {
      *
      * @param material The material to find the team from.
      * @return The team.
+     * @deprecated Stupid method.
      */
     @NotNull
+    @Deprecated(since = "6.24.0")
     public static Team getMaterialColorTeam(@NotNull final Material material) {
         return fromChatColor(MATERIAL_COLORS.getOrDefault(material, ChatColor.WHITE));
     }
@@ -89,17 +90,15 @@ public final class TeamUtils {
         MATERIAL_COLORS.put(Material.EMERALD_ORE, ChatColor.GREEN);
         MATERIAL_COLORS.put(Material.ANCIENT_DEBRIS, ChatColor.DARK_RED);
 
-        if (Prerequisite.HAS_1_17.isMet()) {
-            MATERIAL_COLORS.put(Material.COPPER_ORE, ChatColor.GOLD);
-            MATERIAL_COLORS.put(Material.DEEPSLATE_COPPER_ORE, ChatColor.GOLD);
-            MATERIAL_COLORS.put(Material.DEEPSLATE_COAL_ORE, ChatColor.BLACK);
-            MATERIAL_COLORS.put(Material.DEEPSLATE_IRON_ORE, ChatColor.GRAY);
-            MATERIAL_COLORS.put(Material.DEEPSLATE_GOLD_ORE, ChatColor.YELLOW);
-            MATERIAL_COLORS.put(Material.DEEPSLATE_LAPIS_ORE, ChatColor.BLUE);
-            MATERIAL_COLORS.put(Material.DEEPSLATE_REDSTONE_ORE, ChatColor.RED);
-            MATERIAL_COLORS.put(Material.DEEPSLATE_DIAMOND_ORE, ChatColor.AQUA);
-            MATERIAL_COLORS.put(Material.DEEPSLATE_EMERALD_ORE, ChatColor.GREEN);
-        }
+        MATERIAL_COLORS.put(Material.COPPER_ORE, ChatColor.GOLD);
+        MATERIAL_COLORS.put(Material.DEEPSLATE_COPPER_ORE, ChatColor.GOLD);
+        MATERIAL_COLORS.put(Material.DEEPSLATE_COAL_ORE, ChatColor.BLACK);
+        MATERIAL_COLORS.put(Material.DEEPSLATE_IRON_ORE, ChatColor.GRAY);
+        MATERIAL_COLORS.put(Material.DEEPSLATE_GOLD_ORE, ChatColor.YELLOW);
+        MATERIAL_COLORS.put(Material.DEEPSLATE_LAPIS_ORE, ChatColor.BLUE);
+        MATERIAL_COLORS.put(Material.DEEPSLATE_REDSTONE_ORE, ChatColor.RED);
+        MATERIAL_COLORS.put(Material.DEEPSLATE_DIAMOND_ORE, ChatColor.AQUA);
+        MATERIAL_COLORS.put(Material.DEEPSLATE_EMERALD_ORE, ChatColor.GREEN);
     }
 
     private TeamUtils() {

eco-api/src/main/kotlin/com/willfp/eco/core/commands/CommandHelpers.kt

@@ -0,0 +1,142 @@
+@file:JvmName("CommandHelperExtensions")
+
+package com.willfp.eco.core.commands
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.command.CommandBase
+import com.willfp.eco.core.command.impl.PluginCommand
+import com.willfp.eco.core.command.impl.Subcommand
+import org.bukkit.command.CommandSender
+
+/**
+ * Helper class for creating commands with builders.
+ *
+ * @param plugin The plugin.
+ * @param name The command name.
+ * @param permission The permission.
+ * @param playersOnly If only players should run the command.
+ * @param executor The command executor.
+ * @param tabCompleter The tab completer.
+ */
+class BuiltPluginCommand internal constructor(
+    plugin: EcoPlugin,
+    name: String,
+    permission: String,
+    playersOnly: Boolean = false,
+    var executor: (CommandSender, List<String>) -> Unit,
+    var tabCompleter: (CommandSender, List<String>) -> List<String>,
+) : PluginCommand(plugin, name, permission, playersOnly) {
+    override fun onExecute(sender: CommandSender, args: List<String>) =
+        executor(sender, args)
+
+    override fun tabComplete(sender: CommandSender, args: List<String>): List<String> =
+        tabCompleter(sender, args)
+}
+
+
+/**
+ * Helper class for creating commands with builders.
+ *
+ * @param plugin The plugin.
+ * @param name The command name.
+ * @param permission The permission.
+ * @param playersOnly If only players should run the command.
+ * @param executor The command executor.
+ * @param tabCompleter The tab completer.
+ */
+class BuiltSubcommand internal constructor(
+    plugin: EcoPlugin,
+    name: String,
+    permission: String,
+    playersOnly: Boolean = false,
+    var executor: (CommandSender, List<String>) -> Unit,
+    var tabCompleter: (CommandSender, List<String>) -> List<String>,
+) : Subcommand(plugin, name, permission, playersOnly) {
+    internal constructor(
+        parent: CommandBase,
+        name: String,
+        executor: (CommandSender, List<String>) -> Unit,
+        tabCompleter: (CommandSender, List<String>) -> List<String>,
+    ) : this(parent.plugin, name, parent.permission, parent.isPlayersOnly, executor, tabCompleter)
+
+    override fun onExecute(sender: CommandSender, args: List<String>) =
+        executor(sender, args)
+
+    override fun tabComplete(sender: CommandSender, args: List<String>): List<String> =
+        tabCompleter(sender, args)
+}
+
+/**
+ * Kotlin builder for commands.
+ *
+ * @param plugin The plugin.
+ * @param name The command name.
+ * @param permission The permission.
+ * @param playersOnly If only players should execute the command.
+ * @param init The builder.
+ */
+fun command(
+    plugin: EcoPlugin,
+    name: String,
+    permission: String,
+    playersOnly: Boolean = false,
+    init: BuiltPluginCommand.() -> Unit
+): PluginCommand {
+    val command = BuiltPluginCommand(
+        plugin,
+        name,
+        permission,
+        playersOnly,
+        { _, _ -> },
+        { _, _ -> emptyList() }
+    )
+    init(command)
+    return command
+}
+
+/**
+ * Kotlin builder for commands.
+ *
+ * @param name The command name.
+ * @param permission The permission.
+ * @param playersOnly If only players should execute the command.
+ * @param init The builder.
+ */
+fun CommandBase.addSubcommand(
+    name: String,
+    permission: String,
+    playersOnly: Boolean = false,
+    init: BuiltSubcommand.() -> Unit
+): Subcommand {
+    val command = BuiltSubcommand(
+        this.plugin,
+        name,
+        permission,
+        playersOnly,
+        { _, _ -> },
+        { _, _ -> emptyList() }
+    )
+    init(command)
+    return command
+}
+
+/**
+ * Kotlin builder for commands.
+ * Inherits plugin, permission, players only.
+ *
+ * @param name The command name.
+ * @param init The builder.
+ */
+fun CommandBase.addSubcommand(
+    name: String,
+    init: BuiltSubcommand.() -> Unit
+): Subcommand {
+    val command = BuiltSubcommand(
+        this,
+        name,
+        { _, _ -> },
+        { _, _ -> emptyList() }
+    )
+    init(command)
+    return command
+}

eco-api/src/main/kotlin/com/willfp/eco/core/data/Profiles.kt

@@ -0,0 +1,18 @@
+@file:JvmName("ProfileExtensions")
+
+package com.willfp.eco.core.data
+
+import org.bukkit.OfflinePlayer
+import org.bukkit.Server
+
+/**
+ * @see PlayerProfile.load
+ */
+val OfflinePlayer.profile: PlayerProfile
+    get() = PlayerProfile.load(this)
+
+/**
+ * @see ServerProfile.load
+ */
+val Server.profile: ServerProfile
+    get() = ServerProfile.load()

eco-api/src/main/kotlin/com/willfp/eco/core/fast/FastItemStack.kt

@@ -0,0 +1,11 @@
+@file:JvmName("FastItemStackExtensions")
+
+package com.willfp.eco.core.fast
+
+import org.bukkit.inventory.ItemStack
+
+/**
+ * @see FastItemStack.wrap
+ */
+fun ItemStack.fast(): FastItemStack =
+    FastItemStack.wrap(this)

eco-api/src/main/kotlin/com/willfp/eco/core/gui/GUIHelpers.kt

@@ -0,0 +1,105 @@
+@file:JvmName("GUIHelperExtensions")
+
+package com.willfp.eco.core.gui
+
+import com.willfp.eco.core.gui.menu.Menu
+import com.willfp.eco.core.gui.menu.MenuBuilder
+import com.willfp.eco.core.gui.slot.Slot
+import com.willfp.eco.core.gui.slot.SlotBuilder
+import org.bukkit.entity.Player
+import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.event.inventory.InventoryCloseEvent
+import org.bukkit.inventory.ItemStack
+
+/**
+ * @see SlotBuilder.onLeftClick
+ */
+fun SlotBuilder.onLeftClick(action: (InventoryClickEvent, Slot, Menu) -> Unit): SlotBuilder =
+    this.onLeftClick { a, b, c -> action(a, b, c) }
+
+/**
+ * @see SlotBuilder.onRightClick
+ */
+fun SlotBuilder.onRightClick(action: (InventoryClickEvent, Slot, Menu) -> Unit): SlotBuilder =
+    this.onRightClick { a, b, c -> action(a, b, c) }
+
+/**
+ * @see SlotBuilder.onShiftLeftClick
+ */
+fun SlotBuilder.onShiftLeftClick(action: (InventoryClickEvent, Slot, Menu) -> Unit): SlotBuilder =
+    this.onShiftLeftClick { a, b, c -> action(a, b, c) }
+
+/**
+ * @see SlotBuilder.onShiftRightClick
+ */
+fun SlotBuilder.onShiftRightClick(action: (InventoryClickEvent, Slot, Menu) -> Unit): SlotBuilder =
+    this.onShiftRightClick { a, b, c -> action(a, b, c) }
+
+/**
+ * @see SlotBuilder.onShiftRightClick
+ */
+fun SlotBuilder.onMiddleClick(action: (InventoryClickEvent, Slot, Menu) -> Unit): SlotBuilder =
+    this.onMiddleClick { a, b, c -> action(a, b, c) }
+
+/**
+ * @see SlotBuilder.setModifier
+ * @deprecated Use SlotUpdater instead.
+ */
+@Deprecated("Use SlotUpdater instead")
+@Suppress("DEPRECATION")
+fun SlotBuilder.setModifier(action: (Player, Menu, ItemStack) -> Unit): SlotBuilder =
+    this.setUpdater { a, b, c -> c.apply { action(a, b, c) } }
+
+/**
+ * @see SlotBuilder.setUpdater
+ */
+fun SlotBuilder.setUpdater(action: (Player, Menu, ItemStack) -> ItemStack): SlotBuilder =
+    this.setUpdater { a, b, c -> action(a, b, c) }
+
+/**
+ * Kotlin builder for slots.
+ */
+fun slot(
+    item: ItemStack,
+    init: SlotBuilder.() -> Unit
+): Slot {
+    val builder = Slot.builder(item)
+    init(builder)
+    return builder.build()
+}
+
+/**
+ * Kotlin builder for slots.
+ */
+fun slot(
+    provider: (Player, Menu) -> ItemStack,
+    init: SlotBuilder.() -> Unit
+): Slot {
+    val builder = Slot.builder { a, b -> provider(a, b) }
+    init(builder)
+    return builder.build()
+}
+
+/**
+ * @see MenuBuilder.onClose
+ */
+fun MenuBuilder.onClose(action: (InventoryCloseEvent, Menu) -> Unit): MenuBuilder =
+    this.onClose { a, b -> action(a, b) }
+
+/**
+ * @see MenuBuilder.modify
+ */
+fun MenuBuilder.modify(modifier: (MenuBuilder) -> Unit): MenuBuilder =
+    this.modfiy { modifier(it) }
+
+/**
+ * Kotlin builder for menus.
+ */
+fun menu(
+    rows: Int,
+    init: MenuBuilder.() -> Unit
+): Menu {
+    val builder = Menu.builder(rows)
+    init(builder)
+    return builder.build()
+}

eco-api/src/main/kotlin/com/willfp/eco/util/ArrowUtils.kt

@@ -0,0 +1,12 @@
+@file:JvmName("ArrowUtilsExtensions")
+
+package com.willfp.eco.util
+
+import org.bukkit.entity.Arrow
+import org.bukkit.inventory.ItemStack
+
+/**
+ * @see ArrowUtils.getBow
+ */
+val Arrow.bow: ItemStack?
+    get() = ArrowUtils.getBow(this)

eco-api/src/main/kotlin/com/willfp/eco/util/BlockUtils.kt

@@ -0,0 +1,11 @@
+@file:JvmName("BlockUtilsExtensions")
+
+package com.willfp.eco.util
+
+import org.bukkit.block.Block
+
+/**
+ * @see ArrowUtils.getBow
+ */
+val Block.isPlayerPlaced: Boolean
+    get() = BlockUtils.isPlayerPlaced(this)

eco-api/src/main/kotlin/com/willfp/eco/util/DurabilityUtils.kt

@@ -0,0 +1,18 @@
+@file:JvmName("DurabilityUtilsExtensions")
+
+package com.willfp.eco.util
+
+import org.bukkit.entity.Player
+import org.bukkit.inventory.ItemStack
+
+/**
+ * @see DurabilityUtils.damageItem
+ */
+fun ItemStack.damage(damage: Int) =
+    DurabilityUtils.damageItem(this, damage)
+
+/**
+ * @see DurabilityUtils.damageItem
+ */
+fun ItemStack.damage(damage: Int, player: Player) =
+    DurabilityUtils.damageItem(player, this, damage)

eco-api/src/main/kotlin/com/willfp/eco/util/ListUtils.kt

@@ -0,0 +1,21 @@
+@file:JvmName("ListUtilsExtensions")
+
+package com.willfp.eco.util
+
+/**
+ * @see ListUtils.listToFrequencyMap
+ */
+fun <T> List<T>.toFrequencyMap(): Map<T, Int> =
+    ListUtils.listToFrequencyMap(this)
+
+/**
+ * @see ListUtils.containsIgnoreCase
+ */
+fun Iterable<String>.containsIgnoreCase(element: String): Boolean =
+    ListUtils.containsIgnoreCase(this, element)
+
+/**
+ * @see ListUtils.create2DList
+ */
+fun <T> create2DList(rows: Int, columns: Int): MutableList<MutableList<T>> =
+    ListUtils.create2DList(rows, columns)

eco-api/src/main/kotlin/com/willfp/eco/util/NamespacedKeyUtils.kt

@@ -0,0 +1,29 @@
+@file:JvmName("NamespacedKeyUtilsExtensions")
+
+package com.willfp.eco.util
+
+import com.willfp.eco.core.EcoPlugin
+
+/**
+ * @see NamespacedKeyUtils.fromString
+ */
+fun namespacedKeyOf(string: String) =
+    NamespacedKeyUtils.fromString(string)
+
+/**
+ * @see NamespacedKeyUtils.fromString
+ */
+fun safeNamespacedKeyOf(string: String) =
+    NamespacedKeyUtils.fromStringOrNull(string)
+
+/**
+ * @see NamespacedKeyUtils.create
+ */
+fun namespacedKeyOf(namespace: String, key: String) =
+    NamespacedKeyUtils.create(namespace, key)
+
+/**
+ * @see EcoPlugin.namespacedKeyFactory
+ */
+fun namespacedKeyOf(plugin: EcoPlugin, key: String) =
+    plugin.namespacedKeyFactory.create(key)

eco-api/src/main/kotlin/com/willfp/eco/util/NumberUtils.kt

@@ -0,0 +1,9 @@
+@file:JvmName("NumberUtilsExtensions")
+
+package com.willfp.eco.util
+
+/**
+ * @see NumberUtils.toNumeral
+ */
+fun Number.toNumeral(): String =
+    NumberUtils.toNumeral(this.toInt())

eco-api/src/main/kotlin/com/willfp/eco/util/PlayerUtils.kt

@@ -0,0 +1,32 @@
+@file:JvmName("PlayerUtilsExtensions")
+
+package com.willfp.eco.util
+
+import net.kyori.adventure.audience.Audience
+import org.bukkit.OfflinePlayer
+import org.bukkit.command.CommandSender
+import org.bukkit.entity.Player
+
+/**
+ * @see PlayerUtils.getSavedDisplayName
+ */
+val OfflinePlayer.savedDisplayName: String
+    get() = PlayerUtils.getSavedDisplayName(this)
+
+/**
+ * @see PlayerUtils.getAudience
+ */
+fun Player.asAudience(): Audience =
+    PlayerUtils.getAudience(this)
+
+/**
+ * @see PlayerUtils.getAudience
+ */
+fun CommandSender.asAudience(): Audience =
+    PlayerUtils.getAudience(this)
+
+/**
+ * @see PlayerUtils.runExempted
+ */
+fun Player.runExempted(action: () -> Unit) =
+    PlayerUtils.runExempted(this, action)

eco-api/src/main/kotlin/com/willfp/eco/util/PotionUtils.kt

@@ -0,0 +1,11 @@
+@file:JvmName("PotionUtilsExtensions")
+
+package com.willfp.eco.util
+
+import org.bukkit.potion.PotionData
+
+/**
+ * @see PotionData.duration
+ */
+val PotionData.duration: Int
+    get() = PotionUtils.getDuration(this)

eco-api/src/main/kotlin/com/willfp/eco/util/ServerUtils.kt

@@ -0,0 +1,11 @@
+@file:JvmName("ServerUtilsExtensions")
+
+package com.willfp.eco.util
+
+import org.bukkit.Server
+
+/**
+ * @see ServerUtils.getTps
+ */
+val Server.tps: Double
+    get() = ServerUtils.getTps()

eco-api/src/main/kotlin/com/willfp/eco/util/SkullUtils.kt

@@ -0,0 +1,17 @@
+@file:JvmName("SkullUtilsExtensions")
+
+package com.willfp.eco.util
+
+import org.bukkit.inventory.meta.SkullMeta
+
+/**
+ * @see SkullUtils.getSkullTexture
+ * @see SkullUtils.setSkullTexture
+ */
+var SkullMeta.texture: String?
+    get() = SkullUtils.getSkullTexture(this)
+    set(value) {
+        if (value != null) {
+            SkullUtils.setSkullTexture(this, value)
+        }
+    }

eco-api/src/main/kotlin/com/willfp/eco/util/StringUtils.kt

@@ -0,0 +1,54 @@
+@file:JvmName("StringUtilsExtensions")
+
+package com.willfp.eco.util
+
+import net.kyori.adventure.text.Component
+import org.bukkit.entity.Player
+
+/**
+ * @see StringUtils.toComponent
+ */
+fun String.toComponent(): Component =
+    StringUtils.toComponent(this)
+
+/**
+ * @see StringUtils.toLegacy
+ */
+fun Component.toLegacy(): String =
+    StringUtils.toLegacy(this)
+
+/**
+ * @see StringUtils.format
+ */
+fun String.formatEco(
+    player: Player? = null,
+    formatPlaceholders: Boolean = false
+) = StringUtils.format(
+    this,
+    player,
+    if (formatPlaceholders) StringUtils.FormatOption.WITH_PLACEHOLDERS else StringUtils.FormatOption.WITHOUT_PLACEHOLDERS
+)
+
+/**
+ * @see StringUtils.formatList
+ */
+fun List<String>.formatEco(
+    player: Player? = null,
+    formatPlaceholders: Boolean = false
+): List<String> = StringUtils.formatList(
+    this,
+    player,
+    if (formatPlaceholders) StringUtils.FormatOption.WITH_PLACEHOLDERS else StringUtils.FormatOption.WITHOUT_PLACEHOLDERS
+)
+
+/**
+ * @see StringUtils.splitAround
+ */
+fun String.splitAround(separator: String): Array<String> =
+    StringUtils.splitAround(this, separator)
+
+/**
+ * @see StringUtils.toNiceString
+ */
+fun Any?.toNiceString(): String =
+    StringUtils.toNiceString(this)

eco-api/src/main/kotlin/com/willfp/eco/util/VectorUtils.kt

@@ -0,0 +1,17 @@
+@file:JvmName("VectorUtilsExtensions")
+
+package com.willfp.eco.util
+
+import org.bukkit.util.Vector
+
+/**
+ * @see VectorUtils.isFinite
+ */
+val Vector.isFinite: Boolean
+    get() = VectorUtils.isFinite(this)
+
+/**
+ * @see VectorUtils.simplifyVector
+ */
+fun Vector.simplify(): Vector =
+    VectorUtils.simplifyVector(this)

eco-api/src/test/java/StringUtilsTest.java

@@ -0,0 +1,29 @@
+import com.willfp.eco.util.StringUtils;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class StringUtilsTest {
+    @Test
+    public void testSplitAround() {
+        Assertions.assertArrayEquals(
+                new String[]{"one", "two"},
+                StringUtils.splitAround("one ? two", "?")
+        );
+        Assertions.assertArrayEquals(
+                new String[]{"one? two"},
+                StringUtils.splitAround("one? two", "?")
+        );
+        Assertions.assertArrayEquals(
+                new String[]{"one", "two", "three"},
+                StringUtils.splitAround("one ? two ? three", "?")
+        );
+        Assertions.assertArrayEquals(
+                new String[]{"one", "two"},
+                StringUtils.splitAround("one || two", "||")
+        );
+        Assertions.assertArrayEquals(
+                new String[]{"one|| two"},
+                StringUtils.splitAround("one|| two", "||")
+        );
+    }
+}

eco-core/build.gradle

@@ -1,29 +1,8 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.6.0"
-    }
-}
-
 group 'com.willfp'
 version rootProject.version
 
 subprojects {
-    apply plugin: "kotlin"
-
     dependencies {
         compileOnly project(":eco-api")
-        compileOnly 'org.jetbrains.kotlin:kotlin-stdlib:1.6.0'
     }
-
-    compileKotlin {
-        kotlinOptions {
-            jvmTarget = "17"
-        }
-        targetCompatibility = JavaVersion.VERSION_17
-        sourceCompatibility = JavaVersion.VERSION_17
-    }
-}
+}

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

@@ -0,0 +1,35 @@
+package com.willfp.eco.internal
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.PluginProps
+import com.willfp.eco.core.config.TransientConfig
+import com.willfp.eco.core.config.interfaces.Config
+
+object EcoPropsParser : PluginProps.PropsParser<Config> {
+    override fun parseFrom(config: Config): PluginProps {
+        val resourceId = config.getIntOrNull("resource-id") ?: 0
+        val bStatsId = config.getIntOrNull("bstats-id") ?: 0
+        val proxyPackage = config.getStringOrNull("proxy-package") ?: ""
+        val color = config.getStringOrNull("color") ?: "&f"
+        val supportsExtensions = config.getBoolOrNull("supports-extensions") ?: false
+
+        return blankProps.apply {
+            this.resourceId = resourceId
+            this.bStatsId = bStatsId
+            this.proxyPackage = proxyPackage
+            this.color = color
+            this.isSupportingExtensions = supportsExtensions
+        }
+    }
+
+    fun parseForPlugin(plugin: Class<out EcoPlugin>): PluginProps {
+        if (!PluginProps.hasParserFor(Config::class.java)) {
+            PluginProps.registerParser(Config::class.java, this)
+        }
+
+        return PluginProps.parse(
+            TransientConfig(plugin.getResourceAsStream("/eco.yml")),
+            Config::class.java
+        )
+    }
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/config/EcoConfigFactory.kt

@@ -15,7 +15,7 @@ import com.willfp.eco.internal.config.yaml.EcoYamlConfigSection
 import org.bukkit.configuration.file.YamlConfiguration
 import java.io.StringReader
 
-class EcoConfigFactory : ConfigFactory {
+object EcoConfigFactory : ConfigFactory {
     override fun createConfig(config: YamlConfiguration): Config {
         return EcoYamlConfigSection(config)
     }

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/display/EcoDisplayHandler.kt

@@ -5,7 +5,7 @@ import com.willfp.eco.core.display.Display
 import com.willfp.eco.core.display.DisplayHandler
 import com.willfp.eco.core.display.DisplayModule
 import com.willfp.eco.core.display.DisplayPriority
-import com.willfp.eco.core.fast.FastItemStack
+import com.willfp.eco.core.fast.fast
 import org.bukkit.NamespacedKey
 import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
@@ -60,7 +60,7 @@ class EcoDisplayHandler(plugin: EcoPlugin) : DisplayHandler {
             Display.unfinalize(itemStack)
         }
 
-        val fast = FastItemStack.wrap(itemStack)
+        val fast = itemStack.fast()
         val lore = fast.lore
 
         if (lore.isNotEmpty() && lore.removeIf { line: String ->

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/drops/impl/EcoDropQueue.kt

@@ -10,7 +10,6 @@ import org.bukkit.Material
 import org.bukkit.entity.EntityType
 import org.bukkit.entity.ExperienceOrb
 import org.bukkit.entity.Player
-import org.bukkit.event.player.PlayerExpChangeEvent
 import org.bukkit.inventory.ItemStack
 import org.bukkit.util.Vector
 

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

@@ -0,0 +1,10 @@
+package com.willfp.eco.internal.entities
+
+import com.willfp.eco.core.entities.DummyEntity
+import org.bukkit.entity.Entity
+
+class EcoDummyEntity(private val handle: Entity) : DummyEntity, Entity by handle {
+    override fun toString(): String {
+        return "DummyEntity{id=${this.entityId}}"
+    }
+}

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

@@ -2,7 +2,7 @@ package com.willfp.eco.internal.entities
 
 import com.willfp.eco.core.entities.args.EntityArgParseResult
 import com.willfp.eco.core.entities.args.EntityArgParser
-import org.bukkit.entity.Animals
+import org.bukkit.entity.Ageable
 
 class EntityArgParserAdult : EntityArgParser {
     override fun parseArguments(args: Array<out String>): EntityArgParseResult? {
@@ -20,14 +20,14 @@ class EntityArgParserAdult : EntityArgParser {
 
         return EntityArgParseResult(
             {
-                if (it !is Animals) {
+                if (it !is Ageable) {
                     return@EntityArgParseResult false
                 }
 
                 it.isAdult
             },
             {
-                (it as? Animals)?.setAdult()
+                (it as? Ageable)?.setAdult()
             }
         )
     }

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

@@ -2,7 +2,7 @@ package com.willfp.eco.internal.entities
 
 import com.willfp.eco.core.entities.args.EntityArgParseResult
 import com.willfp.eco.core.entities.args.EntityArgParser
-import org.bukkit.entity.Animals
+import org.bukkit.entity.Ageable
 
 class EntityArgParserBaby : EntityArgParser {
     override fun parseArguments(args: Array<out String>): EntityArgParseResult? {
@@ -20,14 +20,14 @@ class EntityArgParserBaby : EntityArgParser {
 
         return EntityArgParseResult(
             {
-                if (it !is Animals) {
+                if (it !is Ageable) {
                     return@EntityArgParseResult false
                 }
 
                 !it.isAdult
             },
             {
-                (it as? Animals)?.setBaby()
+                (it as? Ageable)?.setBaby()
             }
         )
     }

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

@@ -0,0 +1,56 @@
+package com.willfp.eco.internal.entities
+
+import com.willfp.eco.core.entities.args.EntityArgParseResult
+import com.willfp.eco.core.entities.args.EntityArgParser
+import com.willfp.eco.core.items.Items
+import com.willfp.eco.core.items.TestableItem
+import org.bukkit.entity.LivingEntity
+import org.bukkit.inventory.EquipmentSlot
+
+class EntityArgParserEquipment : EntityArgParser {
+    override fun parseArguments(args: Array<out String>): EntityArgParseResult? {
+        val equipment = mutableMapOf<EquipmentSlot, TestableItem>()
+
+        for (arg in args) {
+            for (slot in EquipmentSlot.values()) {
+                if (!arg.lowercase().startsWith("${slot.name.lowercase()}:")) {
+                    continue
+                }
+                equipment[slot] = Items.lookup(arg.substring(slot.name.length + 1, arg.length))
+            }
+        }
+
+        if (equipment.isEmpty()) {
+            return null
+        }
+
+        return EntityArgParseResult(
+            {
+                if (it !is LivingEntity) {
+                    return@EntityArgParseResult false
+                }
+
+                val entityEquipment = it.equipment ?: return@EntityArgParseResult false
+
+                for ((slot, item) in equipment) {
+                    if (!item.matches(entityEquipment.getItem(slot))) {
+                        return@EntityArgParseResult false
+                    }
+                }
+
+                return@EntityArgParseResult true
+            },
+            {
+                if (it !is LivingEntity) {
+                    return@EntityArgParseResult
+                }
+
+                val entityEquipment = it.equipment ?: return@EntityArgParseResult
+
+                for ((slot, item) in equipment) {
+                    entityEquipment.setItem(slot, item.item, false)
+                }
+            }
+        )
+    }
+}

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

@@ -9,14 +9,10 @@ class EntityArgParserName : EntityArgParser {
         var name: String? = null
 
         for (arg in args) {
-            val argSplit = arg.split(":")
-            if (!argSplit[0].equals("name", ignoreCase = true)) {
+            if (!arg.lowercase().startsWith("name:")) {
                 continue
             }
-            if (argSplit.size < 2) {
-                continue
-            }
-            name = argSplit[1]
+            name = arg.substring(5, arg.length)
         }
 
         name ?: return null

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

@@ -2,7 +2,6 @@ package com.willfp.eco.internal.entities
 
 import com.willfp.eco.core.entities.args.EntityArgParseResult
 import com.willfp.eco.core.entities.args.EntityArgParser
-import org.bukkit.entity.Animals
 
 class EntityArgParserSilent : EntityArgParser {
     override fun parseArguments(args: Array<out String>): EntityArgParseResult? {

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/extensions/EcoExtensionLoader.kt

@@ -1,6 +1,7 @@
 package com.willfp.eco.internal.extensions
 
 import com.google.common.collect.ImmutableSet
+import com.willfp.eco.core.Eco
 import com.willfp.eco.core.EcoPlugin
 import com.willfp.eco.core.config.TransientConfig
 import com.willfp.eco.core.extensions.Extension
@@ -32,6 +33,9 @@ class EcoExtensionLoader(
 
             runCatching { loadExtension(extensionJar) }.onFailure {
                 this.plugin.logger.warning(extensionJar.name + " caused an error!")
+                if (Eco.getHandler().ecoPlugin.configYml.getBool("log-full-extension-errors")) {
+                    it.printStackTrace()
+                }
             }
         }
     }

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/gui/slot/EcoCaptiveSlot.kt

@@ -12,7 +12,7 @@ class EcoCaptiveSlot(
     allowMovingItem,
     allowMovingItem,
     allowMovingItem,
-    { _, _, _ -> }
+    { _, _, prev -> prev }
 ) {
     override fun isCaptive(): Boolean {
         return true

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/gui/slot/EcoFillerSlot.kt

@@ -9,5 +9,5 @@ class EcoFillerSlot(itemStack: ItemStack) : EcoSlot(
     { _, _, _ -> },
     { _, _, _ -> },
     { _, _, _ -> },
-    { _, _, _ -> }
+    { _, _, prev -> prev }
 )

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/gui/slot/EcoSlot.kt

@@ -3,8 +3,8 @@ package com.willfp.eco.internal.gui.slot
 import com.willfp.eco.core.gui.menu.Menu
 import com.willfp.eco.core.gui.slot.Slot
 import com.willfp.eco.core.gui.slot.functional.SlotHandler
-import com.willfp.eco.core.gui.slot.functional.SlotModifier
 import com.willfp.eco.core.gui.slot.functional.SlotProvider
+import com.willfp.eco.core.gui.slot.functional.SlotUpdater
 import com.willfp.eco.internal.gui.menu.MenuHandler
 import org.bukkit.entity.Player
 import org.bukkit.event.inventory.ClickType
@@ -18,7 +18,7 @@ open class EcoSlot(
     private val onShiftLeftClick: SlotHandler,
     private val onShiftRightClick: SlotHandler,
     private val onMiddleClick: SlotHandler,
-    private val modifier: SlotModifier
+    private val updater: SlotUpdater
 ) : Slot {
 
     fun handleInventoryClick(
@@ -38,8 +38,7 @@ open class EcoSlot(
     override fun getItemStack(player: Player): ItemStack {
         val menu = MenuHandler.getMenu(player.openInventory.topInventory)!!
         val prev = provider.provide(player, menu)
-        modifier.modify(player, menu, prev)
-        return prev
+        return updater.update(player, menu, prev)
     }
 
     fun getItemStack(
@@ -47,8 +46,7 @@ open class EcoSlot(
         menu: Menu
     ): ItemStack {
         val prev = provider.provide(player, menu)
-        modifier.modify(player, menu, prev)
-        return prev
+        return updater.update(player, menu, prev)
     }
 
     override fun isCaptive(): Boolean {

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/gui/slot/EcoSlotBuilder.kt

@@ -3,12 +3,12 @@ package com.willfp.eco.internal.gui.slot
 import com.willfp.eco.core.gui.slot.Slot
 import com.willfp.eco.core.gui.slot.SlotBuilder
 import com.willfp.eco.core.gui.slot.functional.SlotHandler
-import com.willfp.eco.core.gui.slot.functional.SlotModifier
 import com.willfp.eco.core.gui.slot.functional.SlotProvider
+import com.willfp.eco.core.gui.slot.functional.SlotUpdater
 
 class EcoSlotBuilder(private val provider: SlotProvider) : SlotBuilder {
     private var captive = false
-    private var modifier: SlotModifier = SlotModifier{ player, menu, _ -> provider.provide(player, menu)}
+    private var updater: SlotUpdater = SlotUpdater { player, menu, _ -> provider.provide(player, menu) }
 
     private var onLeftClick =
         SlotHandler { _, _, _ -> run { } }
@@ -51,8 +51,8 @@ class EcoSlotBuilder(private val provider: SlotProvider) : SlotBuilder {
         return this
     }
 
-    override fun setModifier(modifier: SlotModifier): SlotBuilder {
-        this.modifier = modifier
+    override fun setUpdater(updater: SlotUpdater): SlotBuilder {
+        this.updater = updater
         return this
     }
 
@@ -60,7 +60,7 @@ class EcoSlotBuilder(private val provider: SlotProvider) : SlotBuilder {
         return if (captive) {
             EcoCaptiveSlot(provider)
         } else {
-            EcoSlot(provider, onLeftClick, onRightClick, onShiftLeftClick, onShiftRightClick, onMiddleClick, modifier)
+            EcoSlot(provider, onLeftClick, onRightClick, onShiftLeftClick, onShiftRightClick, onMiddleClick, updater)
         }
     }
 }

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

@@ -1,6 +1,6 @@
 package com.willfp.eco.internal.items
 
-import com.willfp.eco.core.fast.FastItemStack
+import com.willfp.eco.core.fast.fast
 import com.willfp.eco.core.items.args.LookupArgParser
 import com.willfp.eco.util.NamespacedKeyUtils
 import org.bukkit.enchantments.Enchantment
@@ -41,7 +41,7 @@ class ArgParserEnchantment : LookupArgParser {
         }
 
         return Predicate {
-            val onItem = FastItemStack.wrap(it).getEnchantmentsOnItem(true)
+            val onItem = it.fast().getEnchants(true)
 
             for ((enchant, level) in enchants) {
                 if ((onItem[enchant] ?: 0) < level) {

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

@@ -11,20 +11,17 @@ class ArgParserName : LookupArgParser {
         var name: String? = null
 
         for (arg in args) {
-            val argSplit = arg.split(":")
-            if (!argSplit[0].equals("name", ignoreCase = true)) {
+            if (!arg.lowercase().startsWith("name:")) {
                 continue
             }
-            if (argSplit.size < 2) {
-                continue
-            }
-            name = argSplit[1]
+            name = arg.substring(5, arg.length)
         }
 
         name ?: return null
 
         val formatted = StringUtils.format(name)
 
+        @Suppress("UsePropertyAccessSyntax")
         meta.setDisplayName(formatted)
 
         return Predicate {

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/lookup/SegmentParserGroup.kt

@@ -0,0 +1,24 @@
+package com.willfp.eco.internal.lookup
+
+import com.willfp.eco.core.lookup.LookupHandler
+import com.willfp.eco.core.lookup.SegmentParser
+import com.willfp.eco.core.lookup.Testable
+
+class SegmentParserGroup : SegmentParser("||") {
+    override fun <T : Testable<*>> handleSegments(segments: Array<out String>, handler: LookupHandler<T>): T {
+        val possibleOptions = mutableListOf<T>()
+
+        for (option in segments) {
+            val lookup = handler.parseKey(option)
+            if (handler.validate(lookup)) {
+                possibleOptions.add(lookup)
+            }
+        }
+
+        if (possibleOptions.isEmpty()) {
+            return handler.failsafe
+        }
+
+        return handler.join(possibleOptions)
+    }
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/lookup/SegmentParserUseIfPresent.kt

@@ -0,0 +1,18 @@
+package com.willfp.eco.internal.lookup
+
+import com.willfp.eco.core.lookup.LookupHandler
+import com.willfp.eco.core.lookup.SegmentParser
+import com.willfp.eco.core.lookup.Testable
+
+class SegmentParserUseIfPresent : SegmentParser("?") {
+    override fun <T : Testable<*>> handleSegments(segments: Array<out String>, handler: LookupHandler<T>): T {
+        for (option in segments) {
+            val lookup = handler.parseKey(option)
+            if (handler.validate(lookup)) {
+                return lookup
+            }
+        }
+
+        return handler.failsafe
+    }
+}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/proxy/EcoProxyFactory.kt

@@ -4,7 +4,7 @@ import com.willfp.eco.core.EcoPlugin
 import com.willfp.eco.core.proxy.ProxyConstants
 import com.willfp.eco.core.proxy.ProxyFactory
 import com.willfp.eco.core.proxy.exceptions.ProxyError
-import com.willfp.eco.core.proxy.exceptions.UnsupportedVersionException
+import com.willfp.eco.core.proxy.exceptions.UnsupportedVersionError
 import java.net.URLClassLoader
 import java.util.IdentityHashMap
 
@@ -34,21 +34,26 @@ class EcoProxyFactory(
                 return proxy
             }
         } catch (e: Exception) {
-            throwError(e)
+            throw proxyErrorFrom(e)
         }
 
-        throwError(IllegalArgumentException())
-
-        throw RuntimeException("Something went wrong.")
+        throw proxyErrorFrom(IllegalArgumentException("Class doesn't seem to be a proxy."))
     }
 
-    private fun throwError(e: Exception?) {
-        e?.printStackTrace()
+    private fun proxyErrorFrom(e: Exception): Throwable {
+        plugin.logger.severe("Fatal error with proxies! This plugin can't load.")
 
-        if (!SUPPORTED_VERSIONS.contains(ProxyConstants.NMS_VERSION)) {
-            throw UnsupportedVersionException("You're running an unsupported server version: " + ProxyConstants.NMS_VERSION)
+        return if (!ProxyConstants.SUPPORTED_VERSIONS.contains(ProxyConstants.NMS_VERSION)) {
+            ProxyError(
+                "Could not initialize proxy.",
+                UnsupportedVersionError()
+            )
         } else {
-            throw ProxyError("Error with proxies - here's a stacktrace. Only god can help you now.")
+            ProxyError(
+                "Could not initialize proxy. If you're seeing this error message"
+                        + ", something has gone badly wrong. This almost definitely isn't user error, blame the developer.",
+                e
+            )
         }
     }
 
@@ -69,12 +74,4 @@ class EcoProxyFactory(
 
         cache.clear()
     }
-
-    companion object {
-        val SUPPORTED_VERSIONS = listOf(
-            "v1_16_R3",
-            "v1_17_R1",
-            "v1_18_R1"
-        )
-    }
 }

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/requirement/EcoRequirementFactory.kt

@@ -1,21 +0,0 @@
-package com.willfp.eco.internal.requirement
-
-import com.willfp.eco.core.requirement.Requirement
-import com.willfp.eco.core.requirement.RequirementFactory
-import com.willfp.eco.internal.requirement.requirements.RequirementHasPermission
-import com.willfp.eco.internal.requirement.requirements.RequirementPlaceholderEquals
-import com.willfp.eco.internal.requirement.requirements.RequirementPlaceholderGreaterThan
-import com.willfp.eco.internal.requirement.requirements.RequirementPlaceholderLessThan
-import com.willfp.eco.internal.requirement.requirements.RequirementTrue
-
-class EcoRequirementFactory: RequirementFactory {
-    override fun create(name: String): Requirement {
-        return when (name.lowercase()) {
-            "has-permission" -> RequirementHasPermission()
-            "placeholder-equals" -> RequirementPlaceholderEquals()
-            "placeholder-greater-than" -> RequirementPlaceholderGreaterThan()
-            "placeholder-less-than" -> RequirementPlaceholderLessThan()
-            else -> RequirementTrue()
-        }
-    }
-}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/requirement/requirements/RequirementHasPermission.kt

@@ -1,18 +0,0 @@
-package com.willfp.eco.internal.requirement.requirements
-
-import com.willfp.eco.core.requirement.Requirement
-import org.bukkit.entity.Player
-
-class RequirementHasPermission : Requirement() {
-    override fun doesPlayerMeet(
-        player: Player,
-        args: List<String>
-    ): Boolean {
-        if (args.isEmpty()) {
-            return false
-        }
-
-        val permission = args[0]
-        return player.hasPermission(permission)
-    }
-}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/requirement/requirements/RequirementPlaceholderEquals.kt

@@ -1,20 +0,0 @@
-package com.willfp.eco.internal.requirement.requirements
-
-import com.willfp.eco.core.integrations.placeholder.PlaceholderManager
-import com.willfp.eco.core.requirement.Requirement
-import org.bukkit.entity.Player
-
-class RequirementPlaceholderEquals : Requirement() {
-    override fun doesPlayerMeet(
-        player: Player,
-        args: List<String>
-    ): Boolean {
-        if (args.size < 2) {
-            return false
-        }
-
-        val placeholder = args[0]
-        val equals = args[1]
-        return PlaceholderManager.translatePlaceholders(placeholder, player).equals(equals, ignoreCase = true)
-    }
-}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/requirement/requirements/RequirementPlaceholderGreaterThan.kt

@@ -1,20 +0,0 @@
-package com.willfp.eco.internal.requirement.requirements
-
-import com.willfp.eco.core.integrations.placeholder.PlaceholderManager
-import com.willfp.eco.core.requirement.Requirement
-import org.bukkit.entity.Player
-
-class RequirementPlaceholderGreaterThan : Requirement() {
-    override fun doesPlayerMeet(
-        player: Player,
-        args: List<String>
-    ): Boolean {
-        if (args.size < 2) {
-            return false
-        }
-
-        val placeholder = args[0]
-        val equals = args[1].toDoubleOrNull() ?: return false
-        return (PlaceholderManager.translatePlaceholders(placeholder, player).toDoubleOrNull() ?: 0.0) >= equals
-    }
-}

eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/requirement/requirements/RequirementPlaceholderLessThan.kt

@@ -1,20 +0,0 @@
-package com.willfp.eco.internal.requirement.requirements
-
-import com.willfp.eco.core.integrations.placeholder.PlaceholderManager
-import com.willfp.eco.core.requirement.Requirement
-import org.bukkit.entity.Player
-
-class RequirementPlaceholderLessThan : Requirement() {
-    override fun doesPlayerMeet(
-        player: Player,
-        args: List<String>
-    ): Boolean {
-        if (args.size < 2) {
-            return false
-        }
-
-        val placeholder = args[0]
-        val equals = args[1].toDoubleOrNull() ?: return false
-        return (PlaceholderManager.translatePlaceholders(placeholder, player).toDoubleOrNull() ?: 0.0) < equals
-    }
-}