Fixed javadoc

Change to not quit after first iteration of loop

CONTRIBUTING.md

@@ -1,38 +1,7 @@
 # How to contribute to eco
 
-## Codestyle
+Please open any Pull Requests into the `develop` branch or ideally into a new branch for your changes. PRs that go into `master` won't be ignored, but I have to checkout and merge manually, which makes your PR show as being closed.
 
-1. The eco checkstyle is in /config/checkstyle.xml
+Do not write any Kotlin-only APIs; all API components should be written in Java, Kotlin extensions should not have functionality that isn't available in java. The same applies the other way round, do not write any backend code in Java, it should be Kotlin-exclusive.
 
-- 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
-
-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.
-
-## Other
-
-- All drops **must** be sent through a DropQueue - calls to World#dropItem will get your PR rejected.
-- eco is built with java 17.
+If you have any questions about contributing, feel free to ask in the [Discord](https://discord.gg/ZcwpSsE)!

README.md

@@ -1,5 +1,5 @@
 # eco
-eco is a powerful Spigot development library that simplifies the process of plugin creation and supercharges
+eco is a powerful Spigot plugin framework that simplifies the process of plugin creation and supercharges
 your plugins.
 It's the engine behind [EcoEnchants](https://polymart.org/resource/490), [Reforges](https://polymart.org/resource/1330),
 [EcoItems](https://polymart.org/resource/1247), [EcoSkills](https://polymart.org/resource/1351),
@@ -16,30 +16,54 @@ and many more.
     <a href="https://bstats.org/plugin/bukkit/EcoEnchants" alt="bstats players">
         <img src="https://img.shields.io/bstats/players/7666?color=informational"/>
     </a>
-    <a href="https://plugins.auxilor.io/" alt="Docs (gitbook)">
-        <img src="https://img.shields.io/badge/docs-gitbook-informational"/>
-    </a>
     <a href="https://discord.gg/ZcwpSsE/" alt="Discord">
         <img src="https://img.shields.io/discord/452518336627081236?label=discord&color=informational"/>
     </a>
     <a href="https://github.com/Auxilor/eco/actions/workflows/java-ci.yml" alt="Latest Dev Build">
-        <img src="https://img.shields.io/github/workflow/status/Auxilor/eco/Java%20CI/develop?color=informational"/>
+        <img src="https://img.shields.io/github/actions/workflow/status/Auxilor/eco/java-ci.yml?branch=develop&color=informational"/>
     </a>
 </p>
 
+eco comes packed with all the tools you need in your plugins:
+
+- Modern command API
+- Native color parsing with full hex/RGB/MiniMessage support
+- Yaml/JSON/TOML config system
+- Persistent data storage API with Yaml/MySQL/MongoDB support
+- Packet item display system
+- Entity AI API with near-1:1 NMS mappings
+- More events
+- Extension API, essentially plugins for plugins
+- Fluent dependency injection for NamespacedKey, Metadata values, etc.
+- Ultra-fast ItemStack reimplementation bypassing ItemMeta
+- Complete GUI API with pre-made components available from [ecomponent](https://github.com/Auxilor/ecomponent)
+- Over 30 native integrations for other plugins
+- First-class custom item support with lookup strings
+- Math expression parsing via [Crunch](https://github.com/Redempt/Crunch)
+- Particle lookups
+- Complete Placeholder API
+- Price system, supporting economy plugins, XP, Items, etc.
+- NMS/Version-specific tooling
+- Custom crafting recipe API with support for stacks and custom items
+- Native plugin update checking
+- Native bStats support
+- Full Kotlin support and native extensions
+- Tooling to make meta-frameworks, like [libreforge](https://github.com/Auxilor/libreforge)
+- And much more
+
 # For server owners
 - Requires ProtocolLib to be installed: get the latest version [here](https://www.spigotmc.org/resources/protocollib.1997/)
 - Supports 1.17+
 
 ## Downloads
 
-- Stable (Recommended): [GitHub](https://github.com/Auxilor/eco/releases), [Polymart](https://polymart.org/resource/eco.773)
-- Dev (Not Recommended): [GitHub](https://github.com/Auxilor/eco/actions/workflows/java-ci.yml) (Open latest run and download)
+- Stable: [GitHub](https://github.com/Auxilor/eco/releases), [Polymart](https://polymart.org/resource/eco.773)
+- Dev: [GitHub](https://github.com/Auxilor/eco/actions/workflows/java-ci.yml) (Open latest run and download)
 
 # For developers
 
 ## Javadoc
-The 6.38.2 Javadoc can be found [here](https://javadoc.jitpack.io/com/willfp/eco/6.38.2/javadoc/)
+The 6.49.0 Javadoc can be found [here](https://javadoc.jitpack.io/com/willfp/eco/6.49.0/javadoc/)
 
 ## Plugin Information
 
@@ -68,7 +92,7 @@ dependencies {
 }
 ```
 
-Replace `Tag` with a release tag for eco, eg `6.27.2`.
+Replace `Tag` with a release tag for eco, eg `6.49.0`.
 
 Maven:
 
@@ -88,7 +112,7 @@ Maven:
 </dependency>
 ```
 
-Replace `Tag` with a release tag for eco, eg `6.27.2`.
+Replace `Tag` with a release tag for eco, eg `6.49.0`.
 
 ## Build locally:
 
@@ -103,7 +127,7 @@ cd eco
 
 ## License
 
-*Click here to read [the entire license](https://github.com/Auxilor/eco/blob/master/LICENSE.md).*
+eco is licensed under GNU GPL3. *Click here to read [the entire license](https://github.com/Auxilor/eco/blob/master/LICENSE.md).*
 
 <h1 align="center">
   Check out our partners!

build.gradle.kts

@@ -25,6 +25,7 @@ dependencies {
     implementation(project(path = ":eco-core:core-nms:v1_18_R1", configuration = "reobf"))
     implementation(project(path = ":eco-core:core-nms:v1_18_R2", configuration = "reobf"))
     implementation(project(path = ":eco-core:core-nms:v1_19_R1", configuration = "reobf"))
+    implementation(project(path = ":eco-core:core-nms:v1_19_R2", configuration = "reobf"))
 }
 
 allprojects {
@@ -77,6 +78,8 @@ allprojects {
 
         // LibsDisguises
         maven("https://repo.md-5.net/content/groups/public/")
+
+        maven("https://repo.techscode.com/repository/maven-releases/")
     }
 
     dependencies {

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

@@ -1,5 +1,8 @@
 package com.willfp.eco.core;
 
+import com.willfp.eco.core.command.CommandBase;
+import com.willfp.eco.core.command.PluginCommandBase;
+import com.willfp.eco.core.command.impl.PluginCommand;
 import com.willfp.eco.core.config.ConfigType;
 import com.willfp.eco.core.config.interfaces.Config;
 import com.willfp.eco.core.config.interfaces.LoadableConfig;
@@ -21,16 +24,15 @@ import com.willfp.eco.core.gui.menu.MenuBuilder;
 import com.willfp.eco.core.gui.menu.MenuType;
 import com.willfp.eco.core.gui.slot.SlotBuilder;
 import com.willfp.eco.core.gui.slot.functional.SlotProvider;
-import com.willfp.eco.core.integrations.placeholder.PlaceholderIntegration;
 import com.willfp.eco.core.items.TestableItem;
-import com.willfp.eco.core.placeholder.AdditionalPlayer;
-import com.willfp.eco.core.placeholder.PlaceholderInjectable;
+import com.willfp.eco.core.math.MathContext;
 import com.willfp.eco.core.proxy.ProxyFactory;
 import com.willfp.eco.core.scheduling.Scheduler;
 import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.apache.commons.lang.Validate;
 import org.bukkit.Location;
 import org.bukkit.NamespacedKey;
+import org.bukkit.command.CommandMap;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Mob;
@@ -42,7 +44,6 @@ import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -50,18 +51,18 @@ import java.util.UUID;
 import java.util.logging.Logger;
 
 /**
- * Holds the instance of eco for bridging between the frontend
- * and backend.
+ * Holds the instance of eco for bridging between the frontend and backend.
  * <p>
  * <strong>Do not use this in your plugins!</strong> It can and will contain
- * breaking changes between minor versions and even patches, and you will create
- * compatibility issues by. All parts of this have been abstracted
- * into logically named API components that you can use.
+ * breaking changes between minor versions and even patches, and you will create compatibility
+ * issues by. All parts of this have been abstracted into logically named API components that you
+ * can use.
  *
  * @see Eco#get()
  */
 @ApiStatus.Internal
 public interface Eco {
+
     /**
      * Create a scheduler.
      *
@@ -74,7 +75,7 @@ public interface Eco {
     /**
      * Create an event manager.
      *
-     * @param plugin The plugin.
+     * @param plugin The plugin.F
      * @return The event manager.
      */
     @NotNull
@@ -138,10 +139,8 @@ public interface Eco {
      * Create a PAPI integration.
      *
      * @param plugin The plugin.
-     * @return The integration.
      */
-    @NotNull
-    PlaceholderIntegration createPAPIIntegration(@NotNull EcoPlugin plugin);
+    void createPAPIIntegration(@NotNull EcoPlugin plugin);
 
     /**
      * Create a proxy factory.
@@ -160,6 +159,40 @@ public interface Eco {
     @NotNull
     EcoPlugin getEcoPlugin();
 
+    /**
+     * Create PluginCommandBase implementation of {@link PluginCommand}.
+     *
+     * @param parentDelegate the enclosing class of this implementation.
+     * @param plugin         the plugin.
+     * @param name           the name of the command.
+     * @param permission     the permission of the command.
+     * @param playersOnly    if the command is players only.
+     * @return The PluginCommandBase implementation
+     */
+    @NotNull
+    PluginCommandBase createPluginCommand(@NotNull CommandBase parentDelegate,
+                                          @NotNull EcoPlugin plugin,
+                                          @NotNull String name,
+                                          @NotNull String permission,
+                                          boolean playersOnly);
+
+    /**
+     * Create CommandBase implementation of {@link com.willfp.eco.core.command.impl.Subcommand Subcommand}.
+     *
+     * @param parentDelegate the enclosing class of this implementation.
+     * @param plugin         the plugin.
+     * @param name           the name of the command.
+     * @param permission     the permission of the command.
+     * @param playersOnly    if the command is players only.
+     * @return The CommandBase implementation
+     */
+    @NotNull
+    CommandBase createSubcommand(@NotNull CommandBase parentDelegate,
+                                 @NotNull EcoPlugin plugin,
+                                 @NotNull String name,
+                                 @NotNull String permission,
+                                 boolean playersOnly);
+
     /**
      * Updatable config.
      *
@@ -173,6 +206,7 @@ public interface Eco {
      * @param requiresChangesToSave If the config must be changed in order to save the config.
      * @return The config implementation.
      */
+    @NotNull
     LoadableConfig createUpdatableConfig(@NotNull String configName,
                                          @NotNull PluginLike plugin,
                                          @NotNull String subDirectoryPath,
@@ -193,6 +227,7 @@ public interface Eco {
      * @param requiresChangesToSave If the config must be changed in order to save the config.
      * @return The config implementation.
      */
+    @NotNull
     LoadableConfig createLoadableConfig(@NotNull String configName,
                                         @NotNull PluginLike plugin,
                                         @NotNull String subDirectoryPath,
@@ -206,6 +241,7 @@ public interface Eco {
      * @param config The handle.
      * @return The config implementation.
      */
+    @NotNull
     Config wrapConfigurationSection(@NotNull ConfigurationSection config);
 
     /**
@@ -215,6 +251,7 @@ public interface Eco {
      * @param type   The config type.
      * @return The config implementation.
      */
+    @NotNull
     Config createConfig(@NotNull Map<String, Object> values,
                         @NotNull ConfigType type);
 
@@ -225,6 +262,7 @@ public interface Eco {
      * @param type     The type.
      * @return The config implementation.
      */
+    @NotNull
     Config createConfig(@NotNull String contents,
                         @NotNull ConfigType type);
 
@@ -335,23 +373,16 @@ public interface Eco {
      *
      * @return The keys.
      */
+    @NotNull
     Set<PersistentDataKey<?>> getRegisteredPersistentDataKeys();
 
-    /**
-     * Get persistent data key from namespaced key.
-     *
-     * @param namespacedKey The key.
-     * @return The key, or null if not found.
-     */
-    @Nullable
-    PersistentDataKey<?> getPersistentDataKeyFrom(@NotNull NamespacedKey namespacedKey);
-
     /**
      * Load a player profile.
      *
      * @param uuid The UUID.
      * @return The profile.
      */
+    @NotNull
     PlayerProfile loadPlayerProfile(@NotNull UUID uuid);
 
     /**
@@ -359,6 +390,7 @@ public interface Eco {
      *
      * @return The profile.
      */
+    @NotNull
     ServerProfile getServerProfile();
 
     /**
@@ -370,24 +402,6 @@ public interface Eco {
      */
     void unloadPlayerProfile(@NotNull UUID uuid);
 
-    /**
-     * Save keys for a player.
-     * <p>
-     * Can run async if using MySQL.
-     *
-     * @param uuid The uuid.
-     * @param keys The keys.
-     */
-    void savePersistentDataKeysFor(@NotNull UUID uuid,
-                                   @NotNull Set<PersistentDataKey<?>> keys);
-
-    /**
-     * Commit all changes to the file.
-     * <p>
-     * Does nothing if using MySQL.
-     */
-    void saveAllProfiles();
-
     /**
      * Create dummy entity - never spawned, exists purely in code.
      *
@@ -400,9 +414,8 @@ public interface Eco {
     /**
      * Create a {@link NamespacedKey} quickly
      * <p>
-     * Bypasses the constructor, allowing for the creation of invalid keys,
-     * therefore this is considered unsafe and should only be called after
-     * the key has been confirmed to be valid.
+     * Bypasses the constructor, allowing for the creation of invalid keys, therefore this is
+     * considered unsafe and should only be called after the key has been confirmed to be valid.
      *
      * @param namespace The namespace.
      * @param key       The key.
@@ -513,16 +526,12 @@ public interface Eco {
     /**
      * Evaluate an expression.
      *
-     * @param expression        The expression.
-     * @param player            The player.
-     * @param injectable        The injectable placeholders.
-     * @param additionalPlayers The additional players.
+     * @param expression The expression.
+     * @param context    The context.
      * @return The value of the expression, or zero if invalid.
      */
     double evaluate(@NotNull String expression,
-                    @Nullable Player player,
-                    @NotNull PlaceholderInjectable injectable,
-                    @NotNull Collection<AdditionalPlayer> additionalPlayers);
+                    @NotNull MathContext context);
 
     /**
      * Get the menu a player currently has open.
@@ -534,8 +543,26 @@ public interface Eco {
     Menu getOpenMenu(@NotNull Player player);
 
     /**
-     * Get the instance of eco; the bridge between the api frontend
-     * and the implementation backend.
+     * Sync commands.
+     */
+    void syncCommands();
+
+    /**
+     * Get the command map.
+     *
+     * @return The command map.
+     */
+    @NotNull CommandMap getCommandMap();
+
+    /**
+     * Unregister a command.
+     *
+     * @param command The command.
+     */
+    void unregisterCommand(@NotNull final PluginCommand command);
+
+    /**
+     * Get the instance of eco; the bridge between the api frontend and the implementation backend.
      *
      * @return The instance of eco.
      */
@@ -549,6 +576,7 @@ public interface Eco {
      */
     @ApiStatus.Internal
     final class Instance {
+
         /**
          * Instance of eco.
          */

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

@@ -13,7 +13,6 @@ import com.willfp.eco.core.factory.MetadataValueFactory;
 import com.willfp.eco.core.factory.NamespacedKeyFactory;
 import com.willfp.eco.core.factory.RunnableFactory;
 import com.willfp.eco.core.integrations.IntegrationLoader;
-import com.willfp.eco.core.integrations.placeholder.PlaceholderManager;
 import com.willfp.eco.core.proxy.ProxyFactory;
 import com.willfp.eco.core.scheduling.Scheduler;
 import com.willfp.eco.core.web.UpdateChecker;
@@ -153,6 +152,31 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
     @Nullable
     private final ProxyFactory proxyFactory;
 
+    /**
+     * The tasks to run on enable.
+     */
+    private final List<Runnable> onEnable = new ArrayList<>();
+
+    /**
+     * The tasks to run on disable.
+     */
+    private final List<Runnable> onDisable = new ArrayList<>();
+
+    /**
+     * The tasks to run on reload.
+     */
+    private final List<Runnable> onReload = new ArrayList<>();
+
+    /**
+     * The tasks to run on load.
+     */
+    private final List<Runnable> onLoad = new ArrayList<>();
+
+    /**
+     * The tasks to run after load.
+     */
+    private final List<Runnable> afterLoad = new ArrayList<>();
+
     /**
      * Create a new plugin.
      * <p>
@@ -320,6 +344,13 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         this.configHandler = Eco.get().createConfigHandler(this);
 
         this.langYml = this.createLangYml();
+
+        if (!this.langYml.isValid()) {
+            this.getLogger().warning("Notify plugin authors " + String.join(", ", this.getDescription().getAuthors()) + " that");
+            this.getLogger().warning("they are missing crucial lang.yml keys! They can be found");
+            this.getLogger().warning("in the LangYml class.");
+        }
+
         this.configYml = this.createConfigYml();
 
         Eco.get().addNewPlugin(this);
@@ -375,8 +406,7 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
                 .collect(Collectors.toSet());
 
         if (enabledPlugins.contains("PlaceholderAPI".toLowerCase())) {
-            this.loadedIntegrations.add("PlaceholderAPI");
-            PlaceholderManager.addIntegration(Eco.get().createPAPIIntegration(this));
+            Eco.get().createPAPIIntegration(this);
         }
 
         this.loadIntegrationLoaders().forEach(integrationLoader -> {
@@ -386,6 +416,8 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
             }
         });
 
+        this.loadedIntegrations.removeIf(pl -> pl.equalsIgnoreCase(this.getName()));
+
         this.getLogger().info("Loaded integrations: " + String.join(", ", this.getLoadedIntegrations()));
 
         Prerequisite.update();
@@ -414,10 +446,20 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         }
 
         this.handleEnable();
+        this.onEnable.forEach(Runnable::run);
 
         this.getLogger().info("");
     }
 
+    /**
+     * Add new task to run on enable.
+     *
+     * @param task The task.
+     */
+    public final void onEnable(@NotNull final Runnable task) {
+        this.onEnable.add(task);
+    }
+
     /**
      * Default code to be executed on plugin disable.
      */
@@ -429,6 +471,7 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         this.getScheduler().cancelAll();
 
         this.handleDisable();
+        this.onDisable.forEach(Runnable::run);
 
         if (this.isSupportingExtensions()) {
             this.getExtensionLoader().unloadExtensions();
@@ -438,6 +481,15 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         Eco.get().clean(this);
     }
 
+    /**
+     * Add new task to run on disable.
+     *
+     * @param task The task.
+     */
+    public final void onDisable(@NotNull final Runnable task) {
+        this.onDisable.add(task);
+    }
+
     /**
      * Default code to be executed on plugin load.
      */
@@ -446,6 +498,16 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         super.onLoad();
 
         this.handleLoad();
+        this.onLoad.forEach(Runnable::run);
+    }
+
+    /**
+     * Add new task to run on load.
+     *
+     * @param task The task.
+     */
+    public final void onLoad(@NotNull final Runnable task) {
+        this.onLoad.add(task);
     }
 
     /**
@@ -478,6 +540,7 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         }
 
         this.handleAfterLoad();
+        this.afterLoad.forEach(Runnable::run);
 
         this.reload();
 
@@ -488,6 +551,15 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         this.getLogger().info("Loaded " + this.color + this.getName());
     }
 
+    /**
+     * Add new task to run after load.
+     *
+     * @param task The task.
+     */
+    public final void afterLoad(@NotNull final Runnable task) {
+        this.afterLoad.add(task);
+    }
+
     /**
      * Reload the plugin.
      */
@@ -499,12 +571,22 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
         this.getConfigHandler().callUpdate(); // Call twice to fix issues
 
         this.handleReload();
+        this.onReload.forEach(Runnable::run);
 
         for (Extension extension : this.extensionLoader.getLoadedExtensions()) {
             extension.handleReload();
         }
     }
 
+    /**
+     * Add new task to run on enable.
+     *
+     * @param task The task.
+     */
+    public final void onReload(@NotNull final Runnable task) {
+        this.onReload.add(task);
+    }
+
     /**
      * Reload the plugin and return the time taken to reload.
      *
@@ -624,7 +706,15 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
      * @return lang.yml.
      */
     protected LangYml createLangYml() {
-        return new LangYml(this);
+        try {
+            return new LangYml(this);
+        } catch (NullPointerException e) {
+            this.getLogger().severe("Failed to load lang.yml!");
+            this.getLogger().severe("For the developer of this plugin: make sure you have a lang.yml");
+            e.printStackTrace();
+            Bukkit.getPluginManager().disablePlugin(this);
+            return null;
+        }
     }
 
     /**
@@ -635,7 +725,15 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
      * @return config.yml.
      */
     protected ConfigYml createConfigYml() {
-        return new ConfigYml(this);
+        try {
+            return new ConfigYml(this);
+        } catch (NullPointerException e) {
+            this.getLogger().severe("Failed to load config.yml!");
+            this.getLogger().severe("For the developer of this plugin: make sure you have a config.yml");
+            e.printStackTrace();
+            Bukkit.getPluginManager().disablePlugin(this);
+            return null;
+        }
     }
 
     /**

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

@@ -221,7 +221,7 @@ public final class PluginProps {
 
     /**
      * Create new props from known values.
-     *
+     * <p>
      * 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.

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

@@ -70,7 +70,10 @@ public class Prerequisite {
 
     /**
      * Requires the server to be running an implementation of BungeeCord.
+     *
+     * @deprecated This will never return true.
      */
+    @Deprecated(since = "6.49.0", forRemoval = true)
     public static final Prerequisite HAS_BUNGEECORD = new Prerequisite(
             () -> ClassUtils.exists("net.md_5.bungee.api.event.ServerConnectedEvent"),
             "Requires server to be running BungeeCord (or a fork)"
@@ -78,7 +81,10 @@ public class Prerequisite {
 
     /**
      * Requires the server to be running an implementation of Velocity.
+     *
+     * @deprecated This will never return true.
      */
+    @Deprecated(since = "6.49.0", forRemoval = true)
     public static final Prerequisite HAS_VELOCITY = new Prerequisite(
             () -> ClassUtils.exists("com.velocitypowered.api.event.player.ServerConnectedEvent"),
             "Requires server to be running Velocity (or a fork)"

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

@@ -1,30 +1,37 @@
 package com.willfp.eco.core.command;
 
 import com.willfp.eco.core.EcoPlugin;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
+import java.util.function.Predicate;
 
 /**
- * Interface for all command implementations.
+ * Generic interface for commands.
  */
-@SuppressWarnings("removal")
+@SuppressWarnings("null")
 public interface CommandBase {
+
     /**
      * Get command name.
      *
      * @return The name.
      */
-    String getName();
+    @NotNull String getName();
 
     /**
      * Get command permission.
      *
      * @return The permission.
      */
-    String getPermission();
+    @NotNull String getPermission();
 
     /**
      * If only players can execute the command.
@@ -39,79 +46,237 @@ public interface CommandBase {
      * @param command The subcommand.
      * @return The parent command.
      */
-    CommandBase addSubcommand(@NotNull CommandBase command);
+    @NotNull CommandBase addSubcommand(@NotNull CommandBase command);
+
+    /**
+     * Get the subcommands of the command.
+     *
+     * @return The subcommands.
+     */
+    @NotNull List<CommandBase> getSubcommands();
+
+    /**
+     * Intended for returning the enclosing CommandBase,
+     * when this instance is serving as the delegate command base.
+     *
+     * @return the wrapping object of this delegate.
+     */
+    default @NotNull CommandBase getWrapped() {
+        return this;
+    }
 
     /**
      * Handle command execution.
      * <p>
-     * Marked as default void with no implementation for backwards compatibility.
+     * This will always be called on command execution.
      *
      * @param sender The sender.
      * @param args   The args.
+     * @throws NotificationException naturally, this is handled as a part of the command system.
      */
-    default void onExecute(@NotNull CommandSender sender,
-                           @NotNull List<String> args) {
+    default void onExecute(@NotNull final CommandSender sender, @NotNull final List<String> args) throws NotificationException {
+        // Do nothing.
+    }
+
+    /**
+     * Handle command execution from players.
+     * <p>
+     * This will only be called if the sender is a player.
+     *
+     * @param sender The sender.
+     * @param args   The args.
+     * @throws NotificationException naturally, this is handled as a part of the command system.
+     */
+    default void onExecute(@NotNull final Player sender, @NotNull final List<String> args) throws NotificationException {
         // Do nothing.
     }
 
     /**
      * Handle tab completion.
      * <p>
-     * Marked as default void with no implementation for backwards compatibility.
+     * This will always be called on tab completion.
      *
      * @param sender The sender.
      * @param args   The args.
      * @return The results.
      */
-    default List<String> tabComplete(@NotNull CommandSender sender,
-                                     @NotNull List<String> args) {
+    @NotNull
+    default List<String> tabComplete(@NotNull final CommandSender sender, @NotNull final List<String> args) {
         return new ArrayList<>();
     }
 
+    /**
+     * Handle tab completion.
+     * <p>
+     * This will only be called if the sender is a player.
+     *
+     * @param sender The sender.
+     * @param args   The args.
+     * @return The results.
+     */
+    @NotNull
+    default List<String> tabComplete(@NotNull final Player sender, @NotNull final List<String> args) {
+        return new ArrayList<>();
+    }
+
+    /**
+     * Throws an {@link NotificationException} relating to a specific lang.yml key.
+     * <p>
+     * This is automatically handled with eco, and should not be surrounded by a
+     * try/catch block.
+     *
+     * @param key The lang.yml key for the message to be sent.
+     * @throws NotificationException always.
+     */
+    default void notify(@NotNull final String key) throws NotificationException {
+        throw new NotificationException(key);
+    }
+
+    /**
+     * Throws an {@link NotificationException} relating to a specific lang.yml key
+     * if the passed object is null.
+     * <p>
+     * This is automatically handled with eco, and should not be surrounded by a
+     * try/catch block.
+     *
+     * @param obj The object to test.
+     * @param key The lang.yml key for the message to be sent.
+     * @param <T> The object type.
+     * @return Returns the object, definitely not-null.
+     * @throws NotificationException If the object is null.
+     */
+    @NotNull
+    default <T> T notifyNull(@Nullable final T obj,
+                             @NotNull final String key) throws NotificationException {
+        if (Objects.isNull(obj)) {
+            notify(key);
+        }
+
+        return Objects.requireNonNull(obj);
+    }
+
+    /**
+     * Throws an {@link NotificationException} relating to a specific lang.yml key
+     * if the passed object doesn't match the predicate.
+     * <p>
+     * This is automatically handled with eco, and should not be surrounded by a
+     * try/catch block.
+     *
+     * @param obj       The object to test.
+     * @param key       The lang.yml key for the message to be sent.
+     * @param predicate The predicate to test the object against.
+     * @param <T>       The type of the object.
+     * @return Returns the object, definitely not-null.
+     * @throws NotificationException If the object doesn't satisfy the predicate.
+     */
+    @NotNull
+    default <T> T notifyFalse(@NotNull final T obj,
+                              @NotNull final String key,
+                              @NotNull final Predicate<T> predicate) throws NotificationException {
+        notifyFalse(predicate.test(obj), key);
+
+        return obj;
+    }
+
+
+    /**
+     * Throws an {@link NotificationException} relating to a specific lang.yml key
+     * if a condition is false.
+     * <p>
+     * This is automatically handled with eco, and should not be surrounded by a
+     * try/catch block.
+     *
+     * @param condition The condition to test.
+     * @param key       The lang.yml key for the message to be sent.
+     * @return True.
+     * @throws NotificationException If the condition is false.
+     */
+    default boolean notifyFalse(final boolean condition,
+                                @NotNull final String key) throws NotificationException {
+        if (!condition) {
+            notify(key);
+        }
+
+        return true;
+    }
+
+    /**
+     * Throws an {@link NotificationException} relating to a specific lang.yml key
+     * if the passed string doesn't relate to a currently online player.
+     * <p>
+     * This is automatically handled with eco, and should not be surrounded by a
+     * try/catch block.
+     *
+     * @param playerName The player name.
+     * @param key        The lang.yml key for the message to be sent.
+     * @return Returns the player, definitely not-null.
+     * @throws NotificationException If the player name is invalid.
+     */
+    @NotNull
+    default Player notifyPlayerRequired(@Nullable final String playerName, @NotNull final String key) throws NotificationException {
+        if (playerName == null) {
+            notify(key);
+        }
+
+        assert playerName != null;
+
+        final Player player = Bukkit.getPlayer(playerName);
+
+        notifyNull(player, key);
+
+        return Objects.requireNonNull(player);
+    }
+
+    /**
+     * Throws an {@link NotificationException} relating to a specific lang.yml key
+     * if the passed string doesn't relate to a player on the server.
+     * <p>
+     * This is automatically handled with eco, and should not be surrounded by a
+     * try/catch block.
+     *
+     * @param playerName The player name.
+     * @param key        The lang.yml key for the message to be sent.
+     * @return Returns the offline player, definitely not-null.
+     * @throws NotificationException If the player name is invalid.
+     */
+    @NotNull
+    default OfflinePlayer notifyOfflinePlayerRequired(@Nullable final String playerName,
+                                                      @NotNull final String key) throws NotificationException {
+        if (playerName == null) {
+            notify(key);
+        }
+
+        assert playerName != null;
+
+        @SuppressWarnings("deprecation") final OfflinePlayer player = Bukkit.getOfflinePlayer(playerName);
+
+        boolean hasPlayedBefore = player.hasPlayedBefore() || player.isOnline();
+
+        notifyFalse(!hasPlayedBefore, key);
+
+        return player;
+    }
+
+    /**
+     * Throws an exception containing a langYml key if player doesn't have permission.
+     *
+     * @param player     The player.
+     * @param permission The permission.
+     * @param key        The lang.yml key for the message to be sent.
+     * @return The player.
+     * @throws NotificationException If the player doesn't have the required permission.
+     */
+    @NotNull
+    default Player notifyPermissionRequired(@NotNull final Player player,
+                                            @NotNull final String permission,
+                                            @NotNull final String key) throws NotificationException {
+        return notifyFalse(player, key, p -> p.hasPermission(permission));
+    }
+
     /**
      * Get the plugin.
      *
      * @return The plugin.
      */
     EcoPlugin getPlugin();
-
-    /**
-     * Get the handler.
-     *
-     * @return The handler.
-     * @see CommandHandler
-     * @deprecated Use {@link CommandBase#onExecute(CommandSender, List)} instead.
-     */
-    @Deprecated(forRemoval = true)
-    CommandHandler getHandler();
-
-    /**
-     * Set the handler.
-     *
-     * @param handler The handler.
-     * @see CommandHandler
-     * @deprecated Handlers have been deprecated.
-     */
-    @Deprecated(forRemoval = true)
-    void setHandler(@NotNull CommandHandler handler);
-
-    /**
-     * Get the tab completer.
-     *
-     * @return The tab completer.
-     * @see TabCompleteHandler
-     * @deprecated Use {@link CommandBase#tabComplete(CommandSender, List)} instead.
-     */
-    @Deprecated(forRemoval = true)
-    TabCompleteHandler getTabCompleter();
-
-    /**
-     * Set the tab completer.
-     *
-     * @param handler The handler.
-     * @see TabCompleteHandler
-     * @deprecated Handlers have been deprecated.
-     */
-    @Deprecated(forRemoval = true)
-    void setTabCompleter(@NotNull TabCompleteHandler handler);
 }

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

@@ -1,29 +0,0 @@
-package com.willfp.eco.core.command;
-
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.List;
-
-/**
- * A command handler handles the actual code for a command.
- * <p>
- * The replacement for {@link org.bukkit.command.CommandExecutor#onCommand(CommandSender, Command, String, String[])}
- *
- * @see CommandBase
- * @deprecated Handlers have been deprecated. This legacy system will eventually be removed,
- * update to use the new system: {@link CommandBase#onExecute(CommandSender, List)}.
- */
-@FunctionalInterface
-@Deprecated(since = "6.17.0", forRemoval = true)
-public interface CommandHandler {
-    /**
-     * The code to be called on execution.
-     *
-     * @param sender The sender.
-     * @param args   The arguments.
-     */
-    void onExecute(@NotNull CommandSender sender,
-                   @NotNull List<String> args);
-}

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

@@ -0,0 +1,34 @@
+package com.willfp.eco.core.command;
+
+/**
+ * A notification exception is thrown when {@link org.bukkit.command.CommandSender}s don't
+ * specify valid arguments in commands.
+ * <p>
+ * Methods in eco that throw this will contain automatic handling and thus
+ * should not be surrounded by try / catch blocks.
+ */
+public class NotificationException extends Exception {
+    /**
+     * The key for the lang.yml message to be sent.
+     */
+    private final String key;
+
+    /**
+     * Creates a notification exception.
+     *
+     * @param key The lang key of the notification.
+     */
+    public NotificationException(String key) {
+        super(key);
+        this.key = key;
+    }
+
+    /**
+     * Get the lang key.
+     *
+     * @return The lang key.
+     */
+    public String getKey() {
+        return key;
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.willfp.eco.core.command;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Plugin command bases can be registered directly with the server,
+ * this essentially functions as the interface that is implemented generically
+ * via {@link com.willfp.eco.core.command.impl.PluginCommand}.
+ */
+public interface PluginCommandBase extends CommandBase {
+    /**
+     * Register the PluginCommandBase to the bukkit commandMap.
+     */
+    void register();
+
+    /**
+     * Unregister the PluginCommandBase from the bukkit commandMap.
+     */
+    void unregister();
+
+    /**
+     * Get aliases. Leave null if this command is from plugin.yml.
+     *
+     * @return The aliases.
+     */
+    @NotNull
+    default List<String> getAliases() {
+        return new ArrayList<>();
+    }
+
+    /**
+     * Get description.
+     *
+     * @return The description.
+     */
+    @Nullable
+    default String getDescription() {
+        return null;
+    }
+}

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

@@ -1,30 +0,0 @@
-package com.willfp.eco.core.command;
-
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.List;
-
-/**
- * A Tab Complete handler handles the actual tab-completion code.
- * <p>
- * The replacement for {@link org.bukkit.command.TabCompleter#onTabComplete(CommandSender, Command, String, String[])}
- *
- * @see CommandBase
- * @deprecated Handlers have been deprecated. This legacy system will eventually be removed,
- * update to use the new system: {@link CommandBase#tabComplete(CommandSender, List)}
- */
-@FunctionalInterface
-@Deprecated(since = "6.17.0", forRemoval = true)
-public interface TabCompleteHandler {
-    /**
-     * Handle Tab Completion.
-     *
-     * @param sender The sender.
-     * @param args   The arguments.
-     * @return The tab completion results.
-     */
-    List<String> tabComplete(@NotNull CommandSender sender,
-                             @NotNull List<String> args);
-}

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

@@ -0,0 +1,72 @@
+package com.willfp.eco.core.command.impl;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.PluginIdentifiableCommand;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * Delegates a bukkit command to an eco command (for registrations).
+ *
+ * @deprecated Internal command implementations have been removed from the API.
+ */
+@Deprecated(forRemoval = true, since = "6.49.0")
+public final class DelegatedBukkitCommand extends Command implements TabCompleter, PluginIdentifiableCommand {
+    /**
+     * The delegate command.
+     */
+    private final PluginCommand delegate;
+
+    /**
+     * Create a new delegated command.
+     *
+     * @param delegate The delegate.
+     */
+    public DelegatedBukkitCommand(@NotNull final PluginCommand delegate) {
+        super(delegate.getName());
+
+        this.delegate = delegate;
+    }
+
+    @Override
+    public boolean execute(@NotNull final CommandSender commandSender,
+                           @NotNull final String label,
+                           @NotNull final String[] args) {
+        return false;
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull final CommandSender commandSender,
+                                      @NotNull final Command command,
+                                      @NotNull final String label,
+                                      @NotNull final String[] args) {
+        return List.of();
+    }
+
+    @NotNull
+    @Override
+    public Plugin getPlugin() {
+        return this.delegate.getPlugin();
+    }
+
+    @Override
+    public @NotNull String getPermission() {
+        return this.delegate.getPermission();
+    }
+
+    @NotNull
+    @Override
+    public String getDescription() {
+        return this.delegate.getDescription() == null ? "" : this.delegate.getDescription();
+    }
+
+    @NotNull
+    @Override
+    public List<String> getAliases() {
+        return this.delegate.getAliases();
+    }
+}

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

@@ -1,287 +0,0 @@
-package com.willfp.eco.core.command.impl;
-
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.command.CommandBase;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.util.StringUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
-
-/**
- * Abstract class for commands that can be handled.
- * <p>
- * Handled commands have a method to pass in raw input from bukkit commands
- * in order to execute the command-specific code. It's essentially an internal
- * layer, hence why it's a package-private class.
- */
-@SuppressWarnings({"DeprecatedIsStillUsed", "removal"})
-abstract class HandledCommand implements CommandBase {
-    /**
-     * The plugin.
-     */
-    private final EcoPlugin plugin;
-
-    /**
-     * The name of the command.
-     */
-    private final String name;
-
-    /**
-     * The permission required to execute the command.
-     * <p>
-     * Written out as a string for flexibility with subclasses.
-     */
-    private final String permission;
-
-    /**
-     * Should the command only be allowed to be executed by players?
-     * <p>
-     * In other worlds, only allowed to be executed by console.
-     */
-    private final boolean playersOnly;
-
-    /**
-     * The actual code to be executed in the command.
-     */
-    @Deprecated
-    @Nullable
-    private com.willfp.eco.core.command.CommandHandler handler = null;
-
-    /**
-     * The tab completion code to be executed in the command.
-     */
-    @Deprecated
-    @Nullable
-    private com.willfp.eco.core.command.TabCompleteHandler tabCompleter = null;
-
-    /**
-     * All subcommands for the command.
-     */
-    private final List<CommandBase> subcommands;
-
-    /**
-     * Create a new command.
-     * <p>
-     * The name cannot be the same as an existing command as this will conflict.
-     *
-     * @param plugin      Instance of a plugin.
-     * @param name        The name used in execution.
-     * @param permission  The permission required to execute the command.
-     * @param playersOnly If only players should be able to execute this command.
-     */
-    HandledCommand(@NotNull final EcoPlugin plugin,
-                   @NotNull final String name,
-                   @NotNull final String permission,
-                   final boolean playersOnly) {
-        this.plugin = plugin;
-        this.name = name;
-        this.permission = permission;
-        this.playersOnly = playersOnly;
-        this.subcommands = new ArrayList<>();
-    }
-
-    /**
-     * Add a subcommand to the command.
-     *
-     * @param subcommand The subcommand.
-     * @return The parent command.
-     */
-    @Override
-    public final CommandBase addSubcommand(@NotNull final CommandBase subcommand) {
-        subcommands.add(subcommand);
-
-        return this;
-    }
-
-    /**
-     * Get the plugin.
-     *
-     * @return The plugin.
-     */
-    @Override
-    public EcoPlugin getPlugin() {
-        return this.plugin;
-    }
-
-    /**
-     * Handle the command.
-     *
-     * @param sender The sender.
-     * @param args   The arguments.
-     */
-    protected final void handle(@NotNull final CommandSender sender,
-                                @NotNull final String[] args) {
-        if (!canExecute(sender, this, this.getPlugin())) {
-            return;
-        }
-
-        if (args.length > 0) {
-            for (CommandBase subcommand : this.getSubcommands()) {
-                if (subcommand.getName().equalsIgnoreCase(args[0])) {
-                    if (!canExecute(sender, subcommand, this.getPlugin())) {
-                        return;
-                    }
-
-                    ((HandledCommand) subcommand).handle(sender, Arrays.copyOfRange(args, 1, args.length));
-
-                    return;
-                }
-            }
-        }
-
-        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 {
-            this.onExecute(sender, Arrays.asList(args));
-        }
-    }
-
-    /**
-     * Handle the tab completion.
-     *
-     * @param sender The sender.
-     * @param args   The arguments.
-     * @return The tab completion results.
-     */
-    protected final List<String> handleTabCompletion(@NotNull final CommandSender sender,
-                                                     @NotNull final String[] args) {
-
-        if (!sender.hasPermission(this.getPermission())) {
-            return null;
-        }
-
-        if (args.length == 1) {
-            List<String> completions = new ArrayList<>();
-
-            StringUtil.copyPartialMatches(
-                    args[0],
-                    this.getSubcommands().stream()
-                            .filter(subCommand -> sender.hasPermission(subCommand.getPermission()))
-                            .map(CommandBase::getName)
-                            .collect(Collectors.toList()),
-                    completions
-            );
-
-            Collections.sort(completions);
-
-            if (!completions.isEmpty()) {
-                return completions;
-            }
-        }
-
-        if (args.length >= 2) {
-            HandledCommand command = null;
-
-            for (CommandBase subcommand : this.getSubcommands()) {
-                if (!sender.hasPermission(subcommand.getPermission())) {
-                    continue;
-                }
-
-                if (args[0].equalsIgnoreCase(subcommand.getName())) {
-                    command = (HandledCommand) subcommand;
-                }
-            }
-
-            if (command != null) {
-                return command.handleTabCompletion(sender, Arrays.copyOfRange(args, 1, args.length));
-            }
-        }
-
-        if (this.getTabCompleter() != null) {
-            return this.getTabCompleter().tabComplete(sender, Arrays.asList(args));
-        } else {
-            return this.tabComplete(sender, Arrays.asList(args));
-        }
-    }
-
-    /**
-     * If a sender can execute the command.
-     *
-     * @param sender  The sender.
-     * @param command The command.
-     * @param plugin  The plugin.
-     * @return If the sender can execute.
-     */
-    public static boolean canExecute(@NotNull final CommandSender sender,
-                                     @NotNull final CommandBase command,
-                                     @NotNull final EcoPlugin plugin) {
-        if (!sender.hasPermission(command.getPermission()) && sender instanceof Player) {
-            sender.sendMessage(plugin.getLangYml().getNoPermission());
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * Get the command name.
-     *
-     * @return The name.
-     */
-    public String getName() {
-        return this.name;
-    }
-
-    /**
-     * Get the permission required to execute the command.
-     *
-     * @return The permission.
-     */
-    public String getPermission() {
-        return this.permission;
-    }
-
-    /**
-     * Get if the command can only be executed by players.
-     *
-     * @return If players only.
-     */
-    public boolean isPlayersOnly() {
-        return this.playersOnly;
-    }
-
-    /**
-     * Get the subcommands of the command.
-     *
-     * @return The subcommands.
-     */
-    public List<CommandBase> getSubcommands() {
-        return this.subcommands;
-    }
-
-    @Deprecated(forRemoval = true)
-    @Override
-    public @Nullable com.willfp.eco.core.command.CommandHandler getHandler() {
-        return this.handler;
-    }
-
-    @Deprecated(forRemoval = true)
-    @Override
-    public @Nullable com.willfp.eco.core.command.TabCompleteHandler getTabCompleter() {
-        return this.tabCompleter;
-    }
-
-    @Deprecated(forRemoval = true)
-    @Override
-    public void setHandler(@Nullable final com.willfp.eco.core.command.CommandHandler handler) {
-        this.handler = handler;
-    }
-
-    @Deprecated(forRemoval = true)
-    @Override
-    public void setTabCompleter(@Nullable final com.willfp.eco.core.command.TabCompleteHandler tabCompleter) {
-        this.tabCompleter = tabCompleter;
-    }
-}

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

@@ -1,26 +1,28 @@
 package com.willfp.eco.core.command.impl;
 
+import com.willfp.eco.core.Eco;
 import com.willfp.eco.core.EcoPlugin;
-import org.bukkit.Bukkit;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.TabCompleter;
+import com.willfp.eco.core.command.CommandBase;
+import com.willfp.eco.core.command.PluginCommandBase;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
 /**
- * PluginCommands are the class to be used instead of CommandExecutor,
- * they function as the base command, e.g. {@code /ecoenchants} would be a base command, with each
- * subsequent argument functioning as subcommands.
+ * PluginCommands are the class to be used instead of CommandExecutor, they function as the base
+ * command, e.g. {@code /ecoenchants} would be a base command, with each subsequent argument
+ * functioning as subcommands.
  * <p>
  * The command will not be registered until register() is called.
  * <p>
  * The name cannot be the same as an existing command as this will conflict.
  */
-public abstract class PluginCommand extends HandledCommand implements CommandExecutor, TabCompleter {
+public abstract class PluginCommand implements PluginCommandBase {
+    /**
+     * The delegate command.
+     */
+    private final PluginCommandBase delegate;
+
     /**
      * Create a new command.
      *
@@ -33,64 +35,51 @@ public abstract class PluginCommand extends HandledCommand implements CommandExe
                             @NotNull final String name,
                             @NotNull final String permission,
                             final boolean playersOnly) {
-        super(plugin, name, permission, playersOnly);
+        this.delegate = Eco.get().createPluginCommand(this, plugin, name, permission, playersOnly);
     }
 
-    /**
-     * Registers the command with the server,
-     * <p>
-     * Requires the command name to exist, defined in plugin.yml.
-     */
-    public final void register() {
-        org.bukkit.command.PluginCommand command = Bukkit.getPluginCommand(this.getName());
-        assert command != null;
-        command.setExecutor(this);
-        command.setTabCompleter(this);
-    }
-
-    /**
-     * Internal implementation used to clean up boilerplate.
-     * Used for parity with {@link CommandExecutor#onCommand(CommandSender, Command, String, String[])}.
-     *
-     * @param sender  The executor of the command.
-     * @param command The bukkit command.
-     * @param label   The name of the executed command.
-     * @param args    The arguments of the command (anything after the physical command name)
-     * @return If the command was processed by the linked {@link EcoPlugin}
-     */
     @Override
-    public final boolean onCommand(@NotNull final CommandSender sender,
-                                   @NotNull final Command command,
-                                   @NotNull final String label,
-                                   @NotNull final String[] args) {
-        if (!command.getName().equalsIgnoreCase(this.getName())) {
-            return false;
-        }
-
-        this.handle(sender, args);
-
-        return true;
+    public @NotNull String getName() {
+        return delegate.getName();
     }
 
-    /**
-     * Internal implementation used to clean up boilerplate.
-     * Used for parity with {@link TabCompleter#onTabComplete(CommandSender, Command, String, String[])}.
-     *
-     * @param sender  The executor of the command.
-     * @param command The bukkit command.
-     * @param label   The name of the executed command.
-     * @param args    The arguments of the command (anything after the physical command name).
-     * @return The list of tab-completions.
-     */
     @Override
-    public @Nullable List<String> onTabComplete(@NotNull final CommandSender sender,
-                                                @NotNull final Command command,
-                                                @NotNull final String label,
-                                                @NotNull final String[] args) {
-        if (!command.getName().equalsIgnoreCase(this.getName())) {
-            return null;
-        }
+    public @NotNull String getPermission() {
+        return delegate.getPermission();
+    }
 
-        return this.handleTabCompletion(sender, args);
+    @Override
+    public boolean isPlayersOnly() {
+        return delegate.isPlayersOnly();
+    }
+
+    @Override
+    public @NotNull CommandBase addSubcommand(@NotNull CommandBase command) {
+        return delegate.addSubcommand(command);
+    }
+
+    @Override
+    public @NotNull List<CommandBase> getSubcommands() {
+        return delegate.getSubcommands();
+    }
+
+    @Override
+    public @NotNull CommandBase getWrapped() {
+        return this;
+    }
+
+    @Override
+    public void register() {
+        delegate.register();
+    }
+
+    @Override
+    public void unregister() {
+        delegate.unregister();
+    }
+
+    @Override
+    public EcoPlugin getPlugin() {
+        return delegate.getPlugin();
     }
 }

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

@@ -1,13 +1,21 @@
 package com.willfp.eco.core.command.impl;
 
+import com.willfp.eco.core.Eco;
 import com.willfp.eco.core.EcoPlugin;
 import com.willfp.eco.core.command.CommandBase;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.List;
+
 /**
- * Subcommands can be added to PluginCommands or to other Subcommands.
+ * A command implementation that must exist as a subcommand (i.e. cannot be registered directly).
  */
-public abstract class Subcommand extends HandledCommand {
+public abstract class Subcommand implements CommandBase {
+    /**
+     * The delegate command.
+     */
+    private final CommandBase delegate;
+
     /**
      * Create subcommand.
      *
@@ -20,7 +28,7 @@ public abstract class Subcommand extends HandledCommand {
                          @NotNull final String name,
                          @NotNull final String permission,
                          final boolean playersOnly) {
-        super(plugin, name, permission, playersOnly);
+        this.delegate = Eco.get().createSubcommand(this, plugin, name, permission, playersOnly);
     }
 
     /**
@@ -33,6 +41,41 @@ public abstract class Subcommand extends HandledCommand {
     protected Subcommand(@NotNull final EcoPlugin plugin,
                          @NotNull final String name,
                          @NotNull final CommandBase parent) {
-        super(plugin, name, parent.getPermission(), parent.isPlayersOnly());
+        this(plugin, name, parent.getPermission(), parent.isPlayersOnly());
+    }
+
+    @Override
+    public @NotNull String getName() {
+        return delegate.getName();
+    }
+
+    @Override
+    public @NotNull String getPermission() {
+        return delegate.getPermission();
+    }
+
+    @Override
+    public boolean isPlayersOnly() {
+        return delegate.isPlayersOnly();
+    }
+
+    @Override
+    public @NotNull CommandBase addSubcommand(@NotNull CommandBase command) {
+        return delegate.addSubcommand(command);
+    }
+
+    @Override
+    public @NotNull List<CommandBase> getSubcommands() {
+        return delegate.getSubcommands();
+    }
+
+    @Override
+    public @NotNull CommandBase getWrapped() {
+        return this;
+    }
+
+    @Override
+    public EcoPlugin getPlugin() {
+        return delegate.getPlugin();
     }
 }

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

@@ -6,12 +6,12 @@ import org.jetbrains.annotations.Nullable;
 /**
  * Builder for configs to create them programmatically.
  */
-public class BuildableConfig extends TransientConfig {
+public class BuildableConfig extends GenericConfig {
     /**
      * Create a new empty config builder.
      */
     public BuildableConfig() {
-        super();
+
     }
 
     /**

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

@@ -0,0 +1,157 @@
+package com.willfp.eco.core.config;
+
+import com.willfp.eco.core.Eco;
+import com.willfp.eco.core.config.interfaces.Config;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.file.Files;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Utilities / API methods for configs.
+ */
+public final class Configs {
+    /**
+     * Load a Config from a bukkit {@link ConfigurationSection}.
+     *
+     * @param config The ConfigurationSection.
+     * @return The config.
+     */
+    @NotNull
+    public static Config fromBukkit(@Nullable final ConfigurationSection config) {
+        return config == null ? empty() : Eco.get().wrapConfigurationSection(config);
+    }
+
+    /**
+     * Load a config from an {@link InputStream}.
+     * <p>
+     * Only for yaml configs.
+     *
+     * @param stream The InputStream.
+     * @return The config.
+     */
+    @NotNull
+    public static Config fromStream(@Nullable final InputStream stream) {
+        return stream != null ? fromBukkit(YamlConfiguration.loadConfiguration(
+                new InputStreamReader(stream)
+        )) : empty();
+    }
+
+    /**
+     * Load a config from a file.
+     *
+     * @param file The file.
+     * @return The config.
+     */
+    @NotNull
+    public static Config fromFile(@Nullable final File file) {
+        if (file == null) {
+            return empty();
+        }
+
+        int lastIndex = file.getName().lastIndexOf(".");
+
+        if (lastIndex < 0) {
+            return empty();
+        }
+
+        for (ConfigType type : ConfigType.values()) {
+            if (file.getName().substring(lastIndex + 1).equalsIgnoreCase(type.getExtension())) {
+                return fromFile(file, type);
+            }
+        }
+
+        return empty();
+    }
+
+    /**
+     * Load a config from a file.
+     *
+     * @param file The file.
+     * @param type The type.
+     * @return The config.
+     */
+    @NotNull
+    public static Config fromFile(@Nullable final File file,
+                                  @NotNull final ConfigType type) {
+        if (file == null) {
+            return empty();
+        }
+
+        try {
+            return Eco.get().createConfig(Files.readString(file.toPath()), type);
+        } catch (IOException e) {
+            return empty();
+        }
+    }
+
+    /**
+     * Load config from map (uses {@link ConfigType#JSON}).
+     *
+     * @param values The values.
+     * @return The config.
+     */
+    @NotNull
+    public static Config fromMap(@NotNull final Map<String, Object> values) {
+        return fromMap(values, ConfigType.JSON);
+    }
+
+    /**
+     * Load config from map.
+     *
+     * @param values The values.
+     * @param type   The type.
+     * @return The config.
+     */
+    @NotNull
+    public static Config fromMap(@NotNull final Map<String, Object> values,
+                                 @NotNull final ConfigType type) {
+        return Eco.get().createConfig(values, type);
+    }
+
+    /**
+     * Create empty config (uses {@link ConfigType#JSON}).
+     *
+     * @return An empty config.
+     */
+    @NotNull
+    public static Config empty() {
+        return fromMap(new HashMap<>(), ConfigType.JSON);
+    }
+
+    /**
+     * Create empty config.
+     *
+     * @param type The type.
+     * @return An empty config.
+     */
+    @NotNull
+    public static Config empty(@NotNull final ConfigType type) {
+        return fromMap(new HashMap<>(), type);
+    }
+
+    /**
+     * Load config from string.
+     *
+     * @param contents The contents of the config.
+     * @param type     The config type.
+     * @return The config.
+     */
+    @NotNull
+    public static Config fromString(@NotNull final String contents,
+                                    @NotNull final ConfigType type) {
+        return Eco.get().createConfig(contents, type);
+    }
+
+    private Configs() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+}

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

@@ -0,0 +1,27 @@
+package com.willfp.eco.core.config;
+
+import com.willfp.eco.core.config.interfaces.Config;
+import com.willfp.eco.core.config.wrapper.ConfigWrapper;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Generic config to simplify creating custom configs without having
+ * to meddle with delegation.
+ */
+public abstract class GenericConfig extends ConfigWrapper<Config> {
+    /**
+     * Create a new generic config.
+     */
+    protected GenericConfig() {
+        super(Configs.empty());
+    }
+
+    /**
+     * Create a new generic config.
+     *
+     * @param type The config type.
+     */
+    protected GenericConfig(@NotNull final ConfigType type) {
+        super(Configs.empty(type));
+    }
+}

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

@@ -20,7 +20,10 @@ import java.util.Map;
  * Config that exists purely in the code, not linked to any file.
  * <p>
  * Use for inline configs to move data around or to add subsections to other configs.
+ *
+ * @deprecated Poorly named class, makes the config system seem needlessly complicated.
  */
+@Deprecated(since = "6.44.0", forRemoval = true)
 public class TransientConfig extends ConfigWrapper<Config> {
     /**
      * @param config The ConfigurationSection handle.

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

@@ -6,10 +6,32 @@ import com.willfp.eco.core.config.ConfigType;
 import com.willfp.eco.util.StringUtils;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.List;
+
 /**
  * Default plugin lang.yml.
  */
 public class LangYml extends BaseConfig {
+    /**
+     * The messages key.
+     */
+    public static final String KEY_MESSAGES = "messages";
+
+    /**
+     * The prefix key.
+     */
+    public static final String KEY_PREFIX = "messages.prefix";
+
+    /**
+     * The no permission key.
+     */
+    public static final String KEY_NO_PERMISSION = "messages.no-permission";
+
+    /**
+     * The not player key.
+     */
+    public static final String KEY_NOT_PLAYER = "messages.not-player";
+
     /**
      * Lang.yml.
      *
@@ -19,13 +41,31 @@ public class LangYml extends BaseConfig {
         super("lang", plugin, false, ConfigType.YAML);
     }
 
+    /**
+     * lang.yml requires certain keys to be present.
+     * <p>
+     * If the lang.yml does not contain these keys, it is considered to be
+     * invalid and thus will show a warning in console.
+     *
+     * @return If valid.
+     */
+    public boolean isValid() {
+        for (String key : List.of(KEY_MESSAGES, KEY_PREFIX, KEY_NO_PERMISSION, KEY_NOT_PLAYER)) {
+            if (!this.has(key)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Get the prefix for messages in chat.
      *
      * @return The prefix.
      */
     public String getPrefix() {
-        return this.getFormattedString("messages.prefix");
+        return this.getFormattedString(KEY_PREFIX);
     }
 
     /**
@@ -34,7 +74,7 @@ public class LangYml extends BaseConfig {
      * @return The message.
      */
     public String getNoPermission() {
-        return getPrefix() + this.getFormattedString("messages.no-permission");
+        return getPrefix() + this.getFormattedString(KEY_NO_PERMISSION);
     }
 
     /**
@@ -56,6 +96,6 @@ public class LangYml extends BaseConfig {
      */
     public String getMessage(@NotNull final String message,
                              @NotNull final StringUtils.FormatOption option) {
-        return getPrefix() + this.getFormattedString("messages." + message, option);
+        return getPrefix() + this.getFormattedString(KEY_MESSAGES + "." + message, option);
     }
 }

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

@@ -2,7 +2,7 @@ package com.willfp.eco.core.config.interfaces;
 
 import com.willfp.eco.core.config.BuildableConfig;
 import com.willfp.eco.core.config.ConfigType;
-import com.willfp.eco.core.config.TransientConfig;
+import com.willfp.eco.core.config.Configs;
 import com.willfp.eco.core.placeholder.AdditionalPlayer;
 import com.willfp.eco.core.placeholder.InjectablePlaceholder;
 import com.willfp.eco.core.placeholder.PlaceholderInjectable;
@@ -103,7 +103,7 @@ public interface Config extends Cloneable, PlaceholderInjectable {
      */
     @NotNull
     default Config getSubsection(@NotNull String path) {
-        return Objects.requireNonNullElse(getSubsectionOrNull(path), new TransientConfig());
+        return Objects.requireNonNullElse(getSubsectionOrNull(path), Configs.empty());
     }
 
     /**

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

@@ -134,7 +134,7 @@ public final class PersistentDataKey<T> {
         if (this == o) {
             return true;
         }
-        if (!(o instanceof PersistentDataKey that)) {
+        if (!(o instanceof PersistentDataKey<?> that)) {
             return false;
         }
         return Objects.equals(this.getKey(), that.getKey());

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

@@ -99,7 +99,7 @@ public final class PersistentDataKeyType<T> {
         if (this == that) {
             return true;
         }
-        if (!(that instanceof PersistentDataKeyType type)) {
+        if (!(that instanceof PersistentDataKeyType<?> type)) {
             return false;
         }
         return Objects.equals(this.name, type.name);

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

@@ -7,7 +7,6 @@ import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.persistence.PersistentDataType;
-import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 

eco-api/src/main/java/com/willfp/eco/core/gui/menu/Menu.java

@@ -63,11 +63,29 @@ public interface Menu {
      * @param player The player
      * @param menu   The menu.
      * @return The slot.
+     * @deprecated Menu shouldn't be a parameter.
      */
-    default Slot getSlot(int row,
-                         int column,
-                         @NotNull Player player,
-                         @NotNull Menu menu) {
+    @Deprecated(since = "6.46.0", forRemoval = true)
+    default Slot getSlot(final int row,
+                         final int column,
+                         @NotNull final Player player,
+                         @NotNull final Menu menu) {
+        return this.getSlot(row, column, player);
+    }
+
+    /**
+     * Get a slot at a given row and column.
+     * <p>
+     * Defaults to static slot if no reactive slot exists.
+     *
+     * @param row    The row.
+     * @param column The column.
+     * @param player The player
+     * @return The slot.
+     */
+    default Slot getSlot(final int row,
+                         final int column,
+                         @NotNull final Player player) {
         return this.getSlot(row, column);
     }
 
@@ -110,15 +128,32 @@ public interface Menu {
     }
 
     /**
-     * Add state for a player.
+     * Set state for a player.
      *
      * @param player The player.
      * @param key    The key.
      * @param value  The state.
      */
-    void addState(@NotNull Player player,
-                  @NotNull String key,
-                  @Nullable Object value);
+    default void setState(@NotNull Player player,
+                          @NotNull String key,
+                          @Nullable Object value) {
+        // Blank method for backwards compatibility.
+    }
+
+    /**
+     * Add state for a player.
+     *
+     * @param player The player.
+     * @param key    The key.
+     * @param value  The state.
+     * @deprecated Poorly named, use setState instead.
+     */
+    @Deprecated(since = "6.44.0", forRemoval = true)
+    default void addState(@NotNull Player player,
+                          @NotNull String key,
+                          @Nullable Object value) {
+        this.setState(player, key, value);
+    }
 
     /**
      * Remove state for a player.
@@ -221,7 +256,7 @@ public interface Menu {
                                   @NotNull final NamespacedKey key,
                                   @NotNull final PersistentDataType<T, Z> type,
                                   @NotNull final Z value) {
-        this.addState(player, key.toString(), value);
+        this.setState(player, key.toString(), value);
     }
 
     /**

eco-api/src/main/java/com/willfp/eco/core/gui/menu/MenuBuilder.java

@@ -139,7 +139,7 @@ public interface MenuBuilder extends PageBuilder {
      * @return The builder.
      */
     default MenuBuilder maxPages(@NotNull final Function<Player, Integer> pages) {
-        return onOpen((player, menu) -> menu.addState(player, Page.MAX_PAGE_KEY, pages.apply(player)));
+        return this.onRender((player, menu) -> menu.setState(player, Page.MAX_PAGE_KEY, pages.apply(player)));
     }
 
     /**
@@ -195,6 +195,16 @@ public interface MenuBuilder extends PageBuilder {
         return this;
     }
 
+    /**
+     * Add an action to run on build.
+     *
+     * @param action The action.
+     * @return The builder.
+     */
+    default MenuBuilder onBuild(@NotNull Consumer<Menu> action) {
+        return this;
+    }
+
     /**
      * Build the menu.
      *

eco-api/src/main/java/com/willfp/eco/core/gui/menu/events/CaptiveItemChangeEvent.java

@@ -0,0 +1,22 @@
+package com.willfp.eco.core.gui.menu.events;
+
+import com.willfp.eco.core.gui.menu.MenuEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Represents a captive item change.
+ *
+ * @param row    The row.
+ * @param column The column.
+ * @param before The previous item in the slot.
+ * @param after  The new item in the slot.
+ */
+public record CaptiveItemChangeEvent(
+        int row,
+        int column,
+        @Nullable ItemStack before,
+        @Nullable ItemStack after
+) implements MenuEvent {
+
+}

eco-api/src/main/java/com/willfp/eco/core/gui/page/Page.java

@@ -9,8 +9,6 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Objects;
-
 /**
  * A page is a component representing another menu.
  * This allows full component support in pagination.
@@ -85,7 +83,7 @@ public final class Page implements GUIComponent {
             delegate = Eco.get().blendMenuState(page, menu);
         }
 
-        return page.getSlot(row, column, player, delegate);
+        return page.getSlot(row, column, player);
     }
 
     @Override

eco-api/src/main/java/com/willfp/eco/core/gui/page/PageChanger.java

@@ -48,7 +48,7 @@ public final class PageChanger implements GUIComponent {
                         return;
                     }
 
-                    menu.addState(player, Page.PAGE_KEY, newPage);
+                    menu.setState(player, Page.PAGE_KEY, newPage);
                     menu.callEvent(player, new PageChangeEvent(
                             newPage,
                             page

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

@@ -1,12 +1,14 @@
 package com.willfp.eco.core.gui.slot;
 
 import com.willfp.eco.core.config.interfaces.Config;
+import com.willfp.eco.core.fast.FastItemStack;
 import com.willfp.eco.core.gui.slot.functional.SlotHandler;
 import com.willfp.eco.core.items.Items;
 import com.willfp.eco.util.StringUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
@@ -37,7 +39,25 @@ public class ConfigSlot extends CustomSlot {
     public ConfigSlot(@NotNull final Config config) {
         this.config = config;
 
-        SlotBuilder builder = Slot.builder(Items.lookup(config.getString("item")));
+        ItemStack item = Items.lookup(config.getString("item")).getItem();
+
+        SlotBuilder builder = Slot.builder((player, menu) -> {
+            if (!config.has("lore")) {
+                return item;
+            } else {
+                FastItemStack fast = FastItemStack.wrap(item.clone());
+                List<String> newLore = new ArrayList<>(fast.getLore());
+                newLore.addAll(
+                        StringUtils.formatList(
+                                config.getStrings("lore"),
+                                player,
+                                StringUtils.FormatOption.WITH_PLACEHOLDERS
+                        )
+                );
+                fast.setLore(newLore);
+                return fast.unwrap();
+            }
+        });
 
         for (ClickType clickType : ClickType.values()) {
             builder.onClick(

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

@@ -4,6 +4,7 @@ import com.willfp.eco.core.gui.menu.Menu;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Base class for custom slot implementations.
@@ -31,7 +32,7 @@ public abstract class CustomSlot implements Slot {
     }
 
     @Override
-    public ItemStack getItemStack(@NotNull final Player player) {
+    public final @NotNull ItemStack getItemStack(@NotNull final Player player) {
         if (delegate == null) {
             throw new IllegalStateException("Custom Slot was not initialized!");
         }
@@ -40,8 +41,8 @@ public abstract class CustomSlot implements Slot {
     }
 
     @Override
-    public boolean isCaptive(@NotNull final Player player,
-                             @NotNull final Menu menu) {
+    public final boolean isCaptive(@NotNull final Player player,
+                                   @NotNull final Menu menu) {
         if (delegate == null) {
             throw new IllegalStateException("Custom Slot was not initialized!");
         }
@@ -50,7 +51,18 @@ public abstract class CustomSlot implements Slot {
     }
 
     @Override
-    public boolean isCaptiveFromEmpty() {
+    public final boolean isAllowedCaptive(@NotNull final Player player,
+                                          @NotNull final Menu menu,
+                                          @Nullable final ItemStack itemStack) {
+        if (delegate == null) {
+            throw new IllegalStateException("Custom Slot was not initialized!");
+        }
+
+        return delegate.isAllowedCaptive(player, menu, itemStack);
+    }
+
+    @Override
+    public final boolean isCaptiveFromEmpty() {
         if (delegate == null) {
             throw new IllegalStateException("Custom Slot was not initialized!");
         }
@@ -59,8 +71,8 @@ public abstract class CustomSlot implements Slot {
     }
 
     @Override
-    public final Slot getActionableSlot(@NotNull final Player player,
-                                        @NotNull final Menu menu) {
+    public final @NotNull Slot getActionableSlot(@NotNull final Player player,
+                                                 @NotNull final Menu menu) {
         return delegate;
     }
 

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

@@ -5,6 +5,7 @@ import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Base class for custom slot implementations.
@@ -29,19 +30,26 @@ public abstract class ReactiveSlot implements Slot {
                                  @NotNull final Menu menu);
 
     @Override
-    public ItemStack getItemStack(@NotNull final Player player) {
-        return new ItemStack(Material.STONE);
+    public @NotNull ItemStack getItemStack(@NotNull final Player player) {
+        return new ItemStack(Material.AIR);
     }
 
     @Override
-    public boolean isCaptive(@NotNull final Player player,
-                             @NotNull final Menu menu) {
+    public final boolean isCaptive(@NotNull final Player player,
+                                   @NotNull final Menu menu) {
         return getSlot(player, menu).isCaptive(player, menu);
     }
 
     @Override
-    public final Slot getActionableSlot(@NotNull final Player player,
-                                        @NotNull final Menu menu) {
+    public final boolean isAllowedCaptive(@NotNull final Player player,
+                                          @NotNull final Menu menu,
+                                          @Nullable final ItemStack itemStack) {
+        return getSlot(player, menu).isAllowedCaptive(player, menu, itemStack);
+    }
+
+    @Override
+    public final @NotNull Slot getActionableSlot(@NotNull final Player player,
+                                                 @NotNull final Menu menu) {
         return getSlot(player, menu);
     }
 

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

@@ -9,6 +9,7 @@ import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.function.Function;
 
@@ -30,6 +31,7 @@ public interface Slot extends GUIComponent {
      * @param player The player.
      * @return The ItemStack.
      */
+    @NotNull
     ItemStack getItemStack(@NotNull Player player);
 
     /**
@@ -44,6 +46,20 @@ public interface Slot extends GUIComponent {
         return false;
     }
 
+    /**
+     * If the slot allows a certain item to be placed in it.
+     *
+     * @param player    The player.
+     * @param menu      The menu.
+     * @param itemStack The item; use null if the item is unknown.
+     * @return If captive.
+     */
+    default boolean isAllowedCaptive(@NotNull final Player player,
+                                     @NotNull final Menu menu,
+                                     @Nullable final ItemStack itemStack) {
+        return this.isCaptive(player, menu);
+    }
+
     /**
      * Get the actionable slot to be shown.
      * <p>
@@ -60,6 +76,7 @@ public interface Slot extends GUIComponent {
      * @param menu   The menu.
      * @return The slot.
      */
+    @NotNull
     default Slot getActionableSlot(@NotNull final Player player,
                                    @NotNull final Menu menu) {
         return this;
@@ -125,7 +142,9 @@ public interface Slot extends GUIComponent {
      *
      * @param provider The provider.
      * @return The builder.
+     * @deprecated This method was written incorrectly, should have been a Player + Menu function.
      */
+    @Deprecated(since = "6.45.0", forRemoval = true)
     static SlotBuilder builder(@NotNull final Function<Player, ItemStack> provider) {
         return Eco.get().createSlotBuilder((player, menu) -> provider.apply(player));
     }

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

@@ -1,5 +1,6 @@
 package com.willfp.eco.core.gui.slot;
 
+import com.willfp.eco.core.gui.slot.functional.CaptiveFilter;
 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;
@@ -143,7 +144,17 @@ public interface SlotBuilder {
      * @param predicate The predicate. Returns true when the slot should not be captive.
      * @return The builder.
      */
-    SlotBuilder notCaptiveFor(@NotNull Predicate<Player> predicate);
+    SlotBuilder notCaptiveFor(@NotNull final Predicate<Player> predicate);
+
+    /**
+     * Set a whitelist for allowed captive items.
+     *
+     * @param filter The filter.
+     * @return The builder.
+     */
+    default SlotBuilder setCaptiveFilter(@NotNull final CaptiveFilter filter) {
+        return this;
+    }
 
     /**
      * Set the ItemStack updater.

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

@@ -0,0 +1,25 @@
+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;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface to test if a captive slot is allowed to contain an item given a player and a menu.
+ */
+@FunctionalInterface
+public interface CaptiveFilter {
+    /**
+     * Get if allowed.
+     *
+     * @param player    The player.
+     * @param menu      The menu.
+     * @param itemStack The item.
+     * @return If captive.
+     */
+    boolean isAllowed(@NotNull Player player,
+                      @NotNull Menu menu,
+                      @Nullable ItemStack itemStack);
+}

eco-api/src/main/java/com/willfp/eco/core/integrations/mcmmo/McmmoManager.java

@@ -33,10 +33,15 @@ public final class McmmoManager {
      * @return The bonus drop count.
      */
     public static int getBonusDropCount(@NotNull final Block block) {
+        int finalValue = 0;
         for (McmmoIntegration mcmmoIntegration : REGISTERED) {
-            return mcmmoIntegration.getBonusDropCount(block);
+            finalValue += mcmmoIntegration.getBonusDropCount(block);
+            
+
+
+            
         }
-        return 0;
+        return finalValue;
     }
 
     /**
@@ -47,7 +52,10 @@ public final class McmmoManager {
      */
     public static boolean isFake(@NotNull final Event event) {
         for (McmmoIntegration mcmmoIntegration : REGISTERED) {
-            return mcmmoIntegration.isFake(event);
+            if (mcmmoIntegration.isFake(event)) {
+                return true;
+            }
+
         }
         return false;
     }

eco-api/src/main/java/com/willfp/eco/core/integrations/placeholder/PlaceholderManager.java

@@ -51,10 +51,15 @@ public final class PlaceholderManager {
             .expireAfterWrite(50, TimeUnit.MILLISECONDS)
             .build(key -> key.entry.getValue(key.player));
 
+    /**
+     * The default PlaceholderAPI pattern; brought in for compatibility.
+     */
+    private static final Pattern PATTERN = Pattern.compile("[%]([^% ]+)[%]");
+
     /**
      * Empty injectable object.
      */
-    private static final PlaceholderInjectable EMPTY_INJECTABLE = new PlaceholderInjectable() {
+    public static final PlaceholderInjectable EMPTY_INJECTABLE = new PlaceholderInjectable() {
         @Override
         public void clearInjectedPlaceholders() {
             // Do nothing.
@@ -67,11 +72,6 @@ public final class PlaceholderManager {
         }
     };
 
-    /**
-     * The default PlaceholderAPI pattern; brought in for compatibility.
-     */
-    private static final Pattern PATTERN = Pattern.compile("[%]([^%]+)[%]");
-
     /**
      * Register a new placeholder integration.
      *

eco-api/src/main/java/com/willfp/eco/core/integrations/shop/ShopIntegration.java

@@ -1,6 +1,8 @@
 package com.willfp.eco.core.integrations.shop;
 
 import com.willfp.eco.core.integrations.Integration;
+import com.willfp.eco.core.price.Price;
+import com.willfp.eco.core.price.impl.PriceFree;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Listener;
 import org.bukkit.inventory.ItemStack;
@@ -29,12 +31,41 @@ public interface ShopIntegration extends Integration {
         return null;
     }
 
+    /**
+     * Get if an item is sellable for a player.
+     *
+     * @param itemStack The item.
+     * @param player    The player.
+     * @return If sellable.
+     */
+    default boolean isSellable(@NotNull final ItemStack itemStack,
+                               @NotNull final Player player) {
+        return false;
+    }
+
+    /**
+     * Get the value of one of an item for a player.
+     * <p>
+     * For example, if you pass in a stack, it will only return the value of <b>one</b> item, not the full stack.
+     *
+     * @param itemStack The item.
+     * @param player    The player.
+     * @return The price.
+     */
+    @NotNull
+    default Price getUnitValue(@NotNull final ItemStack itemStack,
+                               @NotNull final Player player) {
+        return new PriceFree();
+    }
+
     /**
      * Get the price of an item.
      *
      * @param itemStack The item.
      * @return The price.
+     * @deprecated Use getValue instead.
      */
+    @Deprecated(since = "6.47.0", forRemoval = true)
     default double getPrice(@NotNull final ItemStack itemStack) {
         // Do nothing unless overridden.
         return 0.0;
@@ -46,9 +77,11 @@ public interface ShopIntegration extends Integration {
      * @param itemStack The item.
      * @param player    The player.
      * @return The price.
+     * @deprecated Use getValue instead.
      */
+    @Deprecated(since = "6.47.0", forRemoval = true)
     default double getPrice(@NotNull final ItemStack itemStack,
                             @NotNull final Player player) {
-        return getPrice(itemStack);
+        return getUnitValue(itemStack, player).getValue(player);
     }
 }

eco-api/src/main/java/com/willfp/eco/core/integrations/shop/ShopManager.java

@@ -1,10 +1,9 @@
 package com.willfp.eco.core.integrations.shop;
 
-import com.willfp.eco.core.EcoPlugin;
+import com.willfp.eco.core.price.Price;
+import com.willfp.eco.core.price.impl.PriceFree;
 import org.bukkit.entity.Player;
-import org.bukkit.event.Listener;
 import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -39,12 +38,57 @@ public final class ShopManager {
         }
     }
 
+    /**
+     * Get if an item is sellable for a player.
+     *
+     * @param itemStack The item.
+     * @param player    The player.
+     * @return If sellable.
+     */
+    public static boolean isSellable(@Nullable final ItemStack itemStack,
+                                     @NotNull final Player player) {
+        if (itemStack == null) {
+            return false;
+        }
+
+        for (ShopIntegration integration : REGISTERED) {
+            return integration.isSellable(itemStack, player);
+        }
+
+        return false;
+    }
+
+    /**
+     * Get the value of one of an item for a player.
+     * <p>
+     * For example, if you pass in a stack, it will only return the value of <b>one</b> item, not the full stack.
+     *
+     * @param itemStack The item.
+     * @param player    The player.
+     * @return The price.
+     */
+    @NotNull
+    public static Price getUnitValue(@Nullable final ItemStack itemStack,
+                                     @NotNull final Player player) {
+        if (itemStack == null) {
+            return new PriceFree();
+        }
+
+        for (ShopIntegration integration : REGISTERED) {
+            return integration.getUnitValue(itemStack, player);
+        }
+
+        return new PriceFree();
+    }
+
     /**
      * Get the price of an item.
      *
      * @param itemStack The item.
      * @return The price.
+     * @deprecated Use getValue instead. This will always return 0 as prices depend on players.
      */
+    @Deprecated(since = "6.47.0", forRemoval = true)
     public static double getItemPrice(@Nullable final ItemStack itemStack) {
         return getItemPrice(itemStack, null);
     }
@@ -55,19 +99,17 @@ public final class ShopManager {
      * @param itemStack The item.
      * @param player    The player.
      * @return The price.
+     * @deprecated Use getValue instead. Null players / null items will always return 0.
      */
+    @Deprecated(since = "6.47.0", forRemoval = true)
     public static double getItemPrice(@Nullable final ItemStack itemStack,
                                       @Nullable final Player player) {
-        if (itemStack == null) {
+        if (itemStack == null || player == null) {
             return 0.0;
         }
 
         for (ShopIntegration shopIntegration : REGISTERED) {
-            if (player == null) {
-                return shopIntegration.getPrice(itemStack);
-            } else {
-                return shopIntegration.getPrice(itemStack, player);
-            }
+            return shopIntegration.getUnitValue(itemStack, player).getValue(player, itemStack.getAmount());
         }
 
         return 0.0;

eco-api/src/main/java/com/willfp/eco/core/integrations/shop/ShopSellEvent.java

@@ -1,5 +1,7 @@
 package com.willfp.eco.core.integrations.shop;
 
+import com.willfp.eco.core.price.Price;
+import com.willfp.eco.core.price.impl.PriceEconomy;
 import org.bukkit.entity.Player;
 import org.bukkit.event.HandlerList;
 import org.bukkit.event.player.PlayerEvent;
@@ -19,7 +21,12 @@ public class ShopSellEvent extends PlayerEvent {
     /**
      * The sell price.
      */
-    private double price;
+    private Price price;
+
+    /**
+     * The price multiplier.
+     */
+    private double multiplier;
 
     /**
      * The item to be sold.
@@ -33,31 +40,64 @@ public class ShopSellEvent extends PlayerEvent {
      * @param who   The player.
      * @param price The price.
      * @param item  The item.
+     * @deprecated Use the price system instead.
      */
+    @Deprecated(since = "6.47.0", forRemoval = true)
     public ShopSellEvent(@NotNull final Player who,
                          final double price,
                          @Nullable final ItemStack item) {
+        this(who, new PriceEconomy(price), item);
+    }
+
+    /**
+     * Create new shop sell event.
+     *
+     * @param who   The player.
+     * @param price The price.
+     * @param item  The item.
+     */
+    public ShopSellEvent(@NotNull final Player who,
+                         @NotNull final Price price,
+                         @Nullable final ItemStack item) {
+        this(who, price, item, 1.0);
+    }
+
+    /**
+     * Create new shop sell event.
+     *
+     * @param who        The player.
+     * @param price      The price.
+     * @param item       The item.
+     * @param multiplier The multiplier.
+     */
+    public ShopSellEvent(@NotNull final Player who,
+                         @NotNull final Price price,
+                         @Nullable final ItemStack item,
+                         final double multiplier) {
         super(who);
 
         this.price = price;
         this.item = item;
+
+        this.multiplier = multiplier;
     }
 
     /**
-     * Get the price.
+     * Get the value.
      *
-     * @return The price.
+     * @return The value.
      */
-    public double getPrice() {
+    @NotNull
+    public Price getValue() {
         return this.price;
     }
 
     /**
-     * Set the price.
+     * Set the value.
      *
-     * @param price The price.
+     * @param price The value.
      */
-    public void setPrice(final double price) {
+    public void setValue(@NotNull final Price price) {
         this.price = price;
     }
 
@@ -81,6 +121,46 @@ public class ShopSellEvent extends PlayerEvent {
         return item != null;
     }
 
+    /**
+     * Get the price multiplier.
+     *
+     * @return The multiplier.
+     */
+    public double getMultiplier() {
+        return multiplier;
+    }
+
+    /**
+     * Set the price multiplier.
+     *
+     * @param multiplier The multiplier.
+     */
+    public void setMultiplier(final double multiplier) {
+        this.multiplier = multiplier;
+    }
+
+    /**
+     * Get the price.
+     *
+     * @return The price.
+     * @deprecated Use the price system instead.
+     */
+    @Deprecated(since = "6.47.0", forRemoval = true)
+    public double getPrice() {
+        return this.getValue().getValue(player);
+    }
+
+    /**
+     * Set the price.
+     *
+     * @param price The price.
+     * @deprecated Use the price system instead.
+     */
+    @Deprecated(since = "6.47.0", forRemoval = true)
+    public void setPrice(final double price) {
+        this.setValue(new PriceEconomy(price));
+    }
+
     /**
      * Bukkit parity.
      *

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

@@ -25,6 +25,7 @@ import org.jetbrains.annotations.Nullable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -86,6 +87,11 @@ public final class Items {
      */
     private static final TestableItem EMPTY_TESTABLE_ITEM = new EmptyTestableItem();
 
+    /**
+     * Friendly material names (without underscores, etc.)
+     */
+    private static final Map<String, Material> FRIENDLY_MATERIAL_NAMES = new HashMap<>();
+
     /**
      * Register a new custom item.
      *
@@ -216,7 +222,7 @@ public final class Items {
             if (isWildcard) {
                 itemType = itemType.substring(1);
             }
-            Material material = Material.getMaterial(itemType.toUpperCase());
+            Material material = FRIENDLY_MATERIAL_NAMES.get(itemType.toLowerCase());
             if (material == null || material == Material.AIR) {
                 return new EmptyTestableItem();
             }
@@ -565,4 +571,25 @@ public final class Items {
     private Items() {
         throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
     }
+
+    static {
+        for (Material material : Material.values()) {
+            FRIENDLY_MATERIAL_NAMES.put(material.name().toLowerCase(), material);
+
+            String oneWord = material.name().toLowerCase().replace("_", "");
+            if (!FRIENDLY_MATERIAL_NAMES.containsKey(oneWord)) {
+                FRIENDLY_MATERIAL_NAMES.put(oneWord, material);
+            }
+
+            String plural = material.name().toLowerCase() + "s";
+            if (!FRIENDLY_MATERIAL_NAMES.containsKey(plural)) {
+                FRIENDLY_MATERIAL_NAMES.put(plural, material);
+            }
+
+            String oneWordPlural = oneWord + "s";
+            if (!FRIENDLY_MATERIAL_NAMES.containsKey(oneWordPlural)) {
+                FRIENDLY_MATERIAL_NAMES.put(oneWordPlural, material);
+            }
+        }
+    }
 }

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

@@ -14,7 +14,6 @@ import org.bukkit.persistence.PersistentDataType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Supplier;
 
@@ -71,7 +70,7 @@ public abstract class AbstractItemStackBuilder<T extends ItemMeta, U extends Abs
 
     @Override
     public U setAmount(final int amount) {
-        Validate.isTrue(amount >= 1 && amount <= base.getMaxStackSize());
+        Validate.isTrue(amount >= 1);
         base.setAmount(amount);
         return (U) this;
     }

eco-api/src/main/java/com/willfp/eco/core/math/MathContext.java

@@ -0,0 +1,63 @@
+package com.willfp.eco.core.math;
+
+import com.willfp.eco.core.integrations.placeholder.PlaceholderManager;
+import com.willfp.eco.core.placeholder.AdditionalPlayer;
+import com.willfp.eco.core.placeholder.PlaceholderInjectable;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * Represents a context to do math in.
+ *
+ * @param injectableContext The PlaceholderInjectable context.
+ * @param player            The player.
+ * @param additionalPlayers The additional players.
+ */
+public record MathContext(
+        @NotNull PlaceholderInjectable injectableContext,
+        @Nullable Player player,
+        @NotNull Collection<AdditionalPlayer> additionalPlayers
+) {
+    /**
+     * Empty math context.
+     */
+    public static final MathContext EMPTY = new MathContext(
+            PlaceholderManager.EMPTY_INJECTABLE,
+            null,
+            Collections.emptyList()
+    );
+
+    /**
+     * Create MathContext of a PlaceholderInjectable context.
+     *
+     * @param injectableContext The PlaceholderInjectable context.
+     * @return The MathContext.
+     */
+    public static MathContext of(@NotNull final PlaceholderInjectable injectableContext) {
+        return new MathContext(
+                injectableContext,
+                null,
+                Collections.emptyList()
+        );
+    }
+
+    /**
+     * Copy a MathContext with a player.
+     *
+     * @param context The context.
+     * @param player  The player.
+     * @return The new MathContext.
+     */
+    public static MathContext copyWithPlayer(@NotNull final MathContext context,
+                                             @Nullable final Player player) {
+        return new MathContext(
+                context.injectableContext(),
+                player,
+                context.additionalPlayers()
+        );
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/particle/ParticleFactory.java

@@ -0,0 +1,28 @@
+package com.willfp.eco.core.particle;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * Create particles.
+ */
+public interface ParticleFactory {
+    /**
+     * Get the names (how the particle looks in lookup strings).
+     * <p>
+     * For example, for RGB particles this would be 'rgb', 'color', etc.
+     *
+     * @return The allowed names.
+     */
+    @NotNull List<String> getNames();
+
+    /**
+     * Create the particle
+     *
+     * @param key The key.
+     * @return The particle.
+     */
+    @Nullable SpawnableParticle create(@NotNull String key);
+}

eco-api/src/main/java/com/willfp/eco/core/particle/Particles.java

@@ -0,0 +1,83 @@
+package com.willfp.eco.core.particle;
+
+import com.willfp.eco.core.particle.impl.EmptyParticle;
+import com.willfp.eco.core.particle.impl.SimpleParticle;
+import com.willfp.eco.util.StringUtils;
+import org.bukkit.Particle;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Class to manage particles.
+ */
+public final class Particles {
+    /**
+     * All factories.
+     */
+    private static final Map<String, ParticleFactory> FACTORIES = new ConcurrentHashMap<>();
+
+    /**
+     * Register a new particle factory.
+     *
+     * @param factory The factory.
+     */
+    public static void registerParticleFactory(@NotNull final ParticleFactory factory) {
+        for (String name : factory.getNames()) {
+            FACTORIES.put(name.toLowerCase(), factory);
+        }
+    }
+
+    /**
+     * Lookup a particle from a string.
+     * <p>
+     * A particle string should look like {@code magic}, {@code rgb:00ff00}
+     *
+     * @param key The key.
+     * @return The particle, or an {@link EmptyParticle} if invalid.
+     */
+    @NotNull
+    public static SpawnableParticle lookup(@NotNull final String key) {
+        String[] args = StringUtils.parseTokens(key.toLowerCase());
+
+        if (args.length == 0) {
+            return new EmptyParticle();
+        }
+
+        SpawnableParticle spawnableParticle;
+
+        String[] split = args[0].split(":");
+
+        if (split.length == 1) {
+            try {
+                Particle particle = Particle.valueOf(args[0].toUpperCase());
+                spawnableParticle = new SimpleParticle(particle);
+            } catch (IllegalArgumentException e) {
+                spawnableParticle = new EmptyParticle();
+            }
+        } else if (split.length == 2) {
+            String name = split[0];
+            String factoryKey = split[1];
+
+            ParticleFactory factory = FACTORIES.get(name);
+            if (factory == null) {
+                spawnableParticle = new EmptyParticle();
+            } else {
+                spawnableParticle = factory.create(factoryKey);
+            }
+        } else {
+            return new EmptyParticle();
+        }
+
+        if (spawnableParticle == null || spawnableParticle instanceof EmptyParticle) {
+            return new EmptyParticle();
+        }
+
+        return spawnableParticle;
+    }
+
+    private Particles() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/particle/SpawnableParticle.java

@@ -0,0 +1,27 @@
+package com.willfp.eco.core.particle;
+
+import org.bukkit.Location;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A particle that can be spawned.
+ */
+public interface SpawnableParticle {
+    /**
+     * Spawn the particle at a location.
+     *
+     * @param location The location.
+     * @param amount   The amount to spawn.
+     */
+    void spawn(@NotNull Location location,
+               int amount);
+
+    /**
+     * Spawn the particle at a location.
+     *
+     * @param location The location.
+     */
+    default void spawn(@NotNull Location location) {
+        spawn(location, 1);
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/particle/impl/EmptyParticle.java

@@ -0,0 +1,16 @@
+package com.willfp.eco.core.particle.impl;
+
+import com.willfp.eco.core.particle.SpawnableParticle;
+import org.bukkit.Location;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Empty (invalid) particle that is spawned when an invalid key is provided.
+ */
+public final class EmptyParticle implements SpawnableParticle {
+    @Override
+    public void spawn(@NotNull final Location location,
+                      final int amount) {
+        // Do nothing.
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/particle/impl/SimpleParticle.java

@@ -0,0 +1,38 @@
+package com.willfp.eco.core.particle.impl;
+
+import com.willfp.eco.core.particle.SpawnableParticle;
+import org.bukkit.Location;
+import org.bukkit.Particle;
+import org.bukkit.World;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Empty (invalid) particle that is spawned when an invalid key is provided.
+ */
+public final class SimpleParticle implements SpawnableParticle {
+    /**
+     * The particle to be spawned.
+     */
+    private final Particle particle;
+
+    /**
+     * Create a new spawnable particle.
+     *
+     * @param particle The particle.
+     */
+    public SimpleParticle(@NotNull final Particle particle) {
+        this.particle = particle;
+    }
+
+    @Override
+    public void spawn(@NotNull final Location location,
+                      final int amount) {
+        World world = location.getWorld();
+
+        if (world == null) {
+            return;
+        }
+
+        world.spawnParticle(particle, location, amount, 0, 0, 0, 0, null);
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/price/CombinedDisplayPrice.java

@@ -0,0 +1,156 @@
+package com.willfp.eco.core.price;
+
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A group of {@link ConfiguredPrice}s in order to show them
+ * to players in one go.
+ */
+public final class CombinedDisplayPrice {
+    /**
+     * Maps configured prices to multipliers.
+     */
+    private final Map<ConfiguredPrice, Double> prices;
+
+    /**
+     * The player to format for.
+     */
+    private final Player player;
+
+    /**
+     * Initialize a new combined price mapping formatters to multipliers.
+     *
+     * @param player The player.
+     * @param prices The prices.
+     */
+    private CombinedDisplayPrice(@NotNull final Player player,
+                                 @NotNull final Map<ConfiguredPrice, Double> prices) {
+        this.player = player;
+        this.prices = prices;
+    }
+
+    /**
+     * Get the display strings.
+     *
+     * @return The display strings.
+     */
+    @NotNull
+    public String[] getDisplayStrings() {
+        List<String> displayStrings = new ArrayList<>();
+
+        for (Map.Entry<ConfiguredPrice, Double> entry : prices.entrySet()) {
+            displayStrings.add(entry.getKey().getDisplay(player, entry.getValue()));
+        }
+
+        return displayStrings.toArray(new String[0]);
+    }
+
+    /**
+     * The builder.
+     */
+    public static class Builder {
+        /**
+         * All multiplied prices.
+         */
+        private final List<MultipliedPrice> prices = new ArrayList<>();
+
+        /**
+         * The player.
+         */
+        private final Player player;
+
+        /**
+         * Create a new builder.
+         *
+         * @param player The player.
+         */
+        Builder(@NotNull final Player player) {
+            this.player = player;
+        }
+
+        /**
+         * Add a new price with a certain multiplier.
+         *
+         * @param price      The price.
+         * @param multiplier The multiplier.
+         * @return The builder.
+         */
+        @NotNull
+        public Builder add(@NotNull final ConfiguredPrice price,
+                           final double multiplier) {
+            prices.add(new MultipliedPrice(price, multiplier));
+            return this;
+        }
+
+
+        /**
+         * Add a new price.
+         *
+         * @param price The price.
+         * @return The builder.
+         */
+        @NotNull
+        public Builder add(@NotNull final ConfiguredPrice price) {
+            return this.add(price, 1D);
+        }
+
+        /**
+         * Build into a {@link CombinedDisplayPrice}.
+         *
+         * @return The combined price.
+         */
+        @NotNull
+        public CombinedDisplayPrice build() {
+            Map<ConfiguredPrice, Double> unitPrices = new HashMap<>();
+
+            // Take first configured price at each ID as the format for all prices with that ID.
+            for (MultipliedPrice price : prices) {
+                // Find the base price.
+                ConfiguredPrice base = unitPrices.keySet()
+                        .stream()
+                        .filter(it -> it.getIdentifier().equals(price.price().getIdentifier()))
+                        .findFirst()
+                        .orElse(price.price());
+
+                // Find the multiplier for a value of 1, e.g. a price that's worth 20 will be 0.05.
+                double unitMultiplier = 1 / base.getValue(player);
+
+                double currentMultiplier = unitPrices.getOrDefault(base, 0D);
+                currentMultiplier += unitMultiplier * price.price().getValue(player, price.multiplier());
+                unitPrices.put(base, currentMultiplier);
+            }
+
+            return new CombinedDisplayPrice(player, unitPrices);
+        }
+
+        /**
+         * A price with a multiplier.
+         *
+         * @param price      The price.
+         * @param multiplier The multiplier.
+         */
+        private record MultipliedPrice(
+                @NotNull ConfiguredPrice price,
+                double multiplier
+        ) {
+
+        }
+    }
+
+    /**
+     * Create a new builder for a player.
+     *
+     * @param player The player.
+     * @return The builder.
+     */
+    @NotNull
+    public static Builder builder(@NotNull final Player player) {
+        return new Builder(player);
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/price/ConfiguredPrice.java

@@ -0,0 +1,177 @@
+package com.willfp.eco.core.price;
+
+import com.willfp.eco.core.config.interfaces.Config;
+import com.willfp.eco.core.math.MathContext;
+import com.willfp.eco.core.price.impl.PriceFree;
+import com.willfp.eco.core.serialization.ConfigDeserializer;
+import com.willfp.eco.util.NumberUtils;
+import com.willfp.eco.util.StringUtils;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+/**
+ * A price that can be shown to a player.
+ */
+public final class ConfiguredPrice implements Price {
+    /**
+     * The deserializer.
+     */
+    private static final ConfigDeserializer<ConfiguredPrice> DESERIALIZER = new Deserializer();
+
+    /**
+     * Free.
+     */
+    public static final ConfiguredPrice FREE = new ConfiguredPrice(
+            new PriceFree(),
+            "Free"
+    );
+
+    /**
+     * The price.
+     */
+    private final Price price;
+
+    /**
+     * The format string.
+     */
+    private final String formatString;
+
+    /**
+     * Create a new Configured Price.
+     *
+     * @param price        The price.
+     * @param formatString The format string.
+     */
+    public ConfiguredPrice(@NotNull final Price price,
+                           @NotNull final String formatString) {
+        this.price = price;
+        this.formatString = formatString;
+    }
+
+    @Override
+    public boolean canAfford(@NotNull final Player player,
+                             final double multiplier) {
+        return this.price.canAfford(player, multiplier);
+    }
+
+    @Override
+    public void pay(@NotNull final Player player,
+                    final double multiplier) {
+        this.price.pay(player, multiplier);
+    }
+
+    @Override
+    public void giveTo(@NotNull final Player player,
+                       final double multiplier) {
+        this.price.giveTo(player, multiplier);
+    }
+
+    @Override
+    public double getValue(@NotNull final Player player,
+                           final double multiplier) {
+        return this.price.getValue(player, multiplier);
+    }
+
+    @Override
+    public double getMultiplier(@NotNull final Player player) {
+        return this.price.getMultiplier(player);
+    }
+
+    @Override
+    public void setMultiplier(@NotNull final Player player,
+                              final double multiplier) {
+        this.price.setMultiplier(player, multiplier);
+    }
+
+    @Override
+    public String getIdentifier() {
+        return this.price.getIdentifier();
+    }
+
+    /**
+     * Get the price that this delegates to.
+     *
+     * @return The price.
+     */
+    public Price getPrice() {
+        return price;
+    }
+
+    /**
+     * Get the display string for a player.
+     *
+     * @param player The player.
+     * @return The display string.
+     */
+    public String getDisplay(@NotNull final Player player) {
+        return this.getDisplay(player, 1.0);
+    }
+
+    /**
+     * Get the display string for a player.
+     *
+     * @param player     The player.
+     * @param multiplier The multiplier.
+     * @return The display string.
+     */
+    public String getDisplay(@NotNull final Player player,
+                             final double multiplier) {
+        return StringUtils.format(
+                formatString.replace("%value%", NumberUtils.format(this.getPrice().getValue(player, multiplier))),
+                player,
+                StringUtils.FormatOption.WITH_PLACEHOLDERS
+        );
+    }
+
+    /**
+     * Parse a configured price from config.
+     *
+     * @param config The config.
+     * @return The price, or null if it's invalid.
+     */
+    @Nullable
+    public static ConfiguredPrice create(@NotNull final Config config) {
+        return DESERIALIZER.deserialize(config);
+    }
+
+    /**
+     * Parse a configured price from config.
+     *
+     * @param config The config.
+     * @return The price, or free if invalid.
+     */
+    @NotNull
+    public static ConfiguredPrice createOrFree(@NotNull final Config config) {
+        return Objects.requireNonNullElse(create(config), FREE);
+    }
+
+    /**
+     * The deserializer for {@link ConfiguredPrice}.
+     */
+    private static final class Deserializer implements ConfigDeserializer<ConfiguredPrice> {
+        @Override
+        @Nullable
+        public ConfiguredPrice deserialize(@NotNull final Config config) {
+            if (!(
+                    config.has("value")
+                            && config.has("type")
+                            && config.has("display")
+            )) {
+                return null;
+            }
+
+            String formatString = config.getString("display");
+
+            Price price = Prices.create(
+                    config.getString("value"),
+                    config.getString("type"),
+                    MathContext.of(config)
+            );
+
+            return new ConfiguredPrice(price, formatString);
+        }
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/price/Price.java

@@ -0,0 +1,171 @@
+package com.willfp.eco.core.price;
+
+import org.apache.commons.lang.NotImplementedException;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A price that a player should pay.
+ * <p>
+ * There are important implementation details:
+ * <p>
+ * For backwards compatibility, all methods are default, however you must override the following:
+ * <ul>
+ *     <li><code>canAfford(Player, double)</code></li>
+ *     <li><code>pay(Player, double)</code></li>
+ *     <li><code>giveTo(Player, double)</code></li>
+ *     <li><code>getValue(Player, double)</code></li>
+ *     <li><code>getMultiplier(Player)</code></li>
+ *     <li><code>setMultiplier(Player, double)</code></li>
+ * </ul>
+ * Otherwise, your implementation will throw {@link NotImplementedException}.
+ * <p>
+ * Also, getValue() should always return the value with player multipliers applied.
+ */
+public interface Price {
+    /**
+     * Get if a player can afford to pay the price.
+     *
+     * @param player The player.
+     * @return If the player can afford.
+     */
+    default boolean canAfford(@NotNull final Player player) {
+        return this.canAfford(player, 1);
+    }
+
+    /**
+     * Get if a player can afford to pay x times the price.
+     *
+     * @param player     The player.
+     * @param multiplier The multiplier.
+     * @return If the player can afford.
+     */
+    default boolean canAfford(@NotNull final Player player,
+                              final double multiplier) {
+        throw new NotImplementedException("Override canAfford(Player, double) in your Price implementation!");
+    }
+
+    /**
+     * Make the player pay the price.
+     * <p>
+     * Check canAfford first.
+     *
+     * @param player The player.
+     */
+    default void pay(@NotNull final Player player) {
+        this.pay(player, 1);
+    }
+
+    /**
+     * Make the player pay the price x times.
+     * <p>
+     * Check canAfford first.
+     *
+     * @param player     The player.
+     * @param multiplier The multiplier.
+     */
+    default void pay(@NotNull final Player player,
+                     final double multiplier) {
+        throw new NotImplementedException("Override pay(Player, double) in your Price implementation!");
+    }
+
+    /**
+     * Give the price to the player.
+     *
+     * @param player The player.
+     */
+    default void giveTo(@NotNull final Player player) {
+        this.giveTo(player, 1);
+    }
+
+    /**
+     * Give the price to the player x times.
+     *
+     * @param player     The player.
+     * @param multiplier The multiplier.
+     */
+    default void giveTo(@NotNull final Player player,
+                        final double multiplier) {
+        throw new NotImplementedException("Override giveTo(Player, double) in your Price implementation!");
+    }
+
+    /**
+     * Get the numerical value that backs this price.
+     *
+     * @param player The player.
+     * @return The value.
+     */
+    default double getValue(@NotNull final Player player) {
+        return getValue(player, 1);
+    }
+
+    /**
+     * Get the numeral value that backs this price multiplied x times.
+     *
+     * @param player     The player.
+     * @param multiplier The multiplier.
+     * @return The value.
+     */
+    default double getValue(@NotNull final Player player,
+                            final double multiplier) {
+        throw new NotImplementedException("Override getValue(Player, double) in your Price implementation!");
+    }
+
+    /**
+     * Get the value multiplier for the player.
+     *
+     * @param player The player.
+     * @return The multiplier.
+     */
+    default double getMultiplier(@NotNull final Player player) {
+        return 1;
+    }
+
+    /**
+     * Set the value multiplier for the player.
+     *
+     * @param player     The player.
+     * @param multiplier The multiplier.
+     */
+    default void setMultiplier(@NotNull final Player player,
+                               final double multiplier) {
+        throw new NotImplementedException("Override setMultiplier(Player, double) in your Price implementation!");
+    }
+
+    /**
+     * Get the identifier of this price (as type/instance checks break with delegation,
+     * this is used for combining prices, etc.)
+     * <p>
+     * By default, this uses the class name, but it's good practice to override this.
+     * <p>
+     * It's also good practice to prefix your identifiers with some kind of namespace or
+     * internal ID, in order to prevent conflicts.
+     *
+     * @return The identifier.
+     */
+    default String getIdentifier() {
+        return this.getClass().getName();
+    }
+
+    /**
+     * If the price is backed by a value, get it here.
+     *
+     * @return The value.
+     * @deprecated Use getValue(Player) instead.
+     */
+    @Deprecated(since = "6.45.0", forRemoval = true)
+    default double getValue() {
+        return 0;
+    }
+
+    /**
+     * If the price is backed by a value, set it here.
+     *
+     * @param value The value.
+     * @deprecated Values shouldn't be fixed. This method should never work.
+     */
+    @Deprecated(since = "6.45.0", forRemoval = true)
+    default void setValue(final double value) {
+        // Override when needed.
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/price/PriceFactory.java

@@ -0,0 +1,46 @@
+package com.willfp.eco.core.price;
+
+import com.willfp.eco.core.math.MathContext;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * Create prices.
+ * <p>
+ * You must override one of the create methods.
+ */
+public interface PriceFactory {
+    /**
+     * Get the names (how the price looks in lookup strings).
+     * <p>
+     * For example, for XP Levels this would be 'l', 'xpl', 'levels', etc.
+     *
+     * @return The allowed names.
+     */
+    @NotNull List<String> getNames();
+
+    /**
+     * Create the price.
+     *
+     * @param value The value.
+     * @return The price.
+     */
+    default @NotNull Price create(final double value) {
+        return create(MathContext.EMPTY, (ctx) -> value);
+    }
+
+    /**
+     * Create the price.
+     *
+     * @param baseContext The base MathContext.
+     * @param function    The function to use. Should use {@link MathContext#copyWithPlayer(MathContext, Player)} on calls.
+     * @return The price.
+     */
+    default @NotNull Price create(@NotNull final MathContext baseContext,
+                                  @NotNull final Function<MathContext, Double> function) {
+        return create(function.apply(baseContext));
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/price/Prices.java

@@ -0,0 +1,103 @@
+package com.willfp.eco.core.price;
+
+import com.willfp.eco.core.items.Items;
+import com.willfp.eco.core.items.TestableItem;
+import com.willfp.eco.core.math.MathContext;
+import com.willfp.eco.core.price.impl.PriceEconomy;
+import com.willfp.eco.core.price.impl.PriceFree;
+import com.willfp.eco.core.price.impl.PriceItem;
+import com.willfp.eco.core.recipe.parts.EmptyTestableItem;
+import com.willfp.eco.util.NumberUtils;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+
+/**
+ * Class to manage prices.
+ */
+public final class Prices {
+    /**
+     * All factories.
+     */
+    private static final Map<String, PriceFactory> FACTORIES = new ConcurrentHashMap<>();
+
+    /**
+     * Register a new price factory.
+     *
+     * @param factory The factory.
+     */
+    public static void registerPriceFactory(@NotNull final PriceFactory factory) {
+        for (String name : factory.getNames()) {
+            FACTORIES.put(name.toLowerCase(), factory);
+        }
+    }
+
+    /**
+     * Create price from an expression (representing the value),
+     * and a price name.
+     * <p>
+     * Supports items as price names.
+     *
+     * @param expression The expression for the value.
+     * @param priceName  The price name.
+     * @return The price, or free if invalid.
+     */
+    @NotNull
+    public static Price create(@NotNull final String expression,
+                               @Nullable final String priceName) {
+        return create(expression, priceName, MathContext.EMPTY);
+    }
+
+    /**
+     * Create price from an expression (representing the value),
+     * and a price name. Uses a context to parse the expression.
+     * <p>
+     * Supports items as price names.
+     *
+     * @param expression The expression for the value.
+     * @param priceName  The price name.
+     * @param context    The math context to parse the expression.
+     * @return The price, or free if invalid.
+     */
+    @NotNull
+    public static Price create(@NotNull final String expression,
+                               @Nullable final String priceName,
+                               @NotNull final MathContext context) {
+        Function<MathContext, Double> function = (ctx) -> NumberUtils.evaluateExpression(
+                expression,
+                ctx
+        );
+
+        if (function.apply(context) <= 0) {
+            return new PriceFree();
+        }
+
+        // Default to economy
+        if (priceName == null) {
+            return new PriceEconomy(context, function);
+        }
+
+        // Find price factory
+        PriceFactory factory = FACTORIES.get(priceName);
+
+        // If no price factory, default to item price
+        if (factory == null) {
+            TestableItem item = Items.lookup(priceName);
+
+            if (item instanceof EmptyTestableItem) {
+                return new PriceFree();
+            }
+
+            return new PriceItem(context, function, item);
+        } else {
+            return factory.create(context, function);
+        }
+    }
+
+    private Prices() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/price/impl/PriceEconomy.java

@@ -0,0 +1,93 @@
+package com.willfp.eco.core.price.impl;
+
+import com.willfp.eco.core.integrations.economy.EconomyManager;
+import com.willfp.eco.core.math.MathContext;
+import com.willfp.eco.core.price.Price;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.Function;
+
+/**
+ * Economy-based price (for Vault, Treasury, etc.)
+ */
+public final class PriceEconomy implements Price {
+    /**
+     * The value of the price.
+     */
+    private final Function<MathContext, Double> function;
+
+    /**
+     * The base math context.
+     */
+    private final MathContext baseContext;
+
+    /**
+     * The multipliers.
+     */
+    private final Map<UUID, Double> multipliers = new HashMap<>();
+
+    /**
+     * Create a new economy-based price.
+     *
+     * @param value The value.
+     */
+    public PriceEconomy(final double value) {
+        this(MathContext.EMPTY, ctx -> value);
+    }
+
+    /**
+     * Create a new economy-based price.
+     *
+     * @param baseContext The base context.
+     * @param function    The function.
+     */
+    public PriceEconomy(@NotNull final MathContext baseContext,
+                        @NotNull final Function<MathContext, Double> function) {
+        this.baseContext = baseContext;
+        this.function = function;
+    }
+
+    @Override
+    public boolean canAfford(@NotNull final Player player,
+                             final double multiplier) {
+        return EconomyManager.getBalance(player) >= getValue(player, multiplier);
+    }
+
+    @Override
+    public void pay(@NotNull final Player player,
+                    final double multiplier) {
+        EconomyManager.removeMoney(player, getValue(player, multiplier));
+    }
+
+    @Override
+    public void giveTo(@NotNull final Player player,
+                       final double multiplier) {
+        EconomyManager.giveMoney(player, getValue(player, multiplier));
+    }
+
+    @Override
+    public double getValue(@NotNull final Player player,
+                           final double multiplier) {
+        return this.function.apply(MathContext.copyWithPlayer(baseContext, player)) * getMultiplier(player) * multiplier;
+    }
+
+    @Override
+    public double getMultiplier(@NotNull final Player player) {
+        return this.multipliers.getOrDefault(player.getUniqueId(), 1.0);
+    }
+
+    @Override
+    public void setMultiplier(@NotNull final Player player,
+                              final double multiplier) {
+        this.multipliers.put(player.getUniqueId(), multiplier);
+    }
+
+    @Override
+    public String getIdentifier() {
+        return "eco:economy";
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/price/impl/PriceFree.java

@@ -0,0 +1,57 @@
+package com.willfp.eco.core.price.impl;
+
+import com.willfp.eco.core.price.Price;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Free (default) price.
+ */
+public final class PriceFree implements Price {
+    /**
+     * Create a new free price.
+     */
+    public PriceFree() {
+
+    }
+
+    @Override
+    public boolean canAfford(@NotNull final Player player,
+                             final double multiplier) {
+        return true;
+    }
+
+    @Override
+    public void pay(@NotNull final Player player,
+                    final double multiplier) {
+        // Nothing.
+    }
+
+    @Override
+    public void giveTo(@NotNull final Player player,
+                       final double multiplier) {
+        // Nothing.
+    }
+
+    @Override
+    public double getMultiplier(@NotNull final Player player) {
+        return 1.0;
+    }
+
+    @Override
+    public void setMultiplier(@NotNull final Player player,
+                              final double multiplier) {
+        // Nothing.
+    }
+
+    @Override
+    public double getValue(@NotNull final Player player,
+                           final double multiplier) {
+        return 0;
+    }
+
+    @Override
+    public String getIdentifier() {
+        return "eco:free";
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/price/impl/PriceItem.java

@@ -0,0 +1,160 @@
+package com.willfp.eco.core.price.impl;
+
+import com.willfp.eco.core.drops.DropQueue;
+import com.willfp.eco.core.items.HashedItem;
+import com.willfp.eco.core.items.TestableItem;
+import com.willfp.eco.core.math.MathContext;
+import com.willfp.eco.core.price.Price;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.Function;
+
+/**
+ * Item-based price.
+ */
+public final class PriceItem implements Price {
+    /**
+     * The base MathContext.
+     */
+    private final MathContext baseContext;
+
+    /**
+     * The amount of items.
+     */
+    private final Function<MathContext, Double> function;
+
+    /**
+     * The item.
+     */
+    private final TestableItem item;
+
+    /**
+     * The multipliers.
+     */
+    private final Map<UUID, Double> multipliers = new HashMap<>();
+
+    /**
+     * Create a new item-based price.
+     *
+     * @param amount The amount.
+     * @param item   The item.
+     */
+    public PriceItem(final int amount,
+                     @NotNull final TestableItem item) {
+        this(MathContext.EMPTY, ctx -> (double) amount, item);
+    }
+
+    /**
+     * Create a new item-based price.
+     *
+     * @param baseContext The base MathContext.
+     * @param function    The function to get the amount of items to remove.
+     * @param item        The item.
+     */
+    public PriceItem(@NotNull final MathContext baseContext,
+                     @NotNull final Function<MathContext, Double> function,
+                     @NotNull final TestableItem item) {
+        this.baseContext = baseContext;
+        this.function = function;
+        this.item = item;
+    }
+
+    /**
+     * Get the item.
+     *
+     * @return The item.
+     */
+    public TestableItem getItem() {
+        return item;
+    }
+
+    @Override
+    public boolean canAfford(@NotNull final Player player,
+                             final double multiplier) {
+        int toRemove = (int) getValue(player, multiplier);
+        if (toRemove <= 0) {
+            return true;
+        }
+
+        int count = 0;
+
+        for (ItemStack itemStack : player.getInventory().getContents()) {
+            if (item.matches(itemStack)) {
+                count += itemStack.getAmount();
+            }
+        }
+
+        return count >= toRemove;
+    }
+
+    @Override
+    public void pay(@NotNull final Player player,
+                    final double multiplier) {
+        int toRemove = (int) getValue(player, multiplier);
+        int count = 0;
+
+        for (ItemStack itemStack : player.getInventory().getContents()) {
+            if (count >= toRemove) {
+                break;
+            }
+
+            if (item.matches(itemStack)) {
+                int itemAmount = itemStack.getAmount();
+
+                if (itemAmount > toRemove) {
+                    itemStack.setAmount(itemAmount - toRemove);
+                }
+
+                if (itemAmount <= toRemove) {
+                    itemStack.setAmount(0);
+                    itemStack.setType(Material.AIR);
+                }
+
+                count += itemAmount;
+            }
+        }
+    }
+
+    @Override
+    public void giveTo(@NotNull final Player player,
+                       final double multiplier) {
+        ItemStack itemStack = item.getItem().clone();
+        itemStack.setAmount((int) getValue(player, multiplier));
+
+        new DropQueue(player)
+                .addItem(itemStack)
+                .forceTelekinesis()
+                .push();
+    }
+
+    @Override
+    public double getValue(@NotNull final Player player,
+                           final double multiplier) {
+        return Math.toIntExact(Math.round(
+                this.function.apply(MathContext.copyWithPlayer(baseContext, player))
+                        * getMultiplier(player) * multiplier
+        ));
+    }
+
+    @Override
+    public double getMultiplier(@NotNull final Player player) {
+        return this.multipliers.getOrDefault(player.getUniqueId(), 1.0);
+    }
+
+    @Override
+    public void setMultiplier(@NotNull final Player player,
+                              final double multiplier) {
+        this.multipliers.put(player.getUniqueId(), multiplier);
+    }
+
+    @Override
+    public String getIdentifier() {
+        return "eco:item-" + HashedItem.of(this.item.getItem()).getHash();
+    }
+}

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

@@ -21,7 +21,8 @@ public final class ProxyConstants {
             "v1_17_R1",
             "v1_18_R1",
             "v1_18_R2",
-            "v1_19_R1"
+            "v1_19_R1",
+            "v1_19_R2"
     );
 
     private ProxyConstants() {

eco-api/src/main/java/com/willfp/eco/core/sound/PlayableSound.java

@@ -0,0 +1,101 @@
+package com.willfp.eco.core.sound;
+
+import com.willfp.eco.core.config.interfaces.Config;
+import com.willfp.eco.core.serialization.ConfigDeserializer;
+import org.bukkit.Location;
+import org.bukkit.Sound;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+/**
+ * A sound that can be played at a location.
+ *
+ * @param sound  The sound.
+ * @param pitch  The pitch.
+ * @param volume The volume.
+ */
+public record PlayableSound(@NotNull Sound sound,
+                            double pitch,
+                            double volume) {
+    /**
+     * The deserializer.
+     */
+    private static final ConfigDeserializer<PlayableSound> DESERIALIZER = new Deserializer();
+
+    /**
+     * Create a sound with a default volume.
+     *
+     * @param sound The sound.
+     * @param pitch The pitch.
+     */
+    public PlayableSound(@NotNull final Sound sound,
+                         final double pitch) {
+        this(sound, pitch, 1.0);
+    }
+
+    /**
+     * Play the sound to a player.
+     *
+     * @param player The player.
+     */
+    public void playTo(@NotNull final Player player) {
+        player.playSound(player.getLocation(), sound, (float) volume, (float) pitch);
+    }
+
+    /**
+     * Play the sound at a location.
+     *
+     * @param location The location.
+     */
+    public void playAt(@NotNull final Location location) {
+        World world = location.getWorld();
+
+        if (world == null) {
+            return;
+        }
+
+        world.playSound(location, sound, (float) volume, (float) pitch);
+    }
+
+    /**
+     * Parse a playable sound from config.
+     *
+     * @param config The config.
+     * @return The sound, or null if it's invalid.
+     */
+    @Nullable
+    public static PlayableSound create(@NotNull final Config config) {
+        return DESERIALIZER.deserialize(config);
+    }
+
+    /**
+     * The deserializer for {@link PlayableSound}.
+     */
+    private static final class Deserializer implements ConfigDeserializer<PlayableSound> {
+        @Override
+        public @Nullable PlayableSound deserialize(@NotNull final Config config) {
+            if (!config.has("sound")) {
+                return null;
+            }
+
+            try {
+                Sound sound = Sound.valueOf(config.getString("sound").toUpperCase());
+
+                double pitch = Objects.requireNonNullElse(config.getDoubleOrNull("pitch"), 1.0);
+                double volume = Objects.requireNonNullElse(config.getDoubleOrNull("volume"), 1.0);
+
+                return new PlayableSound(
+                        sound,
+                        pitch,
+                        volume
+                );
+            } catch (IllegalArgumentException e) {
+                return null;
+            }
+        }
+    }
+}

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

@@ -16,6 +16,8 @@ import org.jetbrains.annotations.NotNull;
 /**
  * Utilities / API methods for item durability.
  */
+// Have to suppress casts to ItemMeta because the methods don't exist for some older versions that eco supports.
+@SuppressWarnings("RedundantCast")
 public final class DurabilityUtils {
     /**
      * Damage an item in a player's inventory.

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

@@ -1,8 +1,10 @@
 package com.willfp.eco.util;
 
 import com.willfp.eco.core.Eco;
+import com.willfp.eco.core.integrations.placeholder.PlaceholderManager;
 import com.willfp.eco.core.placeholder.AdditionalPlayer;
 import com.willfp.eco.core.placeholder.InjectablePlaceholder;
+import com.willfp.eco.core.math.MathContext;
 import com.willfp.eco.core.placeholder.PlaceholderInjectable;
 import com.willfp.eco.core.placeholder.StaticPlaceholder;
 import org.bukkit.entity.Player;
@@ -12,7 +14,6 @@ import org.jetbrains.annotations.Nullable;
 import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
@@ -240,7 +241,7 @@ public final class NumberUtils {
      * @return The value of the expression, or zero if invalid.
      */
     public static double evaluateExpression(@NotNull final String expression) {
-        return evaluateExpression(expression, null);
+        return evaluateExpression(expression, MathContext.EMPTY);
     }
 
     /**
@@ -252,18 +253,7 @@ public final class NumberUtils {
      */
     public static double evaluateExpression(@NotNull final String expression,
                                             @Nullable final Player player) {
-        return evaluateExpression(expression, player, new PlaceholderInjectable() {
-            @Override
-            public void clearInjectedPlaceholders() {
-                // Nothing.
-            }
-
-            @Override
-            public @NotNull
-            List<InjectablePlaceholder> getPlaceholderInjections() {
-                return Collections.emptyList();
-            }
-        });
+        return evaluateExpression(expression, player, PlaceholderManager.EMPTY_INJECTABLE);
     }
 
     /**
@@ -323,7 +313,23 @@ public final class NumberUtils {
                                             @Nullable final Player player,
                                             @NotNull final PlaceholderInjectable context,
                                             @NotNull final Collection<AdditionalPlayer> additionalPlayers) {
-        return Eco.get().evaluate(expression, player, context, additionalPlayers);
+        return Eco.get().evaluate(expression, new MathContext(
+                context,
+                player,
+                additionalPlayers
+        ));
+    }
+
+    /**
+     * Evaluate an expression with respect to a player (for placeholders).
+     *
+     * @param expression The expression.
+     * @param context    The math context.
+     * @return The value of the expression, or zero if invalid.
+     */
+    public static double evaluateExpression(@NotNull final String expression,
+                                            @NotNull final MathContext context) {
+        return Eco.get().evaluate(expression, context);
     }
 
     private NumberUtils() {

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

@@ -579,7 +579,7 @@ public final class StringUtils {
      *
      * @param lookup The lookup string.
      * @return An array of tokens to be processed.
-     * @author Shawn (https://stackoverflow.com/questions/70606170/split-a-list-on-spaces-and-group-quoted-characters/70606653#70606653)
+     * @author Shawn (<a href="https://stackoverflow.com/questions/70606170/split-a-list-on-spaces-and-group-quoted-characters/70606653#70606653">...</a>)
      */
     @NotNull
     public static String[] parseTokens(@NotNull final String lookup) {

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

@@ -4,9 +4,14 @@ 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.NotificationException
 import com.willfp.eco.core.command.impl.PluginCommand
 import com.willfp.eco.core.command.impl.Subcommand
+import org.bukkit.Bukkit
+import org.bukkit.OfflinePlayer
 import org.bukkit.command.CommandSender
+import org.bukkit.entity.Player
+import java.util.function.Predicate
 
 /**
  * Helper class for creating commands with builders.
@@ -140,3 +145,92 @@ fun CommandBase.addSubcommand(
     init(command)
     return command
 }
+
+/**
+ * Throws an exception containing a langYml key if obj is null.
+ * <p>The {@link CommandBase#onExecute(CommandSender, List) onExecute } in PluginCommand and Subcommand
+ * automatically handles sending the message to the sender.</p>
+ * <br>
+ * @param key key of notification message in langYml
+ * @return Returns the object given or throws an exception
+ * @throws NotificationException exception thrown when null
+ */
+fun <T> T.notifyNull(key: String): T {
+    return this ?: throw NotificationException(key)
+}
+
+/**
+ * Throws an exception containing a langYml key if predicate tests false
+ * <p>The {@link CommandBase#onExecute(CommandSender, List) onExecute } in PluginCommand and Subcommand
+ * automatically handles sending the message to the sender.</p>
+ * <br>
+ * @param predicate predicate to test
+ * @param key       key of notification message in langYml
+ * @param <T>       the generic type of object
+ * @return Returns the object given or throws an exception
+ */
+fun <T> T.notifyFalse(predicate: Predicate<T>, key: String): T {
+    predicate.test(this).notifyFalse(key)
+    return this
+}
+
+/**
+ * Throws an exception containing a langYml key if condition is false.
+ * <p>The {@link CommandBase#onExecute(CommandSender, List) onExecute } in PluginCommand and Subcommand
+ * automatically handles sending the message to the sender.</p>
+ * <br>
+ * @param key       value in the langYml
+ * @return Returns the condition given or throws an exception
+ * @throws NotificationException exception thrown when false
+ */
+fun Boolean?.notifyFalse(key: String): Boolean {
+    return if (this == true) true else throw NotificationException(key)
+}
+
+/**
+ * Throws an exception containing a langYml key if Bukkit.getPlayer(playerName) is null.
+ * <p>The {@link CommandBase#onExecute(CommandSender, List) onExecute } in PluginCommand and Subcommand
+ * automatically handles sending the message to the sender.</p>
+ * <br>
+ * @param key        value in the langYml
+ * @return Returns the player
+ * @throws NotificationException exception thrown when invalid playerName
+ */
+fun String?.notifyPlayerRequired(key: String): Player {
+    return Bukkit.getPlayer(this ?: "") ?: throw NotificationException(key)
+}
+
+/**
+ * Throws an exception containing a langYml key if Bukkit.getPlayer(playerName) is null.
+ * <p>The {@link CommandBase#onExecute(CommandSender, List) onExecute } in PluginCommand and Subcommand
+ * automatically handles sending the message to the sender.</p>
+ * <br>
+ * @param key        value in the langYml
+ * @return Returns the player
+ * @throws NotificationException exception thrown when invalid playerName
+ */
+fun String?.notifyOfflinePlayerRequired(key: String): OfflinePlayer {
+    @Suppress("DEPRECATION")
+    val player = Bukkit.getOfflinePlayer(this ?: "")
+
+    if (!player.hasPlayedBefore() && !player.isOnline) {
+        throw NotificationException(key)
+    }
+
+    return player
+}
+
+/**
+ * Throws an exception containing a langYml key if player doesn't have permission.
+ * <p>The {@link CommandBase#onExecute(CommandSender, List) onExecute } in PluginCommand and Subcommand
+ * automatically handles sending the message to the sender.</p>
+ * <br>
+ * @param permission the permission
+ * @param key        value in the langYml
+ * @return Returns the player
+ * @throws NotificationException exception thrown when player doesn't have permission
+ */
+fun Player?.notifyPermissionRequired(permission: String, key: String): Player {
+    this ?: throw NotificationException(key)
+    return this.notifyFalse({ this.hasPermission(permission) }, key)
+}

eco-api/src/main/kotlin/com/willfp/eco/core/config/ConfigHelpers.kt

@@ -3,9 +3,12 @@
 package com.willfp.eco.core.config
 
 import com.willfp.eco.core.config.interfaces.Config
+import org.bukkit.configuration.ConfigurationSection
+import java.io.File
+import java.io.InputStream
 
 /** Helper class to create configs with a kotlin DSL. */
-class DSLConfig internal constructor(type: ConfigType) : TransientConfig(emptyMap(), type) {
+class DSLConfig internal constructor(type: ConfigType) : GenericConfig(type) {
     /**
      * Map a key to a value.
      *
@@ -34,3 +37,30 @@ class DSLConfig internal constructor(type: ConfigType) : TransientConfig(emptyMa
  */
 fun config(type: ConfigType = ConfigType.YAML, builder: DSLConfig.() -> Unit): Config =
     DSLConfig(type).apply(builder)
+
+/** @see Configs.empty */
+fun emptyConfig() = Configs.empty()
+
+/** @see Configs.empty */
+fun emptyConfig(type: ConfigType) = Configs.empty(type)
+
+/** @see Configs.fromBukkit */
+fun ConfigurationSection?.toConfig() = Configs.fromBukkit(this)
+
+/** @see Configs.fromStream */
+fun InputStream?.readConfig() = Configs.fromStream(this)
+
+/** @see Configs.fromFile */
+fun File?.readConfig() = Configs.fromFile(this)
+
+/** @see Configs.fromFile */
+fun File?.readConfig(type: ConfigType) = Configs.fromFile(this, type)
+
+/** @see Configs.fromMap */
+fun Map<String?, Any?>.toConfig() = Configs.fromMap(this)
+
+/** @see Configs.fromMap */
+fun Map<String?, Any?>.toConfig(type: ConfigType) = Configs.fromMap(this, type)
+
+/** @see Configs.fromString */
+fun readConfig(contents: String, type: ConfigType) = Configs.fromString(contents, type)

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

@@ -4,9 +4,9 @@ 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.menu.MenuType
 import com.willfp.eco.core.gui.menu.MenuEvent
 import com.willfp.eco.core.gui.menu.MenuEventHandler
+import com.willfp.eco.core.gui.menu.MenuType
 import com.willfp.eco.core.gui.page.Page
 import com.willfp.eco.core.gui.page.PageBuilder
 import com.willfp.eco.core.gui.slot.Slot
@@ -74,12 +74,15 @@ fun SlotBuilder.onClick(clickType: ClickType, action: (Player, InventoryClickEve
 fun SlotBuilder.notCaptiveFor(test: (Player) -> Boolean): SlotBuilder =
     this.notCaptiveFor { test(it) }
 
+/** @see SlotBuilder.setCaptiveFilter */
+fun SlotBuilder.setCaptiveFilter(test: (Player, Menu, ItemStack?) -> Boolean): SlotBuilder =
+    this.setCaptiveFilter { a, b, c -> test(a, b, c) }
+
 /**
  * @see SlotBuilder.setModifier
  * @deprecated Use SlotUpdater instead.
  */
 @Deprecated("Use SlotUpdater instead")
-@Suppress("DEPRECATION")
 fun SlotBuilder.setModifier(action: (Player, Menu, item: ItemStack) -> Unit): SlotBuilder =
     this.setUpdater { a, b, c -> c.apply { action(a, b, c) } }
 
@@ -184,6 +187,10 @@ inline fun <reified T : MenuEvent> MenuBuilder.onEvent(crossinline handler: (Pla
     })
 }
 
+/** @see MenuBuilder.onBuild */
+fun MenuBuilder.onBuild(action: (Menu) -> Unit): MenuBuilder =
+    this.onBuild { action(it) }
+
 /** Kotlin builder for menus. */
 fun menu(
     rows: Int,

eco-api/src/main/kotlin/com/willfp/eco/core/integrations/shop/ShopHelpers.kt

@@ -2,13 +2,31 @@
 
 package com.willfp.eco.core.integrations.shop
 
+import com.willfp.eco.core.price.Price
 import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
 
-/** @see ShopManager.getItemPrice **/
+/** @see ShopManager.getItemPrice * */
+@Deprecated(
+    "Prices depend on players, this will always return 0.",
+    level = DeprecationLevel.ERROR,
+    replaceWith = ReplaceWith("this.getValue(player)")
+)
 val ItemStack.price: Double
-    get() = ShopManager.getItemPrice(this)
+    get() = 0.0
 
-/** @see ShopManager.getItemPrice **/
+/** @see ShopManager.getItemPrice * */
+@Deprecated(
+    "Use the price system instead, prices may not be currencies.",
+    ReplaceWith("this.getValue(player)"),
+)
 fun ItemStack.getPrice(player: Player): Double =
-    ShopManager.getItemPrice(this, player)
+    this.getUnitValue(player).getValue(player, this.amount.toDouble())
+
+/** @see ShopManager.getUnitValue */
+fun ItemStack.getUnitValue(player: Player): Price =
+    ShopManager.getUnitValue(this, player)
+
+/** @see ShopManager.isSellable */
+fun ItemStack?.isSellable(player: Player): Boolean =
+    ShopManager.isSellable(this, player)

eco-api/src/main/kotlin/com/willfp/eco/core/items/builder/ItemBuilderHelpers.kt

@@ -0,0 +1,14 @@
+@file:JvmName("ItemBuilderExtensions")
+
+package com.willfp.eco.core.items.builder
+
+import com.willfp.eco.core.items.TestableItem
+import org.bukkit.inventory.ItemStack
+
+/** Modify an item with a builder. */
+fun TestableItem.modify(builder: ItemBuilder.() -> Unit): ItemStack =
+    this.item.modify(builder)
+
+/** Modify an item with a builder. */
+fun ItemStack.modify(builder: ItemBuilder.() -> Unit): ItemStack =
+    ItemStackBuilder(this).apply(builder).build()

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

@@ -0,0 +1,7 @@
+@file:JvmName("TestableExtensions")
+
+package com.willfp.eco.core.lookup
+
+/** @see Testable.matches */
+fun <T> T?.matches(test: Testable<T>) =
+    test.matches(this)

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

@@ -2,8 +2,8 @@ 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
+import com.willfp.eco.core.config.readConfig
 
 object EcoPropsParser : PluginProps.PropsParser<Config> {
     override fun parseFrom(config: Config): PluginProps {
@@ -28,7 +28,7 @@ object EcoPropsParser : PluginProps.PropsParser<Config> {
         }
 
         return PluginProps.parse(
-            TransientConfig(plugin.getResourceAsStream("/eco.yml")),
+            plugin.getResourceAsStream("/eco.yml").readConfig(),
             Config::class.java
         )
     }

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

@@ -0,0 +1,28 @@
+package com.willfp.eco.internal.command
+
+import org.bukkit.command.Command
+import org.bukkit.command.CommandSender
+import org.bukkit.command.PluginIdentifiableCommand
+import org.bukkit.command.TabCompleter
+
+class DelegatedBukkitCommand(
+    private val delegate: EcoPluginCommand
+) : Command(delegate.name), TabCompleter, PluginIdentifiableCommand {
+    override fun execute(sender: CommandSender, label: String, args: Array<out String>?): Boolean {
+        return false
+    }
+
+    override fun onTabComplete(
+        sender: CommandSender,
+        command: Command,
+        label: String,
+        args: Array<out String>?
+    ): List<String> {
+        return mutableListOf() // Mutable in case bukkit requires this (I haven't checked.)
+    }
+
+    override fun getPlugin() = delegate.plugin
+    override fun getPermission() = delegate.permission
+    override fun getDescription() = delegate.description ?: ""
+    override fun getAliases(): List<String> = delegate.aliases
+}

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

@@ -0,0 +1,52 @@
+package com.willfp.eco.internal.command
+
+import com.willfp.eco.core.Eco
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.command.CommandBase
+import com.willfp.eco.core.command.PluginCommandBase
+import org.bukkit.Bukkit
+
+class EcoPluginCommand(
+    parentDelegate: CommandBase,
+    plugin: EcoPlugin,
+    name: String,
+    permission: String,
+    playersOnly: Boolean
+) : HandledCommand(parentDelegate, plugin, name, permission, playersOnly),
+    PluginCommandBase {
+    override fun register() {
+        val command = Bukkit.getPluginCommand(name)
+
+        if (command == null) {
+            unregister()
+
+            commandMap.register(plugin.name.lowercase(), DelegatedBukkitCommand(this))
+        } else {
+            command.setExecutor(this)
+
+
+            description?.let {
+                command.setDescription(it)
+            }
+
+            if (aliases.isNotEmpty()) {
+                command.aliases = aliases
+            }
+        }
+    }
+
+    override fun unregister() {
+        val found = commandMap.getCommand(name)
+        found?.unregister(commandMap)
+
+        Eco.get().syncCommands()
+    }
+}
+
+class EcoSubcommand(
+    parentDelegate: CommandBase,
+    plugin: EcoPlugin,
+    name: String,
+    permission: String,
+    playersOnly: Boolean
+) : HandledCommand(parentDelegate, plugin, name, permission, playersOnly)

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

@@ -0,0 +1,183 @@
+package com.willfp.eco.internal.command
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.command.CommandBase
+import com.willfp.eco.core.command.NotificationException
+import com.willfp.eco.core.config.base.LangYml
+import org.bukkit.Bukkit
+import org.bukkit.command.Command
+import org.bukkit.command.CommandExecutor
+import org.bukkit.command.CommandMap
+import org.bukkit.command.CommandSender
+import org.bukkit.command.TabCompleter
+import org.bukkit.entity.Player
+import org.bukkit.util.StringUtil
+
+/**
+ * Abstract class for commands that can be handled.
+ * <p>
+ * Handled commands have a method to pass in raw input from bukkit commands
+ * in order to execute the command-specific code.
+ */
+abstract class HandledCommand(
+    private val parentDelegate: CommandBase,
+    private val plugin: EcoPlugin,
+    private val name: String,
+    private val permission: String,
+    private val playersOnly: Boolean
+) : CommandBase, CommandExecutor, TabCompleter {
+    private val subcommands = mutableListOf<CommandBase>()
+
+    override fun onCommand(
+        sender: CommandSender,
+        command: Command,
+        label: String,
+        args: Array<out String>?
+    ): Boolean {
+        if (!command.name.equals(name, true)) {
+            return false
+        }
+
+        if (args != null) {
+            handleExecution(sender, args.toList())
+        }
+
+        return true
+    }
+
+    override fun onTabComplete(
+        sender: CommandSender,
+        command: Command,
+        label: String,
+        args: Array<out String>?
+    ): MutableList<String>? {
+        return handleTabComplete(sender, args?.toList() ?: listOf()).toMutableList()
+    }
+
+    override fun getPlugin() = this.plugin
+
+    override fun getName() = this.name
+
+    override fun getPermission() = this.permission
+
+    override fun isPlayersOnly() = this.playersOnly
+
+    override fun getSubcommands() = this.subcommands
+
+    override fun getWrapped() = this.parentDelegate
+
+    override fun addSubcommand(command: CommandBase): CommandBase {
+        subcommands.add(command)
+        return this
+    }
+
+    override fun onExecute(sender: CommandSender, args: List<String>) = parentDelegate.onExecute(sender, args)
+
+    override fun onExecute(sender: Player, args: List<String>) = parentDelegate.onExecute(sender, args)
+
+    override fun tabComplete(sender: CommandSender, args: List<String>): List<String> =
+        parentDelegate.tabComplete(sender, args)
+
+    override fun tabComplete(sender: Player, args: List<String>): List<String> =
+        parentDelegate.tabComplete(sender, args)
+
+    /**
+     * Handle the command.
+     *
+     * @param sender The sender.
+     * @param args   The arguments.
+     */
+    private fun CommandBase.handleExecution(sender: CommandSender, args: List<String>) {
+        if (!sender.canExecute(this, plugin)) {
+            return
+        }
+
+        if (args.isNotEmpty()) {
+            for (subcommand in subcommands) {
+                if (subcommand.name.equals(args[0], true)) {
+                    if (!sender.canExecute(subcommand, plugin)) {
+                        return
+                    }
+
+                    subcommand.handleExecution(sender, args.subList(1, args.size))
+                    return
+                }
+            }
+        }
+
+        try {
+            notifyFalse(!isPlayersOnly || sender is Player, LangYml.KEY_NOT_PLAYER)
+
+            onExecute(sender, args)
+
+            if (sender is Player) {
+                onExecute(sender, args)
+            }
+        } catch (e: NotificationException) {
+            sender.sendMessage(plugin.langYml.getMessage(e.key))
+            return
+        }
+    }
+
+    /**
+     * Handle the tab completion.
+     *
+     * @param sender The sender.
+     * @param args   The arguments.
+     * @return The tab completion results.
+     */
+    private fun CommandBase.handleTabComplete(sender: CommandSender, args: List<String>): List<String> {
+        if (!sender.hasPermission(permission)) return emptyList()
+
+        if (args.size == 1) {
+            val completions = subcommands.filter { sender.hasPermission(it.permission) }.map { it.name }
+
+            val list = mutableListOf<String>()
+
+            StringUtil.copyPartialMatches(args[0], completions, list)
+            if (completions.isNotEmpty()) {
+                return completions
+            }
+        }
+
+        if (args.size >= 2) {
+            val matchingCommand =
+                subcommands.firstOrNull {
+                    sender.hasPermission(it.permission) && it.name.equals(args[0], true)
+                }
+            if (matchingCommand != null) {
+                val completions = matchingCommand.handleTabComplete(sender, args.subList(1, args.size)).toMutableList()
+
+                if (sender is Player) {
+                    completions.addAll(matchingCommand.handleTabComplete(sender, args.subList(1, args.size)))
+                }
+
+                return completions
+            }
+        }
+
+        val completions = tabComplete(sender, args).toMutableList()
+        if (sender is Player) {
+            completions.addAll(tabComplete(sender, args))
+        }
+        return completions.sorted()
+    }
+}
+
+val commandMap: CommandMap
+    get() = try {
+        val fCommandMap = Bukkit.getServer().javaClass.getDeclaredField("commandMap")
+        fCommandMap.trySetAccessible()
+        fCommandMap.get(Bukkit.getServer()) as CommandMap
+    } catch (e: Exception) {
+        throw NullPointerException("Command map wasn't found!")
+    }
+
+fun CommandSender.canExecute(command: CommandBase, plugin: EcoPlugin): Boolean {
+    if (!this.hasPermission(command.permission) && this is Player) {
+        this.sendMessage(plugin.langYml.noPermission)
+        return false
+    }
+
+    return true
+}

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

@@ -77,7 +77,7 @@ private abstract class ConfigTypeHandler(
     val type: ConfigType
 ) {
     fun toMap(input: String?): Map<String, Any?> {
-        if (input == null || input.isBlank()) {
+        if (input.isNullOrBlank()) {
             return emptyMap()
         }
 

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

@@ -108,7 +108,7 @@ open class EcoConfig(
     }
 
     override fun getSubsectionsOrNull(path: String): List<Config>? {
-        return (get(path) as? Iterable<Config>)
+        return getList<Config>(path)
             ?.map { it.apply { this.addInjectablePlaceholder(injections) } }
             ?.toList()
     }
@@ -122,7 +122,7 @@ open class EcoConfig(
     }
 
     override fun getIntsOrNull(path: String): List<Int>? {
-        return (get(path) as? Iterable<Number>)?.map { it.toInt() }
+        return getList<Number>(path)?.map { it.toInt() }
     }
 
     override fun getBoolOrNull(path: String): Boolean? {
@@ -130,7 +130,7 @@ open class EcoConfig(
     }
 
     override fun getBoolsOrNull(path: String): List<Boolean>? {
-        return (get(path) as? Iterable<Boolean>)?.toList()
+        return getList<Boolean>(path)?.toList()
     }
 
     override fun getStringOrNull(
@@ -154,7 +154,7 @@ open class EcoConfig(
         format: Boolean,
         option: StringUtils.FormatOption
     ): List<String>? {
-        val strings = (get(path) as? Iterable<*>)
+        val strings = getList<Any?>(path)
             ?.map { it?.toString() ?: "" }
             ?.toMutableList() ?: return null
         if (placeholderInjections.isNotEmpty() && format && option == StringUtils.FormatOption.WITH_PLACEHOLDERS) {
@@ -176,7 +176,7 @@ open class EcoConfig(
     }
 
     override fun getDoublesOrNull(path: String): List<Double>? {
-        return (get(path) as? Iterable<Number>)?.map { it.toDouble() }
+        return getList<Number>(path)?.map { it.toDouble() }
     }
 
     override fun addInjectablePlaceholder(placeholders: Iterable<InjectablePlaceholder>) {
@@ -215,4 +215,15 @@ open class EcoConfig(
     override fun toString(): String {
         return this.toPlaintext()
     }
+
+    private inline fun <reified T> getList(path: String): List<T>? {
+        val asIterable = get(path) as? Iterable<*> ?: return null
+        val asList = asIterable.toList()
+
+        if (asList.firstOrNull() !is T?) {
+            return emptyList()
+        }
+
+        return asList as List<T>
+    }
 }

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

@@ -3,7 +3,6 @@ package com.willfp.eco.internal.config
 import com.willfp.eco.core.config.ConfigType
 import com.willfp.eco.core.placeholder.InjectablePlaceholder
 
-@Suppress("UNCHECKED_CAST")
 class EcoConfigSection(
     type: ConfigType,
     values: Map<String, Any?> = emptyMap(),

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

@@ -3,7 +3,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.config.toConfig
 import com.willfp.eco.core.extensions.Extension
 import com.willfp.eco.core.extensions.ExtensionLoader
 import com.willfp.eco.core.extensions.ExtensionMetadata
@@ -48,7 +48,7 @@ class EcoExtensionLoader(
         val ymlIn = classLoader.getResourceAsStream("extension.yml")
             ?: throw MalformedExtensionException("No extension.yml found in " + extensionJar.name)
 
-        val extensionYml = TransientConfig(YamlConfiguration.loadConfiguration(InputStreamReader(ymlIn)))
+        val extensionYml = YamlConfiguration.loadConfiguration(InputStreamReader(ymlIn)).toConfig()
 
         val mainClass = extensionYml.getStringOrNull("main")
         var name = extensionYml.getStringOrNull("name")

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

@@ -3,6 +3,7 @@ package com.willfp.eco.internal.gui
 import com.willfp.eco.core.gui.menu.Menu
 import org.bukkit.entity.Player
 
+// To check in the future, I'm not sure if this is necessary functionality at all.
 class MergedStateMenu(
     private val base: Menu,
     private val additional: Menu
@@ -11,8 +12,8 @@ class MergedStateMenu(
         return base.getState(player) + additional.getState(player)
     }
 
-    override fun addState(player: Player, key: String, value: Any?) {
-        base.addState(player, key, value)
+    override fun setState(player: Player, key: String, value: Any?) {
+        base.setState(player, key, value)
     }
 
     override fun clearState(player: Player) {

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

@@ -39,7 +39,7 @@ class EcoMenu(
     override fun getSlot(row: Int, column: Int): Slot =
         getPossiblyReactiveSlot(row, column, null)
 
-    override fun getSlot(row: Int, column: Int, player: Player, menu: Menu): Slot =
+    override fun getSlot(row: Int, column: Int, player: Player): Slot =
         getPossiblyReactiveSlot(row, column, player)
 
     override fun open(player: Player): Inventory {
@@ -110,7 +110,7 @@ class EcoMenu(
         this.handle(player, this@EcoMenu, event as T)
     }
 
-    override fun addState(player: Player, key: String, value: Any?) {
+    override fun setState(player: Player, key: String, value: Any?) {
         val inventory = player.renderedInventory ?: return
         inventory.state[key] = value
     }

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

@@ -22,6 +22,7 @@ class EcoMenuBuilder(
     private val onOpen = mutableListOf<OpenHandler>()
     private val onRender = mutableListOf<(Player, Menu) -> Unit>()
     private val menuEventHandlers = mutableListOf<MenuEventHandler<*>>()
+    private val onBuild = mutableListOf<(Menu) -> Unit>()
     private var allowsChangingHeldItem = false
 
     override fun getRows() = rows
@@ -80,6 +81,11 @@ class EcoMenuBuilder(
         return this
     }
 
+    override fun onBuild(action: Consumer<Menu>): MenuBuilder {
+        onBuild += { action.accept(it) }
+        return this
+    }
+
     override fun allowChangingHeldItem(): MenuBuilder {
         allowsChangingHeldItem = true
         return this
@@ -122,7 +128,7 @@ class EcoMenuBuilder(
             }
         }
 
-        return EcoMenu(
+        val menu = EcoMenu(
             rows,
             columns,
             layeredComponents,
@@ -133,5 +139,9 @@ class EcoMenuBuilder(
             menuEventHandlers,
             allowsChangingHeldItem
         )
+
+        onBuild.forEach { it(menu) } // Run on build functions.
+
+        return menu
     }
 }

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

@@ -1,8 +1,10 @@
 package com.willfp.eco.internal.gui.menu
 
+import com.willfp.eco.core.gui.menu.events.CaptiveItemChangeEvent
 import com.willfp.eco.core.items.isEmpty
 import com.willfp.eco.core.recipe.parts.EmptyTestableItem
 import com.willfp.eco.util.MenuUtils
+import com.willfp.eco.util.openMenu
 import org.bukkit.entity.Player
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.ItemStack
@@ -31,14 +33,22 @@ class RenderedInventory(
     val state = mutableMapOf<String, Any?>()
 
     fun render() {
-        captiveItems.clear()
+        // This can happen when opening menus from other menus,
+        // fixing a bug where multiple paginated menus on top of
+        // each other caused bugs with page changer display.
+        if (this.menu != player.openMenu) {
+            MenuHandler.unregisterInventory(this.inventory)
+            return
+        }
+
+        val newCaptive = mutableMapOf<GUIPosition, ItemStack>()
 
         for (row in (1..menu.rows)) {
             for (column in (1..menu.columns)) {
                 val position = GUIPosition(row, column)
                 val bukkit = MenuUtils.rowColumnToSlot(row, column, menu.columns)
 
-                val slot = menu.getSlot(row, column, player, menu)
+                val slot = menu.getSlot(row, column, player)
                 val renderedItem = slot.getItemStack(player)
 
                 if (slot.isCaptive(player, menu)) {
@@ -46,11 +56,11 @@ class RenderedInventory(
 
                     if (slot.isCaptiveFromEmpty) {
                         if (!actualItem.isEmpty) {
-                            captiveItems[position] = actualItem
+                            newCaptive[position] = actualItem
                         }
                     } else {
                         if (actualItem != renderedItem && !EmptyTestableItem().matches(actualItem)) {
-                            captiveItems[position] = actualItem
+                            newCaptive[position] = actualItem
                         }
                     }
                 } else {
@@ -59,15 +69,51 @@ class RenderedInventory(
             }
         }
 
+        val previousCaptive = captiveItems.toMap()
+        captiveItems.clear()
+        captiveItems.putAll(newCaptive)
+
+        // Call captive item change event
+        for (position in previousCaptive.keys union newCaptive.keys) {
+            if (previousCaptive[position] != newCaptive[position]) {
+                menu.callEvent(
+                    player, CaptiveItemChangeEvent(
+                        position.row,
+                        position.column,
+                        previousCaptive[position],
+                        newCaptive[position]
+                    )
+                )
+            }
+        }
+
         menu.runOnRender(player)
+
+        // Run second render if captive items changed
+        if (captiveItems != previousCaptive) {
+            for (row in (1..menu.rows)) {
+                for (column in (1..menu.columns)) {
+                    val bukkit = MenuUtils.rowColumnToSlot(row, column, menu.columns)
+
+                    val slot = menu.getSlot(row, column, player)
+                    val renderedItem = slot.getItemStack(player)
+
+                    if (!slot.isCaptive(player, menu)) {
+                        inventory.setItem(bukkit, renderedItem)
+                    }
+                }
+            }
+        }
     }
 
     fun renderDefaultCaptiveItems() {
+        menu.runOnRender(player)
+
         for (row in (1..menu.rows)) {
             for (column in (1..menu.columns)) {
                 val bukkit = MenuUtils.rowColumnToSlot(row, column, menu.columns)
 
-                val slot = menu.getSlot(row, column, player, menu)
+                val slot = menu.getSlot(row, column, player)
 
                 if (slot.isCaptive(player, menu)) {
                     inventory.setItem(bukkit, slot.getItemStack(player))

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

@@ -1,20 +1,24 @@
 package com.willfp.eco.internal.gui.slot
 
 import com.willfp.eco.core.gui.menu.Menu
+import com.willfp.eco.core.gui.slot.functional.CaptiveFilter
 import com.willfp.eco.core.gui.slot.functional.SlotHandler
 import com.willfp.eco.core.gui.slot.functional.SlotProvider
 import com.willfp.eco.util.toSingletonList
+import org.bukkit.Material
 import org.bukkit.entity.Player
 import org.bukkit.event.inventory.ClickType
+import org.bukkit.inventory.ItemStack
 
 class EcoCaptiveSlot(
     provider: SlotProvider,
     private val captiveFromEmpty: Boolean,
-    private val notCaptiveFor: (Player) -> Boolean
+    private val notCaptiveFor: (Player) -> Boolean,
+    private val filter: CaptiveFilter
 ) : EcoSlot(
     provider,
     ClickType.values().associateWith {
-        captiveWithTest(notCaptiveFor).toSingletonList()
+        captiveWithTest(notCaptiveFor, filter).toSingletonList()
     },
     { _, _, prev -> prev }
 ) {
@@ -22,13 +26,25 @@ class EcoCaptiveSlot(
         return !notCaptiveFor(player)
     }
 
+    override fun isAllowedCaptive(player: Player, menu: Menu, itemStack: ItemStack?): Boolean {
+        return filter.isAllowed(player, menu, itemStack)
+    }
+
     override fun isCaptiveFromEmpty(): Boolean {
         return captiveFromEmpty
     }
 }
 
-private fun captiveWithTest(test: (Player) -> Boolean): SlotHandler {
-    return SlotHandler { event, _, _ ->
-        event.isCancelled = test(event.whoClicked as Player)
-    }
+private fun captiveWithTest(
+    notCaptiveFor: (Player) -> Boolean,
+    filter: CaptiveFilter
+): SlotHandler = SlotHandler { event, _, menu ->
+    val player = event.whoClicked as Player
+
+    val item = event.currentItem.nullIfAir() ?: event.cursor.nullIfAir()
+
+    event.isCancelled = !filter.isAllowed(player, menu, item) || notCaptiveFor(player)
 }
+
+private fun ItemStack?.nullIfAir(): ItemStack? =
+    if (this?.type == Material.AIR) null else this

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

@@ -33,9 +33,5 @@ open class EcoSlot(
         return updater.update(player, menu, base) ?: return ItemStack(Material.AIR)
     }
 
-    override fun isCaptive(player: Player, menu: Menu): Boolean {
-        return false
-    }
-
     override fun getActionableSlot(player: Player, menu: Menu): EcoSlot = this
 }

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

@@ -2,6 +2,7 @@ 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.CaptiveFilter
 import com.willfp.eco.core.gui.slot.functional.SlotHandler
 import com.willfp.eco.core.gui.slot.functional.SlotProvider
 import com.willfp.eco.core.gui.slot.functional.SlotUpdater
@@ -16,7 +17,9 @@ class EcoSlotBuilder(private val provider: SlotProvider) : SlotBuilder {
 
     private val handlers = mutableMapOf<ClickType, MutableList<SlotHandler>>()
 
-    private var notCaptiveFor: (Player) -> Boolean = { false }
+    private var captiveFilter =
+        CaptiveFilter { _, _, _ -> true }
+    private var notCaptiveFor: (Player) -> Boolean = { _ -> false}
 
     override fun onClick(type: ClickType, action: SlotHandler): SlotBuilder {
         handlers.computeIfAbsent(type) { mutableListOf() } += action
@@ -24,7 +27,12 @@ class EcoSlotBuilder(private val provider: SlotProvider) : SlotBuilder {
     }
 
     override fun notCaptiveFor(predicate: Predicate<Player>): SlotBuilder {
-        notCaptiveFor = { predicate.test(it) }
+        notCaptiveFor = { player -> predicate.test(player) }
+        return this
+    }
+
+    override fun setCaptiveFilter(filter: CaptiveFilter): SlotBuilder {
+        captiveFilter = filter
         return this
     }
 
@@ -44,7 +52,8 @@ class EcoSlotBuilder(private val provider: SlotProvider) : SlotBuilder {
             EcoCaptiveSlot(
                 provider,
                 captiveFromEmpty,
-                notCaptiveFor
+                notCaptiveFor,
+                captiveFilter
             )
         } else {
             EcoSlot(

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

@@ -1,13 +1,15 @@
 package com.willfp.eco.internal.integrations
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.integrations.placeholder.PlaceholderIntegration
 import com.willfp.eco.core.integrations.placeholder.PlaceholderManager
-import me.clip.placeholderapi.PlaceholderAPI
 import me.clip.placeholderapi.expansion.PlaceholderExpansion
 import org.bukkit.entity.Player
 
-class PlaceholderIntegrationPAPI(private val plugin: EcoPlugin) : PlaceholderExpansion(), PlaceholderIntegration {
+class PAPIExpansion(private val plugin: EcoPlugin) : PlaceholderExpansion() {
+    init {
+        register()
+    }
+
     override fun persist(): Boolean {
         return true
     }
@@ -34,29 +36,4 @@ class PlaceholderIntegrationPAPI(private val plugin: EcoPlugin) : PlaceholderExp
     ): String {
         return PlaceholderManager.getResult(player, identifier, plugin)
     }
-
-    override fun registerIntegration() {
-        register()
-    }
-
-    override fun getPluginName(): String {
-        return "PlaceholderAPI"
-    }
-
-    override fun translate(
-        text: String,
-        player: Player?
-    ): String {
-        return PlaceholderAPI.setPlaceholders(player, text)
-    }
-
-    override fun findPlaceholdersIn(text: String): MutableList<String> {
-        val placeholders = mutableListOf<String>()
-        val matcher = PlaceholderAPI.getPlaceholderPattern().matcher(text)
-        while (matcher.find()) {
-            placeholders.add(matcher.group())
-        }
-
-        return placeholders
-    }
 }

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

@@ -27,6 +27,10 @@ object ArgParserCustomModelData : LookupArgParser {
         return Predicate {
             val testMeta = it.itemMeta ?: return@Predicate false
 
+            if (!testMeta.hasCustomModelData()) {
+                return@Predicate false
+            }
+
             testMeta.customModelData == modelData
         }
     }

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

@@ -21,7 +21,8 @@ object ArgParserName : LookupArgParser {
 
         val formatted = StringUtils.format(name)
 
-        @Suppress("UsePropertyAccessSyntax")
+        // I don't know why it says it's redundant, the compiler yells at me
+        @Suppress("UsePropertyAccessSyntax", "RedundantSuppression")
         meta.setDisplayName(formatted)
 
         return Predicate {

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

@@ -0,0 +1,36 @@
+package com.willfp.eco.internal.particle
+
+import com.willfp.eco.core.particle.ParticleFactory
+import com.willfp.eco.core.particle.SpawnableParticle
+import org.bukkit.Color
+import org.bukkit.Location
+import org.bukkit.Particle
+
+object ParticleFactoryRGB : ParticleFactory {
+    override fun getNames() = listOf(
+        "color",
+        "rgb",
+        "hex"
+    )
+
+    override fun create(key: String): SpawnableParticle? {
+        val hex = key.toIntOrNull(16) ?: return null
+        val color = try {
+            Color.fromRGB(hex)
+        } catch (e: IllegalArgumentException) {
+            return null
+        }
+
+        return SpawnableParticleRGB(Particle.DustOptions(color, 1.0f))
+    }
+
+    private class SpawnableParticleRGB(
+        private val options: Particle.DustOptions
+    ) : SpawnableParticle {
+        override fun spawn(location: Location, amount: Int) {
+            val world = location.world ?: return
+
+            world.spawnParticle(Particle.REDSTONE, location, amount, 0.0, 0.0, 0.0, 0.0, options)
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.willfp.eco.internal.price
+
+import com.willfp.eco.core.math.MathContext
+import com.willfp.eco.core.price.Price
+import com.willfp.eco.core.price.PriceFactory
+import com.willfp.eco.core.price.impl.PriceEconomy
+import java.util.function.Function
+
+object PriceFactoryEconomy : PriceFactory {
+    override fun getNames() = listOf(
+        "coins",
+        "$"
+    )
+
+    override fun create(baseContext: MathContext, function: Function<MathContext, Double>): Price {
+        return PriceEconomy(baseContext, function)
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.willfp.eco.internal.price
+
+import com.willfp.eco.core.math.MathContext
+import com.willfp.eco.core.price.Price
+import com.willfp.eco.core.price.PriceFactory
+import org.bukkit.entity.Player
+import java.util.UUID
+import java.util.function.Function
+import kotlin.math.roundToInt
+
+object PriceFactoryXP : PriceFactory {
+    override fun getNames() = listOf(
+        "xp",
+        "exp",
+        "experience"
+    )
+
+    override fun create(baseContext: MathContext, function: Function<MathContext, Double>): Price {
+        return PriceXP(baseContext) { function.apply(it).roundToInt() }
+    }
+
+    private class PriceXP(
+        private val baseContext: MathContext,
+        private val xp: (MathContext) -> Int
+    ) : Price {
+        private val multipliers = mutableMapOf<UUID, Double>()
+
+        override fun canAfford(player: Player, multiplier: Double): Boolean =
+            player.totalExperience >= getValue(player, multiplier)
+
+        override fun pay(player: Player, multiplier: Double) {
+            player.totalExperience -= getValue(player, multiplier).roundToInt()
+        }
+
+        override fun giveTo(player: Player, multiplier: Double) {
+            player.totalExperience += getValue(player, multiplier).roundToInt()
+        }
+
+        override fun getValue(player: Player, multiplier: Double): Double {
+            return xp(MathContext.copyWithPlayer(baseContext, player)) * getMultiplier(player) * multiplier
+        }
+
+        override fun getMultiplier(player: Player): Double {
+            return multipliers[player.uniqueId] ?: 1.0
+        }
+
+        override fun setMultiplier(player: Player, multiplier: Double) {
+            multipliers[player.uniqueId] = multiplier.roundToInt().toDouble()
+        }
+
+        override fun getIdentifier(): String {
+            return "eco:xp"
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.willfp.eco.internal.price
+
+import com.willfp.eco.core.math.MathContext
+import com.willfp.eco.core.price.Price
+import com.willfp.eco.core.price.PriceFactory
+import org.bukkit.entity.Player
+import java.util.UUID
+import java.util.function.Function
+import kotlin.math.roundToInt
+
+object PriceFactoryXPLevels : PriceFactory {
+    override fun getNames() = listOf(
+        "l",
+        "levels",
+        "xplevels",
+        "explevels",
+    )
+
+    override fun create(baseContext: MathContext, function: Function<MathContext, Double>): Price {
+        return PriceXPLevel(baseContext) { function.apply(it).roundToInt() }
+    }
+
+    private class PriceXPLevel(
+        private val baseContext: MathContext,
+        private val level: (MathContext) -> Int
+    ) : Price {
+        private val multipliers = mutableMapOf<UUID, Double>()
+
+        override fun canAfford(player: Player, multiplier: Double) = player.level >= getValue(player, multiplier)
+
+        override fun pay(player: Player, multiplier: Double) {
+            player.level -= getValue(player, multiplier).roundToInt()
+        }
+
+        override fun giveTo(player: Player, multiplier: Double) {
+            player.level += getValue(player, multiplier).roundToInt()
+        }
+
+        override fun getValue(player: Player, multiplier: Double): Double {
+            return level(MathContext.copyWithPlayer(baseContext, player)) * getMultiplier(player) * multiplier
+        }
+
+        override fun getMultiplier(player: Player): Double {
+            return multipliers[player.uniqueId] ?: 1.0
+        }
+
+        override fun setMultiplier(player: Player, multiplier: Double) {
+            multipliers[player.uniqueId] = multiplier.roundToInt().toDouble()
+        }
+
+        override fun getIdentifier(): String {
+            return "eco:xp-levels"
+        }
+    }
+}

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/NMSCommons.kt

@@ -4,7 +4,6 @@ import com.willfp.eco.core.entities.ai.EntityGoal
 import com.willfp.eco.core.entities.ai.TargetGoal
 import com.willfp.eco.internal.spigot.proxy.common.ai.EntityGoalFactory
 import com.willfp.eco.internal.spigot.proxy.common.ai.TargetGoalFactory
-import net.minecraft.core.Registry
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.entity.LivingEntity
@@ -48,17 +47,14 @@ private val MATERIAL_TO_ITEM = mutableMapOf<Material, Item>()
 
 fun Material.toItem(): Item =
     MATERIAL_TO_ITEM.getOrPut(this) {
-        Registry.ITEM.getOptional(this.key.toResourceLocation())
-            .orElseThrow { IllegalArgumentException("Material is not item!") }
+        impl.materialToItem(this)
     }
 
 private val ITEM_TO_MATERIAL = mutableMapOf<Item, Material>()
 
 fun Item.toMaterial(): Material =
     ITEM_TO_MATERIAL.getOrPut(this) {
-        val material = Material.getMaterial(Registry.ITEM.getKey(this).path.uppercase())
-            ?: throw IllegalArgumentException("Invalid material!")
-        material
+        impl.itemToMaterial(this)
     }
 
 fun CompoundTag.makePdc(base: Boolean = false): PersistentDataContainer =
@@ -94,6 +90,10 @@ interface CommonsProvider {
         return null
     }
 
+    fun materialToItem(material: Material): Item
+
+    fun itemToMaterial(item: Item): Material
+
     companion object {
         fun setIfNeeded(provider: CommonsProvider) {
             if (::impl.isInitialized) {

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/Skull.kt

@@ -29,7 +29,27 @@ var SkullMeta.texture: String?
             setProfile.isAccessible = true
         }
 
-        if (base64 == null) {
+        /* This length check below was lost in the conversion. For some reason the base64
+        * string is length 8 when this is called pretty frequently, causing an
+        * out of bounds exception.
+        *
+        * Could not pass event EntityPotionEffectEvent to Talismans v5.116.0
+        * java.lang.StringIndexOutOfBoundsException: begin -12, end 8, length 8
+        * at java.lang.String.checkBoundsBeginEnd(String.java:4604) ~[?:?]
+        * at java.lang.String.substring(String.java:2707) ~[?:?]
+        * at java.lang.String.substring(String.java:2680) ~[?:?]
+        * at com.willfp.eco.internal.spigot.proxy.v1_19_R1.common.SkullKt.setTexture(Skull.kt:36)
+        *
+        if (base64.length < 20) {
+            return
+        }
+        *
+        * ^ Update to this comment: a length 8 string ("textures") was being sent
+        * because the get() method wasn't working right. This has been fixed, but the
+        * check needs to remain implemented.
+        */
+
+        if (base64 == null || base64.length < 20) {
             setProfile.invoke(this, null)
         } else {
             val uuid = UUID(

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/ai/entity/IllusionerBlindnessSpellGoalFactory.kt

@@ -1,21 +1,23 @@
 package com.willfp.eco.internal.spigot.proxy.common.ai.entity
 
-import com.willfp.eco.core.entities.ai.entity.EntityGoalLeapAtTarget
+import com.willfp.eco.core.entities.ai.entity.EntityGoalIllusionerBlindnessSpell
 import com.willfp.eco.internal.spigot.proxy.common.ai.EntityGoalFactory
-import com.willfp.eco.internal.spigot.proxy.common.ai.opengoals.IllusionerBlindnessSpellGoal
 import net.minecraft.world.entity.PathfinderMob
 import net.minecraft.world.entity.ai.goal.Goal
 import net.minecraft.world.entity.monster.Illusioner
 
-object IllusionerBlindnessSpellGoalFactory : EntityGoalFactory<EntityGoalLeapAtTarget> {
-    override fun create(apiGoal: EntityGoalLeapAtTarget, entity: PathfinderMob): Goal? {
+object IllusionerBlindnessSpellGoalFactory : EntityGoalFactory<EntityGoalIllusionerBlindnessSpell> {
+    override fun create(apiGoal: EntityGoalIllusionerBlindnessSpell, entity: PathfinderMob): Goal? {
         if (entity !is Illusioner) return null
 
-        return IllusionerBlindnessSpellGoal(
-            entity
-        )
+        // Have to use reflection for it to work
+        return Illusioner::class.java.declaredClasses[1]
+            .getDeclaredConstructor(Illusioner::class.java)
+            .apply { isAccessible = true }
+            .newInstance(entity) as Goal
     }
 
-    override fun isGoalOfType(goal: Goal) = goal is IllusionerBlindnessSpellGoal
-            || goal::class.java.name.contains("IllusionerBlindnessSpellGoal")
+    override fun isGoalOfType(goal: Goal): Boolean {
+        return Illusioner::class.java.declaredClasses[1].isInstance(goal)
+    }
 }

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/ai/entity/IllusionerMirrorSpellGoalFactory.kt

@@ -1,21 +1,23 @@
 package com.willfp.eco.internal.spigot.proxy.common.ai.entity
 
-import com.willfp.eco.core.entities.ai.entity.EntityGoalLeapAtTarget
+import com.willfp.eco.core.entities.ai.entity.EntityGoalIllusionerMirrorSpell
 import com.willfp.eco.internal.spigot.proxy.common.ai.EntityGoalFactory
-import com.willfp.eco.internal.spigot.proxy.common.ai.opengoals.IllusionerMirrorSpellGoal
 import net.minecraft.world.entity.PathfinderMob
 import net.minecraft.world.entity.ai.goal.Goal
 import net.minecraft.world.entity.monster.Illusioner
 
-object IllusionerMirrorSpellGoalFactory : EntityGoalFactory<EntityGoalLeapAtTarget> {
-    override fun create(apiGoal: EntityGoalLeapAtTarget, entity: PathfinderMob): Goal? {
+object IllusionerMirrorSpellGoalFactory : EntityGoalFactory<EntityGoalIllusionerMirrorSpell> {
+    override fun create(apiGoal: EntityGoalIllusionerMirrorSpell, entity: PathfinderMob): Goal? {
         if (entity !is Illusioner) return null
 
-        return IllusionerMirrorSpellGoal(
-            entity
-        )
+        // Have to use reflection for it to work
+        return Illusioner::class.java.declaredClasses[0]
+            .getDeclaredConstructor(Illusioner::class.java)
+            .apply { isAccessible = true }
+            .newInstance(entity) as Goal
     }
 
-    override fun isGoalOfType(goal: Goal) = goal is IllusionerMirrorSpellGoal
-            || goal::class.java.name.contains("IllusionerMirrorSpellGoal")
+    override fun isGoalOfType(goal: Goal): Boolean {
+        return Illusioner::class.java.declaredClasses[0].isInstance(goal)
+    }
 }

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/ai/entity/InteractGoalFactory.kt

@@ -39,7 +39,6 @@ private class EnhancedInteractGoal(
         return if (mob.random.nextFloat() >= probability) {
             false
         } else {
-            @Suppress("SENSELESS_COMPARISON")
             if (mob.target != null) {
                 lookAt = mob.target
             }

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/ai/opengoals/IllusionerBlindnessSpellGoal.kt

@@ -1,50 +0,0 @@
-package com.willfp.eco.internal.spigot.proxy.common.ai.opengoals
-
-import net.minecraft.sounds.SoundEvent
-import net.minecraft.sounds.SoundEvents
-import net.minecraft.world.Difficulty
-import net.minecraft.world.effect.MobEffectInstance
-import net.minecraft.world.effect.MobEffects
-import net.minecraft.world.entity.monster.Illusioner
-import net.minecraft.world.entity.monster.SpellcasterIllager
-import org.bukkit.event.entity.EntityPotionEffectEvent
-
-class IllusionerBlindnessSpellGoal(
-    private val illusioner: Illusioner
-) : OpenUseSpellGoal(illusioner) {
-    override val castingInterval = 180
-    override val castingTime = 20
-    override val spellPrepareSound: SoundEvent = SoundEvents.ILLUSIONER_PREPARE_BLINDNESS
-    override val spell: SpellcasterIllager.IllagerSpell = SpellcasterIllager.IllagerSpell.BLINDNESS
-
-    private var lastTargetId = 0
-
-    override fun canUse(): Boolean {
-        return if (super.canUse()) {
-            false
-        } else if (illusioner.target == null) {
-            false
-        } else if (illusioner.target!!.id == lastTargetId) {
-            false
-        } else {
-            illusioner.level.getCurrentDifficultyAt(illusioner.blockPosition()).isHarderThan(
-                Difficulty.NORMAL.ordinal.toFloat()
-            )
-        }
-    }
-
-    override fun start() {
-        super.start()
-        if (illusioner.target != null) {
-            lastTargetId = illusioner.target!!.id
-        }
-    }
-
-    override fun performSpellCasting() {
-        illusioner.target?.addEffect(
-            MobEffectInstance(MobEffects.BLINDNESS, 400),
-            illusioner,
-            EntityPotionEffectEvent.Cause.ATTACK
-        ) // CraftBukkit
-    }
-}

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/ai/opengoals/IllusionerMirrorSpellGoal.kt

@@ -1,29 +0,0 @@
-package com.willfp.eco.internal.spigot.proxy.common.ai.opengoals
-
-import net.minecraft.sounds.SoundEvent
-import net.minecraft.sounds.SoundEvents
-import net.minecraft.world.effect.MobEffectInstance
-import net.minecraft.world.effect.MobEffects
-import net.minecraft.world.entity.monster.Illusioner
-import net.minecraft.world.entity.monster.SpellcasterIllager
-import org.bukkit.event.entity.EntityPotionEffectEvent
-
-class IllusionerMirrorSpellGoal(
-    private val illusioner: Illusioner
-) : OpenUseSpellGoal(illusioner) {
-    override val castingInterval = 340
-    override val castingTime = 20
-    override val spellPrepareSound: SoundEvent = SoundEvents.ILLUSIONER_PREPARE_MIRROR
-    override val spell: SpellcasterIllager.IllagerSpell = SpellcasterIllager.IllagerSpell.DISAPPEAR
-
-    override fun canUse(): Boolean {
-        return if (!super.canUse()) false else !illusioner.hasEffect(MobEffects.INVISIBILITY)
-    }
-
-    override fun performSpellCasting() {
-        illusioner.addEffect(
-            MobEffectInstance(MobEffects.INVISIBILITY, 1200),
-            EntityPotionEffectEvent.Cause.ILLUSION
-        )
-    }
-}

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/ai/opengoals/Spellcaster.kt

@@ -1,79 +0,0 @@
-package com.willfp.eco.internal.spigot.proxy.common.ai.opengoals
-
-import net.minecraft.sounds.SoundEvent
-import net.minecraft.world.entity.EntityType
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.goal.Goal
-import net.minecraft.world.entity.monster.SpellcasterIllager
-
-@Suppress("UNCHECKED_CAST")
-class DelegatedSpellcaster(private val handle: SpellcasterIllager) : SpellcasterIllager(
-    handle.type as EntityType<out SpellcasterIllager>,
-    handle.level
-) {
-    var openSpellCastingTickCount
-        get() = this.spellCastingTickCount
-        set(value) {
-            this.spellCastingTickCount = value
-        }
-
-    val openCastingSoundEvent = this.castingSoundEvent
-
-    override fun applyRaidBuffs(wave: Int, unused: Boolean) {
-        handle.applyRaidBuffs(wave, unused)
-    }
-
-    override fun getCelebrateSound(): SoundEvent {
-        return handle.celebrateSound
-    }
-
-    override fun getCastingSoundEvent(): SoundEvent {
-        return this.openCastingSoundEvent
-    }
-}
-
-@Suppress("NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS")
-abstract class OpenUseSpellGoal(
-    private val handle: SpellcasterIllager
-) : Goal() {
-    private var attackWarmupDelay = 0
-    private var nextAttackTickCount = 0
-
-    private val openHandle = DelegatedSpellcaster(handle)
-
-    override fun canUse(): Boolean {
-        val entityliving: LivingEntity = handle.target ?: return false
-        return if (entityliving.isAlive) if (handle.isCastingSpell) false else handle.tickCount >= nextAttackTickCount else false
-    }
-
-    override fun canContinueToUse(): Boolean {
-        val entityliving: LivingEntity = handle.target ?: return false
-        return entityliving.isAlive && attackWarmupDelay > 0
-    }
-
-    override fun start() {
-        attackWarmupDelay = castWarmupTime
-        openHandle.openSpellCastingTickCount = castingTime
-        nextAttackTickCount = handle.tickCount + castingInterval
-        val soundeffect = spellPrepareSound
-        if (soundeffect != null) {
-            handle.playSound(soundeffect, 1.0f, 1.0f)
-        }
-        handle.setIsCastingSpell(spell)
-    }
-
-    override fun tick() {
-        --attackWarmupDelay
-        if (attackWarmupDelay == 0) {
-            performSpellCasting()
-            handle.playSound(openHandle.openCastingSoundEvent, 1.0f, 1.0f)
-        }
-    }
-
-    protected abstract fun performSpellCasting()
-    protected abstract val castingTime: Int
-    protected abstract val castingInterval: Int
-    protected abstract val spellPrepareSound: SoundEvent?
-    protected abstract val spell: SpellcasterIllager.IllagerSpell?
-    protected open val castWarmupTime: Int = 60
-}

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/ai/target/HurtByGoalFactory.kt

@@ -32,7 +32,6 @@ private class EnhancedHurtByTargetGoal(
             return false
         }
 
-        @Suppress("NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS")
         return super.canAttack(target, targetPredicate)
     }
 }

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/item/EcoFastItemStack.kt

@@ -192,7 +192,7 @@ class EcoFastItemStack(
         apply()
     }
 
-    @Suppress("UNNECESSARY_NOT_NULL_ASSERTION")
+    @Suppress("RedundantSuppression", "UNNECESSARY_NOT_NULL_ASSERTION")
     private var flagBits: Byte
         get() =
             if (handle.hasTag() && handle.getTag()!!.contains(
@@ -255,7 +255,7 @@ class EcoFastItemStack(
     }
 
     override fun hashCode(): Int {
-        @Suppress("UNNECESSARY_SAFE_CALL")
+        @Suppress("RedundantSuppression", "UNNECESSARY_SAFE_CALL")
         return handle.getTag()?.hashCode() ?: (0b00010101 * 31 + Item.getId(handle.getItem()))
     }