Updated to 6.7.0

README.md

@@ -158,8 +158,12 @@ Here's a list of some (not all) of the features of eco:
 
 <h1 align="center">
   <br>
+    <a href="http://gamersupps.gg/discount/Auxilor?afmc=Auxilor" target="_blank">
+      <img src="https://i.imgur.com/uFDpBAC.png" alt="supps banner">
+    </a>
     <a href="https://dedimc.promo/Auxilor" target="_blank">
       <img src="https://i.imgur.com/zdDLhFA.png" alt="dedimc banner">
     </a>
   <br>
 </h1>
+

build.gradle

@@ -51,6 +51,9 @@ allprojects {
 
         // CombatLogX
         maven { url 'https://nexus.sirblobman.xyz/repository/public/' }
+
+        // Head Database
+        maven { url 'https://mvn.intellectualsites.com/content/groups/public/' }
     }
 
     dependencies {

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

@@ -2,6 +2,7 @@ package com.willfp.eco.core.config.base;
 
 import com.willfp.eco.core.EcoPlugin;
 import com.willfp.eco.core.config.yaml.YamlBaseConfig;
+import com.willfp.eco.util.StringUtils;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -42,6 +43,18 @@ public class LangYml extends YamlBaseConfig {
      * @return The message with a prefix appended.
      */
     public String getMessage(@NotNull final String message) {
-        return getPrefix() + this.getString("messages." + message);
+        return getMessage(message, StringUtils.FormatOption.WITH_PLACEHOLDERS);
+    }
+
+    /**
+     * Get a chat message.
+     *
+     * @param message The key of the message.
+     * @param option  The format options.
+     * @return The message with a prefix appended.
+     */
+    public String getMessage(@NotNull final String message,
+                             @NotNull final StringUtils.FormatOption option) {
+        return getPrefix() + this.getString("messages." + message, option);
     }
 }

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

@@ -1,5 +1,6 @@
 package com.willfp.eco.core.config.interfaces;
 
+import com.willfp.eco.util.StringUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -165,7 +166,9 @@ public interface Config extends Cloneable {
      * @return The found value, or an empty string if not found.
      */
     @NotNull
-    String getString(@NotNull String path);
+    default String getString(@NotNull String path) {
+        return getString(path, true);
+    }
 
     /**
      * Get a string from config.
@@ -175,8 +178,36 @@ public interface Config extends Cloneable {
      * @return The found value, or an empty string if not found.
      */
     @NotNull
+    default String getString(@NotNull String path,
+                             boolean format) {
+        return this.getString(path, format, StringUtils.FormatOption.WITH_PLACEHOLDERS);
+    }
+
+    /**
+     * Get a string from config.
+     *
+     * @param path   The key to fetch the value from.
+     * @param option The format option.
+     * @return The found value, or an empty string if not found.
+     */
+    @NotNull
+    default String getString(@NotNull String path,
+                             @NotNull final StringUtils.FormatOption option) {
+        return this.getString(path, true, option);
+    }
+
+    /**
+     * Get a string from config.
+     *
+     * @param path   The key to fetch the value from.
+     * @param format If the string should be formatted.
+     * @param option The format option.
+     * @return The found value, or an empty string if not found.
+     */
+    @NotNull
     String getString(@NotNull String path,
-                     boolean format);
+                     boolean format,
+                     @NotNull StringUtils.FormatOption option);
 
     /**
      * Get a string from config.
@@ -185,7 +216,9 @@ public interface Config extends Cloneable {
      * @return The found value, or null if not found.
      */
     @Nullable
-    String getStringOrNull(@NotNull String path);
+    default String getStringOrNull(@NotNull String path) {
+        return getStringOrNull(path, true);
+    }
 
     /**
      * Get a string from config.
@@ -195,8 +228,36 @@ public interface Config extends Cloneable {
      * @return The found value, or null if not found.
      */
     @Nullable
+    default String getStringOrNull(@NotNull String path,
+                                   boolean format) {
+        return this.getStringOrNull(path, format, StringUtils.FormatOption.WITH_PLACEHOLDERS);
+    }
+
+    /**
+     * Get a string from config.
+     *
+     * @param path   The key to fetch the value from.
+     * @param option The format option.
+     * @return The found value, or null if not found.
+     */
+    @Nullable
+    default String getStringOrNull(@NotNull String path,
+                                   @NotNull StringUtils.FormatOption option) {
+        return this.getStringOrNull(path, true, option);
+    }
+
+    /**
+     * Get a string from config.
+     *
+     * @param path   The key to fetch the value from.
+     * @param format If the string should be formatted.
+     * @param option The format option.
+     * @return The found value, or null if not found.
+     */
+    @Nullable
     String getStringOrNull(@NotNull String path,
-                           boolean format);
+                           boolean format,
+                           @NotNull StringUtils.FormatOption option);
 
     /**
      * Get a list of strings from config.
@@ -207,7 +268,9 @@ public interface Config extends Cloneable {
      * @return The found value, or a blank {@link java.util.ArrayList} if not found.
      */
     @NotNull
-    List<String> getStrings(@NotNull String path);
+    default List<String> getStrings(@NotNull String path) {
+        return getStrings(path, true);
+    }
 
     /**
      * Get a list of strings from config.
@@ -217,8 +280,36 @@ public interface Config extends Cloneable {
      * @return The found value, or a blank {@link java.util.ArrayList} if not found.
      */
     @NotNull
+    default List<String> getStrings(@NotNull String path,
+                                    boolean format) {
+        return this.getStrings(path, format, StringUtils.FormatOption.WITH_PLACEHOLDERS);
+    }
+
+    /**
+     * Get a list of strings from config.
+     *
+     * @param path   The key to fetch the value from.
+     * @param option The format option.
+     * @return The found value, or a blank {@link java.util.ArrayList} if not found.
+     */
+    @Nullable
+    default List<String> getStrings(@NotNull String path,
+                                    @NotNull StringUtils.FormatOption option) {
+        return getStrings(path, true, option);
+    }
+
+    /**
+     * Get a list of strings from config.
+     *
+     * @param path   The key to fetch the value from.
+     * @param format If the strings should be formatted.
+     * @param option The option.
+     * @return The found value, or a blank {@link java.util.ArrayList} if not found.
+     */
+    @NotNull
     List<String> getStrings(@NotNull String path,
-                            boolean format);
+                            boolean format,
+                            @NotNull StringUtils.FormatOption option);
 
     /**
      * Get a list of strings from config.
@@ -227,7 +318,9 @@ public interface Config extends Cloneable {
      * @return The found value, or null if not found.
      */
     @Nullable
-    List<String> getStringsOrNull(@NotNull String path);
+    default List<String> getStringsOrNull(@NotNull String path) {
+        return getStringsOrNull(path, true);
+    }
 
     /**
      * Get a list of strings from config.
@@ -237,8 +330,36 @@ public interface Config extends Cloneable {
      * @return The found value, or null if not found.
      */
     @Nullable
+    default List<String> getStringsOrNull(@NotNull String path,
+                                          boolean format) {
+        return getStringsOrNull(path, format, StringUtils.FormatOption.WITH_PLACEHOLDERS);
+    }
+
+    /**
+     * Get a list of strings from config.
+     *
+     * @param path   The key to fetch the value from.
+     * @param option The format option.
+     * @return The found value, or null if not found.
+     */
+    @Nullable
+    default List<String> getStringsOrNull(@NotNull String path,
+                                          @NotNull StringUtils.FormatOption option) {
+        return getStringsOrNull(path, true, option);
+    }
+
+    /**
+     * Get a list of strings from config.
+     *
+     * @param path   The key to fetch the value from.
+     * @param format If the strings should be formatted.
+     * @param option The format option.
+     * @return The found value, or null if not found.
+     */
+    @Nullable
     List<String> getStringsOrNull(@NotNull String path,
-                                  boolean format);
+                                  boolean format,
+                                  @NotNull StringUtils.FormatOption option);
 
     /**
      * Get a decimal from config.

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

@@ -1,6 +1,7 @@
 package com.willfp.eco.core.config.wrapper;
 
 import com.willfp.eco.core.config.interfaces.Config;
+import com.willfp.eco.util.StringUtils;
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -125,48 +126,33 @@ public abstract class ConfigWrapper<T extends Config> implements Config {
         return handle.getBoolsOrNull(path);
     }
 
-    @Override
-    public @NotNull String getString(@NotNull final String path) {
-        return handle.getString(path);
-    }
 
     @Override
     public @NotNull String getString(@NotNull final String path,
-                                     final boolean format) {
-        return handle.getString(path, format);
-    }
-
-    @Override
-    public @Nullable String getStringOrNull(@NotNull final String path) {
-        return handle.getStringOrNull(path);
+                                     final boolean format,
+                                     @NotNull final StringUtils.FormatOption option) {
+        return handle.getString(path, format, option);
     }
 
     @Override
     public @Nullable String getStringOrNull(@NotNull final String path,
-                                            final boolean format) {
-        return handle.getStringOrNull(path, format);
-    }
-
-    @Override
-    public @NotNull List<String> getStrings(@NotNull final String path) {
-        return handle.getStrings(path);
+                                            final boolean format,
+                                            @NotNull final StringUtils.FormatOption option) {
+        return handle.getStringOrNull(path, format, option);
     }
 
     @Override
     public @NotNull List<String> getStrings(@NotNull final String path,
-                                            final boolean format) {
-        return handle.getStrings(path, format);
-    }
-
-    @Override
-    public @Nullable List<String> getStringsOrNull(@NotNull final String path) {
-        return handle.getStringsOrNull(path);
+                                            final boolean format,
+                                            @NotNull final StringUtils.FormatOption option) {
+        return handle.getStrings(path, format, option);
     }
 
     @Override
     public @Nullable List<String> getStringsOrNull(@NotNull final String path,
-                                                   final boolean format) {
-        return handle.getStringsOrNull(path, format);
+                                                   final boolean format,
+                                                   @NotNull final StringUtils.FormatOption option) {
+        return handle.getStringsOrNull(path, format, option);
     }
 
     @Override

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

@@ -71,10 +71,6 @@ public class Display {
      */
     public ItemStack display(@NotNull final ItemStack itemStack,
                              @Nullable final Player player) {
-        if (!itemStack.hasItemMeta()) {
-            return itemStack; // return early if there's no customization of the item
-        }
-
         Map<String, Object[]> pluginVarArgs = new HashMap<>();
 
         for (DisplayPriority priority : DisplayPriority.values()) {
@@ -139,10 +135,6 @@ public class Display {
             unfinalize(itemStack);
         }
 
-        if (!itemStack.hasItemMeta()) {
-            return itemStack;
-        }
-
         ItemMeta meta = itemStack.getItemMeta();
 
         if (meta == null) {

eco-api/src/main/java/com/willfp/eco/core/events/ArmorEquipEvent.java

@@ -16,7 +16,6 @@ import org.jetbrains.annotations.NotNull;
  *
  * @see ArmorChangeEvent
  */
-@Deprecated
 public class ArmorEquipEvent extends PlayerEvent {
     /**
      * Bukkit parity.

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

@@ -3,6 +3,7 @@ package com.willfp.eco.core.fast;
 import com.willfp.eco.core.Eco;
 import org.bukkit.Material;
 import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemFlag;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -10,6 +11,7 @@ import org.jetbrains.annotations.Nullable;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 
 /**
  * FastItemStack contains methods to modify and read items faster than in default bukkit.
@@ -47,6 +49,51 @@ public interface FastItemStack {
      */
     List<String> getLore();
 
+
+    /**
+     * Set the rework penalty.
+     *
+     * @param cost The rework penalty to set.
+     */
+    void setRepairCost(int cost);
+
+    /**
+     * Get the rework penalty.
+     * .
+     *
+     * @return The rework penalty found on the item.
+     */
+    int getRepairCost();
+
+    /**
+     * Add ItemFlags.
+     *
+     * @param hideFlags The flags.
+     */
+    void addItemFlags(ItemFlag... hideFlags);
+
+    /**
+     * Remove ItemFlags.
+     *
+     * @param hideFlags The flags.
+     */
+    void removeItemFlags(ItemFlag... hideFlags);
+
+    /**
+     * Get the ItemFlags.
+     *
+     * @return The flags.
+     */
+    Set<ItemFlag> getItemFlags();
+
+    /**
+     * Test the item for a flag.
+     *
+     * @param flag The flag.
+     * @return If the flag is present.
+     */
+    boolean hasItemFlag(ItemFlag flag);
+
     /**
      * Get the Bukkit ItemStack again.
      *

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

@@ -2,12 +2,10 @@ package com.willfp.eco.core.gui;
 
 import com.willfp.eco.core.gui.menu.MenuBuilder;
 import com.willfp.eco.core.gui.slot.SlotBuilder;
-import org.bukkit.entity.Player;
+import com.willfp.eco.core.gui.slot.functional.SlotProvider;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.function.Function;
-
 /**
  * Internal component used by {@link com.willfp.eco.core.gui.menu.Menu#builder(int)}
  * and {@link com.willfp.eco.core.gui.slot.Slot#builder(ItemStack)}.
@@ -19,7 +17,7 @@ public interface GUIFactory {
      * @param provider The provider.
      * @return The builder.
      */
-    SlotBuilder createSlotBuilder(@NotNull Function<Player, ItemStack> provider);
+    SlotBuilder createSlotBuilder(@NotNull SlotProvider provider);
 
     /**
      * Create menu builder.

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

@@ -0,0 +1,19 @@
+package com.willfp.eco.core.gui.menu;
+
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Interface to run on menu close.
+ */
+@FunctionalInterface
+public interface CloseHandler {
+    /**
+     * Performs this operation on the given arguments.
+     *
+     * @param event The close event.
+     * @param menu  The menu.
+     */
+    void handle(@NotNull InventoryCloseEvent event,
+                @NotNull Menu menu);
+}

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

@@ -2,9 +2,16 @@ package com.willfp.eco.core.gui.menu;
 
 import com.willfp.eco.core.Eco;
 import com.willfp.eco.core.gui.slot.Slot;
+import org.bukkit.NamespacedKey;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Set;
 
 /**
  * GUI version of {@link Inventory}.
@@ -44,6 +51,51 @@ public interface Menu {
      */
     Inventory open(@NotNull Player player);
 
+    /**
+     * Get captive items.
+     *
+     * @param player The player.
+     * @return The items.
+     */
+    List<ItemStack> getCaptiveItems(@NotNull Player player);
+
+    /**
+     * Write data.
+     *
+     * @param player The player.
+     * @param key    The key.
+     * @param type   The type.
+     * @param value  The value.
+     * @param <T>    The type.
+     * @param <Z>    The type.
+     */
+    <T, Z> void writeData(@NotNull Player player,
+                          @NotNull NamespacedKey key,
+                          @NotNull PersistentDataType<T, Z> type,
+                          @NotNull Z value);
+
+    /**
+     * Read data.
+     *
+     * @param player The player.
+     * @param key    The key.
+     * @param type   The type.
+     * @param <T>    The type.
+     * @param <Z>    The type.
+     * @return The data.
+     */
+    @Nullable <T, Z> T readData(@NotNull Player player,
+                                @NotNull NamespacedKey key,
+                                @NotNull PersistentDataType<T, Z> type);
+
+    /**
+     * Get all data keys for a player.
+     *
+     * @param player The player.
+     * @return The keys.
+     */
+    Set<NamespacedKey> getKeys(@NotNull Player player);
+
     /**
      * Create a builder with a given amount of rows.
      *

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

@@ -31,6 +31,14 @@ public interface MenuBuilder {
                         int column,
                         @NotNull Slot slot);
 
+    /**
+     * Run function to modify the builder.
+     *
+     * @param modifier The modifier.
+     * @return The builder.
+     */
+    MenuBuilder modfiy(@NotNull Consumer<MenuBuilder> modifier);
+
     /**
      * Set the menu mask.
      *
@@ -45,7 +53,18 @@ public interface MenuBuilder {
      * @param action The handler.
      * @return The builder.
      */
-    MenuBuilder onClose(@NotNull Consumer<InventoryCloseEvent> action);
+    default MenuBuilder onClose(@NotNull Consumer<InventoryCloseEvent> action) {
+        onClose((event, menu) -> action.accept(event));
+        return this;
+    }
+
+    /**
+     * Set the menu close handler.
+     *
+     * @param action The handler.
+     * @return The builder.
+     */
+    MenuBuilder onClose(@NotNull CloseHandler action);
 
     /**
      * Build the menu.

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

@@ -7,6 +7,7 @@ import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -39,35 +40,46 @@ public class FillerMask {
      */
     public FillerMask(@NotNull final Material material,
                       @NotNull final String... pattern) {
-        if (material == Material.AIR) {
-            throw new IllegalArgumentException("Material cannot be air!");
+        this(new MaskMaterials(material), pattern);
+    }
+
+    /**
+     * Create a new filler mask.
+     *
+     * @param materials The mask materials.
+     * @param pattern  The pattern.
+     */
+    public FillerMask(@NotNull final MaskMaterials materials,
+                      @NotNull final String... pattern) {
+        if (Arrays.stream(materials.materials()).anyMatch(material -> material == Material.AIR)) {
+            throw new IllegalArgumentException("Materials cannot be air!");
         }
 
         mask = ListUtils.create2DList(6, 9);
 
-        ItemStack itemStack = new ItemStackBuilder(material)
-                .setDisplayName("&r")
-                .build();
+        for (int i = 0; i < materials.materials().length; i++) {
+            ItemStack itemStack = new ItemStackBuilder(materials.materials()[i])
+                    .setDisplayName("&r")
+                    .build();
 
-        int row = 0;
+            int row = 0;
 
-        for (String patternRow : pattern) {
-            int column = 0;
-            if (patternRow.length() != 9) {
-                throw new IllegalArgumentException("Invalid amount of columns in pattern!");
-            }
-            for (char c : patternRow.toCharArray()) {
-                if (c == '0') {
-                    mask.get(row).set(column, null);
-                } else if (c == '1') {
-                    mask.get(row).set(column, new FillerSlot(itemStack));
-                } else {
-                    throw new IllegalArgumentException("Invalid character in pattern! (Must only be 0 and 1)");
+            for (String patternRow : pattern) {
+                int column = 0;
+                if (patternRow.length() != 9) {
+                    throw new IllegalArgumentException("Invalid amount of columns in pattern!");
                 }
+                for (char c : patternRow.toCharArray()) {
+                    if (c == '0') {
+                        mask.get(row).set(column, null);
+                    } else if (c == Character.forDigit(i + 1, 10)) {
+                        mask.get(row).set(column, new FillerSlot(itemStack));
+                    }
 
-                column++;
+                    column++;
+                }
+                row++;
             }
-            row++;
         }
     }
 }

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

@@ -30,4 +30,9 @@ public class FillerSlot implements Slot {
     public ItemStack getItemStack(@NotNull final Player player) {
         return itemStack;
     }
+
+    @Override
+    public boolean isCaptive() {
+        return false;
+    }
 }

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

@@ -0,0 +1,14 @@
+package com.willfp.eco.core.gui.slot;
+
+import org.bukkit.Material;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Mask materials store a set of materials which can be accessed by
+ * a filler mask.
+ *
+ * @param materials The materials.
+ */
+public record MaskMaterials(@NotNull Material... materials) {
+
+}

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

@@ -1,6 +1,8 @@
 package com.willfp.eco.core.gui.slot;
 
 import com.willfp.eco.core.Eco;
+import com.willfp.eco.core.gui.slot.functional.SlotProvider;
+import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
@@ -19,6 +21,22 @@ public interface Slot {
      */
     ItemStack getItemStack(@NotNull Player player);
 
+    /**
+     * If the slot is captive. (Can items be placed in it).
+     *
+     * @return If captive.
+     */
+    boolean isCaptive();
+
+    /**
+     * Create a builder for an ItemStack.
+     *
+     * @return The builder.
+     */
+    static SlotBuilder builder() {
+        return Eco.getHandler().getGUIFactory().createSlotBuilder((player, menu) -> new ItemStack(Material.AIR));
+    }
+
     /**
      * Create a builder for an ItemStack.
      *
@@ -26,7 +44,7 @@ public interface Slot {
      * @return The builder.
      */
     static SlotBuilder builder(@NotNull final ItemStack itemStack) {
-        return Eco.getHandler().getGUIFactory().createSlotBuilder(player -> itemStack);
+        return Eco.getHandler().getGUIFactory().createSlotBuilder((player, menu) -> itemStack);
     }
 
     /**
@@ -36,6 +54,16 @@ public interface Slot {
      * @return The builder.
      */
     static SlotBuilder builder(@NotNull final Function<Player, ItemStack> provider) {
+        return Eco.getHandler().getGUIFactory().createSlotBuilder((player, menu) -> provider.apply(player));
+    }
+
+    /**
+     * Create a builder for a player-specific ItemStack.
+     *
+     * @param provider The provider.
+     * @return The builder.
+     */
+    static SlotBuilder builder(@NotNull final SlotProvider provider) {
         return Eco.getHandler().getGUIFactory().createSlotBuilder(provider);
     }
 }

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

@@ -1,5 +1,7 @@
 package com.willfp.eco.core.gui.slot;
 
+import com.willfp.eco.core.gui.slot.functional.SlotHandler;
+import com.willfp.eco.core.gui.slot.functional.SlotModifier;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.jetbrains.annotations.NotNull;
 
@@ -15,7 +17,17 @@ public interface SlotBuilder {
      * @param action The handler.
      * @return The builder.
      */
-    SlotBuilder onLeftClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action);
+    default SlotBuilder onLeftClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action) {
+        return onLeftClick((event, slot, menu) -> action.accept(event, slot));
+    }
+
+    /**
+     * Set click handler.
+     *
+     * @param handler The handler.
+     * @return The builder.
+     */
+    SlotBuilder onLeftClick(@NotNull SlotHandler handler);
 
     /**
      * Set click handler.
@@ -23,7 +35,17 @@ public interface SlotBuilder {
      * @param action The handler.
      * @return The builder.
      */
-    SlotBuilder onRightClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action);
+    default SlotBuilder onRightClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action) {
+        return onRightClick((event, slot, menu) -> action.accept(event, slot));
+    }
+
+    /**
+     * Set click handler.
+     *
+     * @param handler The handler.
+     * @return The builder.
+     */
+    SlotBuilder onRightClick(@NotNull SlotHandler handler);
 
     /**
      * Set click handler.
@@ -31,7 +53,17 @@ public interface SlotBuilder {
      * @param action The handler.
      * @return The builder.
      */
-    SlotBuilder onShiftLeftClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action);
+    default SlotBuilder onShiftLeftClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action) {
+        return onShiftLeftClick((event, slot, menu) -> action.accept(event, slot));
+    }
+
+    /**
+     * Set click handler.
+     *
+     * @param handler The handler.
+     * @return The builder.
+     */
+    SlotBuilder onShiftLeftClick(@NotNull SlotHandler handler);
 
     /**
      * Set click handler.
@@ -39,7 +71,17 @@ public interface SlotBuilder {
      * @param action The handler.
      * @return The builder.
      */
-    SlotBuilder onShiftRightClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action);
+    default SlotBuilder onShiftRightClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action) {
+        return onShiftRightClick((event, slot, menu) -> action.accept(event, slot));
+    }
+
+    /**
+     * Set click handler.
+     *
+     * @param handler The handler.
+     * @return The builder.
+     */
+    SlotBuilder onShiftRightClick(@NotNull SlotHandler handler);
 
     /**
      * Set click handler.
@@ -47,7 +89,32 @@ public interface SlotBuilder {
      * @param action The handler.
      * @return The builder.
      */
-    SlotBuilder onMiddleClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action);
+    default SlotBuilder onMiddleClick(@NotNull BiConsumer<InventoryClickEvent, Slot> action) {
+        return onMiddleClick((event, slot, menu) -> action.accept(event, slot));
+    }
+
+    /**
+     * Set click handler.
+     *
+     * @param handler The handler.
+     * @return The builder.
+     */
+    SlotBuilder onMiddleClick(@NotNull SlotHandler handler);
+
+    /**
+     * Modify the ItemStack.
+     *
+     * @param modifier The modifier.
+     * @return The builder.
+     */
+    SlotBuilder setModifier(@NotNull SlotModifier modifier);
+
+    /**
+     * Set slot to be a captive slot.
+     *
+     * @return The builder.
+     */
+    SlotBuilder setCaptive();
 
     /**
      * Build the slot.

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

@@ -0,0 +1,23 @@
+package com.willfp.eco.core.gui.slot.functional;
+
+import com.willfp.eco.core.gui.menu.Menu;
+import com.willfp.eco.core.gui.slot.Slot;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Interface to run on slot click.
+ */
+@FunctionalInterface
+public interface SlotHandler {
+    /**
+     * Performs this operation on the given arguments.
+     *
+     * @param event The click event.
+     * @param slot  The slot
+     * @param menu  The menu.
+     */
+    void handle(@NotNull InventoryClickEvent event,
+                @NotNull Slot slot,
+                @NotNull Menu menu);
+}

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

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

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

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

eco-api/src/main/java/com/willfp/eco/core/integrations/customitems/CustomItemsWrapper.java

@@ -1,9 +1,11 @@
 package com.willfp.eco.core.integrations.customitems;
 
+import com.willfp.eco.core.integrations.Integration;
+
 /**
  * Wrapper class for custom item integrations.
  */
-public interface CustomItemsWrapper {
+public interface CustomItemsWrapper extends Integration {
     /**
      * Register all the custom items for a specific plugin into eco.
      *

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

@@ -16,7 +16,7 @@ public class McmmoManager {
     /**
      * A set of all registered integrations.
      */
-    private final Set<McmmoWrapper> regsistered = new HashSet<>();
+    private final Set<McmmoWrapper> registered = new HashSet<>();
 
     /**
      * Register a new integration.
@@ -24,7 +24,7 @@ public class McmmoManager {
      * @param integration The integration to register.
      */
     public void register(@NotNull final McmmoWrapper integration) {
-        regsistered.add(integration);
+        registered.add(integration);
     }
 
     /**
@@ -34,7 +34,7 @@ public class McmmoManager {
      * @return The bonus drop count.
      */
     public int getBonusDropCount(@NotNull final Block block) {
-        for (McmmoWrapper mcmmoWrapper : regsistered) {
+        for (McmmoWrapper mcmmoWrapper : registered) {
             return mcmmoWrapper.getBonusDropCount(block);
         }
         return 0;
@@ -47,7 +47,7 @@ public class McmmoManager {
      * @return If the event is fake.
      */
     public boolean isFake(@NotNull final Event event) {
-        for (McmmoWrapper mcmmoWrapper : regsistered) {
+        for (McmmoWrapper mcmmoWrapper : registered) {
             return mcmmoWrapper.isFake(event);
         }
         return false;

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

@@ -56,7 +56,7 @@ public class PlaceholderManager {
                                    @NotNull final String identifier) {
         Optional<PlaceholderEntry> matching = REGISTERED_PLACEHOLDERS.stream().filter(expansion -> expansion.getIdentifier().equalsIgnoreCase(identifier)).findFirst();
         if (matching.isEmpty()) {
-            return null;
+            return "";
         }
         PlaceholderEntry entry = matching.get();
         if (player == null && entry.requiresPlayer()) {

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

@@ -0,0 +1,36 @@
+package com.willfp.eco.core.integrations.shop;
+
+import lombok.experimental.UtilityClass;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Class to handle shop integrations.
+ */
+@UtilityClass
+public class ShopManager {
+    /**
+     * A set of all registered integrations.
+     */
+    private final Set<ShopWrapper> registered = new HashSet<>();
+
+    /**
+     * Register a new integration.
+     *
+     * @param integration The integration to register.
+     */
+    public void register(@NotNull final ShopWrapper integration) {
+        registered.add(integration);
+    }
+
+    /**
+     * Register eco item provider for shop plugins.
+     */
+    public void registerEcoProvider() {
+        for (ShopWrapper shopWrapper : registered) {
+            shopWrapper.registerEcoProvider();
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.willfp.eco.core.integrations.shop;
+
+/**
+ * Wrapper class for shop integrations.
+ */
+public interface ShopWrapper {
+    /**
+     * Register eco item provider for shop plugins.
+     */
+    void registerEcoProvider();
+}

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

@@ -1,7 +1,6 @@
 package com.willfp.eco.core.items;
 
-import com.willfp.eco.core.items.builder.ItemBuilder;
-import com.willfp.eco.core.items.builder.ItemStackBuilder;
+import com.willfp.eco.core.items.args.LookupArgParser;
 import com.willfp.eco.core.recipe.parts.EmptyTestableItem;
 import com.willfp.eco.core.recipe.parts.MaterialTestableItem;
 import com.willfp.eco.core.recipe.parts.ModifiedTestableItem;
@@ -10,16 +9,19 @@ import com.willfp.eco.util.NamespacedKeyUtils;
 import lombok.experimental.UtilityClass;
 import org.bukkit.Material;
 import org.bukkit.NamespacedKey;
-import org.bukkit.enchantments.Enchantment;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
+import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Predicate;
 
 /**
  * Class to manage all custom and vanilla items.
@@ -29,19 +31,33 @@ public final class Items {
     /**
      * All recipe parts.
      */
-    private static final Map<NamespacedKey, CustomItem> REGISTRY = new HashMap<>();
+    private static final Map<NamespacedKey, CustomItem> REGISTRY = new ConcurrentHashMap<>();
 
     /**
-     * Register a new recipe part.
+     * All recipe parts.
+     */
+    private static final List<LookupArgParser> ARG_PARSERS = new ArrayList<>();
+
+    /**
+     * Register a new custom item.
      *
-     * @param key  The key of the recipe part.
-     * @param part The recipe part.
+     * @param key  The key of the item.
+     * @param part The item.
      */
     public void registerCustomItem(@NotNull final NamespacedKey key,
                                    @NotNull final CustomItem part) {
         REGISTRY.put(key, part);
     }
 
+    /**
+     * Register a new arg parser.
+     *
+     * @param parser The parser.
+     */
+    public void registerArgParser(@NotNull final LookupArgParser parser) {
+        ARG_PARSERS.add(parser);
+    }
+
     /**
      * Remove an item.
      *
@@ -52,14 +68,41 @@ public final class Items {
     }
 
     /**
-     * Lookup item from string.
+     * This is the backbone of the entire eco item system.
      * <p>
-     * Used for recipes.
+     * You can lookup a TestableItem for any material, custom item,
+     * or item in general, and it will return it with any modifiers
+     * passed as parameters. This includes stack size (item amount)
+     * and enchantments that should be present on the item.
+     * <p>
+     * If you want to get an ItemStack instance from this, then just call
+     * {@link TestableItem#getItem()}.
+     * <p>
+     * The advantages of the testable item system are that there is the inbuilt
+     * {@link TestableItem#matches(ItemStack)} - this allows to check if any item
+     * is that testable item; which may sound negligible but actually it allows for
+     * much more power an flexibility. For example, you can have an item with an
+     * extra metadata tag, extra lore lines, different display name - and it
+     * will still work as long as the test passes. This is very important
+     * for custom crafting recipes where other plugins may add metadata
+     * values or the play may rename the item.
      *
-     * @param key The string to test.
-     * @return The found testable item, or an empty item if not found.
+     * @param key The lookup string.
+     * @return The testable item, or an {@link EmptyTestableItem}.
      */
     public TestableItem lookup(@NotNull final String key) {
+        if (key.contains("?")) {
+            String[] options = key.split("\\?");
+            for (String option : options) {
+                TestableItem lookup = lookup(option);
+                if (!(lookup instanceof EmptyTestableItem)) {
+                    return lookup;
+                }
+            }
+
+            return new EmptyTestableItem();
+        }
+
         String[] args = key.split(" ");
         if (args.length == 0) {
             return new EmptyTestableItem();
@@ -67,6 +110,8 @@ public final class Items {
 
         TestableItem item = null;
 
+        int stackAmount = 1;
+
         String[] split = args[0].toLowerCase().split(":");
 
         if (split.length == 1) {
@@ -80,71 +125,83 @@ public final class Items {
         if (split.length == 2) {
             CustomItem part = REGISTRY.get(NamespacedKeyUtils.create(split[0], split[1]));
 
+            /*
+            Legacy id:amount format
+            This has been superseded by id amount
+             */
             if (part == null) {
                 Material material = Material.getMaterial(split[0].toUpperCase());
                 if (material == null || material == Material.AIR) {
                     return new EmptyTestableItem();
                 }
-                item = new TestableStack(new MaterialTestableItem(material), Integer.parseInt(split[1]));
+                item = new MaterialTestableItem(material);
+                stackAmount = Integer.parseInt(split[1]);
             } else {
                 item = part;
             }
         }
 
+        /*
+        Legacy namespace:id:amount format
+        This has been superseded by namespace:id amount
+         */
         if (split.length == 3) {
             CustomItem part = REGISTRY.get(NamespacedKeyUtils.create(split[0], split[1]));
-            item = part == null ? new EmptyTestableItem() : new TestableStack(part, Integer.parseInt(split[2]));
+            if (part == null) {
+                return new EmptyTestableItem();
+            }
+            item = part;
+            stackAmount = Integer.parseInt(split[2]);
         }
 
-        if (item == null || item instanceof EmptyTestableItem) {
+        boolean usingNewStackFormat = false;
+
+        if (args.length >= 2) {
+            try {
+                stackAmount = Integer.parseInt(args[1]);
+                usingNewStackFormat = true;
+            } catch (NumberFormatException ignored) {
+            }
+        }
+
+        if (item == null) {
             return new EmptyTestableItem();
         }
 
-        String[] enchantArgs = Arrays.copyOfRange(args, 1, args.length);
+        ItemStack example = item.getItem();
+        ItemMeta meta = example.getItemMeta();
+        assert meta != null;
 
-        Map<Enchantment, Integer> requiredEnchantments = new HashMap<>();
+        String[] modifierArgs = Arrays.copyOfRange(args, usingNewStackFormat ? 2 : 1, args.length);
 
-        for (String enchantArg : enchantArgs) {
-            String[] enchantArgSplit = enchantArg.split(":");
+        List<Predicate<ItemStack>> predicates = new ArrayList<>();
 
-            Enchantment enchantment = Enchantment.getByKey(NamespacedKey.minecraft(enchantArgSplit[0].toLowerCase()));
-            int level = Integer.parseInt(enchantArgSplit[1]);
-
-            requiredEnchantments.put(enchantment, level);
+        for (LookupArgParser argParser : ARG_PARSERS) {
+            predicates.add(argParser.parseArguments(modifierArgs, meta));
         }
 
-        if (requiredEnchantments.isEmpty()) {
+        example.setItemMeta(meta);
+        if (!predicates.isEmpty()) {
+            item = new ModifiedTestableItem(
+                    item,
+                    test -> {
+                        for (Predicate<ItemStack> predicate : predicates) {
+                            if (!predicate.test(test)) {
+                                return false;
+                            }
+                        }
+
+                        return true;
+                    },
+                    example
+            );
+        }
+
+        if (stackAmount == 1) {
             return item;
+        } else {
+            return new TestableStack(item, stackAmount);
         }
-
-        ItemBuilder builder = new ItemStackBuilder(item.getItem());
-        requiredEnchantments.forEach(builder::addEnchantment);
-        ItemStack example = builder.build();
-
-        return new ModifiedTestableItem(
-                item,
-                itemStack -> {
-                    if (!itemStack.hasItemMeta()) {
-                        return false;
-                    }
-
-                    ItemMeta meta = itemStack.getItemMeta();
-
-                    assert meta != null;
-
-                    for (Map.Entry<Enchantment, Integer> entry : requiredEnchantments.entrySet()) {
-                        if (!meta.hasEnchant(entry.getKey())) {
-                            return false;
-                        }
-                        if (meta.getEnchantLevel(entry.getKey()) < entry.getValue()) {
-                            return false;
-                        }
-                    }
-
-                    return true;
-                },
-                example
-        );
     }
 
     /**
@@ -162,6 +219,22 @@ public final class Items {
         return false;
     }
 
+    /**
+     * Get custom item from item.
+     *
+     * @param itemStack The item.
+     * @return The custom item, or null if not exists.
+     */
+    @Nullable
+    public CustomItem getCustomItem(@NotNull final ItemStack itemStack) {
+        for (CustomItem item : REGISTRY.values()) {
+            if (item.matches(itemStack)) {
+                return item;
+            }
+        }
+        return null;
+    }
+
     /**
      * Get all registered custom items.
      *

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

@@ -0,0 +1,75 @@
+package com.willfp.eco.core.items.args;
+
+import org.bukkit.NamespacedKey;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.EnchantmentStorageMeta;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Predicate;
+
+public class EnchantmentArgParser implements LookupArgParser {
+    @Override
+    public Predicate<ItemStack> parseArguments(@NotNull final String[] args,
+                                               @NotNull final ItemMeta meta) {
+        Map<Enchantment, Integer> requiredEnchantments = new HashMap<>();
+
+        for (String enchantArg : args) {
+            String[] enchantArgSplit = enchantArg.split(":");
+
+            Enchantment enchantment = Enchantment.getByKey(NamespacedKey.minecraft(enchantArgSplit[0].toLowerCase()));
+            if (enchantment == null) {
+                continue;
+            }
+
+            if (enchantArgSplit.length < 2) {
+                continue;
+            }
+
+            int level = Integer.parseInt(enchantArgSplit[1]);
+
+            requiredEnchantments.put(enchantment, level);
+        }
+
+        if (meta instanceof EnchantmentStorageMeta storageMeta) {
+            requiredEnchantments.forEach((enchantment, integer) -> storageMeta.addStoredEnchant(enchantment, integer, true));
+        } else {
+            requiredEnchantments.forEach((enchantment, integer) -> meta.addEnchant(enchantment, integer, true));
+        }
+
+        return test -> {
+            if (!test.hasItemMeta()) {
+                return false;
+            }
+
+            ItemMeta testMeta = test.getItemMeta();
+
+            assert testMeta != null;
+
+            if (testMeta instanceof EnchantmentStorageMeta storageMeta) {
+                for (Map.Entry<Enchantment, Integer> entry : requiredEnchantments.entrySet()) {
+                    if (!storageMeta.hasStoredEnchant(entry.getKey())) {
+                        return false;
+                    }
+                    if (storageMeta.getStoredEnchantLevel(entry.getKey()) < entry.getValue()) {
+                        return false;
+                    }
+                }
+            } else {
+                for (Map.Entry<Enchantment, Integer> entry : requiredEnchantments.entrySet()) {
+                    if (!testMeta.hasEnchant(entry.getKey())) {
+                        return false;
+                    }
+                    if (testMeta.getEnchantLevel(entry.getKey()) < entry.getValue()) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        };
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.willfp.eco.core.items.args;
+
+import com.willfp.eco.core.items.TestableItem;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Predicate;
+
+public interface LookupArgParser {
+    /**
+     * Parse the arguments.
+     * <p>
+     * An argument parser should generate the predicate as well
+     * as modify the ItemMeta for {@link TestableItem#getItem()}
+     *
+     * @param args The arguments.
+     * @param meta The ItemMeta to modify.
+     * @return The predicate test to apply to the modified item.
+     */
+    Predicate<ItemStack> parseArguments(@NotNull String[] args,
+                                        @NotNull ItemMeta meta);
+}

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

@@ -0,0 +1,51 @@
+package com.willfp.eco.core.items.args;
+
+import com.willfp.eco.util.SkullUtils;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Predicate;
+
+public class TextureArgParser implements LookupArgParser {
+    @Override
+    public Predicate<ItemStack> parseArguments(@NotNull final String[] args,
+                                               @NotNull final ItemMeta meta) {
+        String skullTexture = null;
+
+        for (String arg : args) {
+            String[] argSplit = arg.split(":");
+            if (!argSplit[0].equalsIgnoreCase("texture")) {
+                continue;
+            }
+
+            if (argSplit.length < 2) {
+                continue;
+            }
+
+            skullTexture = argSplit[1];
+        }
+
+        if (meta instanceof SkullMeta skullMeta && skullTexture != null) {
+            SkullUtils.setSkullTexture(skullMeta, skullTexture);
+        }
+
+        String finalSkullTexture = skullTexture;
+        return test -> {
+            if (!test.hasItemMeta()) {
+                return false;
+            }
+
+            ItemMeta testMeta = test.getItemMeta();
+
+            assert testMeta != null;
+
+            if (testMeta instanceof SkullMeta skullMeta && finalSkullTexture != null) {
+                return finalSkullTexture.equalsIgnoreCase(SkullUtils.getSkullTexture(skullMeta));
+            }
+
+            return true;
+        };
+    }
+}

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

@@ -17,6 +17,7 @@ public class ModifiedTestableItem implements TestableItem {
     /**
      * The item.
      */
+    @Getter
     private final TestableItem handle;
 
     /**

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

@@ -1,17 +1,12 @@
 package com.willfp.eco.core.recipe.parts;
 
-import com.willfp.eco.core.Eco;
 import com.willfp.eco.core.items.TestableItem;
 import lombok.Getter;
 import org.apache.commons.lang.Validate;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
-import java.util.List;
-
 /**
  * Stacks of items.
  */
@@ -19,6 +14,7 @@ public class TestableStack implements TestableItem {
     /**
      * The item.
      */
+    @Getter
     private final TestableItem handle;
 
     /**
@@ -55,19 +51,7 @@ public class TestableStack implements TestableItem {
     @Override
     public ItemStack getItem() {
         ItemStack temp = handle.getItem().clone();
-        ItemMeta meta = temp.getItemMeta();
-        assert meta != null;
-
-        List<String> lore = meta.hasLore() ? meta.getLore() : new ArrayList<>();
-        assert lore != null;
-        lore.add("");
-        String add = Eco.getHandler().getEcoPlugin().getLangYml().getString("multiple-in-craft");
-        add = add.replace("%amount%", String.valueOf(amount));
-        lore.add(add);
-        meta.setLore(lore);
-        temp.setItemMeta(meta);
         temp.setAmount(amount);
-
         return temp;
     }
 }

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

@@ -1,16 +1,19 @@
 package com.willfp.eco.core.recipe.recipes;
 
+import com.willfp.eco.core.Eco;
 import com.willfp.eco.core.EcoPlugin;
 import com.willfp.eco.core.PluginDependent;
 import com.willfp.eco.core.items.TestableItem;
 import com.willfp.eco.core.recipe.Recipes;
 import com.willfp.eco.core.recipe.parts.EmptyTestableItem;
+import com.willfp.eco.core.recipe.parts.TestableStack;
 import lombok.Getter;
 import org.bukkit.Bukkit;
 import org.bukkit.NamespacedKey;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.RecipeChoice;
 import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.inventory.meta.ItemMeta;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
@@ -87,7 +90,23 @@ public final class ShapedCraftingRecipe extends PluginDependent<EcoPlugin> imple
         displayedRecipe.shape("012", "345", "678");
         for (int i = 0; i < 9; i++) {
             char character = String.valueOf(i).toCharArray()[0];
-            displayedRecipe.setIngredient(character, new RecipeChoice.ExactChoice(parts.get(i).getItem()));
+            ItemStack item = parts.get(i).getItem();
+
+            if (parts.get(i) instanceof TestableStack) {
+                ItemMeta meta = item.getItemMeta();
+                assert meta != null;
+
+                List<String> lore = meta.hasLore() ? meta.getLore() : new ArrayList<>();
+                assert lore != null;
+                lore.add("");
+                String add = Eco.getHandler().getEcoPlugin().getLangYml().getString("multiple-in-craft");
+                add = add.replace("%amount%", String.valueOf(item.getAmount()));
+                lore.add(add);
+                meta.setLore(lore);
+                item.setItemMeta(meta);
+            }
+
+            displayedRecipe.setIngredient(character, new RecipeChoice.ExactChoice(item));
         }
 
         Bukkit.getServer().addRecipe(shapedRecipe);

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

@@ -0,0 +1,22 @@
+package com.willfp.eco.util;
+
+import com.willfp.eco.core.tuples.Pair;
+import lombok.experimental.UtilityClass;
+
+/**
+ * Utilities / API methods for menus.
+ */
+@UtilityClass
+public class MenuUtils {
+    /**
+     * Convert 0-53 slot to row and column pair.
+     *
+     * @param slot The slot.
+     * @return The pair of row and columns.
+     */
+    public Pair<Integer, Integer> convertSlotToRowColumn(final int slot) {
+        int row = Math.floorDiv(slot, 9);
+        int column = slot - row * 9;
+        return new Pair<>(row + 1, column + 1);
+    }
+}

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

@@ -7,6 +7,7 @@ import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 /**
  * Utilities / API methods for player heads.
@@ -23,6 +24,11 @@ public class SkullUtils {
      */
     private BiConsumer<SkullMeta, String> metaSetConsumer = null;
 
+    /**
+     * The meta get function.
+     */
+    private Function<SkullMeta, String> metaGetConsumer = null;
+
     /**
      * Set the texture of a skull from base64.
      *
@@ -37,16 +43,32 @@ public class SkullUtils {
         metaSetConsumer.accept(meta, base64);
     }
 
+    /**
+     * Get the texture of a skull - in base64.
+     *
+     * @param meta The meta to modify.
+     * @return The texture.
+     */
+    public String getSkullTexture(@NotNull final SkullMeta meta) {
+        Validate.isTrue(initialized, "Must be initialized!");
+        Validate.notNull(metaGetConsumer, "Must be initialized!");
+
+        return metaGetConsumer.apply(meta);
+    }
+
     /**
      * Initialize the skull texture function.
      *
-     * @param function The function.
+     * @param function  The function.
+     * @param function2 Get function.
      */
     @ApiStatus.Internal
-    public void initialize(@NotNull final BiConsumer<SkullMeta, String> function) {
+    public void initialize(@NotNull final BiConsumer<SkullMeta, String> function,
+                           @NotNull final Function<SkullMeta, String> function2) {
         Validate.isTrue(!initialized, "Already initialized!");
 
         metaSetConsumer = function;
+        metaGetConsumer = function2;
         initialized = true;
     }
 }

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

@@ -12,7 +12,7 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.awt.*;
+import java.awt.Color;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -48,7 +48,30 @@ public class StringUtils {
             .build();
 
     /**
-     * Format a list of strings - converts Placeholders and Color codes.
+     * Legacy serializer.
+     */
+    private static final LegacyComponentSerializer LEGACY_COMPONENT_SERIALIZER = LegacyComponentSerializer.builder()
+            .character('\u00a7')
+            .useUnusualXRepeatedCharacterHexFormat()
+            .hexColors()
+            .build();
+
+    /**
+     * Format a list of strings.
+     * <p>
+     * Converts color codes and placeholders.
+     *
+     * @param list The messages to format.
+     * @return The message, formatted.
+     */
+    public List<String> formatList(@NotNull final List<String> list) {
+        return formatList(list, (Player) null);
+    }
+
+    /**
+     * Format a list of strings.
+     * <p>
+     * Coverts color codes and placeholders for a player.
      *
      * @param list   The messages to format.
      * @param player The player to translate placeholders with respect to.
@@ -56,26 +79,61 @@ public class StringUtils {
      */
     public List<String> formatList(@NotNull final List<String> list,
                                    @Nullable final Player player) {
+        return formatList(list, player, FormatOption.WITH_PLACEHOLDERS);
+    }
+
+    /**
+     * Format a list of strings.
+     * <p>
+     * Converts color codes and placeholders if specified.
+     *
+     * @param list   The messages to format.
+     * @param option The format option.
+     * @return The message, formatted.
+     */
+    public List<String> formatList(@NotNull final List<String> list,
+                                   @NotNull final FormatOption option) {
+        return formatList(list, null, option);
+    }
+
+    /**
+     * Format a list of strings.
+     * <p>
+     * Coverts color codes and placeholders for a player if specified.
+     *
+     * @param list   The messages to format.
+     * @param player The player to translate placeholders with respect to.
+     * @param option The options.
+     * @return The message, format.
+     */
+    public List<String> formatList(@NotNull final List<String> list,
+                                   @Nullable final Player player,
+                                   @NotNull final FormatOption option) {
         List<String> translated = new ArrayList<>();
         for (String string : list) {
-            translated.add(format(string, player));
+            translated.add(format(string, player, option));
         }
 
         return translated;
     }
 
     /**
-     * Format a list of strings - converts Placeholders and Color codes.
+     * Format a string.
+     * <p>
+     * Converts color codes and placeholders.
      *
-     * @param list The messages to format.
+     * @param message The message to translate.
      * @return The message, formatted.
+     * @see StringUtils#format(String, Player)
      */
-    public List<String> formatList(@NotNull final List<String> list) {
-        return formatList(list, null);
+    public String format(@NotNull final String message) {
+        return format(message, (Player) null);
     }
 
     /**
-     * Format a string - converts Placeholders and Color codes.
+     * Format a string.
+     * <p>
+     * Converts color codes and placeholders for a player.
      *
      * @param message The message to format.
      * @param player  The player to translate placeholders with respect to.
@@ -83,23 +141,45 @@ public class StringUtils {
      */
     public String format(@NotNull final String message,
                          @Nullable final Player player) {
-        String processedMessage = message;
-        processedMessage = translateGradients(processedMessage);
-        processedMessage = PlaceholderManager.translatePlaceholders(processedMessage, player);
-        processedMessage = translateHexColorCodes(processedMessage);
-        processedMessage = ChatColor.translateAlternateColorCodes('&', processedMessage);
-        return processedMessage;
+        return format(message, player, FormatOption.WITH_PLACEHOLDERS);
     }
 
     /**
-     * Format a string without respect to a player.
+     * Format a string.
+     * <p>
+     * Converts color codes and placeholders if specified.
      *
      * @param message The message to translate.
+     * @param option  The format option.
      * @return The message, formatted.
      * @see StringUtils#format(String, Player)
      */
-    public String format(@NotNull final String message) {
-        return format(message, null);
+    public String format(@NotNull final String message,
+                         @NotNull final FormatOption option) {
+        return format(message, null, option);
+    }
+
+    /**
+     * Format a string.
+     * <p>
+     * Coverts color codes and placeholders for a player if specified.
+     *
+     * @param message The message to format.
+     * @param player  The player to translate placeholders with respect to.
+     * @param option  The format options.
+     * @return The message, formatted.
+     */
+    public String format(@NotNull final String message,
+                         @Nullable final Player player,
+                         @NotNull final FormatOption option) {
+        String processedMessage = message;
+        processedMessage = translateGradients(processedMessage);
+        if (option == FormatOption.WITH_PLACEHOLDERS) {
+            processedMessage = PlaceholderManager.translatePlaceholders(processedMessage, player);
+        }
+        processedMessage = translateHexColorCodes(processedMessage);
+        processedMessage = ChatColor.translateAlternateColorCodes('&', processedMessage);
+        return processedMessage;
     }
 
     private static String translateHexColorCodes(@NotNull final String message) {
@@ -246,7 +326,7 @@ public class StringUtils {
     public String legacyToJson(@NotNull final String legacy) {
         return GsonComponentSerializer.gson().serialize(
                 Component.empty().decoration(TextDecoration.ITALIC, false).append(
-                        LegacyComponentSerializer.legacySection().deserialize(legacy)
+                        LEGACY_COMPONENT_SERIALIZER.deserialize(legacy)
                 )
         );
     }
@@ -258,8 +338,23 @@ public class StringUtils {
      * @return The legacy string.
      */
     public String jsonToLegacy(@NotNull final String json) {
-        return LegacyComponentSerializer.legacySection().serialize(
+        return LEGACY_COMPONENT_SERIALIZER.serialize(
                 GsonComponentSerializer.gson().deserialize(json)
         );
     }
+
+    /**
+     * Options for formatting.
+     */
+    public enum FormatOption {
+        /**
+         * Completely formatted.
+         */
+        WITH_PLACEHOLDERS,
+
+        /**
+         * Completely formatted without placeholders.
+         */
+        WITHOUT_PLACEHOLDERS
+    }
 }

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

@@ -11,9 +11,9 @@ import java.util.*
 open class EcoJSONConfigWrapper : JSONConfig {
     val handle: Gson = GsonBuilder().setPrettyPrinting().create()
 
-    val values: MutableMap<String, Any?> = HashMap()
+    val values = mutableMapOf<String, Any?>()
 
-    private val cache: MutableMap<String, Any> = HashMap()
+    private val cache = mutableMapOf<String, Any>()
 
     fun init(values: Map<String, Any?>) {
         this.values.clear()
@@ -138,17 +138,17 @@ open class EcoJSONConfigWrapper : JSONConfig {
 
     override fun getSubsections(path: String): List<JSONConfig> {
         val subsections = getSubsectionsOrNull(path)
-        return subsections ?: ArrayList()
+        return subsections ?: mutableListOf()
     }
 
     override fun getSubsectionsOrNull(path: String): List<JSONConfig>? {
         val maps = getOfKnownType(path, Any::class.java) as List<Map<String, Any>>?
             ?: return null
-        val configs: MutableList<JSONConfig> = ArrayList()
+        val configs = mutableListOf<JSONConfig>()
         for (map in maps) {
             configs.add(EcoJSONConfigSection(map))
         }
-        return configs
+        return configs.toMutableList()
     }
 
     override fun getInt(path: String): Int {
@@ -170,11 +170,11 @@ open class EcoJSONConfigWrapper : JSONConfig {
         return Objects.requireNonNullElse(getOfKnownType(path, Int::class.java), def)
     }
 
-    override fun getInts(path: String): List<Int> {
-        return Objects.requireNonNullElse(getOfKnownType(path, Any::class.java), ArrayList<Any>()) as List<Int>
+    override fun getInts(path: String): MutableList<Int> {
+        return (Objects.requireNonNullElse(getOfKnownType(path, Any::class.java), emptyList<Int>()) as List<Int>).toMutableList()
     }
 
-    override fun getIntsOrNull(path: String): List<Int>? {
+    override fun getIntsOrNull(path: String): MutableList<Int>? {
         return if (has(path)) {
             getInts(path)
         } else {
@@ -194,11 +194,11 @@ open class EcoJSONConfigWrapper : JSONConfig {
         }
     }
 
-    override fun getBools(path: String): List<Boolean> {
-        return Objects.requireNonNullElse(getOfKnownType(path, Any::class.java), ArrayList<Any>()) as List<Boolean>
+    override fun getBools(path: String): MutableList<Boolean> {
+        return (Objects.requireNonNullElse(getOfKnownType(path, Any::class.java), emptyList<Boolean>()) as List<Boolean>).toMutableList()
     }
 
-    override fun getBoolsOrNull(path: String): List<Boolean>? {
+    override fun getBoolsOrNull(path: String): MutableList<Boolean>? {
         return if (has(path)) {
             getBools(path)
         } else {
@@ -206,64 +206,44 @@ open class EcoJSONConfigWrapper : JSONConfig {
         }
     }
 
-    override fun getString(path: String): String {
-        return getString(path, true)
-    }
-
     override fun getString(
         path: String,
-        format: Boolean
+        format: Boolean,
+        option: StringUtils.FormatOption
     ): String {
         val string = getOfKnownType(path, String::class.java) ?: ""
-        return if (format) StringUtils.format(string) else string
-    }
-
-    override fun getStringOrNull(path: String): String? {
-        return if (has(path)) {
-            getString(path)
-        } else {
-            null
-        }
+        return if (format) StringUtils.format(string, option) else string
     }
 
     override fun getStringOrNull(
         path: String,
-        format: Boolean
+        format: Boolean,
+        option: StringUtils.FormatOption
     ): String? {
         return if (has(path)) {
-            getString(path, format)
+            getString(path, format, option)
         } else {
             null
         }
     }
 
-    override fun getStrings(path: String): List<String> {
-        return getStrings(path, true)
-    }
-
     override fun getStrings(
         path: String,
-        format: Boolean
-    ): List<String> {
+        format: Boolean,
+        option: StringUtils.FormatOption
+    ): MutableList<String> {
         val strings =
-            Objects.requireNonNullElse(getOfKnownType(path, Any::class.java), ArrayList<Any>()) as List<String>
-        return if (format) StringUtils.formatList(strings) else strings
-    }
-
-    override fun getStringsOrNull(path: String): List<String>? {
-        return if (has(path)) {
-            getStrings(path)
-        } else {
-            null
-        }
+            (Objects.requireNonNullElse(getOfKnownType(path, Any::class.java), emptyList<String>()) as List<String>).toMutableList()
+        return if (format) StringUtils.formatList(strings, option) else strings
     }
 
     override fun getStringsOrNull(
         path: String,
-        format: Boolean
-    ): List<String>? {
+        format: Boolean,
+        option: StringUtils.FormatOption
+    ): MutableList<String>? {
         return if (has(path)) {
-            getStrings(path, format)
+            getStrings(path, format, option)
         } else {
             null
         }
@@ -281,11 +261,11 @@ open class EcoJSONConfigWrapper : JSONConfig {
         }
     }
 
-    override fun getDoubles(path: String): List<Double> {
-        return Objects.requireNonNullElse(getOfKnownType(path, Any::class.java), ArrayList<Any>()) as List<Double>
+    override fun getDoubles(path: String): MutableList<Double> {
+        return (Objects.requireNonNullElse(getOfKnownType(path, Any::class.java), emptyList<Double>()) as List<Double>).toMutableList()
     }
 
-    override fun getDoublesOrNull(path: String): List<Double>? {
+    override fun getDoublesOrNull(path: String): MutableList<Double>? {
         return if (has(path)) {
             getDoubles(path)
         } else {

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

@@ -27,7 +27,6 @@ class EcoLoadableJSONConfig(
     }
 
     override fun createFile() {
-        val resourcePath = resourcePath
         val inputStream = source.getResourceAsStream(resourcePath)!!
         val outFile = File(this.plugin.dataFolder, resourcePath)
         val lastIndex = resourcePath.lastIndexOf('/')
@@ -37,11 +36,7 @@ class EcoLoadableJSONConfig(
         }
         if (!outFile.exists()) {
             val out: OutputStream = FileOutputStream(outFile)
-            val buf = ByteArray(1024)
-            var len: Int
-            while (inputStream.read(buf).also { len = it } > 0) {
-                out.write(buf, 0, len)
-            }
+            inputStream.copyTo(out, 1024)
             out.close()
             inputStream.close()
         }

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

@@ -1,7 +1,6 @@
 package com.willfp.eco.internal.config.updating
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import com.willfp.eco.core.config.interfaces.LoadableConfig
 import com.willfp.eco.core.config.updating.ConfigHandler
 import com.willfp.eco.core.config.updating.ConfigUpdater
@@ -14,14 +13,14 @@ import org.reflections.scanners.MethodAnnotationsScanner
 import java.lang.reflect.Modifier
 
 class EcoConfigHandler(
-    plugin: EcoPlugin
-) : PluginDependent<EcoPlugin>(plugin), ConfigHandler {
+    private val plugin: EcoPlugin
+) : ConfigHandler {
     private val reflections: Reflections = Reflections(
         this.plugin::class.java.classLoader,
         MethodAnnotationsScanner()
     )
 
-    private val configs: MutableList<LoadableConfig> = ArrayList()
+    private val configs = mutableListOf<LoadableConfig>()
 
     override fun callUpdate() {
         for (method in reflections.getMethodsAnnotatedWith(ConfigUpdater::class.java)) {

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

@@ -31,7 +31,6 @@ open class EcoLoadableYamlConfig(
     }
 
     final override fun createFile() {
-        val resourcePath = resourcePath
         val inputStream = source.getResourceAsStream(resourcePath)!!
         val outFile = File(this.plugin.dataFolder, resourcePath)
         val lastIndex = resourcePath.lastIndexOf('/')
@@ -41,11 +40,7 @@ open class EcoLoadableYamlConfig(
         }
         if (!outFile.exists()) {
             val out: OutputStream = FileOutputStream(outFile)
-            val buf = ByteArray(1024)
-            var len: Int
-            while (inputStream.read(buf).also { len = it } > 0) {
-                out.write(buf, 0, len)
-            }
+            inputStream.copyTo(out, 1024)
             out.close()
             inputStream.close()
         }

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

@@ -10,7 +10,7 @@ import java.io.StringReader
 @Suppress("UNCHECKED_CAST")
 open class EcoYamlConfigWrapper<T : ConfigurationSection> : Config {
     lateinit var handle: T
-    private val cache: MutableMap<String, Any?> = HashMap()
+    private val cache = mutableMapOf<String, Any?>()
 
     protected fun init(config: T): Config {
         handle = config
@@ -98,16 +98,16 @@ open class EcoYamlConfigWrapper<T : ConfigurationSection> : Config {
         }
     }
 
-    override fun getInts(path: String): List<Int> {
+    override fun getInts(path: String): MutableList<Int> {
         return if (cache.containsKey(path)) {
-            cache[path] as List<Int>
+            (cache[path] as MutableList<Int>).toMutableList()
         } else {
-            cache[path] = if (has(path)) ArrayList(handle.getIntegerList(path)) else ArrayList<Any>()
+            cache[path] = if (has(path)) ArrayList(handle.getIntegerList(path)) else mutableListOf<Int>()
             getInts(path)
         }
     }
 
-    override fun getIntsOrNull(path: String): List<Int>? {
+    override fun getIntsOrNull(path: String): MutableList<Int>? {
         return if (has(path)) {
             getInts(path)
         } else {
@@ -132,17 +132,17 @@ open class EcoYamlConfigWrapper<T : ConfigurationSection> : Config {
         }
     }
 
-    override fun getBools(path: String): List<Boolean> {
+    override fun getBools(path: String): MutableList<Boolean> {
         return if (cache.containsKey(path)) {
-            cache[path] as List<Boolean>
+            (cache[path] as MutableList<Boolean>).toMutableList()
         } else {
             cache[path] =
-                if (has(path)) ArrayList(handle.getBooleanList(path)) else ArrayList<Any>()
+                if (has(path)) ArrayList(handle.getBooleanList(path)) else mutableListOf<Boolean>()
             getBools(path)
         }
     }
 
-    override fun getBoolsOrNull(path: String): List<Boolean>? {
+    override fun getBoolsOrNull(path: String): MutableList<Boolean>? {
         return if (has(path)) {
             getBools(path)
         } else {
@@ -150,91 +150,80 @@ open class EcoYamlConfigWrapper<T : ConfigurationSection> : Config {
         }
     }
 
-    override fun getString(path: String): String {
-        return getString(path, true)
-    }
-
     override fun getString(
         path: String,
-        format: Boolean
+        format: Boolean,
+        option: StringUtils.FormatOption
     ): String {
-        if (format) {
+        if (format && option == StringUtils.FormatOption.WITHOUT_PLACEHOLDERS) {
             return if (cache.containsKey("$path\$FMT")) {
                 cache["$path\$FMT"] as String
             } else {
                 val string: String = handle.getString(path, "")!!
-                cache["$path\$FMT"] = StringUtils.format(string)
-                getString(path, format)
+                cache["$path\$FMT"] = StringUtils.format(string, option)
+                getString(path, format, option)
             }
         } else {
-            return if (cache.containsKey(path)) {
+            val string = if (cache.containsKey(path)) {
                 cache[path] as String
             } else {
                 cache[path] = handle.getString(path, "")!!
-                getString(path)
+                getString(path, format, option)
             }
-        }
-    }
 
-    override fun getStringOrNull(path: String): String? {
-        return if (has(path)) {
-            getString(path)
-        } else {
-            null
+            return if (format) StringUtils.format(string) else string
         }
     }
 
     override fun getStringOrNull(
         path: String,
-        format: Boolean
+        format: Boolean,
+        option: StringUtils.FormatOption
     ): String? {
         return if (has(path)) {
-            getString(path, format)
+            getString(path, format, option)
         } else {
             null
         }
     }
 
-    override fun getStrings(path: String): List<String> {
-        return getStrings(path, true)
-    }
-
     override fun getStrings(
         path: String,
-        format: Boolean
-    ): List<String> {
-        if (format) {
+        format: Boolean,
+        option: StringUtils.FormatOption
+    ): MutableList<String> {
+        if (format && option == StringUtils.FormatOption.WITHOUT_PLACEHOLDERS) {
             return if (cache.containsKey("$path\$FMT")) {
-                cache["$path\$FMT"] as List<String>
+                (cache["$path\$FMT"] as MutableList<String>).toMutableList()
             } else {
-                cache["$path\$FMT"] = StringUtils.formatList(if (has(path)) ArrayList(handle.getStringList(path)) else ArrayList<String>())
-                getStrings(path, true)
+                val list = if (has(path)) handle.getStringList(path) else mutableListOf<String>()
+                cache["$path\$FMT"] = StringUtils.formatList(list, option)
+                getStrings(path, true, option)
             }
         } else {
-            return if (cache.containsKey(path)) {
-                cache[path] as List<String>
+            val strings = if (cache.containsKey(path)) {
+                (cache[path] as MutableList<String>).toMutableList()
             } else {
                 cache[path] =
-                    if (has(path)) ArrayList(handle.getStringList(path)) else ArrayList<Any>()
-                getStrings(path, false)
+                    if (has(path)) ArrayList(handle.getStringList(path)) else mutableListOf<String>()
+                getStrings(path, false, option)
             }
-        }
-    }
 
-    override fun getStringsOrNull(path: String): List<String>? {
-        return if (has(path)) {
-            getStrings(path)
-        } else {
-            null
+            return if (format) {
+                StringUtils.formatList(strings, StringUtils.FormatOption.WITH_PLACEHOLDERS)
+            } else {
+                strings
+            }
         }
     }
 
     override fun getStringsOrNull(
         path: String,
-        format: Boolean
-    ): List<String>? {
+        format: Boolean,
+        option: StringUtils.FormatOption
+    ): MutableList<String>? {
         return if (has(path)) {
-            getStrings(path, format)
+            getStrings(path, format, option)
         } else {
             null
         }
@@ -257,16 +246,16 @@ open class EcoYamlConfigWrapper<T : ConfigurationSection> : Config {
         }
     }
 
-    override fun getDoubles(path: String): List<Double> {
+    override fun getDoubles(path: String): MutableList<Double> {
         return if (cache.containsKey(path)) {
-            cache[path] as List<Double>
+            (cache[path] as MutableList<Double>).toMutableList()
         } else {
-            cache[path] = if (has(path)) ArrayList(handle.getDoubleList(path)) else ArrayList<Any>()
+            cache[path] = if (has(path)) ArrayList(handle.getDoubleList(path)) else emptyList<Double>()
             getDoubles(path)
         }
     }
 
-    override fun getDoublesOrNull(path: String): List<Double>? {
+    override fun getDoublesOrNull(path: String): MutableList<Double>? {
         return if (has(path)) {
             getDoubles(path)
         } else {

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

@@ -13,12 +13,12 @@ import org.bukkit.inventory.ItemStack
 import org.bukkit.util.Vector
 
 open class EcoDropQueue(player: Player) : InternalDropQueue {
-    val items: MutableList<ItemStack>
-    var xp: Int
+    val items = mutableListOf<ItemStack>()
+    var xp: Int = 0
     val player: Player
     var loc: Location
+    var hasTelekinesis = false
 
-    private var hasTelekinesis = false
     override fun addItem(item: ItemStack): InternalDropQueue {
         items.add(item)
         return this
@@ -79,8 +79,6 @@ open class EcoDropQueue(player: Player) : InternalDropQueue {
     }
 
     init {
-        items = ArrayList()
-        xp = 0
         this.player = player
         loc = player.location
     }

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

@@ -10,11 +10,14 @@ class EcoFastCollatedDropQueue(player: Player) : EcoDropQueue(player) {
         val fetched = COLLATED_MAP[player]
 
         if (fetched == null) {
-            COLLATED_MAP[player] = CollatedDrops(items, loc, xp)
+            COLLATED_MAP[player] = CollatedDrops(items, loc, xp, hasTelekinesis)
         } else {
             fetched.addDrops(items)
             fetched.location = loc
             fetched.addXp(xp)
+            if (this.hasTelekinesis) {
+                fetched.forceTelekinesis()
+            }
 
             COLLATED_MAP[player] = fetched
         }
@@ -23,8 +26,10 @@ class EcoFastCollatedDropQueue(player: Player) : EcoDropQueue(player) {
     class CollatedDrops(
         val drops: MutableList<ItemStack>,
         var location: Location,
-        var xp: Int
+        var xp: Int,
+        var telekinetic: Boolean
     ) {
+
         fun addDrops(toAdd: List<ItemStack>): CollatedDrops {
             drops.addAll(toAdd)
             return this
@@ -34,6 +39,10 @@ class EcoFastCollatedDropQueue(player: Player) : EcoDropQueue(player) {
             this.xp += xp
             return this
         }
+
+        fun forceTelekinesis() {
+            telekinetic = true
+        }
     }
 
     companion object {

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

@@ -1,13 +1,12 @@
 package com.willfp.eco.internal.events
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import com.willfp.eco.core.events.EventManager
 import org.bukkit.Bukkit
 import org.bukkit.event.HandlerList
 import org.bukkit.event.Listener
 
-class EcoEventManager constructor(plugin: EcoPlugin) : PluginDependent<EcoPlugin>(plugin), EventManager {
+class EcoEventManager constructor(private val plugin: EcoPlugin) : EventManager {
     override fun registerListener(listener: Listener) {
         Bukkit.getPluginManager().registerEvents(listener, plugin)
     }

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

@@ -2,7 +2,6 @@ package com.willfp.eco.internal.extensions
 
 import com.google.common.collect.ImmutableSet
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import com.willfp.eco.core.config.yaml.YamlTransientConfig
 import com.willfp.eco.core.extensions.Extension
 import com.willfp.eco.core.extensions.ExtensionLoader
@@ -16,9 +15,9 @@ import java.net.URL
 import java.net.URLClassLoader
 
 class EcoExtensionLoader(
-    plugin: EcoPlugin
-) : PluginDependent<EcoPlugin>(plugin), ExtensionLoader {
-    private val extensions: MutableMap<Extension, URLClassLoader> = HashMap()
+    private val plugin: EcoPlugin
+) : ExtensionLoader {
+    private val extensions = mutableMapOf<Extension, URLClassLoader>()
 
     override fun loadExtensions() {
         val dir = File(this.plugin.dataFolder, "/extensions")
@@ -43,7 +42,7 @@ class EcoExtensionLoader(
 
     @Throws(MalformedExtensionException::class)
     private fun loadExtension(extensionJar: File) {
-        lateinit var url : URL
+        lateinit var url: URL
 
         try {
             url = extensionJar.toURI().toURL()
@@ -53,7 +52,7 @@ class EcoExtensionLoader(
 
         val classLoader = URLClassLoader(arrayOf(url), this.plugin::class.java.classLoader)
         val ymlIn = classLoader.getResourceAsStream("extension.yml")
-            ?: throw MalformedExtensionException ("No extension.yml found in " + extensionJar.name)
+            ?: throw MalformedExtensionException("No extension.yml found in " + extensionJar.name)
 
         val extensionYml = YamlTransientConfig(YamlConfiguration.loadConfiguration(InputStreamReader(ymlIn)))
 
@@ -64,7 +63,7 @@ class EcoExtensionLoader(
 
 
         if (mainClass == null) {
-            throw MalformedExtensionException ("Invalid extension.yml found in " + extensionJar.name)
+            throw MalformedExtensionException("Invalid extension.yml found in " + extensionJar.name)
         }
 
         if (name == null) {

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

@@ -1,11 +1,10 @@
 package com.willfp.eco.internal.factory
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import com.willfp.eco.core.factory.MetadataValueFactory
 import org.bukkit.metadata.FixedMetadataValue
 
-class EcoMetadataValueFactory(plugin: EcoPlugin) : PluginDependent<EcoPlugin>(plugin), MetadataValueFactory {
+class EcoMetadataValueFactory(private val plugin: EcoPlugin) : MetadataValueFactory {
     override fun create(value: Any): FixedMetadataValue {
         return FixedMetadataValue(plugin, value)
     }

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

@@ -1,11 +1,10 @@
 package com.willfp.eco.internal.factory
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import com.willfp.eco.core.factory.NamespacedKeyFactory
 import org.bukkit.NamespacedKey
 
-class EcoNamespacedKeyFactory(plugin: EcoPlugin) : PluginDependent<EcoPlugin>(plugin), NamespacedKeyFactory {
+class EcoNamespacedKeyFactory(private val plugin: EcoPlugin) : NamespacedKeyFactory {
     override fun create(key: String): NamespacedKey {
         return NamespacedKey(plugin, key)
     }

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

@@ -1,13 +1,12 @@
 package com.willfp.eco.internal.factory
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import com.willfp.eco.core.factory.RunnableFactory
 import com.willfp.eco.core.scheduling.RunnableTask
 import com.willfp.eco.internal.scheduling.EcoRunnableTask
 import java.util.function.Consumer
 
-class EcoRunnableFactory(plugin: EcoPlugin) : PluginDependent<EcoPlugin>(plugin), RunnableFactory {
+class EcoRunnableFactory(private val plugin: EcoPlugin) : RunnableFactory {
     override fun create(consumer: Consumer<RunnableTask>): RunnableTask {
         return object : EcoRunnableTask(plugin) {
             override fun run() {

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

@@ -1,6 +1,7 @@
 package com.willfp.eco.internal.fast
 
 import com.willfp.eco.core.fast.FastItemStack
+import org.bukkit.inventory.ItemFlag
 import org.bukkit.inventory.ItemStack
 
 abstract class EcoFastItemStack<T: Any>(
@@ -10,4 +11,8 @@ abstract class EcoFastItemStack<T: Any>(
     override fun unwrap(): ItemStack {
         return bukkit
     }
+
+    fun getBitModifier(hideFlag: ItemFlag): Int {
+        return 1 shl hideFlag.ordinal
+    }
 }

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

@@ -3,14 +3,12 @@ package com.willfp.eco.internal.gui
 import com.willfp.eco.core.gui.GUIFactory
 import com.willfp.eco.core.gui.menu.MenuBuilder
 import com.willfp.eco.core.gui.slot.SlotBuilder
+import com.willfp.eco.core.gui.slot.functional.SlotProvider
 import com.willfp.eco.internal.gui.menu.EcoMenuBuilder
 import com.willfp.eco.internal.gui.slot.EcoSlotBuilder
-import org.bukkit.entity.Player
-import org.bukkit.inventory.ItemStack
-import java.util.function.Function
 
 class EcoGUIFactory : GUIFactory {
-    override fun createSlotBuilder(provider: Function<Player, ItemStack>): SlotBuilder {
+    override fun createSlotBuilder(provider: SlotProvider): SlotBuilder {
         return EcoSlotBuilder(provider)
     }
 

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

@@ -1,23 +1,25 @@
 package com.willfp.eco.internal.gui.menu
 
+import com.willfp.eco.core.gui.menu.CloseHandler
 import com.willfp.eco.core.gui.menu.Menu
-import com.willfp.eco.core.gui.slot.FillerSlot
 import com.willfp.eco.core.gui.slot.Slot
-import com.willfp.eco.internal.gui.slot.EcoFillerSlot
+import com.willfp.eco.internal.gui.slot.EcoSlot
 import com.willfp.eco.util.StringUtils
 import org.bukkit.Bukkit
+import org.bukkit.NamespacedKey
 import org.bukkit.entity.Player
 import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.inventory.Inventory
-import java.util.function.Consumer
+import org.bukkit.inventory.ItemStack
+import org.bukkit.persistence.PersistentDataType
 
+@Suppress("UNCHECKED_CAST")
 class EcoMenu(
     private val rows: Int,
-    private val slots: List<MutableList<Slot>>,
+    val slots: List<MutableList<EcoSlot>>,
     private val title: String,
-    private val onClose: Consumer<InventoryCloseEvent>
+    private val onClose: CloseHandler
 ): Menu {
-
     override fun getSlot(row: Int, column: Int): Slot {
         if (row < 1 || row > this.rows) {
             throw IllegalArgumentException("Invalid row number!")
@@ -27,14 +29,7 @@ class EcoMenu(
             throw IllegalArgumentException("Invalid column number!")
         }
 
-        val slot = slots[row - 1][column - 1]
-        if (slot is FillerSlot) {
-            slots[row - 1][column - 1] = EcoFillerSlot(slot.itemStack)
-
-            return getSlot(row, column)
-        }
-
-        return slot
+        return slots[row - 1][column - 1]
     }
 
     override fun open(player: Player): Inventory {
@@ -46,7 +41,7 @@ class EcoMenu(
                 if (i == rows * 9) {
                     break
                 }
-                val slotItem = item.getItemStack(player)
+                val slotItem = item.getItemStack(player, this)
                 val meta = slotItem.itemMeta
                 if (meta != null) {
                     val lore = meta.lore
@@ -67,7 +62,8 @@ class EcoMenu(
     }
 
     fun handleClose(event: InventoryCloseEvent) {
-        onClose.accept(event)
+        onClose.handle(event, this)
+        MenuHandler.unregisterMenu(event.inventory)
     }
 
     override fun getRows(): Int {
@@ -77,4 +73,34 @@ class EcoMenu(
     override fun getTitle(): String {
         return title
     }
+
+    override fun getCaptiveItems(player: Player): MutableList<ItemStack> {
+        val inventory = MenuHandler.getExtendedInventory(player.openInventory.topInventory)
+        inventory ?: return mutableListOf()
+        return inventory.captiveItems
+    }
+
+    override fun <T : Any, Z : Any> writeData(
+        player: Player,
+        key: NamespacedKey,
+        type: PersistentDataType<T, Z>,
+        value: Z
+    ) {
+        val inventory = MenuHandler.getExtendedInventory(player.openInventory.topInventory)
+        inventory ?: return
+        inventory.data[key] = value
+        inventory.refresh(player)
+    }
+
+    override fun <T : Any, Z : Any> readData(player: Player, key: NamespacedKey, type: PersistentDataType<T, Z>): T? {
+        val inventory = MenuHandler.getExtendedInventory(player.openInventory.topInventory)
+        inventory ?: return null
+        return inventory.data[key] as T?
+    }
+
+    override fun getKeys(player: Player): MutableSet<NamespacedKey> {
+        val inventory = MenuHandler.getExtendedInventory(player.openInventory.topInventory)
+        inventory ?: return HashSet()
+        return inventory.data.keys
+    }
 }

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

@@ -1,22 +1,24 @@
 package com.willfp.eco.internal.gui.menu
 
+import com.willfp.eco.core.gui.menu.CloseHandler
 import com.willfp.eco.core.gui.menu.Menu
 import com.willfp.eco.core.gui.menu.MenuBuilder
 import com.willfp.eco.core.gui.slot.FillerMask
+import com.willfp.eco.core.gui.slot.FillerSlot
 import com.willfp.eco.core.gui.slot.Slot
 import com.willfp.eco.internal.gui.slot.EcoFillerSlot
+import com.willfp.eco.internal.gui.slot.EcoSlot
 import com.willfp.eco.util.ListUtils
 import com.willfp.eco.util.StringUtils
 import org.bukkit.Material
-import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.inventory.ItemStack
 import java.util.function.Consumer
 
 class EcoMenuBuilder(private val rows: Int) : MenuBuilder {
     private var title = "Menu"
     private var maskSlots: List<MutableList<Slot?>>
-    private val slots: List<MutableList<Slot>> = ListUtils.create2DList(rows, 9)
-    private var onClose = Consumer { _: InventoryCloseEvent -> }
+    private val slots: List<MutableList<Slot?>> = ListUtils.create2DList(rows, 9)
+    private var onClose = CloseHandler { _, _ -> }
 
     override fun setTitle(title: String): MenuBuilder {
         this.title = StringUtils.format(title)
@@ -34,35 +36,45 @@ class EcoMenuBuilder(private val rows: Int) : MenuBuilder {
         return this
     }
 
+    override fun modfiy(modifier: Consumer<MenuBuilder>): MenuBuilder {
+        modifier.accept(this)
+        return this
+    }
+
     override fun setMask(mask: FillerMask): MenuBuilder {
         maskSlots = mask.mask
         return this
     }
 
-    override fun onClose(action: Consumer<InventoryCloseEvent>): MenuBuilder {
+    override fun onClose(action: CloseHandler): MenuBuilder {
         onClose = action
         return this
     }
 
     override fun build(): Menu {
-        val finalSlots: MutableList<MutableList<Slot>> = ArrayList()
-
-        for (maskRow in maskSlots) {
-            val row = ArrayList<Slot>()
-            for (slot in maskRow) {
-                row.add(slot ?: EcoFillerSlot(ItemStack(Material.AIR)))
-            }
-            finalSlots.add(ArrayList())
-            finalSlots.add(row)
-        }
+        val tempSlots: MutableList<MutableList<Slot?>> = ArrayList(maskSlots)
 
         for (i in slots.indices) {
             for (j in slots[i].indices) {
-                val slot = slots[i][j]
-                finalSlots[i][j] = slot
+                val slot = slots[i][j] ?: continue
+                tempSlots[i][j] = slot
             }
         }
 
+        val finalSlots = mutableListOf<MutableList<EcoSlot>>()
+
+        for (row in tempSlots) {
+            val tempRow = mutableListOf<EcoSlot>()
+            for (slot in row) {
+                var tempSlot = slot
+                if (tempSlot is FillerSlot) {
+                    tempSlot = EcoFillerSlot(tempSlot.itemStack)
+                }
+                tempRow.add((tempSlot ?: EcoFillerSlot(ItemStack(Material.AIR))) as EcoSlot)
+            }
+            finalSlots.add(tempRow)
+        }
+
         return EcoMenu(rows, finalSlots, title, onClose)
     }
 

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

@@ -0,0 +1,57 @@
+package com.willfp.eco.internal.gui.menu
+
+import com.willfp.eco.internal.gui.slot.EcoCaptivatorSlot
+import com.willfp.eco.util.MenuUtils
+import com.willfp.eco.util.StringUtils
+import org.bukkit.NamespacedKey
+import org.bukkit.entity.Player
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.ItemStack
+
+class ExtendedInventory(
+    val inventory: Inventory,
+    private val menu: EcoMenu
+) {
+    val captiveItems = mutableListOf<ItemStack>()
+    val data = mutableMapOf<NamespacedKey, Any>()
+
+    fun refresh(player: Player) {
+        captiveItems.clear()
+        for (i in 0 until inventory.size) {
+            val pair = MenuUtils.convertSlotToRowColumn(i)
+            val row = pair.first!!
+            val column = pair.second!!
+            val slot = menu.getSlot(row, column)
+            if (slot is EcoCaptivatorSlot) {
+                val defaultItem = slot.getItemStack(player)
+                val item = inventory.getItem(i) ?: continue
+                if (item != defaultItem) {
+                    captiveItems.add(item)
+                }
+            }
+        }
+
+        var i = 0
+        for (row in menu.slots) {
+            for (slot in row) {
+                if (i == menu.rows * 9) {
+                    break
+                }
+                val slotItem = slot.getItemStack(player, menu)
+                val meta = slotItem.itemMeta
+                if (meta != null) {
+                    val lore = meta.lore
+                    if (lore != null) {
+                        lore.replaceAll{ s -> StringUtils.format(s, player) }
+                        meta.lore = lore
+                    }
+                    slotItem.itemMeta = meta
+                }
+                if (!slot.isCaptive) {
+                    inventory.setItem(i, slotItem)
+                }
+                i++
+            }
+        }
+    }
+}

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

@@ -4,20 +4,28 @@ import com.willfp.eco.core.gui.menu.Menu
 import org.bukkit.inventory.Inventory
 
 object MenuHandler {
-    private val MENUS: MutableMap<Inventory, Menu> = HashMap()
+    private val menus = mutableMapOf<ExtendedInventory, EcoMenu>()
+    private val inventories = mutableMapOf<Inventory, ExtendedInventory>()
 
     fun registerMenu(
         inventory: Inventory,
-        menu: Menu
+        menu: EcoMenu
     ) {
-        MENUS[inventory] = menu
+        val extendedInventory = ExtendedInventory(inventory, menu)
+        inventories[inventory] = extendedInventory
+        menus[extendedInventory] = menu
     }
 
     fun unregisterMenu(inventory: Inventory) {
-        MENUS.remove(inventory)
+        menus.remove(inventories[inventory])
+        inventories.remove(inventory)
     }
 
     fun getMenu(inventory: Inventory): Menu? {
-        return MENUS[inventory]
+        return menus[inventories[inventory]]
+    }
+
+    fun getExtendedInventory(inventory: Inventory): ExtendedInventory? {
+        return inventories[inventory]
     }
 }

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

@@ -0,0 +1,28 @@
+package com.willfp.eco.internal.gui.slot
+
+import com.willfp.eco.core.Eco
+import com.willfp.eco.core.gui.slot.functional.SlotHandler
+import org.bukkit.Material
+import org.bukkit.inventory.ItemStack
+
+class EcoCaptivatorSlot : EcoSlot(
+    { _, _ -> ItemStack(Material.AIR) },
+    allowMovingItem,
+    allowMovingItem,
+    allowMovingItem,
+    allowMovingItem,
+    allowMovingItem,
+    { _, _, _ -> }
+) {
+    companion object {
+        val plugin = Eco.getHandler().ecoPlugin!!
+
+        val allowMovingItem = SlotHandler { event, _, _ ->
+            event.isCancelled = false
+        }
+    }
+
+    override fun isCaptive(): Boolean {
+        return true
+    }
+}

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

@@ -1,13 +1,13 @@
 package com.willfp.eco.internal.gui.slot
 
 import org.bukkit.inventory.ItemStack
-import java.util.function.Function
 
 class EcoFillerSlot(itemStack: ItemStack) : EcoSlot(
-    Function { itemStack },
-    { _, _ -> },
-    { _, _ -> },
-    { _, _ -> },
-    { _, _ -> },
-    { _, _ -> }
+    { _, _ -> itemStack },
+    { _, _, _ -> },
+    { _, _, _ -> },
+    { _, _, _ -> },
+    { _, _, _ -> },
+    { _, _, _ -> },
+    { _, _, _ -> }
 )

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

@@ -1,34 +1,58 @@
 package com.willfp.eco.internal.gui.slot
 
+import com.willfp.eco.core.gui.menu.Menu
 import com.willfp.eco.core.gui.slot.Slot
+import com.willfp.eco.core.gui.slot.functional.SlotHandler
+import com.willfp.eco.core.gui.slot.functional.SlotModifier
+import com.willfp.eco.core.gui.slot.functional.SlotProvider
+import com.willfp.eco.internal.gui.menu.MenuHandler
 import org.bukkit.entity.Player
 import org.bukkit.event.inventory.ClickType
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.inventory.ItemStack
-import java.util.function.BiConsumer
-import java.util.function.Function
 
 open class EcoSlot(
-    private val provider: Function<Player, ItemStack>,
-    private val onLeftClick: BiConsumer<InventoryClickEvent, Slot>,
-    private val onRightClick: BiConsumer<InventoryClickEvent, Slot>,
-    private val onShiftLeftClick: BiConsumer<InventoryClickEvent, Slot>,
-    private val onShiftRightClick: BiConsumer<InventoryClickEvent, Slot>,
-    private val onMiddleClick: BiConsumer<InventoryClickEvent, Slot>
+    private val provider: SlotProvider,
+    private val onLeftClick: SlotHandler,
+    private val onRightClick: SlotHandler,
+    private val onShiftLeftClick: SlotHandler,
+    private val onShiftRightClick: SlotHandler,
+    private val onMiddleClick: SlotHandler,
+    private val modifier: SlotModifier
 ) : Slot {
 
-    fun handleInventoryClick(event: InventoryClickEvent) {
+    fun handleInventoryClick(
+        event: InventoryClickEvent,
+        menu: Menu
+    ) {
         when (event.click) {
-            ClickType.LEFT -> this.onLeftClick.accept(event, this)
-            ClickType.RIGHT -> this.onRightClick.accept(event, this)
-            ClickType.SHIFT_LEFT -> this.onShiftLeftClick.accept(event, this)
-            ClickType.SHIFT_RIGHT -> this.onShiftRightClick.accept(event, this)
-            ClickType.MIDDLE -> this.onMiddleClick.accept(event, this)
-            else -> { }
+            ClickType.LEFT -> this.onLeftClick.handle(event, this, menu)
+            ClickType.RIGHT -> this.onRightClick.handle(event, this, menu)
+            ClickType.SHIFT_LEFT -> this.onShiftLeftClick.handle(event, this, menu)
+            ClickType.SHIFT_RIGHT -> this.onShiftRightClick.handle(event, this, menu)
+            ClickType.MIDDLE -> this.onMiddleClick.handle(event, this, menu)
+            else -> {
+            }
         }
     }
 
     override fun getItemStack(player: Player): ItemStack {
-        return provider.apply(player)
+        val menu = MenuHandler.getMenu(player.openInventory.topInventory)!!
+        val prev = provider.provide(player, menu)
+        modifier.modify(player, menu, prev)
+        return prev
+    }
+
+    fun getItemStack(
+        player: Player,
+        menu: Menu
+    ): ItemStack {
+        val prev = provider.provide(player, menu)
+        modifier.modify(player, menu, prev)
+        return prev
+    }
+
+    override fun isCaptive(): Boolean {
+        return false
     }
 }

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

@@ -2,45 +2,65 @@ package com.willfp.eco.internal.gui.slot
 
 import com.willfp.eco.core.gui.slot.Slot
 import com.willfp.eco.core.gui.slot.SlotBuilder
-import org.bukkit.entity.Player
-import org.bukkit.event.inventory.InventoryClickEvent
-import org.bukkit.inventory.ItemStack
-import java.util.function.BiConsumer
-import java.util.function.Function
+import com.willfp.eco.core.gui.slot.functional.SlotHandler
+import com.willfp.eco.core.gui.slot.functional.SlotModifier
+import com.willfp.eco.core.gui.slot.functional.SlotProvider
 
-class EcoSlotBuilder(private val provider: Function<Player, ItemStack>) : SlotBuilder {
-    private var onLeftClick: BiConsumer<InventoryClickEvent, Slot> = BiConsumer { _, _ -> run { } }
-    private var onRightClick: BiConsumer<InventoryClickEvent, Slot> = BiConsumer { _, _ -> run { } }
-    private var onShiftLeftClick: BiConsumer<InventoryClickEvent, Slot> = BiConsumer { _, _ -> run { } }
-    private var onShiftRightClick: BiConsumer<InventoryClickEvent, Slot> = BiConsumer { _, _ -> run { } }
-    private var onMiddleClick: BiConsumer<InventoryClickEvent, Slot> = BiConsumer { _, _ -> run { } }
+class EcoSlotBuilder(private val provider: SlotProvider) : SlotBuilder {
+    private var captive = false
+    private var modifier: SlotModifier = SlotModifier{ player, menu, _ -> provider.provide(player, menu)}
 
-    override fun onLeftClick(action: BiConsumer<InventoryClickEvent, Slot>): SlotBuilder {
+    private var onLeftClick =
+        SlotHandler { _, _, _ -> run { } }
+    private var onRightClick =
+        SlotHandler { _, _, _ -> run { } }
+    private var onShiftLeftClick =
+        SlotHandler { _, _, _ -> run { } }
+    private var onShiftRightClick =
+        SlotHandler { _, _, _ -> run { } }
+    private var onMiddleClick =
+        SlotHandler { _, _, _ -> run { } }
+
+    override fun onLeftClick(action: SlotHandler): SlotBuilder {
         onLeftClick = action
         return this
     }
 
-    override fun onRightClick(action: BiConsumer<InventoryClickEvent, Slot>): SlotBuilder {
+    override fun onRightClick(action: SlotHandler): SlotBuilder {
         onRightClick = action
         return this
     }
 
-    override fun onShiftLeftClick(action: BiConsumer<InventoryClickEvent, Slot>): SlotBuilder {
+    override fun onShiftLeftClick(action: SlotHandler): SlotBuilder {
         onShiftLeftClick = action
         return this
     }
 
-    override fun onShiftRightClick(action: BiConsumer<InventoryClickEvent, Slot>): SlotBuilder {
+    override fun onShiftRightClick(action: SlotHandler): SlotBuilder {
         onShiftRightClick = action
         return this
     }
 
-    override fun onMiddleClick(action: BiConsumer<InventoryClickEvent, Slot>): SlotBuilder {
+    override fun onMiddleClick(action: SlotHandler): SlotBuilder {
         onMiddleClick = action
         return this
     }
 
+    override fun setCaptive(): SlotBuilder {
+        captive = true
+        return this
+    }
+
+    override fun setModifier(modifier: SlotModifier): SlotBuilder {
+        this.modifier = modifier
+        return this
+    }
+
     override fun build(): Slot {
-        return EcoSlot(provider, onLeftClick, onRightClick, onShiftLeftClick, onShiftRightClick, onMiddleClick)
+        return if (captive) {
+            EcoCaptivatorSlot()
+        } else {
+            EcoSlot(provider, onLeftClick, onRightClick, onShiftLeftClick, onShiftRightClick, onMiddleClick, modifier)
+        }
     }
 }

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

@@ -1,7 +1,6 @@
-package com.willfp.eco.internal.proxy;
+package com.willfp.eco.internal.proxy
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import com.willfp.eco.core.proxy.AbstractProxy
 import com.willfp.eco.core.proxy.ProxyConstants
 import com.willfp.eco.core.proxy.ProxyFactory
@@ -11,8 +10,8 @@ import java.net.URLClassLoader
 import java.util.*
 
 class EcoProxyFactory(
-    plugin: EcoPlugin
-) : PluginDependent<EcoPlugin>(plugin), ProxyFactory {
+    private val plugin: EcoPlugin
+) : ProxyFactory {
     private val proxyClassLoader: ClassLoader = plugin::class.java.classLoader
     private val cache: MutableMap<Class<out AbstractProxy>, AbstractProxy> = IdentityHashMap()
 

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

@@ -1,12 +1,11 @@
 package com.willfp.eco.internal.scheduling
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import com.willfp.eco.core.scheduling.Scheduler
 import org.bukkit.Bukkit
 import org.bukkit.scheduler.BukkitTask
 
-class EcoScheduler(plugin: EcoPlugin) : PluginDependent<EcoPlugin>(plugin), Scheduler {
+class EcoScheduler(private val plugin: EcoPlugin) : Scheduler {
     override fun runLater(
         runnable: Runnable,
         ticksLater: Long

eco-core/core-nms/v1_16_R3/src/main/java/com/willfp/eco/proxy/v1_16_R3/FastItemStackUtils.java

@@ -0,0 +1,43 @@
+package com.willfp.eco.proxy.v1_16_R3;
+
+import org.bukkit.craftbukkit.libs.org.apache.commons.lang3.Validate;
+import org.bukkit.craftbukkit.v1_16_R3.inventory.CraftItemStack;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Field;
+
+public class FastItemStackUtils {
+    private static final Field FIELD;
+
+    public static net.minecraft.server.v1_16_R3.ItemStack getNMSStack(@NotNull final ItemStack itemStack) {
+        if (!(itemStack instanceof CraftItemStack)) {
+            return CraftItemStack.asNMSCopy(itemStack);
+        } else {
+            try {
+                net.minecraft.server.v1_16_R3.ItemStack nms = (net.minecraft.server.v1_16_R3.ItemStack) FIELD.get(itemStack);
+                return nms == null ? CraftItemStack.asNMSCopy(itemStack) : nms;
+            } catch (ReflectiveOperationException e) {
+                e.printStackTrace();
+                return net.minecraft.server.v1_16_R3.ItemStack.b;
+            }
+        }
+    }
+
+    static {
+        Field temp = null;
+
+        try {
+            Field handleField = CraftItemStack.class.getDeclaredField("handle");
+            handleField.setAccessible(true);
+            temp = handleField;
+        } catch (ReflectiveOperationException e) {
+            e.printStackTrace();
+        }
+
+        assert temp != null;
+        Validate.notNull(temp, "Error occurred in initialization!");
+
+        FIELD = temp;
+    }
+}

eco-core/core-nms/v1_16_R3/src/main/kotlin/com/willfp/eco/proxy/v1_16_R3/Skull.kt

@@ -1,32 +1,43 @@
 package com.willfp.eco.proxy.v1_16_R3
+
 import com.mojang.authlib.GameProfile
 import com.mojang.authlib.properties.Property
-import org.bukkit.inventory.meta.SkullMeta
 import com.willfp.eco.proxy.SkullProxy
+import org.bukkit.inventory.meta.SkullMeta
+import java.lang.reflect.Field
 import java.lang.reflect.Method
 import java.util.*
 
 class Skull : SkullProxy {
     private lateinit var setProfile: Method
+    private lateinit var profile: Field
 
     override fun setSkullTexture(
         meta: SkullMeta,
         base64: String
     ) {
-        try {
-            if (!this::setProfile.isInitialized) {
-                setProfile = meta.javaClass.getDeclaredMethod("setProfile", GameProfile::class.java)
-                setProfile.isAccessible = true
-            }
-            val uuid = UUID(
-                base64.substring(base64.length - 20).hashCode().toLong(),
-                base64.substring(base64.length - 10).hashCode().toLong()
-            )
-            val profile = GameProfile(uuid, "eco")
-            profile.properties.put("textures", Property("textures", base64))
-            setProfile.invoke(meta, profile)
-        } catch (e: ReflectiveOperationException) {
-            e.printStackTrace()
+        if (!this::setProfile.isInitialized) {
+            setProfile = meta.javaClass.getDeclaredMethod("setProfile", GameProfile::class.java)
+            setProfile.isAccessible = true
         }
+        val uuid = UUID(
+            base64.substring(base64.length - 20).hashCode().toLong(),
+            base64.substring(base64.length - 10).hashCode().toLong()
+        )
+        val profile = GameProfile(uuid, "eco")
+        profile.properties.put("textures", Property("textures", base64))
+        setProfile.invoke(meta, profile)
+    }
+
+    override fun getSkullTexture(
+        meta: SkullMeta
+    ): String? {
+        if (!this::profile.isInitialized) {
+            profile = meta.javaClass.getDeclaredField("profile")
+            profile.isAccessible = true
+        }
+        val profile = profile[meta] as GameProfile?
+        val property = profile?.properties?.get("textures") as Property?
+        return property?.value
     }
 }

eco-core/core-nms/v1_16_R3/src/main/kotlin/com/willfp/eco/proxy/v1_16_R3/VillagerTrade.kt

@@ -1,9 +1,9 @@
 package com.willfp.eco.proxy.v1_16_R3
 import com.willfp.eco.core.display.Display
+import com.willfp.eco.proxy.VillagerTradeProxy
 import org.bukkit.craftbukkit.v1_16_R3.inventory.CraftMerchantRecipe
 import org.bukkit.entity.Player
 import org.bukkit.inventory.MerchantRecipe
-import com.willfp.eco.proxy.VillagerTradeProxy
 import java.lang.reflect.Field
 
 class VillagerTrade : VillagerTradeProxy {
@@ -15,7 +15,7 @@ class VillagerTrade : VillagerTradeProxy {
     ): MerchantRecipe {
         val oldRecipe = recipe as CraftMerchantRecipe
         val newRecipe = CraftMerchantRecipe(
-            Display.display(recipe.getResult().clone()),
+            Display.display(recipe.getResult().clone(), player),
             recipe.getUses(),
             recipe.getMaxUses(),
             recipe.hasExperienceReward(),

eco-core/core-nms/v1_16_R3/src/main/kotlin/com/willfp/eco/proxy/v1_16_R3/fast/NMSFastItemStack.kt

@@ -1,17 +1,18 @@
 package com.willfp.eco.proxy.v1_16_R3.fast
 
 import com.willfp.eco.internal.fast.EcoFastItemStack
+import com.willfp.eco.proxy.v1_16_R3.FastItemStackUtils
 import com.willfp.eco.util.StringUtils
 import net.minecraft.server.v1_16_R3.*
 import org.bukkit.craftbukkit.v1_16_R3.inventory.CraftItemStack
 import org.bukkit.craftbukkit.v1_16_R3.util.CraftMagicNumbers
 import org.bukkit.craftbukkit.v1_16_R3.util.CraftNamespacedKey
 import org.bukkit.enchantments.Enchantment
-import java.lang.reflect.Field
+import org.bukkit.inventory.ItemFlag
 import kotlin.experimental.and
 
 class NMSFastItemStack(itemStack: org.bukkit.inventory.ItemStack) : EcoFastItemStack<ItemStack>(
-    getNMSStack(itemStack)!!, itemStack
+    FastItemStackUtils.getNMSStack(itemStack), itemStack
 ) {
     private var loreCache: List<String>? = null
     override fun getEnchantmentsOnItem(checkStored: Boolean): Map<Enchantment, Int> {
@@ -95,33 +96,64 @@ class NMSFastItemStack(itemStack: org.bukkit.inventory.ItemStack) : EcoFastItemS
         }
     }
 
+    override fun addItemFlags(vararg hideFlags: ItemFlag) {
+        for (flag in hideFlags) {
+            this.flagBits = this.flagBits or getBitModifier(flag)
+        }
+
+        apply()
+    }
+
+    override fun removeItemFlags(vararg hideFlags: ItemFlag) {
+        for (flag in hideFlags) {
+            this.flagBits = this.flagBits and getBitModifier(flag)
+        }
+
+        apply()
+    }
+
+    override fun getItemFlags(): MutableSet<ItemFlag> {
+        val flags = mutableSetOf<ItemFlag>()
+
+        var flagArr: Array<ItemFlag>
+        val size = ItemFlag.values().also { flagArr = it }.size
+
+        for (i in 0 until size) {
+            val flag = flagArr[i]
+            if (this.hasItemFlag(flag)) {
+                flags.add(flag)
+            }
+        }
+
+        return flags
+    }
+
+    override fun hasItemFlag(flag: ItemFlag): Boolean {
+        val bitModifier = getBitModifier(flag)
+        return this.flagBits and bitModifier == bitModifier
+    }
+
+    private var flagBits: Int
+        get() =
+            if (handle.hasTag() && handle.tag!!.hasKeyOfType(
+                    "HideFlags",
+                    99
+                )
+            ) handle.tag!!.getInt("HideFlags") else 0
+        set(value) =
+            handle.orCreateTag.setInt("HideFlags", value)
+
+    override fun getRepairCost(): Int {
+        return handle.repairCost
+    }
+
+    override fun setRepairCost(cost: Int) {
+        handle.repairCost = cost
+    }
+
     private fun apply() {
         if (bukkit !is CraftItemStack) {
             bukkit.itemMeta = CraftItemStack.asCraftMirror(handle).itemMeta
         }
     }
-
-    companion object {
-        private var field: Field
-
-        init {
-            lateinit var temp: Field
-            try {
-                val handleField = CraftItemStack::class.java.getDeclaredField("handle")
-                handleField.isAccessible = true
-                temp = handleField
-            } catch (e: ReflectiveOperationException) {
-                e.printStackTrace()
-            }
-            field = temp
-        }
-
-        fun getNMSStack(itemStack: org.bukkit.inventory.ItemStack): ItemStack? {
-            return if (itemStack !is CraftItemStack) {
-                CraftItemStack.asNMSCopy(itemStack)
-            } else {
-                field.get(itemStack) as ItemStack
-            }
-        }
-    }
 }

eco-core/core-nms/v1_17_R1/src/main/java/com/willfp/eco/proxy/v1_17_R1/FastItemStackUtils.java

@@ -0,0 +1,45 @@
+package com.willfp.eco.proxy.v1_17_R1;
+
+import lombok.experimental.UtilityClass;
+import org.bukkit.craftbukkit.libs.org.apache.commons.lang3.Validate;
+import org.bukkit.craftbukkit.v1_17_R1.inventory.CraftItemStack;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Field;
+
+@UtilityClass
+public class FastItemStackUtils {
+    private static final Field FIELD;
+
+    public static net.minecraft.world.item.ItemStack getNMSStack(@NotNull final ItemStack itemStack) {
+        if (!(itemStack instanceof CraftItemStack)) {
+            return CraftItemStack.asNMSCopy(itemStack);
+        } else {
+            try {
+                net.minecraft.world.item.ItemStack nms = (net.minecraft.world.item.ItemStack) FIELD.get(itemStack);
+                return nms == null ? CraftItemStack.asNMSCopy(itemStack) : nms;
+            } catch (ReflectiveOperationException e) {
+                e.printStackTrace();
+                return net.minecraft.world.item.ItemStack.EMPTY;
+            }
+        }
+    }
+
+    static {
+        Field temp = null;
+
+        try {
+            Field handleField = CraftItemStack.class.getDeclaredField("handle");
+            handleField.setAccessible(true);
+            temp = handleField;
+        } catch (ReflectiveOperationException e) {
+            e.printStackTrace();
+        }
+
+        assert temp != null;
+        Validate.notNull(temp, "Error occurred in initialization!");
+
+        FIELD = temp;
+    }
+}

eco-core/core-nms/v1_17_R1/src/main/kotlin/com/willfp/eco/proxy/v1_17_R1/Skull.kt

@@ -4,30 +4,40 @@ import com.mojang.authlib.GameProfile
 import com.mojang.authlib.properties.Property
 import com.willfp.eco.proxy.SkullProxy
 import org.bukkit.inventory.meta.SkullMeta
+import java.lang.reflect.Field
 import java.lang.reflect.Method
 import java.util.*
 
 class Skull : SkullProxy {
     private lateinit var setProfile: Method
+    private lateinit var profile: Field
 
     override fun setSkullTexture(
         meta: SkullMeta,
         base64: String
     ) {
-        try {
-            if (!this::setProfile.isInitialized) {
-                setProfile = meta.javaClass.getDeclaredMethod("setProfile", GameProfile::class.java)
-                setProfile.isAccessible = true
-            }
-            val uuid = UUID(
-                base64.substring(base64.length - 20).hashCode().toLong(),
-                base64.substring(base64.length - 10).hashCode().toLong()
-            )
-            val profile = GameProfile(uuid, "eco")
-            profile.properties.put("textures", Property("textures", base64))
-            setProfile.invoke(meta, profile)
-        } catch (e: ReflectiveOperationException) {
-            e.printStackTrace()
+        if (!this::setProfile.isInitialized) {
+            setProfile = meta.javaClass.getDeclaredMethod("setProfile", GameProfile::class.java)
+            setProfile.isAccessible = true
         }
+        val uuid = UUID(
+            base64.substring(base64.length - 20).hashCode().toLong(),
+            base64.substring(base64.length - 10).hashCode().toLong()
+        )
+        val profile = GameProfile(uuid, "eco")
+        profile.properties.put("textures", Property("textures", base64))
+        setProfile.invoke(meta, profile)
+    }
+
+    override fun getSkullTexture(
+        meta: SkullMeta
+    ): String? {
+        if (!this::profile.isInitialized) {
+            profile = meta.javaClass.getDeclaredField("profile")
+            profile.isAccessible = true
+        }
+        val profile = profile[meta] as GameProfile?
+        val property = profile?.properties?.get("textures") as Property?
+        return property?.value
     }
 }

eco-core/core-nms/v1_17_R1/src/main/kotlin/com/willfp/eco/proxy/v1_17_R1/VillagerTrade.kt

@@ -1,15 +1,15 @@
 package com.willfp.eco.proxy.v1_17_R1
 
 import com.willfp.eco.core.display.Display
+import com.willfp.eco.proxy.VillagerTradeProxy
 import net.minecraft.world.item.trading.MerchantOffer
 import org.bukkit.craftbukkit.v1_17_R1.inventory.CraftMerchantRecipe
 import org.bukkit.entity.Player
 import org.bukkit.inventory.MerchantRecipe
-import com.willfp.eco.proxy.VillagerTradeProxy
 import java.lang.reflect.Field
 
 class VillagerTrade : VillagerTradeProxy {
-    private var handle: Field
+    private val handle: Field = CraftMerchantRecipe::class.java.getDeclaredField("handle")
 
     override fun displayTrade(
         recipe: MerchantRecipe,
@@ -17,7 +17,7 @@ class VillagerTrade : VillagerTradeProxy {
     ): MerchantRecipe {
         val oldRecipe = recipe as CraftMerchantRecipe
         val newRecipe = CraftMerchantRecipe(
-            Display.display(recipe.getResult().clone()),
+            Display.display(recipe.getResult().clone(), player),
             recipe.getUses(),
             recipe.getMaxUses(),
             recipe.hasExperienceReward(),
@@ -32,21 +32,10 @@ class VillagerTrade : VillagerTradeProxy {
     }
 
     private fun getHandle(recipe: CraftMerchantRecipe): MerchantOffer {
-        try {
-            return handle[recipe] as MerchantOffer
-        } catch (e: IllegalAccessException) {
-            e.printStackTrace()
-        }
-        throw IllegalArgumentException("Not CMR")
+        return handle[recipe] as MerchantOffer
     }
 
     init {
-        try {
-            handle = CraftMerchantRecipe::class.java.getDeclaredField("handle")
-            handle.isAccessible = true
-        } catch (e: NoSuchFieldException) {
-            e.printStackTrace()
-            throw RuntimeException("Error!")
-        }
+        handle.isAccessible = true
     }
 }

eco-core/core-nms/v1_17_R1/src/main/kotlin/com/willfp/eco/proxy/v1_17_R1/fast/NMSFastItemStack.kt

@@ -1,6 +1,7 @@
 package com.willfp.eco.proxy.v1_17_R1.fast
 
 import com.willfp.eco.internal.fast.EcoFastItemStack
+import com.willfp.eco.proxy.v1_17_R1.FastItemStackUtils
 import com.willfp.eco.util.StringUtils
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.nbt.ListTag
@@ -12,11 +13,11 @@ import org.bukkit.craftbukkit.v1_17_R1.inventory.CraftItemStack
 import org.bukkit.craftbukkit.v1_17_R1.util.CraftMagicNumbers
 import org.bukkit.craftbukkit.v1_17_R1.util.CraftNamespacedKey
 import org.bukkit.enchantments.Enchantment
-import java.lang.reflect.Field
+import org.bukkit.inventory.ItemFlag
 import kotlin.experimental.and
 
 class NMSFastItemStack(itemStack: org.bukkit.inventory.ItemStack) : EcoFastItemStack<ItemStack>(
-    getNMSStack(itemStack)!!, itemStack
+    FastItemStackUtils.getNMSStack(itemStack), itemStack
 ) {
     private var loreCache: List<String>? = null
 
@@ -115,33 +116,64 @@ class NMSFastItemStack(itemStack: org.bukkit.inventory.ItemStack) : EcoFastItemS
         }
     }
 
+    override fun addItemFlags(vararg hideFlags: ItemFlag) {
+        for (flag in hideFlags) {
+            this.flagBits = this.flagBits or getBitModifier(flag)
+        }
+
+        apply()
+    }
+
+    override fun removeItemFlags(vararg hideFlags: ItemFlag) {
+        for (flag in hideFlags) {
+            this.flagBits = this.flagBits and getBitModifier(flag)
+        }
+
+        apply()
+    }
+
+    override fun getItemFlags(): MutableSet<ItemFlag> {
+        val flags = mutableSetOf<ItemFlag>()
+
+        var flagArr: Array<ItemFlag>
+        val size = ItemFlag.values().also { flagArr = it }.size
+
+        for (i in 0 until size) {
+            val flag = flagArr[i]
+            if (this.hasItemFlag(flag)) {
+                flags.add(flag)
+            }
+        }
+
+        return flags
+    }
+
+    override fun hasItemFlag(flag: ItemFlag): Boolean {
+        val bitModifier = getBitModifier(flag)
+        return this.flagBits and bitModifier == bitModifier
+    }
+
+    private var flagBits: Int
+        get() =
+            if (handle.hasTag() && handle.tag!!.contains(
+                    "HideFlags",
+                    99
+                )
+            ) handle.tag!!.getInt("HideFlags") else 0
+        set(value) =
+            handle.orCreateTag.putInt("HideFlags", value)
+
+    override fun getRepairCost(): Int {
+        return handle.baseRepairCost
+    }
+
+    override fun setRepairCost(cost: Int) {
+        handle.setRepairCost(cost)
+    }
+
     private fun apply() {
         if (bukkit !is CraftItemStack) {
             bukkit.itemMeta = CraftItemStack.asCraftMirror(handle).itemMeta
         }
     }
-
-    companion object {
-        private var field: Field
-
-        init {
-            lateinit var temp: Field
-            try {
-                val handleField = CraftItemStack::class.java.getDeclaredField("handle")
-                handleField.isAccessible = true
-                temp = handleField
-            } catch (e: ReflectiveOperationException) {
-                e.printStackTrace()
-            }
-            field = temp
-        }
-
-        fun getNMSStack(itemStack: org.bukkit.inventory.ItemStack): ItemStack? {
-            return if (itemStack !is CraftItemStack) {
-                CraftItemStack.asNMSCopy(itemStack)
-            } else {
-                field.get(itemStack) as ItemStack
-            }
-        }
-    }
 }

eco-core/core-plugin/build.gradle

@@ -20,8 +20,9 @@ dependencies {
     compileOnly 'com.gmail.nossr50.mcMMO:mcMMO:2.1.157'
     compileOnly 'me.clip:placeholderapi:2.10.9'
     compileOnly 'com.willfp:Oraxen:e1f4003d8d'
-
-    compileOnly 'com.github.LoneDev6:API-ItemsAdder:2.3.8'
+    compileOnly 'com.github.brcdev-minecraft:shopgui-api:2.2.0'
+    compileOnly 'com.github.LoneDev6:API-ItemsAdder:2.4.7'
+    compileOnly 'me.arcaniax:HeadDatabase-API:1.2.0'
 
     // CombatLogX V10 + NewbieHelper Expansion
     compileOnly 'com.SirBlobman.combatlogx:CombatLogX-API:10.0.0.0-SNAPSHOT'

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/recipes/ShapedRecipeListener.java

@@ -6,6 +6,7 @@ import com.willfp.eco.core.items.Items;
 import com.willfp.eco.core.items.TestableItem;
 import com.willfp.eco.core.recipe.Recipes;
 import com.willfp.eco.core.recipe.parts.MaterialTestableItem;
+import com.willfp.eco.core.recipe.parts.ModifiedTestableItem;
 import com.willfp.eco.core.recipe.parts.TestableStack;
 import com.willfp.eco.core.recipe.recipes.CraftingRecipe;
 import com.willfp.eco.core.recipe.recipes.ShapedCraftingRecipe;
@@ -97,16 +98,65 @@ public class ShapedRecipeListener extends PluginDependent<EcoPlugin> implements
             return;
         }
 
-        this.getPlugin().getScheduler().runLater(() -> {
-            for (int i = 0; i < 9; i++) {
-                ItemStack inMatrix = event.getInventory().getMatrix()[i];
-                TestableItem inRecipe = matched.getParts().get(i);
+        boolean isStackedRecipe = false;
 
-                if (inRecipe instanceof TestableStack testableStack) {
+        int upperBound = 64;
+        for (int i = 0; i < 9; i++) {
+            ItemStack inMatrix = event.getInventory().getMatrix()[i];
+            TestableItem inRecipe = matched.getParts().get(i);
+
+            if (inRecipe instanceof TestableStack testableStack) {
+                int max = Math.floorDiv(inMatrix.getAmount(), testableStack.getAmount());
+                if (max < upperBound) {
+                    upperBound = max;
+                }
+                isStackedRecipe = true;
+            } else if (inMatrix != null) {
+                int max = inMatrix.getAmount();
+                if (max < upperBound) {
+                    upperBound = max;
+                }
+            }
+        }
+
+        if (!isStackedRecipe) {
+            return;
+        }
+
+        int toGivePerRecipe = event.getRecipe().getResult().getAmount();
+        int maxStackSize = event.getRecipe().getResult().getMaxStackSize();
+        while (toGivePerRecipe * upperBound > maxStackSize) {
+            upperBound--;
+        }
+
+        for (int i = 0; i < 9; i++) {
+            ItemStack inMatrix = event.getInventory().getMatrix()[i];
+            TestableItem inRecipe = matched.getParts().get(i);
+
+            if (inRecipe instanceof TestableStack testableStack) {
+                if (event.isShiftClick()) {
+                    int amount = inMatrix.getAmount() + 1;
+                    for (int j = 0; j < upperBound; j++) {
+                        amount -= testableStack.getAmount();
+                    }
+                    inMatrix.setAmount(amount);
+                } else {
                     inMatrix.setAmount(inMatrix.getAmount() - (testableStack.getAmount() - 1));
                 }
             }
-        }, 1);
+        }
+
+        int finalUpperBound = upperBound;
+
+        if (event.isShiftClick()) {
+            ItemStack result = event.getInventory().getResult();
+            if (result == null) {
+                return;
+            }
+
+            result.setAmount(result.getAmount() * finalUpperBound);
+            event.getInventory().setResult(result);
+        }
     }
 
     @EventHandler
@@ -130,6 +180,22 @@ public class ShapedRecipeListener extends PluginDependent<EcoPlugin> implements
                     return;
                 }
             }
+            if (part instanceof ModifiedTestableItem modified) {
+                if (modified.getHandle() instanceof MaterialTestableItem) {
+                    if (Items.isCustomItem(itemStack)) {
+                        event.getInventory().setResult(new ItemStack(Material.AIR));
+                        return;
+                    }
+                }
+            }
+            if (part instanceof TestableStack modified) {
+                if (modified.getHandle() instanceof MaterialTestableItem) {
+                    if (Items.isCustomItem(itemStack)) {
+                        event.getInventory().setResult(new ItemStack(Material.AIR));
+                        return;
+                    }
+                }
+            }
         }
     }
     
@@ -156,6 +222,24 @@ public class ShapedRecipeListener extends PluginDependent<EcoPlugin> implements
                     return;
                 }
             }
+            if (part instanceof ModifiedTestableItem modified) {
+                if (modified.getHandle() instanceof MaterialTestableItem) {
+                    if (Items.isCustomItem(itemStack)) {
+                        event.getInventory().setResult(new ItemStack(Material.AIR));
+                        event.setResult(Event.Result.DENY);
+                        event.setCancelled(true);
+                        return;
+                    }
+                }
+            }
+            if (part instanceof TestableStack modified) {
+                if (modified.getHandle() instanceof MaterialTestableItem) {
+                    if (Items.isCustomItem(itemStack)) {
+                        event.getInventory().setResult(new ItemStack(Material.AIR));
+                        return;
+                    }
+                }
+            }
         }
     }
     

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/EcoHandler.kt

@@ -31,9 +31,9 @@ import com.willfp.eco.internal.integrations.PlaceholderIntegrationPAPI
 import com.willfp.eco.internal.logging.EcoLogger
 import com.willfp.eco.internal.proxy.EcoProxyFactory
 import com.willfp.eco.internal.scheduling.EcoScheduler
+import com.willfp.eco.proxy.FastItemStackFactoryProxy
 import com.willfp.eco.spigot.integrations.bstats.MetricHandler
 import org.bukkit.inventory.ItemStack
-import com.willfp.eco.proxy.FastItemStackFactoryProxy
 import java.util.logging.Logger
 
 @Suppress("UNUSED")
@@ -105,7 +105,7 @@ class EcoHandler : EcoSpigotPlugin(), Handler {
     }
 
     override fun getLoadedPlugins(): List<String> {
-        return ArrayList(Plugins.LOADED_ECO_PLUGINS.keys)
+        return Plugins.LOADED_ECO_PLUGINS.keys.toMutableList()
     }
 
     override fun getPluginByName(name: String): EcoPlugin? {

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/EcoSpigotPlugin.kt

@@ -8,6 +8,10 @@ import com.willfp.eco.core.integrations.anticheat.AnticheatManager
 import com.willfp.eco.core.integrations.antigrief.AntigriefManager
 import com.willfp.eco.core.integrations.customitems.CustomItemsManager
 import com.willfp.eco.core.integrations.mcmmo.McmmoManager
+import com.willfp.eco.core.integrations.shop.ShopManager
+import com.willfp.eco.core.items.Items
+import com.willfp.eco.core.items.args.EnchantmentArgParser
+import com.willfp.eco.core.items.args.TextureArgParser
 import com.willfp.eco.internal.drops.DropManager
 import com.willfp.eco.proxy.BlockBreakProxy
 import com.willfp.eco.proxy.FastItemStackFactoryProxy
@@ -19,8 +23,11 @@ import com.willfp.eco.spigot.eventlisteners.*
 import com.willfp.eco.spigot.gui.GUIListener
 import com.willfp.eco.spigot.integrations.anticheat.*
 import com.willfp.eco.spigot.integrations.antigrief.*
+import com.willfp.eco.spigot.integrations.customitems.CustomItemsHeadDatabase
+import com.willfp.eco.spigot.integrations.customitems.CustomItemsItemsAdder
 import com.willfp.eco.spigot.integrations.customitems.CustomItemsOraxen
 import com.willfp.eco.spigot.integrations.mcmmo.McmmoIntegrationImpl
+import com.willfp.eco.spigot.integrations.shop.ShopShopGuiPlus
 import com.willfp.eco.spigot.recipes.ShapedRecipeListener
 import com.willfp.eco.util.BlockUtils
 import com.willfp.eco.util.SkullUtils
@@ -41,8 +48,14 @@ abstract class EcoSpigotPlugin : EcoPlugin(
     init {
         Display.setFinalizeKey(namespacedKeyFactory.create("finalized"))
 
+        Items.registerArgParser(EnchantmentArgParser())
+        Items.registerArgParser(TextureArgParser())
+
         val skullProxy = getProxy(SkullProxy::class.java)
-        SkullUtils.initialize { meta: SkullMeta, base64: String -> skullProxy.setSkullTexture(meta, base64) }
+        SkullUtils.initialize(
+            { meta: SkullMeta, base64: String -> skullProxy.setSkullTexture(meta, base64) },
+            { meta: SkullMeta -> skullProxy.getSkullTexture(meta) }
+        )
 
         val blockBreakProxy = getProxy(BlockBreakProxy::class.java)
         BlockUtils.initialize { player: Player, block: Block -> blockBreakProxy.breakBlock(player, block) }
@@ -109,6 +122,11 @@ abstract class EcoSpigotPlugin : EcoPlugin(
 
             // Custom Items
             IntegrationLoader("Oraxen") { CustomItemsManager.register(CustomItemsOraxen()) },
+            IntegrationLoader("ItemsAdder") { CustomItemsManager.register(CustomItemsItemsAdder(this)) },
+            IntegrationLoader("HeadDatabase") { CustomItemsManager.register(CustomItemsHeadDatabase()) },
+
+            // Shop
+            IntegrationLoader("ShopGuiPlus") { ShopManager.register(ShopShopGuiPlus()) },
 
             // Misc
             IntegrationLoader("mcMMO") { McmmoManager.register(McmmoIntegrationImpl()) }
@@ -116,19 +134,14 @@ abstract class EcoSpigotPlugin : EcoPlugin(
     }
 
     override fun loadPacketAdapters(): List<AbstractPacketAdapter> {
-        val adapters = mutableListOf(
+        return listOf(
             PacketAutoRecipe(this),
             PacketChat(this),
             PacketSetCreativeSlot(this),
             PacketSetSlot(this),
-            PacketWindowItems(this)
+            PacketWindowItems(this),
+            PacketOpenWindowMerchant(this)
         )
-
-        if (!configYml.getBool("disable-display-on-villagers")) {
-            adapters.add(PacketOpenWindowMerchant(this))
-        }
-
-        return adapters
     }
 
     override fun loadListeners(): List<Listener> {

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/arrows/ArrowDataListener.kt

@@ -1,7 +1,6 @@
 package com.willfp.eco.spigot.arrows
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import org.bukkit.Material
 import org.bukkit.entity.Arrow
 import org.bukkit.entity.LivingEntity
@@ -11,8 +10,8 @@ import org.bukkit.event.Listener
 import org.bukkit.event.entity.ProjectileLaunchEvent
 
 class ArrowDataListener(
-    plugin: EcoPlugin
-) : PluginDependent<EcoPlugin>(plugin), Listener {
+    private val plugin: EcoPlugin
+) : Listener {
 
     @EventHandler(priority = EventPriority.LOWEST)
     fun onLaunch(event:ProjectileLaunchEvent) {

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/display/PacketOpenWindowMerchant.kt

@@ -19,7 +19,7 @@ class PacketOpenWindowMerchant(plugin: EcoPlugin) :
         player: Player,
         event: PacketEvent
     ) {
-        val recipes: MutableList<MerchantRecipe> = ArrayList()
+        val recipes = mutableListOf<MerchantRecipe>()
 
 
         /*

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/drops/CollatedRunnable.kt

@@ -8,11 +8,17 @@ class CollatedRunnable(plugin: EcoPlugin) {
     init {
         plugin.scheduler.runTimer({
             for ((key, value) in EcoFastCollatedDropQueue.COLLATED_MAP) {
-                EcoDropQueue(key)
+                val queue = EcoDropQueue(key)
                     .setLocation(value.location)
                     .addItems(value.drops)
                     .addXP(value.xp)
-                    .push()
+
+                if (value.telekinetic) {
+                    queue.forceTelekinesis()
+                }
+
+                queue.push()
+
                 EcoFastCollatedDropQueue.COLLATED_MAP.remove(key)
             }
             EcoFastCollatedDropQueue.COLLATED_MAP.clear()

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/eventlisteners/EntityDeathByEntityListeners.kt

@@ -1,7 +1,6 @@
 package com.willfp.eco.spigot.eventlisteners
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import org.bukkit.entity.LivingEntity
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -11,8 +10,8 @@ import org.bukkit.event.entity.EntityDeathEvent
 import java.util.concurrent.atomic.AtomicReference
 
 class EntityDeathByEntityListeners(
-    plugin: EcoPlugin
-) : PluginDependent<EcoPlugin>(plugin), Listener {
+    private val plugin: EcoPlugin
+) : Listener {
     private val events = HashSet<EntityDeathByEntityBuilder>()
 
     @EventHandler(priority = EventPriority.HIGH)

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/gui/GUIListener.kt

@@ -1,45 +1,105 @@
 package com.willfp.eco.spigot.gui
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
+import com.willfp.eco.core.drops.DropQueue
 import com.willfp.eco.internal.gui.menu.EcoMenu
 import com.willfp.eco.internal.gui.menu.MenuHandler
 import com.willfp.eco.internal.gui.slot.EcoSlot
+import com.willfp.eco.util.MenuUtils
 import org.apache.commons.lang.Validate
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
+import org.bukkit.event.EventPriority
 import org.bukkit.event.Listener
+import org.bukkit.event.inventory.ClickType
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
 
-class GUIListener(plugin: EcoPlugin) : PluginDependent<EcoPlugin>(plugin), Listener {
+class GUIListener(private val plugin: EcoPlugin) : Listener {
     @EventHandler
     fun handleSlotClick(event: InventoryClickEvent) {
-        if (event.whoClicked !is Player) {
+        val player = event.whoClicked
+        if (player !is Player) {
             return
         }
-        if (event.clickedInventory == null) {
-            return
-        }
-        val menu = MenuHandler.getMenu(event.clickedInventory!!) ?: return
-        val row = Math.floorDiv(event.slot, 9)
-        val column = event.slot - row * 9
+        val menu = MenuHandler.getMenu(event.clickedInventory ?: return) ?: return
+        val rowColumn = MenuUtils.convertSlotToRowColumn(event.slot)
+        val row = rowColumn.first!!
+        val column = rowColumn.second!!
         val slot = menu.getSlot(row, column)
         Validate.isTrue(slot is EcoSlot, "Slot not instance of EcoSlot!")
         val ecoSlot = menu.getSlot(row, column) as EcoSlot
         event.isCancelled = true
-        ecoSlot.handleInventoryClick(event)
+        ecoSlot.handleInventoryClick(event, menu)
+
+        if (event.clickedInventory == null) {
+            return
+        }
+
+        val extendedInventory = MenuHandler.getExtendedInventory(event.clickedInventory!!) ?: return
+
+        plugin.scheduler.run { extendedInventory.refresh(player) }
     }
 
     @EventHandler
+    fun handleCaptivatorSlots(event: InventoryClickEvent) {
+        val player = event.whoClicked
+        if (player !is Player) {
+            return
+        }
+
+        MenuHandler.getMenu(player.openInventory.topInventory) ?: return
+        MenuHandler.getExtendedInventory(player.openInventory.topInventory) ?: return
+
+        plugin.scheduler.run { MenuHandler.getExtendedInventory(player.openInventory.topInventory)?.refresh(player) }
+    }
+
+    @EventHandler
+    fun handleShiftClick(event: InventoryClickEvent) {
+        if (!(event.click == ClickType.SHIFT_RIGHT || event.click == ClickType.SHIFT_LEFT)) {
+            return
+        }
+
+        val player = event.whoClicked
+        if (player !is Player) {
+            return
+        }
+
+        val inv = player.openInventory.topInventory
+
+        if (inv == event.clickedInventory) {
+            return
+        }
+
+        val menu = MenuHandler.getMenu(inv) ?: return
+
+        val rowColumn = MenuUtils.convertSlotToRowColumn(inv.firstEmpty())
+        val row = rowColumn.first!!
+        val column = rowColumn.second!!
+        val slot = menu.getSlot(row, column)
+
+        if (!slot.isCaptive) {
+            event.isCancelled = true
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH)
     fun handleClose(event: InventoryCloseEvent) {
-        if (event.player !is Player) {
+        val player = event.player
+        if (player !is Player) {
             return
         }
         val menu = MenuHandler.getMenu(event.inventory) ?: return
         Validate.isTrue(menu is EcoMenu, "Menu not instance of EcoMenu!")
         val ecoMenu = menu as EcoMenu
         ecoMenu.handleClose(event)
+
+        DropQueue(player)
+            .addItems(ecoMenu.getCaptiveItems(player))
+            .setLocation(player.location)
+            .forceTelekinesis()
+            .push()
+
         plugin.scheduler.run { MenuHandler.unregisterMenu(event.inventory) }
     }
 }

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/integrations/antigrief/AntigriefLands.kt

@@ -1,7 +1,6 @@
 package com.willfp.eco.spigot.integrations.antigrief
 
 import com.willfp.eco.core.EcoPlugin
-import com.willfp.eco.core.PluginDependent
 import com.willfp.eco.core.integrations.antigrief.AntigriefWrapper
 import me.angeschossen.lands.api.integration.LandsIntegration
 import me.angeschossen.lands.api.role.enums.RoleSetting
@@ -10,8 +9,8 @@ import org.bukkit.block.Block
 import org.bukkit.entity.LivingEntity
 import org.bukkit.entity.Player
 
-class AntigriefLands(plugin: EcoPlugin) : PluginDependent<EcoPlugin?>(plugin), AntigriefWrapper {
-    private val landsIntegration = LandsIntegration(this.plugin!!)
+class AntigriefLands(private val plugin: EcoPlugin) : AntigriefWrapper {
+    private val landsIntegration = LandsIntegration(this.plugin)
     override fun canBreakBlock(
         player: Player,
         block: Block

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/integrations/customitems/CustomItemsHeadDatabase.kt

@@ -0,0 +1,34 @@
+package com.willfp.eco.spigot.integrations.customitems
+
+import com.willfp.eco.core.integrations.customitems.CustomItemsWrapper
+import com.willfp.eco.core.items.CustomItem
+import com.willfp.eco.util.NamespacedKeyUtils
+import me.arcaniax.hdb.api.HeadDatabaseAPI
+import me.arcaniax.hdb.enums.CategoryEnum
+import java.util.function.Predicate
+
+class CustomItemsHeadDatabase : CustomItemsWrapper {
+    private val api = HeadDatabaseAPI()
+
+    override fun registerAllItems() {
+        for (categoryEnum in CategoryEnum.values()) {
+            for (head in api.getHeads(categoryEnum)) {
+                val stack = head.head
+                val id = head.id
+                val key = NamespacedKeyUtils.create("headdb", id.lowercase());
+                CustomItem(
+                    key,
+                    Predicate { test ->
+                        val headId = api.getItemID(test) ?: return@Predicate false
+                        headId.equals(id, ignoreCase = true)
+                    },
+                    stack
+                ).register()
+            }
+        }
+    }
+
+    override fun getPluginName(): String {
+        return "HeadDatabase"
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/integrations/customitems/CustomItemsItemsAdder.kt

@@ -0,0 +1,36 @@
+package com.willfp.eco.spigot.integrations.customitems
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.integrations.customitems.CustomItemsWrapper
+import com.willfp.eco.core.items.CustomItem
+import com.willfp.eco.util.NamespacedKeyUtils
+import dev.lone.itemsadder.api.CustomStack
+import dev.lone.itemsadder.api.ItemsAdder
+import org.bukkit.inventory.ItemStack
+import java.util.function.Predicate
+
+class CustomItemsItemsAdder(
+    private val plugin: EcoPlugin
+) : CustomItemsWrapper {
+    override fun registerAllItems() {
+        plugin.scheduler.runLater({
+            for (item in ItemsAdder.getAllItems()) {
+                val stack = item.itemStack
+                val id = item.id
+                val key = NamespacedKeyUtils.create("itemsadder", id.lowercase())
+                CustomItem(
+                    key,
+                    Predicate { test: ItemStack ->
+                        val customStack = CustomStack.byItemStack(test) ?: return@Predicate false
+                        customStack.id.equals(id, ignoreCase = true)
+                    },
+                    stack
+                ).register()
+            }
+        }, 2)
+    }
+
+    override fun getPluginName(): String {
+        return "ItemsAdder"
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/integrations/customitems/CustomItemsOraxen.kt

@@ -23,4 +23,8 @@ class CustomItemsOraxen : CustomItemsWrapper {
             ).register()
         }
     }
+
+    override fun getPluginName(): String {
+        return "Oraxen"
+    }
 }

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/spigot/integrations/shop/ShopShopGuiPlus.kt

@@ -0,0 +1,31 @@
+package com.willfp.eco.spigot.integrations.shop
+
+import com.willfp.eco.core.integrations.shop.ShopWrapper
+import com.willfp.eco.core.items.Items
+import net.brcdev.shopgui.ShopGuiPlusApi
+import net.brcdev.shopgui.provider.item.ItemProvider
+import org.bukkit.configuration.ConfigurationSection
+import org.bukkit.inventory.ItemStack
+
+class ShopShopGuiPlus : ShopWrapper {
+    override fun registerEcoProvider() {
+        ShopGuiPlusApi.registerItemProvider(EcoShopGuiPlusProvider())
+    }
+
+    class EcoShopGuiPlusProvider : ItemProvider("eco") {
+        override fun isValidItem(itemStack: ItemStack?): Boolean {
+            itemStack ?: return false
+
+            return Items.isCustomItem(itemStack)
+        }
+
+        override fun loadItem(configurationSection: ConfigurationSection): ItemStack? {
+            val id = configurationSection.getString("eco")
+            return if (id == null) null else Items.lookup(id)?.item
+        }
+
+        override fun compare(itemStack1: ItemStack, itemStack2: ItemStack): Boolean {
+            return Items.getCustomItem(itemStack1)?.key == Items.getCustomItem(itemStack2)?.key
+        }
+    }
+}

eco-core/core-plugin/src/main/resources/config.yml

@@ -5,7 +5,6 @@
 
 
 # Options to fix villager bugs left behind from old (buggy) versions.
-disable-display-on-villagers: false
 villager-display-fix: false
 
 # DropQueue by default uses a faster collated queue system where all drops

eco-core/core-plugin/src/main/resources/plugin.yml

@@ -4,6 +4,7 @@ main: com.willfp.eco.spigot.EcoHandler
 api-version: 1.16
 authors: [Auxilor]
 website: willfp.com
+load: STARTUP
 depend:
   - ProtocolLib
 softdepend:
@@ -20,6 +21,10 @@ softdepend:
   - PlaceholderAPI
   - mcMMO
   - CombatLogX
+  - ShopGuiPlus
+  - ItemsAdder
+  - Oraxen
+  - HeadDatabase
 libraries:
   - org.reflections:reflections:0.9.12
   - org.apache.maven:maven-artifact:3.0.3

eco-core/core-proxy/src/main/kotlin/com/willfp/eco/proxy/SkullProxy.kt

@@ -8,4 +8,8 @@ interface SkullProxy : AbstractProxy {
         meta: SkullMeta,
         base64: String
     )
+
+    fun getSkullTexture(
+        meta: SkullMeta
+    ): String?
 }

gradle.properties

@@ -1,2 +1,2 @@
-version = 6.3.1
+version = 6.7.0
 plugin-name = eco