Reworked getting a reforge for an item

Implemented EffectActivateEvent (enhancing external API usage a lot)

README.md

@@ -1,6 +1,6 @@
 <h1 align="center">
   <br>
-  <img src="https://i.imgur.com/LoZExNf.png" alt="Reforges logo" width="256">
+  <img src="https://i.imgur.com/co0zeyJ.png" alt="Reforges logo" width="256">
   <br>
 </h1>
 

build.gradle

@@ -29,7 +29,8 @@ allprojects {
         mavenCentral()
         maven { url 'https://jitpack.io' }
         maven { url 'https://hub.spigotmc.org/nexus/content/repositories/snapshots/' }
-        maven { url 'https://repo.codemc.org/repository/nms/' }
+        maven { url 'https://papermc.io/repo/repository/maven-public/' }
+        maven { url 'https://repo.rosewooddev.io/repository/public/' }
     }
 
     jar {
@@ -37,6 +38,7 @@ allprojects {
     }
 
     dependencies {
+        compileOnly 'org.black_ixx:playerpoints:3.0.0'
         compileOnly 'com.willfp:eco:6.9.0'
 
         compileOnly 'org.jetbrains:annotations:19.0.0'

eco-core/core-plugin/build.gradle

@@ -2,8 +2,14 @@ group 'com.willfp'
 version rootProject.version
 
 dependencies {
+    compileOnly fileTree(dir: '../../lib', include: ['*.jar'])
     compileOnly 'io.papermc.paper:paper-api:1.17.1-R0.1-SNAPSHOT'
     compileOnly 'com.github.MilkBowl:VaultAPI:1.7'
+    compileOnly 'com.willfp:EcoSkills:1.4.0'
+    compileOnly 'com.willfp:Talismans:4.6.0'
+    compileOnly 'com.github.Archy-X:AureliumSkills:Beta1.2.4'
+    compileOnly 'org.black_ixx:playerpoints:3.0.0'
+    compileOnly fileTree(dir: '../../lib', include: ['*.jar'])
 }
 
 build.dependsOn publishToMavenLocal

eco-core/core-plugin/src/main/java/com/willfp/reforges/ReforgesPlugin.java

@@ -3,22 +3,32 @@ package com.willfp.reforges;
 import com.willfp.eco.core.EcoPlugin;
 import com.willfp.eco.core.command.impl.PluginCommand;
 import com.willfp.eco.core.display.DisplayModule;
+import com.willfp.eco.core.integrations.IntegrationLoader;
 import com.willfp.eco.core.items.Items;
 import com.willfp.reforges.commands.CommandReforge;
 import com.willfp.reforges.commands.CommandReforges;
-import com.willfp.reforges.conditions.Conditions;
 import com.willfp.reforges.config.ReforgesJson;
 import com.willfp.reforges.config.TargetYml;
 import com.willfp.reforges.display.ReforgesDisplay;
+import com.willfp.reforges.effects.ConfiguredEffect;
 import com.willfp.reforges.effects.Effect;
 import com.willfp.reforges.effects.Effects;
+import com.willfp.reforges.integrations.aureliumskills.AureliumSkillsIntegration;
+import com.willfp.reforges.integrations.ecoskills.EcoSkillsIntegration;
+import com.willfp.reforges.integrations.talismans.TalismansIntegration;
+import com.willfp.reforges.integrations.ultimateskills.UltimateSkillsIntegration;
+import com.willfp.reforges.reforges.Reforge;
 import com.willfp.reforges.reforges.Reforges;
 import com.willfp.reforges.reforges.util.ReforgeArgParser;
+import com.willfp.reforges.reforges.util.ReforgeEnableListeners;
+import com.willfp.reforges.reforges.util.ReforgeLookup;
 import com.willfp.reforges.reforges.util.WatcherTriggers;
 import com.willfp.reforges.util.AntiPlaceListener;
 import com.willfp.reforges.util.DiscoverRecipeListener;
 import com.willfp.reforges.vault.EconomyHandler;
 import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
 import org.bukkit.event.HandlerList;
 import org.bukkit.event.Listener;
 import org.jetbrains.annotations.Nullable;
@@ -59,6 +69,17 @@ public class ReforgesPlugin extends EcoPlugin {
         Items.registerArgParser(new ReforgeArgParser());
     }
 
+    @Override
+    protected void handleDisable() {
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            for (Reforge value : Reforges.values()) {
+                for (ConfiguredEffect effect : value.getEffects()) {
+                    effect.getEffect().handleDisabling(player);
+                }
+            }
+        }
+    }
+
     @Override
     protected void handleAfterLoad() {
         EconomyHandler.setEnabled(EconomyHandler.init());
@@ -75,7 +96,11 @@ public class ReforgesPlugin extends EcoPlugin {
             this.getScheduler().run(() -> this.getEventManager().registerListener(effect));
         }
         this.getLogger().info(Reforges.values().size() + " Reforges Loaded");
-        this.getScheduler().runTimer((Runnable) Conditions.HAS_PERMISSION, 103, 100);
+        this.getScheduler().runTimer(() -> {
+            for (Player player : Bukkit.getOnlinePlayers()) {
+                ReforgeLookup.updateReforges(player);
+            }
+        }, 81, 81);
     }
 
     @Override
@@ -83,7 +108,8 @@ public class ReforgesPlugin extends EcoPlugin {
         return Arrays.asList(
                 new DiscoverRecipeListener(this),
                 new AntiPlaceListener(),
-                new WatcherTriggers(this)
+                new WatcherTriggers(this),
+                new ReforgeEnableListeners(this)
         );
     }
 
@@ -100,9 +126,20 @@ public class ReforgesPlugin extends EcoPlugin {
         return new ReforgesDisplay(this);
     }
 
+    @Override
+    protected List<IntegrationLoader> loadIntegrationLoaders() {
+        return Arrays.asList(
+                new IntegrationLoader("UltimateSkills", UltimateSkillsIntegration::load),
+                new IntegrationLoader("EcoSkills", EcoSkillsIntegration::load),
+                new IntegrationLoader("Talismans", TalismansIntegration::registerProvider),
+                new IntegrationLoader("PlayerPoints", () -> EconomyHandler.setUsePlayerPoints(true)),
+                new IntegrationLoader("AureliumSkills", AureliumSkillsIntegration::load)
+        );
+    }
+
     @Override
     public String getMinimumEcoVersion() {
-        return "6.8.0";
+        return "6.9.0";
     }
 
     /**

eco-core/core-plugin/src/main/java/com/willfp/reforges/commands/CommandGive.java

@@ -1,151 +0,0 @@
-package com.willfp.reforges.commands;
-
-
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.command.CommandHandler;
-import com.willfp.eco.core.command.TabCompleteHandler;
-import com.willfp.eco.core.command.impl.Subcommand;
-import com.willfp.eco.core.config.updating.ConfigUpdater;
-import com.willfp.reforges.reforges.Reforge;
-import com.willfp.reforges.reforges.Reforges;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.util.StringUtil;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class CommandGive extends Subcommand {
-    /**
-     * The cached names.
-     */
-    private static final List<String> STONE_NAMES = new ArrayList<>();
-
-    /**
-     * The cached numbers.
-     */
-    private static final List<String> NUMBERS = Arrays.asList(
-            "1",
-            "2",
-            "3",
-            "4",
-            "5",
-            "10",
-            "32",
-            "64"
-    );
-
-    /**
-     * Instantiate a new command handler.
-     *
-     * @param plugin The plugin for the commands to listen for.
-     */
-    public CommandGive(@NotNull final EcoPlugin plugin) {
-        super(plugin, "give", "reforges.command.give", false);
-    }
-
-    /**
-     * Called on reload.
-     */
-    @ConfigUpdater
-    public static void reload() {
-        STONE_NAMES.clear();
-        STONE_NAMES.addAll(Reforges.values().stream()
-                .filter(Reforge::getRequiresStone)
-                .map(Reforge::getId)
-                .collect(Collectors.toList()));
-    }
-
-    @Override
-    public CommandHandler getHandler() {
-        return (sender, args) -> {
-            if (args.isEmpty()) {
-                sender.sendMessage(this.getPlugin().getLangYml().getMessage("needs-player"));
-                return;
-            }
-
-            if (args.size() == 1) {
-                sender.sendMessage(this.getPlugin().getLangYml().getMessage("needs-stone"));
-                return;
-            }
-
-            int amount = 1;
-
-            if (args.size() > 2) {
-                try {
-                    amount = Integer.parseInt(args.get(2));
-                } catch (NumberFormatException ignored) {
-                    // do nothing
-                }
-            }
-
-            String recieverName = args.get(0);
-            Player reciever = Bukkit.getPlayer(recieverName);
-
-            if (reciever == null) {
-                sender.sendMessage(this.getPlugin().getLangYml().getMessage("invalid-player"));
-                return;
-            }
-
-            String key = args.get(1);
-
-            Reforge reforge = Reforges.getByKey(key);
-
-            if (reforge == null) {
-                sender.sendMessage(this.getPlugin().getLangYml().getMessage("invalid-stone"));
-                return;
-            }
-
-            String message = this.getPlugin().getLangYml().getMessage("give-success");
-            message = message.replace("%reforge%", reforge.getName()).replace("%recipient%", reciever.getName());
-            sender.sendMessage(message);
-
-            ItemStack itemStack = reforge.getStone();
-            itemStack.setAmount(amount);
-            reciever.getInventory().addItem(itemStack);
-        };
-    }
-
-    @Override
-    public TabCompleteHandler getTabCompleter() {
-        return (sender, args) -> {
-            List<String> completions = new ArrayList<>();
-
-            if (args.isEmpty()) {
-                // Currently, this case is not ever reached
-                return STONE_NAMES;
-            }
-
-            if (args.size() == 1) {
-                StringUtil.copyPartialMatches(args.get(0), Bukkit.getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList()), completions);
-                return completions;
-            }
-
-            if (args.size() == 2) {
-                StringUtil.copyPartialMatches(args.get(1), STONE_NAMES, completions);
-
-                Collections.sort(completions);
-                return completions;
-            }
-
-            if (args.size() == 3) {
-                StringUtil.copyPartialMatches(args.get(2), NUMBERS, completions);
-
-                completions.sort((s1, s2) -> {
-                    int t1 = Integer.parseInt(s1);
-                    int t2 = Integer.parseInt(s2);
-                    return t1 - t2;
-                });
-
-                return completions;
-            }
-
-            return new ArrayList<>(0);
-        };
-    }
-}

eco-core/core-plugin/src/main/java/com/willfp/reforges/commands/CommandOpen.java

@@ -1,67 +0,0 @@
-package com.willfp.reforges.commands;
-
-
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.command.CommandHandler;
-import com.willfp.eco.core.command.TabCompleteHandler;
-import com.willfp.eco.core.command.impl.PluginCommand;
-import com.willfp.reforges.gui.ReforgeGUI;
-import org.bukkit.Bukkit;
-import org.bukkit.Sound;
-import org.bukkit.entity.Player;
-import org.bukkit.util.StringUtil;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class CommandOpen extends PluginCommand {
-    /**
-     * Instantiate a new command handler.
-     *
-     * @param plugin The plugin for the commands to listen for.
-     */
-    public CommandOpen(@NotNull final EcoPlugin plugin) {
-        super(plugin, "open", "reforges.command.open", false);
-    }
-
-    @Override
-    public CommandHandler getHandler() {
-        return (sender, args) -> {
-            if (args.isEmpty()) {
-                sender.sendMessage(this.getPlugin().getLangYml().getMessage("needs-player"));
-                return;
-            }
-
-            Player player = Bukkit.getPlayer(args.get(0));
-
-            if (player == null) {
-                sender.sendMessage(this.getPlugin().getLangYml().getMessage("invalid-player"));
-                return;
-            }
-
-            player.playSound(
-                    player.getLocation(),
-                    Sound.valueOf(this.getPlugin().getConfigYml().getString("gui.open-sound.id").toUpperCase()),
-                    1f,
-                    (float) this.getPlugin().getConfigYml().getDouble("gui.open-sound.pitch")
-            );
-            ReforgeGUI.getMenu().open(player);
-        };
-    }
-
-    @Override
-    public TabCompleteHandler getTabCompleter() {
-        return (sender, args) -> {
-            List<String> completions = new ArrayList<>();
-
-            if (args.size() == 1) {
-                StringUtil.copyPartialMatches(args.get(0), Bukkit.getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList()), completions);
-                return completions;
-            }
-
-            return new ArrayList<>(0);
-        };
-    }
-}

eco-core/core-plugin/src/main/java/com/willfp/reforges/commands/CommandReforge.java

@@ -1,36 +0,0 @@
-package com.willfp.reforges.commands;
-
-
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.command.CommandHandler;
-import com.willfp.eco.core.command.impl.PluginCommand;
-import com.willfp.reforges.gui.ReforgeGUI;
-import org.bukkit.Sound;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-public class CommandReforge extends PluginCommand {
-    /**
-     * Instantiate a new command handler.
-     *
-     * @param plugin The plugin for the commands to listen for.
-     */
-    public CommandReforge(@NotNull final EcoPlugin plugin) {
-        super(plugin, "reforge", "reforges.command.reforge", true);
-    }
-
-    @Override
-    public CommandHandler getHandler() {
-        return (sender, args) -> {
-            Player player = (Player) sender;
-
-            player.playSound(
-                    player.getLocation(),
-                    Sound.valueOf(this.getPlugin().getConfigYml().getString("gui.open-sound.id").toUpperCase()),
-                    1f,
-                    (float) this.getPlugin().getConfigYml().getDouble("gui.open-sound.pitch")
-            );
-            ReforgeGUI.getMenu().open(player);
-        };
-    }
-}

eco-core/core-plugin/src/main/java/com/willfp/reforges/commands/CommandReforges.java

@@ -1,29 +0,0 @@
-package com.willfp.reforges.commands;
-
-
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.command.CommandHandler;
-import com.willfp.eco.core.command.impl.PluginCommand;
-import org.jetbrains.annotations.NotNull;
-
-public class CommandReforges extends PluginCommand {
-    /**
-     * Instantiate a new command handler.
-     *
-     * @param plugin The plugin for the commands to listen for.
-     */
-    public CommandReforges(@NotNull final EcoPlugin plugin) {
-        super(plugin, "reforges", "reforges.command.reforges", false);
-
-        this.addSubcommand(new CommandReload(plugin))
-                .addSubcommand(new CommandGive(plugin))
-                .addSubcommand(new CommandOpen(plugin));
-    }
-
-    @Override
-    public CommandHandler getHandler() {
-        return (sender, args) -> {
-            sender.sendMessage(this.getPlugin().getLangYml().getMessage("invalid-command"));
-        };
-    }
-}

eco-core/core-plugin/src/main/java/com/willfp/reforges/commands/CommandReload.java

@@ -1,30 +0,0 @@
-package com.willfp.reforges.commands;
-
-
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.command.CommandHandler;
-import com.willfp.eco.core.command.impl.Subcommand;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-public class CommandReload extends Subcommand {
-    /**
-     * Instantiate a new command handler.
-     *
-     * @param plugin The plugin for the commands to listen for.
-     */
-    public CommandReload(@NotNull final EcoPlugin plugin) {
-        super(plugin, "reload", "reforges.command.reload", false);
-    }
-
-    @Override
-    public CommandHandler getHandler() {
-        return (sender, args) -> {
-            this.getPlugin().reload();
-            sender.sendMessage(this.getPlugin().getLangYml().getMessage("reloaded"));
-        };
-    }
-}

eco-core/core-plugin/src/main/java/com/willfp/reforges/config/TargetYml.java

@@ -4,6 +4,7 @@ import com.willfp.eco.core.EcoPlugin;
 import com.willfp.eco.core.config.yaml.YamlBaseConfig;
 import com.willfp.eco.core.items.Items;
 import com.willfp.eco.core.items.TestableItem;
+import com.willfp.reforges.reforges.meta.ReforgeTarget;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.HashSet;
@@ -37,7 +38,17 @@ public class TargetYml extends YamlBaseConfig {
      */
     public Set<TestableItem> getTargetItems(@NotNull final String target) {
         Set<TestableItem> items = new HashSet<>();
-        this.getStrings(target, false).forEach(s -> items.add(Items.lookup(s.toUpperCase())));
+        this.getStrings(target + ".items", false).forEach(s -> items.add(Items.lookup(s.toUpperCase())));
         return items;
     }
+
+    /**
+     * Get all materials from a target name.
+     *
+     * @param target The name of the target.
+     * @return All materials.
+     */
+    public ReforgeTarget.Slot getSlot(@NotNull final String target) {
+        return ReforgeTarget.Slot.valueOf(this.getString(target + ".slot").toUpperCase());
+    }
 }

eco-core/core-plugin/src/main/java/com/willfp/reforges/effects/Effect.java

@@ -5,8 +5,9 @@ import com.willfp.reforges.ReforgesPlugin;
 import com.willfp.reforges.reforges.util.Watcher;
 import lombok.AccessLevel;
 import lombok.Getter;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
 import org.bukkit.event.Listener;
-import org.bukkit.inventory.meta.ItemMeta;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Arrays;
@@ -56,24 +57,47 @@ public abstract class Effect implements Listener, Watcher {
         return UUID.nameUUIDFromBytes((this.id + index + Arrays.hashCode(extra)).getBytes());
     }
 
+    /**
+     * Generate a NamespacedKey with a specified index.
+     *
+     * @param index The index.
+     * @return The NamespacedKey.
+     */
+    protected NamespacedKey getNamespacedKey(final int index) {
+        return this.getPlugin().getNamespacedKeyFactory().create(this.id + "_" + index);
+    }
+
     /**
      * Handle application of a reforge containing this effect.
      *
-     * @param meta   The ItemMeta.
+     * @param player The player.
      * @param config The config.
      */
-    public void handleEnabling(@NotNull final ItemMeta meta,
+    public final void handleEnabling(@NotNull final Player player,
-                               @NotNull final JSONConfig config) {
+                                     @NotNull final JSONConfig config) {
-        // Override when needed
+        PlayerEffectStack.pushEffect(player, this);
+
+        this.handleEnable(player, config);
+    }
+
+    protected void handleEnable(@NotNull final Player player,
+                                @NotNull final JSONConfig config) {
+        // Override when needed.
     }
 
     /**
      * Handle removal of a reforge containing this effect.
      *
-     * @param meta The ItemMeta.
+     * @param player The player.
      */
-    public void handleDisabling(@NotNull final ItemMeta meta) {
+    public final void handleDisabling(@NotNull final Player player) {
-        // Override when needed
+        this.handleDisable(player);
+
+        PlayerEffectStack.popEffect(player, this);
+    }
+
+    protected void handleDisable(@NotNull final Player player) {
+        // Override when needed.
     }
 
     @Override

eco-core/core-plugin/src/main/java/com/willfp/reforges/events/EffectActivateEvent.java

@@ -0,0 +1,106 @@
+package com.willfp.reforges.events;
+
+import com.willfp.reforges.effects.Effect;
+import com.willfp.reforges.reforges.Reforge;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+import org.jetbrains.annotations.NotNull;
+
+public class EffectActivateEvent extends PlayerEvent implements Cancellable {
+    /**
+     * The reforge.
+     */
+    private final Reforge reforge;
+
+    /**
+     * The effect that activated.
+     */
+    private final Effect effect;
+
+    /**
+     * If the event is cancelled.
+     */
+    private boolean cancelled;
+
+    /**
+     * Bukkit parity.
+     */
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    /**
+     * Create new EffectActivateEvent.
+     *
+     * @param who     The player.
+     * @param reforge The reforge.
+     * @param effect  The effect.
+     */
+    public EffectActivateEvent(@NotNull final Player who,
+                               @NotNull final Reforge reforge,
+                               @NotNull final Effect effect) {
+        super(who);
+        this.reforge = reforge;
+        this.effect = effect;
+        this.cancelled = false;
+    }
+
+    /**
+     * Get if the effect activation is cancelled.
+     *
+     * @return If cancelled.
+     */
+    @Override
+    public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    /**
+     * Set if the event is cancelled.
+     *
+     * @param cancel If cancelled.
+     */
+    @Override
+    public void setCancelled(final boolean cancel) {
+        this.cancelled = cancel;
+    }
+
+    /**
+     * Bukkit parity.
+     *
+     * @return The handlers.
+     */
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    /**
+     * Get the reforge associated with the event.
+     *
+     * @return The reforge.
+     */
+    @NotNull
+    public Reforge getReforge() {
+        return this.reforge;
+    }
+
+    /**
+     * Get the effect associated with the event.
+     *
+     * @return The effect.
+     */
+    @NotNull
+    public Effect getEffect() {
+        return this.effect;
+    }
+
+    /**
+     * Bukkit parity.
+     *
+     * @return The handler list.
+     */
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/reforges/gui/ReforgeGUI.java

@@ -1,202 +0,0 @@
-package com.willfp.reforges.gui;
-
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.config.updating.ConfigUpdater;
-import com.willfp.eco.core.drops.DropQueue;
-import com.willfp.eco.core.gui.menu.Menu;
-import com.willfp.eco.core.gui.slot.FillerMask;
-import com.willfp.eco.core.gui.slot.MaskMaterials;
-import com.willfp.eco.core.gui.slot.Slot;
-import com.willfp.eco.core.items.builder.ItemStackBuilder;
-import com.willfp.eco.util.NumberUtils;
-import com.willfp.reforges.ReforgesPlugin;
-import com.willfp.reforges.reforges.util.ReforgeHandler;
-import com.willfp.reforges.reforges.util.ReforgeStatus;
-import com.willfp.reforges.reforges.util.ReforgeUtils;
-import lombok.Getter;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-
-@SuppressWarnings("deprecation")
-@UtilityClass
-public class ReforgeGUI {
-    /**
-     * The reforge GUI.
-     */
-    @Getter
-    private static Menu menu;
-
-    /**
-     * Update the GUI.
-     *
-     * @param plugin The plugin.
-     */
-    @ConfigUpdater
-    public static void update(@NotNull final EcoPlugin plugin) {
-        ReforgeHandler handler = new ReforgeHandler(plugin);
-        Slot activatorSlot = Slot.builder(new ItemStack(Material.ANVIL))
-                .setModifier((player, menu, previous) -> {
-                    ItemMeta meta = previous.getItemMeta();
-                    if (meta == null) {
-                        return;
-                    }
-
-                    ReforgeStatus status = ReforgeUtils.getStatus(menu.getCaptiveItems(player));
-
-                    double cost = plugin.getConfigYml().getDouble("reforge.cost");
-                    if (status == ReforgeStatus.ALLOW) {
-                        ItemStack item = menu.getCaptiveItems(player).get(0);
-                        int reforges = ReforgeUtils.getReforges(item);
-                        cost *= Math.pow(plugin.getConfigYml().getDouble("reforge.cost-exponent"), reforges);
-                    }
-
-                    int xpcost = plugin.getConfigYml().getInt("reforge.xp-cost");
-                    if (status == ReforgeStatus.ALLOW) {
-                        ItemStack item = menu.getCaptiveItems(player).get(0);
-                        int reforges = ReforgeUtils.getReforges(item);
-                        xpcost *= Math.pow(plugin.getConfigYml().getDouble("reforge.cost-exponent"), reforges);
-                    }
-
-                    switch (status) {
-                        case INVALID_ITEM -> {
-                            previous.setType(Objects.requireNonNull(Material.getMaterial(plugin.getConfigYml().getString("gui.invalid-item.material").toUpperCase())));
-                            meta.setDisplayName(plugin.getConfigYml().getString("gui.invalid-item.name"));
-                            List<String> lore = new ArrayList<>();
-                            for (String string : plugin.getConfigYml().getStrings("gui.invalid-item.lore")) {
-                                lore.add(string.replace("%cost%", NumberUtils.format(cost))
-                                .replace("%xpcost%", NumberUtils.format(xpcost)));
-                            }
-                            meta.setLore(lore);
-                        }
-                        case ALLOW -> {
-                            previous.setType(Objects.requireNonNull(Material.getMaterial(plugin.getConfigYml().getString("gui.allow.material").toUpperCase())));
-                            meta.setDisplayName(plugin.getConfigYml().getString("gui.allow.name"));
-                            List<String> lore = new ArrayList<>();
-                            for (String string : plugin.getConfigYml().getStrings("gui.allow.lore")) {
-                                lore.add(string.replace("%cost%", NumberUtils.format(cost))
-                                        .replace("%xpcost%", NumberUtils.format(xpcost)));
-                            }
-                            meta.setLore(lore);
-                        }
-                        case ALLOW_STONE -> {
-                            previous.setType(Objects.requireNonNull(Material.getMaterial(plugin.getConfigYml().getString("gui.allow-stone.material").toUpperCase())));
-                            meta.setDisplayName(plugin.getConfigYml().getString("gui.allow-stone.name"));
-                            List<String> lore = new ArrayList<>();
-                            for (String string : plugin.getConfigYml().getStrings("gui.allow-stone.lore")) {
-                                lore.add(string.replace("%cost%", NumberUtils.format(cost))
-                                        .replace("%xpcost%", NumberUtils.format(xpcost))
-                                        .replace("%stone%", ReforgeUtils.getReforgeStone(menu.getCaptiveItems(player).get(1)).getName()));
-                            }
-                            meta.setLore(lore);
-                        }
-                        default -> {
-                            previous.setType(Objects.requireNonNull(Material.getMaterial(plugin.getConfigYml().getString("gui.no-item.material").toUpperCase())));
-                            meta.setDisplayName(plugin.getConfigYml().getString("gui.no-item.name"));
-                            List<String> lore = new ArrayList<>();
-                            for (String string : plugin.getConfigYml().getStrings("gui.no-item.lore")) {
-                                lore.add(string.replace("%cost%", NumberUtils.format(cost))
-                                        .replace("%xpcost%", NumberUtils.format(xpcost)));
-                            }
-                            meta.setLore(lore);
-                        }
-                    }
-
-                    previous.setItemMeta(meta);
-                })
-                .onLeftClick(handler::handleReforgeClick)
-                .build();
-
-        String[] maskPattern = plugin.getConfigYml().getStrings("gui.mask.pattern", false).toArray(new String[0]);
-        Material[] maskMaterials = plugin.getConfigYml()
-                .getStrings("gui.mask.materials", false)
-                .stream()
-                .map(string -> Material.getMaterial(string.toUpperCase()))
-                .filter(Objects::nonNull)
-                .toArray(Material[]::new);
-
-        Material allowMaterial = Material.getMaterial(plugin.getConfigYml().getString("gui.show-allowed.allow-material", false).toUpperCase());
-        Material denyMaterial = Material.getMaterial(plugin.getConfigYml().getString("gui.show-allowed.deny-material", false).toUpperCase());
-        assert allowMaterial != null;
-        assert denyMaterial != null;
-
-        Material closeMaterial = Material.getMaterial(plugin.getConfigYml().getString("gui.close.material", false).toUpperCase());
-        assert closeMaterial != null;
-
-        menu = Menu.builder(plugin.getConfigYml().getInt("gui.rows"))
-                .setTitle(plugin.getLangYml().getString("menu.title"))
-                .setMask(
-                        new FillerMask(
-                                new MaskMaterials(
-                                        maskMaterials
-                                ),
-                                maskPattern
-                        )
-                )
-                .modfiy(builder -> {
-                    Slot slot = Slot.builder(
-                            new ItemStackBuilder(Material.BLACK_STAINED_GLASS_PANE)
-                                    .setDisplayName("&r")
-                                    .build()
-                    ).setModifier((player, menu, previous) -> {
-                        ReforgeStatus status = ReforgeUtils.getStatus(menu.getCaptiveItems(player));
-                        if (status == ReforgeStatus.ALLOW || status == ReforgeStatus.ALLOW_STONE) {
-                            previous.setType(allowMaterial);
-                        } else {
-                            previous.setType(denyMaterial);
-                        }
-                    }).build();
-
-                    List<String> allowedPattern = plugin.getConfigYml().getStrings("gui.show-allowed.pattern");
-
-                    for (int i = 1; i <= allowedPattern.size(); i++) {
-                        String row = allowedPattern.get(i - 1);
-                        for (int j = 1; j <= 9; j++) {
-                            if (row.charAt(j - 1) != '0') {
-                                builder.setSlot(i, j, slot);
-                            }
-                        }
-                    }
-                })
-                .setSlot(plugin.getConfigYml().getInt("gui.item-slot.row"),
-                        plugin.getConfigYml().getInt("gui.item-slot.column"),
-                        Slot.builder()
-                                .setCaptive()
-                                .build()
-                )
-                .setSlot(plugin.getConfigYml().getInt("gui.stone-slot.row"),
-                        plugin.getConfigYml().getInt("gui.stone-slot.column"),
-                        Slot.builder()
-                                .setCaptive()
-                                .build()
-                )
-                .setSlot(2, 5, activatorSlot)
-                .setSlot(plugin.getConfigYml().getInt("gui.close.location.row"),
-                        plugin.getConfigYml().getInt("gui.close.location.column"),
-                        Slot.builder(
-                                new ItemStackBuilder(closeMaterial)
-                                        .setDisplayName(plugin.getLangYml().getString("menu.close"))
-                                        .build()
-                        ).onLeftClick((event, slot, menu) -> {
-                            event.getWhoClicked().closeInventory();
-                        }).build()
-                ).onClose((event, menu) -> {
-                    new DropQueue((Player) event.getPlayer())
-                            .addItems(menu.getCaptiveItems((Player) event.getPlayer()))
-                            .setLocation(event.getPlayer().getEyeLocation())
-                            .push();
-                })
-                .build();
-    }
-
-    static {
-        update(ReforgesPlugin.getInstance());
-    }
-}

eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/ReforgeLookup.java

@@ -1,112 +0,0 @@
-package com.willfp.reforges.reforges;
-
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.reforges.ReforgesPlugin;
-import com.willfp.reforges.reforges.util.ReforgeUtils;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.UUID;
-import java.util.WeakHashMap;
-import java.util.function.Function;
-
-public class ReforgeLookup {
-    /**
-     * All registered providers.
-     */
-    private static final Set<Function<Player, Collection<ItemStack>>> PROVIDERS = new HashSet<>();
-
-    /**
-     * Cached items.
-     */
-    private static final Map<UUID, Collection<ItemStack>> ITEM_CACHE = new WeakHashMap<>();
-
-    /**
-     * Cached reforges.
-     */
-    private static final Map<UUID, Collection<Reforge>> REFORGE_CACHE = new WeakHashMap<>();
-
-    /**
-     * Instance of Reforges.
-     */
-    private static final EcoPlugin PLUGIN = ReforgesPlugin.getInstance();
-
-    /**
-     * Register provider.
-     *
-     * @param provider The provider.
-     */
-    public static void registerProvider(@NotNull final Function<Player, Collection<ItemStack>> provider) {
-        PROVIDERS.add(provider);
-    }
-
-    /**
-     * Provide ItemStacks.
-     *
-     * @param player The player.
-     * @return The ItemStacks.
-     */
-    public static Set<ItemStack> provide(@NotNull final Player player) {
-        if (ITEM_CACHE.containsKey(player.getUniqueId())) {
-            return new HashSet<>(ITEM_CACHE.get(player.getUniqueId()));
-        }
-
-        Set<ItemStack> found = new HashSet<>();
-        for (Function<Player, Collection<ItemStack>> provider : PROVIDERS) {
-            found.addAll(provider.apply(player));
-        }
-        found.removeIf(Objects::isNull);
-
-        ITEM_CACHE.put(player.getUniqueId(), found);
-        PLUGIN.getScheduler().runLater(() -> ITEM_CACHE.remove(player.getUniqueId()), 40);
-
-        return found;
-    }
-
-    /**
-     * Provide Reforges.
-     *
-     * @param player The player.
-     * @return The Reforges.
-     */
-    public static Set<Reforge> provideReforges(@NotNull final Player player) {
-        if (REFORGE_CACHE.containsKey(player.getUniqueId())) {
-            return new HashSet<>(REFORGE_CACHE.get(player.getUniqueId()));
-        }
-
-        Set<Reforge> found = new HashSet<>();
-
-        for (ItemStack itemStack : provide(player)) {
-            if (itemStack == null) {
-                continue;
-            }
-
-            Reforge reforge = ReforgeUtils.getReforge(itemStack);
-
-            if (reforge == null) {
-                continue;
-            }
-
-            found.add(reforge);
-        }
-
-        REFORGE_CACHE.put(player.getUniqueId(), found);
-        PLUGIN.getScheduler().runLater(() -> REFORGE_CACHE.remove(player.getUniqueId()), 40);
-
-        return found;
-    }
-
-    static {
-        registerProvider(player -> Collections.singletonList(player.getInventory().getItemInMainHand()));
-        registerProvider(player -> Collections.singletonList(player.getInventory().getItemInOffHand()));
-        registerProvider(player -> Arrays.asList(player.getInventory().getArmorContents()));
-    }
-}

eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforges.java

@@ -60,7 +60,7 @@ public class Reforges {
         }
 
         for (JSONConfig config : plugin.getReforgesJson().getSubsections("reforges")) {
-            addNewReforge(new Reforge(config, plugin));
+            new Reforge(config, plugin);
         }
     }
 

eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/meta/ReforgeTarget.java

@@ -8,20 +8,20 @@ import com.willfp.reforges.ReforgesPlugin;
 import lombok.Getter;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 public class ReforgeTarget {
     /**
      * Target containing the materials from all other targets.
      */
-    public static final ReforgeTarget ALL = new ReforgeTarget("all", new HashSet<>());
+    public static final ReforgeTarget ALL = new ReforgeTarget("all", Slot.ANY, new HashSet<>());
 
     /**
      * All registered targets.
@@ -38,12 +38,19 @@ public class ReforgeTarget {
      */
     @Getter
     private final String name;
+
     /**
      * The materials of the target.
      */
     @Getter
     private final Set<TestableItem> items;
 
+    /**
+     * The slot for the target.
+     */
+    @Getter
+    private final Slot slot;
+
     /**
      * Create new target.
      *
@@ -51,10 +58,12 @@ public class ReforgeTarget {
      * @param items The items for the target.
      */
     public ReforgeTarget(@NotNull final String name,
+                         @NotNull final Slot slot,
                          @NotNull final Set<TestableItem> items) {
         this.name = name;
         items.removeIf(item -> item instanceof EmptyTestableItem);
         this.items = items;
+        this.slot = slot;
     }
 
     /**
@@ -89,13 +98,11 @@ public class ReforgeTarget {
      * @param item The item.
      * @return The target.
      */
-    @Nullable
+    public static List<ReforgeTarget> getForItem(@NotNull final ItemStack item) {
-    public static ReforgeTarget getForItem(@NotNull final ItemStack item) {
+        return REGISTERED.values().stream()
-        Optional<ReforgeTarget> matching = REGISTERED.values().stream()
                 .filter(target -> !target.getName().equalsIgnoreCase("all"))
                 .filter(target -> target.matches(item))
-                .findFirst();
+                .collect(Collectors.toList());
-        return matching.orElse(null);
     }
 
     /**
@@ -115,7 +122,11 @@ public class ReforgeTarget {
         }
 
         for (String id : plugin.getTargetYml().getTargets()) {
-            ReforgeTarget target = new ReforgeTarget(id, plugin.getTargetYml().getTargetItems(id));
+            ReforgeTarget target = new ReforgeTarget(
+                    id,
+                    plugin.getTargetYml().getSlot(id),
+                    plugin.getTargetYml().getTargetItems(id)
+            );
             REGISTERED.put(id, target);
             ALL.items.addAll(target.items);
         }
@@ -129,4 +140,13 @@ public class ReforgeTarget {
     public static Set<ReforgeTarget> values() {
         return ImmutableSet.copyOf(REGISTERED.values());
     }
+
+    /**
+     * Reforge slots.
+     */
+    public enum Slot {
+        HANDS,
+        ARMOR,
+        ANY
+    }
 }

eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeArgParser.java

@@ -1,49 +0,0 @@
-package com.willfp.reforges.reforges.util;
-
-import com.willfp.eco.core.items.args.LookupArgParser;
-import com.willfp.reforges.reforges.Reforge;
-import com.willfp.reforges.reforges.Reforges;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.function.Predicate;
-
-public class ReforgeArgParser implements LookupArgParser {
-    @Override
-    public @Nullable Predicate<ItemStack> parseArguments(@NotNull final String[] args,
-                                                         @NotNull final ItemMeta meta) {
-        Reforge reforge = null;
-        for (String arg : args) {
-            String[] split = arg.split(":");
-            if (split.length == 1 || !split[0].equalsIgnoreCase("reforge")) {
-                continue;
-            }
-
-            Reforge match = Reforges.getByKey(split[1].toLowerCase());
-            if (match == null) {
-                continue;
-            }
-
-            reforge = match;
-            break;
-        }
-
-        if (reforge == null) {
-            return null;
-        }
-
-        ReforgeUtils.setReforge(meta, reforge);
-
-        Reforge finalReforge = reforge;
-        return test -> {
-            ItemMeta testMeta = test.getItemMeta();
-            if (testMeta == null) {
-                return false;
-            }
-
-            return finalReforge.equals(ReforgeUtils.getReforge(testMeta));
-        };
-    }
-}

eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeEnableListeners.java

@@ -0,0 +1,126 @@
+package com.willfp.reforges.reforges.util;
+
+import com.willfp.eco.core.EcoPlugin;
+import com.willfp.eco.core.PluginDependent;
+import com.willfp.reforges.effects.ConfiguredEffect;
+import com.willfp.reforges.reforges.Reforge;
+import com.willfp.reforges.reforges.Reforges;
+import com.willfp.reforges.reforges.meta.ReforgeTarget;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityPickupItemEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerItemHeldEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.jetbrains.annotations.NotNull;
+
+public class ReforgeEnableListeners extends PluginDependent<EcoPlugin> implements Listener {
+    /**
+     * Initialize new listeners and link them to a plugin.
+     *
+     * @param plugin The plugin to link to.
+     */
+    public ReforgeEnableListeners(@NotNull final EcoPlugin plugin) {
+        super(plugin);
+    }
+
+    /**
+     * Called on item pickup.
+     *
+     * @param event The event to listen for.
+     */
+    @EventHandler
+    public void onItemPickup(@NotNull final EntityPickupItemEvent event) {
+        if (!(event.getEntity() instanceof Player player)) {
+            return;
+        }
+
+        if (!ReforgeTarget.ALL.matches(event.getItem().getItemStack())) {
+            return;
+        }
+
+        refreshPlayer(player);
+    }
+
+    /**
+     * Called on player join.
+     *
+     * @param event The event to listen for.
+     */
+    @EventHandler
+    public void onPlayerJoin(@NotNull final PlayerJoinEvent event) {
+        refresh();
+    }
+
+    /**
+     * Called on player leave.
+     *
+     * @param event The event to listen for.
+     */
+    @EventHandler
+    public void onPlayerLeave(@NotNull final PlayerQuitEvent event) {
+        refresh();
+
+        Player player = event.getPlayer();
+
+        for (Reforge value : Reforges.values()) {
+            for (ConfiguredEffect effect : value.getEffects()) {
+                effect.getEffect().handleDisabling(player);
+            }
+        }
+    }
+
+    /**
+     * Called on item drop.
+     *
+     * @param event The event to listen for.
+     */
+    @EventHandler
+    public void onInventoryDrop(@NotNull final PlayerDropItemEvent event) {
+        if (!ReforgeTarget.ALL.matches(event.getItemDrop().getItemStack())) {
+            return;
+        }
+
+        refreshPlayer(event.getPlayer());
+    }
+
+    /**
+     * Called on slot change.
+     *
+     * @param event The event to listen for.
+     */
+    @EventHandler
+    public void onChangeSlot(@NotNull final PlayerItemHeldEvent event) {
+        refreshPlayer(event.getPlayer());
+    }
+
+    /**
+     * Called on inventory click.
+     *
+     * @param event The event to listen for.
+     */
+    @EventHandler
+    public void onInventoryClick(@NotNull final InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player)) {
+            return;
+        }
+
+        refreshPlayer((Player) event.getWhoClicked());
+    }
+
+    /**
+     * Force refresh all online players.
+     * <p>
+     * This is a very expensive method.
+     */
+    public void refresh() {
+        this.getPlugin().getServer().getOnlinePlayers().forEach(this::refreshPlayer);
+    }
+
+    private void refreshPlayer(@NotNull final Player player) {
+        ReforgeLookup.updateReforges(player);
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeHandler.java

@@ -13,6 +13,8 @@ import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.List;
+
 public class ReforgeHandler extends PluginDependent<EcoPlugin> {
     /**
      * Pass an {@link EcoPlugin} in order to interface with it.
@@ -32,8 +34,7 @@ public class ReforgeHandler extends PluginDependent<EcoPlugin> {
             return;
         }
 
-        ReforgeTarget target = ReforgeTarget.getForItem(toReforge);
+        List<ReforgeTarget> target = ReforgeTarget.getForItem(toReforge);
-        assert target != null;
 
         Reforge reforge = null;
         boolean usedStone = false;
@@ -56,12 +57,16 @@ public class ReforgeHandler extends PluginDependent<EcoPlugin> {
             return;
         }
 
-
+        double cost = 0;
         if (EconomyHandler.isEnabled()) {
-            double cost = this.getPlugin().getConfigYml().getDouble("reforge.cost");
+            cost = this.getPlugin().getConfigYml().getDouble("reforge.cost");
             int reforges = ReforgeUtils.getReforges(toReforge);
             cost *= Math.pow(this.getPlugin().getConfigYml().getDouble("reforge.cost-exponent"), reforges);
-            if (!EconomyHandler.getInstance().has(player, cost)) {
+            if (reforge.getRequiresStone() && reforge.getStonePrice() != -1) {
+                cost = reforge.getStonePrice();
+            }
+
+            if (!EconomyHandler.has(player, cost)) {
                 player.sendMessage(this.getPlugin().getLangYml().getMessage("insufficient-money"));
 
                 player.playSound(
@@ -73,9 +78,6 @@ public class ReforgeHandler extends PluginDependent<EcoPlugin> {
 
                 return;
             }
-
-
-            EconomyHandler.getInstance().withdrawPlayer(player, cost);
         }
 
         int xpCost = this.getPlugin().getConfigYml().getInt("reforge.xp-cost");
@@ -94,6 +96,10 @@ public class ReforgeHandler extends PluginDependent<EcoPlugin> {
             return;
         }
 
+        if (EconomyHandler.isEnabled()) {
+            EconomyHandler.getInstance().withdrawPlayer(player, cost);
+        }
+
         player.setLevel(player.getLevel() - xpCost);
 
         player.sendMessage(this.getPlugin().getLangYml().getMessage("applied-reforge").replace("%reforge%", reforge.getName()));

eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeLookup.java

@@ -0,0 +1,239 @@
+package com.willfp.reforges.reforges.util;
+
+import com.willfp.eco.core.EcoPlugin;
+import com.willfp.reforges.ReforgesPlugin;
+import com.willfp.reforges.conditions.ConfiguredCondition;
+import com.willfp.reforges.reforges.Reforge;
+import com.willfp.reforges.reforges.meta.ReforgeTarget;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+import java.util.WeakHashMap;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class ReforgeLookup {
+    /**
+     * All registered providers.
+     */
+    private static final Set<Function<Player, Map<ItemStack, ReforgeTarget.Slot>>> PROVIDERS = new HashSet<>();
+
+    /**
+     * Cached items.
+     */
+    private static final Map<UUID, Map<ItemStack, ReforgeTarget.Slot>> ITEM_CACHE = new WeakHashMap<>();
+
+    /**
+     * Cached reforges.
+     */
+    private static final Map<UUID, Collection<Reforge>> REFORGE_CACHE = new WeakHashMap<>();
+
+    /**
+     * Instance of Reforges.
+     */
+    private static final EcoPlugin PLUGIN = ReforgesPlugin.getInstance();
+
+    /**
+     * Register provider.
+     *
+     * @param provider The provider.
+     */
+    public static void registerProvider(@NotNull final Function<Player, Map<ItemStack, ReforgeTarget.Slot>> provider) {
+        PROVIDERS.add(provider);
+    }
+
+    /**
+     * Provide ItemStacks.
+     *
+     * @param player The player.
+     * @return The ItemStacks.
+     */
+    public static Map<ItemStack, ReforgeTarget.Slot> provide(@NotNull final Player player) {
+        if (ITEM_CACHE.containsKey(player.getUniqueId())) {
+            return new HashMap<>(ITEM_CACHE.get(player.getUniqueId()));
+        }
+
+        Map<ItemStack, ReforgeTarget.Slot> found = new HashMap<>();
+        for (Function<Player, Map<ItemStack, ReforgeTarget.Slot>> provider : PROVIDERS) {
+            found.putAll(provider.apply(player));
+        }
+        found.keySet().removeIf(Objects::isNull);
+
+        ITEM_CACHE.put(player.getUniqueId(), found);
+        PLUGIN.getScheduler().runLater(() -> ITEM_CACHE.remove(player.getUniqueId()), 40);
+
+        return found;
+    }
+
+    /**
+     * Provide Reforges.
+     *
+     * @param player The player.
+     * @return The Reforges.
+     */
+    public static List<Reforge> provideReforges(@NotNull final Player player) {
+        if (REFORGE_CACHE.containsKey(player.getUniqueId())) {
+            return new ArrayList<>(REFORGE_CACHE.get(player.getUniqueId()));
+        }
+
+        List<Reforge> found = new ArrayList<>();
+
+        for (Map.Entry<ItemStack, ReforgeTarget.Slot> entry : provide(player).entrySet()) {
+            ItemStack itemStack = entry.getKey();
+            ReforgeTarget.Slot slot = entry.getValue();
+
+            if (itemStack == null) {
+                continue;
+            }
+
+            Reforge reforge = ReforgeUtils.getReforge(itemStack);
+
+            if (reforge == null) {
+                continue;
+            }
+
+            if (!reforge.getTargets().stream()
+                    .map(ReforgeTarget::getSlot)
+                    .collect(Collectors.toList())
+                    .contains(slot)) {
+                continue;
+            }
+
+            found.add(reforge);
+        }
+
+        REFORGE_CACHE.put(player.getUniqueId(), found);
+        PLUGIN.getScheduler().runLater(() -> REFORGE_CACHE.remove(player.getUniqueId()), 40);
+
+        return found;
+    }
+
+    /**
+     * Clear caches.
+     *
+     * @param player The player.
+     */
+    public static void clearCaches(@NotNull final Player player) {
+        REFORGE_CACHE.remove(player.getUniqueId());
+        ITEM_CACHE.remove(player.getUniqueId());
+    }
+
+    /**
+     * Update reforges for a player.
+     *
+     * @param player The player.
+     */
+    public static void updateReforges(@NotNull final Player player) {
+        List<Reforge> before = ReforgeLookup.provideReforges(player);
+        ReforgeLookup.clearCaches(player);
+        PLUGIN.getScheduler().run(() -> {
+            List<Reforge> after = ReforgeLookup.provideReforges(player);
+            Map<Reforge, Integer> beforeFrequency = listToFrequencyMap(before);
+            Map<Reforge, Integer> afterFrequency = listToFrequencyMap(after);
+
+            List<Reforge> added = new ArrayList<>();
+            List<Reforge> removed = new ArrayList<>();
+
+            for (Map.Entry<Reforge, Integer> entry : new HashSet<>(afterFrequency.entrySet())) {
+                int amount = entry.getValue();
+                Reforge reforge = entry.getKey();
+
+                amount -= beforeFrequency.getOrDefault(reforge, 0);
+
+                if (amount < 1) {
+                    continue;
+                }
+
+                for (int i = 0; i < amount; i++) {
+                    added.add(reforge);
+                }
+            }
+
+            for (Map.Entry<Reforge, Integer> entry : new HashSet<>(beforeFrequency.entrySet())) {
+                int amount = entry.getValue();
+                Reforge reforge = entry.getKey();
+
+                amount -= afterFrequency.getOrDefault(reforge, 0);
+
+                if (amount < 1) {
+                    continue;
+                }
+
+                for (int i = 0; i < amount; i++) {
+                    removed.add(reforge);
+                }
+            }
+
+            for (Reforge reforge : added) {
+                boolean areConditionsMet = true;
+                for (ConfiguredCondition condition : reforge.getConditions()) {
+                    if (!condition.getCondition().isConditionMet(player, condition.getConfig())) {
+                        areConditionsMet = false;
+                        break;
+                    }
+                }
+                if (areConditionsMet) {
+                    reforge.handleActivation(player);
+                }
+            }
+
+            for (Reforge reforge : removed) {
+                reforge.handleDeactivation(player);
+            }
+
+            for (Reforge reforge : after) {
+                boolean areConditionsMet = true;
+                for (ConfiguredCondition condition : reforge.getConditions()) {
+                    if (!condition.getCondition().isConditionMet(player, condition.getConfig())) {
+                        areConditionsMet = false;
+                        break;
+                    }
+                }
+                if (!areConditionsMet) {
+                    reforge.handleDeactivation(player);
+                }
+            }
+        });
+    }
+
+    private static <T> Map<T, Integer> listToFrequencyMap(@NotNull final List<T> list) {
+        Map<T, Integer> frequencyMap = new HashMap<>();
+        for (T object : list) {
+            if (frequencyMap.containsKey(object)) {
+                frequencyMap.put(object, frequencyMap.get(object) + 1);
+            } else {
+                frequencyMap.put(object, 1);
+            }
+        }
+
+        return frequencyMap;
+    }
+
+    static {
+        registerProvider(player -> Map.of(
+                player.getInventory().getItemInMainHand(),
+                ReforgeTarget.Slot.HANDS
+        ));
+        registerProvider(player -> Map.of(
+                player.getInventory().getItemInOffHand(),
+                ReforgeTarget.Slot.HANDS
+        ));
+        registerProvider(player -> {
+            Map<ItemStack, ReforgeTarget.Slot> items = new HashMap<>();
+            for (ItemStack stack : player.getInventory().getArmorContents()) {
+                items.put(stack, ReforgeTarget.Slot.ARMOR);
+            }
+            return items;
+        });
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeUtils.java

@@ -16,6 +16,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
@@ -44,14 +45,16 @@ public class ReforgeUtils {
     /**
      * Get a random reforge for a target.
      *
-     * @param target The target.
+     * @param targets The targets.
      */
-    public static Reforge getRandomReforge(@NotNull final ReforgeTarget target) {
+    public static Reforge getRandomReforge(@NotNull final Collection<ReforgeTarget> targets) {
         List<Reforge> applicable = new ArrayList<>();
 
         for (Reforge reforge : Reforges.values()) {
-            if (reforge.getTargets().contains(target) && !reforge.getRequiresStone()) {
+            for (ReforgeTarget target : targets) {
-                applicable.add(reforge);
+                if (reforge.getTargets().contains(target) && !reforge.getRequiresStone()) {
+                    applicable.add(reforge);
+                }
             }
         }
 
@@ -64,43 +67,45 @@ public class ReforgeUtils {
         return applicable.get(0);
     }
 
-    public static ReforgeStatus getStatus(@NotNull final List<ItemStack> captive) {
+    public static MetadatedReforgeStatus getStatus(@NotNull final List<ItemStack> captive) {
         ItemStack toReforge = captive.isEmpty() ? null : captive.get(0);
         ItemStack stone = captive.size() == 2 ? captive.get(1) : null;
         ReforgeStatus status = null;
 
-        ReforgeTarget target = null;
+        List<ReforgeTarget> target = new ArrayList<>();
 
         if (toReforge == null || toReforge.getType() == Material.AIR) {
             status = ReforgeStatus.NO_ITEM;
         } else {
-            target = ReforgeTarget.getForItem(toReforge);
+            target.addAll(ReforgeTarget.getForItem(toReforge));
-            if (target == null) {
+            if (target.isEmpty()) {
                 status = ReforgeStatus.INVALID_ITEM;
             }
         }
 
-        if (target != null) {
+        if (!target.isEmpty()) {
             status = ReforgeStatus.ALLOW;
         }
 
+        double cost = 0;
         if (status == ReforgeStatus.ALLOW) {
             Reforge reforgeStone = getReforgeStone(stone);
             if (reforgeStone != null && reforgeStone.getTargets().stream()
                     .anyMatch(reforgeTarget -> reforgeTarget.getItems().stream()
                             .anyMatch(item -> item.matches(toReforge)))) {
+                cost = reforgeStone.getStonePrice();
                 status = ReforgeStatus.ALLOW_STONE;
             }
         }
 
-        return status;
+        return new MetadatedReforgeStatus(status, cost);
     }
 
     /**
      * Get reforge on an item.
      *
      * @param item The item to query.
-     * @return The found reforge, or null if none active.
+     * @return The found reforge, or null.
      */
     public static Reforge getReforge(@Nullable final ItemStack item) {
         if (item == null) {
@@ -120,7 +125,7 @@ public class ReforgeUtils {
      * Get reforge on an item.
      *
      * @param meta The item to query.
-     * @return The found reforge, or null if none active.
+     * @return The found reforge, or null.
      */
     public static Reforge getReforge(@Nullable final ItemMeta meta) {
         if (meta == null) {
@@ -151,12 +156,6 @@ public class ReforgeUtils {
             return;
         }
 
-        Reforge previous = getReforge(item);
-
-        if (previous != null) {
-            previous.handleRemoval(item);
-        }
-
         ItemMeta meta = item.getItemMeta();
 
         setReforge(meta, reforge);
@@ -175,15 +174,13 @@ public class ReforgeUtils {
         PersistentDataContainer container = meta.getPersistentDataContainer();
 
         container.set(REFORGE_KEY, PersistentDataType.STRING, reforge.getId());
-
-        reforge.handleApplication(meta);
     }
 
     /**
      * Get reforge stone on an item.
      *
      * @param item The item to query.
-     * @return The found reforge, or null if none active.
+     * @return The found reforge, or null.
      */
     public static Reforge getReforgeStone(@Nullable final ItemStack item) {
         if (item == null) {
@@ -203,7 +200,7 @@ public class ReforgeUtils {
      * Get reforge stone on an item.
      *
      * @param meta The item to query.
-     * @return The found reforge, or null if none active.
+     * @return The found reforge, or null.
      */
     public static Reforge getReforgeStone(@Nullable final ItemMeta meta) {
         if (meta == null) {

eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/Watcher.java

@@ -43,7 +43,7 @@ public interface Watcher {
      * @param event    The event.
      * @param config   The effect config.
      */
-    default void onAnyDamage(@NotNull final LivingEntity attacker,
+    default void onAnyDamage(@NotNull final Player attacker,
                              @NotNull final LivingEntity victim,
                              @NotNull final EntityDamageByEntityEvent event,
                              @NotNull final JSONConfig config) {
@@ -59,7 +59,7 @@ public interface Watcher {
      * @param event    The event that called this watcher.
      * @param config   The effect config.
      */
-    default void onArrowDamage(@NotNull final LivingEntity attacker,
+    default void onArrowDamage(@NotNull final Player attacker,
                                @NotNull final LivingEntity victim,
                                @NotNull final Arrow arrow,
                                @NotNull final EntityDamageByEntityEvent event,
@@ -76,7 +76,7 @@ public interface Watcher {
      * @param event    The event that called this watcher.
      * @param config   The effect config.
      */
-    default void onTridentDamage(@NotNull final LivingEntity attacker,
+    default void onTridentDamage(@NotNull final Player attacker,
                                  @NotNull final LivingEntity victim,
                                  @NotNull final Trident trident,
                                  @NotNull final EntityDamageByEntityEvent event,
@@ -105,7 +105,7 @@ public interface Watcher {
      * @param event    The event that called this watcher.
      * @param config   The effect config.
      */
-    default void onMeleeAttack(@NotNull final LivingEntity attacker,
+    default void onMeleeAttack(@NotNull final Player attacker,
                                @NotNull final LivingEntity victim,
                                @NotNull final EntityDamageByEntityEvent event,
                                @NotNull final JSONConfig config) {
@@ -120,7 +120,7 @@ public interface Watcher {
      * @param event      The event that called this watcher.
      * @param config     The effect config.
      */
-    default void onProjectileLaunch(@NotNull final LivingEntity shooter,
+    default void onProjectileLaunch(@NotNull final Player shooter,
                                     @NotNull final Projectile projectile,
                                     @NotNull final ProjectileLaunchEvent event,
                                     @NotNull final JSONConfig config) {
@@ -134,7 +134,7 @@ public interface Watcher {
      * @param event  The event that called this watcher.
      * @param config The effect config.
      */
-    default void onFallDamage(@NotNull final LivingEntity faller,
+    default void onFallDamage(@NotNull final Player faller,
                               @NotNull final EntityDamageEvent event,
                               @NotNull final JSONConfig config) {
         // Empty default as effects only override required watchers.
@@ -147,7 +147,7 @@ public interface Watcher {
      * @param event   The event that called this watcher.
      * @param config  The effect config.
      */
-    default void onProjectileHit(@NotNull final LivingEntity shooter,
+    default void onProjectileHit(@NotNull final Player shooter,
                                  @NotNull final ProjectileHitEvent event,
                                  @NotNull final JSONConfig config) {
         // Empty default as effects only override required watchers.
@@ -161,7 +161,7 @@ public interface Watcher {
      * @param event  The event.
      * @param config The effect config.
      */
-    default void onKill(@NotNull final LivingEntity killer,
+    default void onKill(@NotNull final Player killer,
                         @NotNull final LivingEntity victim,
                         @NotNull final EntityDeathByEntityEvent event,
                         @NotNull final JSONConfig config) {
@@ -175,7 +175,7 @@ public interface Watcher {
      * @param event  The event that called this watcher.
      * @param config The effect config.
      */
-    default void onDamageWearingArmor(@NotNull final LivingEntity victim,
+    default void onDamageWearingArmor(@NotNull final Player victim,
                                       @NotNull final EntityDamageEvent event,
                                       @NotNull final JSONConfig config) {
         // Empty default as effects only override required watchers.
@@ -189,7 +189,7 @@ public interface Watcher {
      * @param event   The event that called this watcher.
      * @param config  The effect config.
      */
-    default void onTridentLaunch(@NotNull final LivingEntity shooter,
+    default void onTridentLaunch(@NotNull final Player shooter,
                                  @NotNull final Trident trident,
                                  @NotNull final ProjectileLaunchEvent event,
                                  @NotNull final JSONConfig config) {

eco-core/core-plugin/src/main/java/com/willfp/reforges/vault/EconomyHandler.java

@@ -1,11 +1,16 @@
 package com.willfp.reforges.vault;
 
+import com.willfp.reforges.ReforgesPlugin;
 import lombok.Setter;
 import lombok.experimental.UtilityClass;
 import net.milkbowl.vault.economy.Economy;
+import org.black_ixx.playerpoints.PlayerPoints;
 import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
 import org.bukkit.plugin.RegisteredServiceProvider;
 
+import java.util.concurrent.ExecutionException;
+
 @UtilityClass
 public final class EconomyHandler {
     /**
@@ -13,6 +18,9 @@ public final class EconomyHandler {
      */
     private static Economy instance = null;
 
+    @Setter
+    private static boolean usePlayerPoints = false;
+
     @Setter
     private static boolean enabled = false;
 
@@ -34,6 +42,24 @@ public final class EconomyHandler {
         return EconomyHandler.instance;
     }
 
+    /**
+     * Get if a player has a specified amount.
+     *
+     * @param player The player.
+     * @param amount The amount.
+     * @return If a player has the amount.
+     */
+    public static boolean has(Player player, double amount) {
+        if (usePlayerPoints && ReforgesPlugin.getInstance().getConfigYml().getBool("reforge.use-player-points")) {
+            try {
+                return PlayerPoints.getInstance().getAPI().lookAsync(player.getUniqueId()).get() >= amount;
+            } catch (ExecutionException | InterruptedException e) {
+                return false;
+            }
+        }
+        return getInstance().has(player, amount);
+    }
+
     public static boolean isEnabled() {
         return EconomyHandler.enabled;
     }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandGive.kt

@@ -0,0 +1,95 @@
+package com.willfp.reforges.commands
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.command.CommandHandler
+import com.willfp.eco.core.command.TabCompleteHandler
+import com.willfp.eco.core.command.impl.Subcommand
+import com.willfp.reforges.reforges.Reforges
+import org.bukkit.Bukkit
+import org.bukkit.util.StringUtil
+
+class CommandGive(
+    plugin: EcoPlugin
+) : Subcommand(plugin, "give", "reforges.command.give", false) {
+    private val numbers = listOf(
+        "1",
+        "2",
+        "3",
+        "4",
+        "5",
+        "10",
+        "32",
+        "64"
+    )
+
+    override fun getHandler(): CommandHandler {
+        return CommandHandler { sender, args ->
+            if (args.isEmpty()) {
+                sender.sendMessage(plugin.langYml.getMessage("needs-player"))
+                return@CommandHandler
+            }
+
+            if (args.size == 1) {
+                sender.sendMessage(plugin.langYml.getMessage("needs-stone"))
+                return@CommandHandler
+            }
+
+            val amount = if (args.size > 2) args[2].toIntOrNull() ?: 1 else 1
+            val recieverName = args[0]
+            val reciever = Bukkit.getPlayer(recieverName)
+            if (reciever == null) {
+                sender.sendMessage(plugin.langYml.getMessage("invalid-player"))
+                return@CommandHandler
+            }
+            val key = args[1]
+            val reforge = Reforges.getByKey(key)
+            if (reforge == null) {
+                sender.sendMessage(plugin.langYml.getMessage("invalid-stone"))
+                return@CommandHandler
+            }
+            var message = plugin.langYml.getMessage("give-success")
+            message = message.replace("%reforge%", reforge.name).replace("%recipient%", reciever.name)
+            sender.sendMessage(message)
+            val itemStack = reforge.stone
+            itemStack.amount = amount
+            reciever.inventory.addItem(itemStack)
+        }
+    }
+
+    override fun getTabCompleter(): TabCompleteHandler {
+        return TabCompleteHandler { _, args ->
+            val completions = mutableListOf<String>()
+            if (args.isEmpty()) {
+                // Currently, this case is not ever reached
+                return@TabCompleteHandler Reforges.values().filter { it.requiresStone }.map { it.id }
+            }
+            if (args.size == 1) {
+                StringUtil.copyPartialMatches(
+                    args[0],
+                    Bukkit.getOnlinePlayers().map { it.name },
+                    completions
+                )
+                return@TabCompleteHandler completions
+            }
+            if (args.size == 2) {
+                StringUtil.copyPartialMatches(
+                    args[1],
+                    Reforges.values().filter { it.requiresStone }.map { it.id },
+                    completions
+                )
+                completions.sort()
+                return@TabCompleteHandler completions
+            }
+            if (args.size == 3) {
+                StringUtil.copyPartialMatches(args[2], numbers, completions)
+                completions.sortWith { s1, s2 ->
+                    val t1 = s1.toInt()
+                    val t2 = s2.toInt()
+                    t1 - t2
+                }
+                return@TabCompleteHandler completions
+            }
+            emptyList()
+        }
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandOpen.kt

@@ -0,0 +1,50 @@
+package com.willfp.reforges.commands
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.command.CommandHandler
+import com.willfp.eco.core.command.TabCompleteHandler
+import com.willfp.eco.core.command.impl.PluginCommand
+import com.willfp.reforges.gui.ReforgeGUI.menu
+import org.bukkit.Bukkit
+import org.bukkit.Sound
+import org.bukkit.util.StringUtil
+
+class CommandOpen(
+    plugin: EcoPlugin
+) : PluginCommand(plugin, "open", "reforges.command.open", false) {
+    override fun getHandler(): CommandHandler {
+        return CommandHandler { sender, args ->
+            if (args.isEmpty()) {
+                sender.sendMessage(plugin.langYml.getMessage("needs-player"))
+                return@CommandHandler
+            }
+            val player = Bukkit.getPlayer(args[0])
+            if (player == null) {
+                sender.sendMessage(plugin.langYml.getMessage("invalid-player"))
+                return@CommandHandler
+            }
+            player.playSound(
+                player.location,
+                Sound.valueOf(plugin.configYml.getString("gui.open-sound.id").uppercase()),
+                1f,
+                plugin.configYml.getDouble("gui.open-sound.pitch").toFloat()
+            )
+            menu.open(player)
+        }
+    }
+
+    override fun getTabCompleter(): TabCompleteHandler {
+        return TabCompleteHandler { _, args ->
+            val completions = mutableListOf<String>()
+            if (args.size == 1) {
+                StringUtil.copyPartialMatches(
+                    args[0],
+                    Bukkit.getOnlinePlayers().map { it.name },
+                    completions
+                )
+                return@TabCompleteHandler completions
+            }
+            emptyList()
+        }
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandReforge.kt

@@ -0,0 +1,25 @@
+package com.willfp.reforges.commands
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.command.CommandHandler
+import com.willfp.eco.core.command.impl.PluginCommand
+import com.willfp.reforges.gui.ReforgeGUI.menu
+import org.bukkit.Sound
+import org.bukkit.entity.Player
+
+class CommandReforge(
+    plugin: EcoPlugin
+) : PluginCommand(plugin, "reforge", "reforges.command.reforge", true) {
+    override fun getHandler(): CommandHandler {
+        return CommandHandler { player, _ ->
+            player as Player
+            player.playSound(
+                player.location,
+                Sound.valueOf(plugin.configYml.getString("gui.open-sound.id").uppercase()),
+                1f,
+                plugin.configYml.getDouble("gui.open-sound.pitch").toFloat()
+            )
+            menu.open(player)
+        }
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandReforges.kt

@@ -0,0 +1,21 @@
+package com.willfp.reforges.commands
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.command.CommandHandler
+import com.willfp.eco.core.command.impl.PluginCommand
+
+class CommandReforges(plugin: EcoPlugin) : PluginCommand(plugin, "reforges", "reforges.command.reforges", false) {
+    override fun getHandler(): CommandHandler {
+        return CommandHandler { sender, _ ->
+            sender.sendMessage(
+                plugin.langYml.getMessage("invalid-command")
+            )
+        }
+    }
+
+    init {
+        addSubcommand(CommandReload(plugin))
+            .addSubcommand(CommandGive(plugin))
+            .addSubcommand(CommandOpen(plugin))
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandReload.kt

@@ -0,0 +1,14 @@
+package com.willfp.reforges.commands
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.command.CommandHandler
+import com.willfp.eco.core.command.impl.Subcommand
+
+class CommandReload(plugin: EcoPlugin) : Subcommand(plugin, "reload", "reforges.command.reload", false) {
+    override fun getHandler(): CommandHandler {
+        return CommandHandler { sender, _ ->
+            plugin.reload()
+            sender.sendMessage(plugin.langYml.getMessage("reloaded"))
+        }
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/ConditionHelper.kt

@@ -1,37 +0,0 @@
-package com.willfp.reforges.conditions
-
-import com.willfp.reforges.ReforgesPlugin
-import com.willfp.reforges.reforges.util.ReforgeUtils
-import org.bukkit.entity.Player
-import org.bukkit.inventory.ItemStack
-
-private val plugin = ReforgesPlugin.getInstance()
-
-fun ItemStack.updateReforge(player: Player, condition: Condition) {
-    plugin.scheduler.run {
-        val meta = this.itemMeta ?: return@run
-
-        val reforge = ReforgeUtils.getReforge(meta) ?: return@run
-
-        var allow = true
-
-        for ((cond, cfg) in reforge.conditions) {
-            if (cond != condition) {
-                continue
-            }
-
-            if (!cond.isConditionMet(player, cfg)) {
-                allow = false
-                break
-            }
-        }
-
-        if (allow) {
-            reforge.handleApplication(meta)
-        } else {
-            reforge.handleRemoval(meta)
-        }
-
-        this.itemMeta = meta
-    }
-}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionAboveHealthPercent.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.attribute.Attribute
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
@@ -23,11 +22,7 @@ class ConditionAboveHealthPercent: Condition("above_health_percent") {
             return
         }
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     @EventHandler(
@@ -41,11 +36,7 @@ class ConditionAboveHealthPercent: Condition("above_health_percent") {
             return
         }
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionAboveHungerPercent.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -22,11 +21,7 @@ class ConditionAboveHungerPercent : Condition("above_hunger_percent") {
             return
         }
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionAboveXPLevel.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -18,11 +17,7 @@ class ConditionAboveXPLevel : Condition("above_xp_level") {
     fun handle(event: PlayerExpChangeEvent) {
         val player = event.player
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionAboveY.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -17,11 +16,11 @@ class ConditionAboveY: Condition("above_y") {
     fun handle(event: PlayerMoveEvent) {
         val player = event.player
 
-        val items = ReforgeLookup.provide(player)
+        if (event.from.y == event.to.y) {
-
+            return
-        for (item in items) {
-            item.updateReforge(player, this)
         }
+
+        ReforgeLookup.updateReforges(player)
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionBelowHealthPercent.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.attribute.Attribute
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
@@ -23,11 +22,7 @@ class ConditionBelowHealthPercent: Condition("below_health_percent") {
             return
         }
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     @EventHandler(
@@ -41,11 +36,7 @@ class ConditionBelowHealthPercent: Condition("below_health_percent") {
             return
         }
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionBelowHungerPercent.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -22,11 +21,7 @@ class ConditionBelowHungerPercent : Condition("below_hunger_percent") {
             return
         }
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionBelowXPLevel.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -18,11 +17,7 @@ class ConditionBelowXPLevel: Condition("below_xp_level") {
     fun handle(event: PlayerExpChangeEvent) {
         val player = event.player
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionBelowY.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -17,11 +16,11 @@ class ConditionBelowY: Condition("below_y") {
     fun handle(event: PlayerMoveEvent) {
         val player = event.player
 
-        val items = ReforgeLookup.provide(player)
+        if (event.from.y == event.to.y) {
-
+            return
-        for (item in items) {
-            item.updateReforge(player, this)
         }
+
+        ReforgeLookup.updateReforges(player)
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionHasPermission.kt

@@ -2,22 +2,10 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
-import com.willfp.reforges.reforges.ReforgeLookup
-import org.bukkit.Bukkit
 import org.bukkit.entity.Player
 
 
-class ConditionHasPermission : Condition("is_sneaking"), Runnable {
+class ConditionHasPermission : Condition("is_sneaking") {
-    override fun run() {
-        for (player in Bukkit.getOnlinePlayers()) {
-            val items = ReforgeLookup.provide(player)
-            for (item in items) {
-                item.updateReforge(player, this)
-            }
-        }
-    }
-
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
         return player.hasPermission(config.getString("permission"))
     }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionInAir.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -17,11 +16,7 @@ class ConditionInAir: Condition("in_air") {
     fun handle(event: PlayerMoveEvent) {
         val player = event.player
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionInBiome.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -17,11 +16,11 @@ class ConditionInBiome: Condition("in_biome") {
     fun handle(event: PlayerMoveEvent) {
         val player = event.player
 
-        val items = ReforgeLookup.provide(player)
+        if (event.from.world?.getBiome(event.from) == event.to.world?.getBiome(event.to)) {
-
+            return
-        for (item in items) {
-            item.updateReforge(player, this)
         }
+
+        ReforgeLookup.updateReforges(player)
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionInWater.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -17,11 +16,11 @@ class ConditionInWater: Condition("in_water") {
     fun handle(event: PlayerMoveEvent) {
         val player = event.player
 
-        val items = ReforgeLookup.provide(player)
+        if (event.from.world?.getBlockAt(event.from)?.type == event.to.world?.getBlockAt(event.to)?.type) {
-
+            return
-        for (item in items) {
-            item.updateReforge(player, this)
         }
+
+        ReforgeLookup.updateReforges(player)
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionInWorld.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -17,11 +16,11 @@ class ConditionInWorld: Condition("in_world") {
     fun handle(event: PlayerMoveEvent) {
         val player = event.player
 
-        val items = ReforgeLookup.provide(player)
+        if (event.from.world == event.to.world) {
-
+            return
-        for (item in items) {
-            item.updateReforge(player, this)
         }
+
+        ReforgeLookup.updateReforges(player)
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionIsSneaking.kt

@@ -2,8 +2,7 @@ package com.willfp.reforges.conditions.conditions
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.conditions.Condition
-import com.willfp.reforges.conditions.updateReforge
+import com.willfp.reforges.reforges.util.ReforgeLookup
-import com.willfp.reforges.reforges.ReforgeLookup
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -17,11 +16,7 @@ class ConditionIsSneaking: Condition("is_sneaking") {
     fun handle(event: PlayerToggleSneakEvent) {
         val player = event.player
 
-        val items = ReforgeLookup.provide(player)
+        ReforgeLookup.updateReforges(player)
-
-        for (item in items) {
-            item.updateReforge(player, this)
-        }
     }
 
     override fun isConditionMet(player: Player, config: JSONConfig): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/display/ReforgesDisplay.kt

@@ -13,17 +13,26 @@ import com.willfp.reforges.reforges.util.ReforgeUtils
 import net.kyori.adventure.text.Component
 import net.kyori.adventure.text.TextReplacementConfig
 import net.kyori.adventure.text.format.TextDecoration
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer
 import org.bukkit.Material
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.SkullMeta
+import org.bukkit.persistence.PersistentDataType
 
 @Suppress("DEPRECATION")
 class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin, DisplayPriority.HIGHEST) {
+    /**
+     * Deprecated
+     */
+    @Deprecated("Use PDC components!")
     private val replacement = TextReplacementConfig.builder()
         .match("§w(.+)§w")
         .replacement("")
         .build()
 
+    private val originalComponentKey = plugin.namespacedKeyFactory.create("real_name")
+    private val serializer = GsonComponentSerializer.gson()
+
     override fun display(
         itemStack: ItemStack,
         vararg args: Any
@@ -56,10 +65,12 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
 
         if (stone != null) {
             meta.setDisplayName(plugin.configYml.getString("reforge.stone.name").replace("%reforge%", stone.name))
-            SkullUtils.setSkullTexture(
+            if (stone.config.has("stone.texture") && stone.config.getString("stone.texture").isNotEmpty()) {
-                meta as SkullMeta,
+                SkullUtils.setSkullTexture(
-                stone.config.getString("stone.texture")
+                    meta as SkullMeta,
-            )
+                    stone.config.getString("stone.texture")
+                )
+            }
             itemStack.itemMeta = meta
             val stoneLore = plugin.configYml.getStrings("reforge.stone.lore").map {
                 "${Display.PREFIX}${it.replace("%reforge%", stone.name)}"
@@ -76,12 +87,13 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
                 lore.addAll(addLore)
             }
             if (plugin.configYml.getBool("reforge.display-in-name") && Prerequisite.HAS_PAPER.isMet) {
-                val displayName =
+                val displayName = (meta.displayName() ?: Component.translatable(itemStack)).replaceText(replacement)
-                    (if (meta.hasDisplayName()) meta.displayName()!! else Component.translatable(itemStack))
+                meta.persistentDataContainer.set(
-                        .replaceText(
+                    originalComponentKey,
-                            replacement
+                    PersistentDataType.STRING,
-                        )
+                    serializer.serialize(displayName)
-                val newName = StringUtils.toComponent("§w${reforge.name} §w")
+                )
+                val newName = StringUtils.toComponent("${reforge.name} ")
                     .decoration(TextDecoration.ITALIC, false).append(displayName)
                 meta.displayName(newName)
             }
@@ -91,21 +103,15 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
     }
 
     override fun revert(itemStack: ItemStack) {
-        val target = ReforgeTarget.getForItem(itemStack)
+        ReforgeTarget.getForItem(itemStack) ?: return
-
-        if (target == null && itemStack.type != Material.PLAYER_HEAD) {
-            return
-        }
 
         val meta = itemStack.itemMeta ?: return
 
         if (plugin.configYml.getBool("reforge.display-in-name") && Prerequisite.HAS_PAPER.isMet) {
-            val displayName = meta.displayName() ?: return
+            val originalName =
-            meta.displayName(
+                meta.persistentDataContainer.get(originalComponentKey, PersistentDataType.STRING) ?: return
-                displayName.replaceText(
+            meta.persistentDataContainer.remove(originalComponentKey)
-                    replacement
+            meta.displayName(serializer.deserialize(originalName).replaceText(replacement))
-                )
-            )
         }
 
         itemStack.itemMeta = meta

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/PlayerEffectStack.kt

@@ -0,0 +1,29 @@
+@file:JvmName("PlayerEffectStack")
+
+package com.willfp.reforges.effects
+
+import org.bukkit.entity.Player
+import java.util.*
+
+private val effectStack = mutableMapOf<UUID, MutableMap<Effect, Int>>()
+
+fun Player.pushEffect(effect: Effect) {
+    val stack = effectStack[this.uniqueId] ?: mutableMapOf()
+    var amount = stack[effect] ?: 0
+    amount++
+    stack[effect] = amount
+    effectStack[this.uniqueId] = stack
+}
+
+fun Player.popEffect(effect: Effect) {
+    val stack = effectStack[this.uniqueId] ?: mutableMapOf()
+    var amount = stack[effect] ?: 0
+    amount--
+    stack[effect] = if (amount < 0) 0 else amount
+    effectStack[this.uniqueId] = stack
+}
+
+fun Player.getEffectAmount(effect: Effect): Int {
+    val stack = effectStack[this.uniqueId] ?: mutableMapOf()
+    return stack[effect] ?: 0
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectAttackSpeedMultiplier.kt

@@ -2,34 +2,31 @@ package com.willfp.reforges.effects.effects
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.effects.Effect
+import com.willfp.reforges.effects.getEffectAmount
 import org.bukkit.attribute.Attribute
 import org.bukkit.attribute.AttributeModifier
-import org.bukkit.inventory.ItemFlag
+import org.bukkit.entity.Player
-import org.bukkit.inventory.meta.ItemMeta
 
 class EffectAttackSpeedMultiplier : Effect("attack_speed_multiplier") {
-    override fun handleEnabling(
+    override fun handleEnable(player: Player, config: JSONConfig) {
-        meta: ItemMeta,
+        val attribute = player.getAttribute(Attribute.GENERIC_ATTACK_SPEED) ?: return
-        config: JSONConfig
+        val uuid = this.getUUID(player.getEffectAmount(this))
-    ) {
+        attribute.removeModifier(AttributeModifier(uuid, this.id, 0.0, AttributeModifier.Operation.MULTIPLY_SCALAR_1))
-        meta.addAttributeModifier(
+        attribute.addModifier(
-            Attribute.GENERIC_ATTACK_SPEED,
             AttributeModifier(
-                this.getUUID(1),
+                uuid,
                 this.id,
                 config.getDouble("multiplier") - 1,
                 AttributeModifier.Operation.MULTIPLY_SCALAR_1
             )
         )
-
-        meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES)
     }
 
-    override fun handleDisabling(meta: ItemMeta) {
+    override fun handleDisable(player: Player) {
-        meta.removeAttributeModifier(
+        val attribute = player.getAttribute(Attribute.GENERIC_ATTACK_SPEED) ?: return
-            Attribute.GENERIC_ATTACK_SPEED,
+        attribute.removeModifier(
             AttributeModifier(
-                this.getUUID(1),
+                this.getUUID(player.getEffectAmount(this)),
                 this.id,
                 0.0,
                 AttributeModifier.Operation.MULTIPLY_SCALAR_1

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectCritMultiplier.kt

@@ -3,16 +3,17 @@ package com.willfp.reforges.effects.effects
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.effects.Effect
 import org.bukkit.entity.LivingEntity
+import org.bukkit.entity.Player
 import org.bukkit.event.entity.EntityDamageByEntityEvent
 
 class EffectCritMultiplier : Effect("crit_multiplier") {
     override fun onAnyDamage(
-        attacker: LivingEntity,
+        attacker: Player,
         victim: LivingEntity,
         event: EntityDamageByEntityEvent,
         config: JSONConfig
     ) {
-        if (attacker.velocity.y > 0) {
+        if (attacker.velocity.y >= 0) {
             return
         }
         event.damage *= config.getDouble("multiplier")

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectDamageMultiplier.kt

@@ -3,11 +3,12 @@ package com.willfp.reforges.effects.effects
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.effects.Effect
 import org.bukkit.entity.LivingEntity
+import org.bukkit.entity.Player
 import org.bukkit.event.entity.EntityDamageByEntityEvent
 
 class EffectDamageMultiplier : Effect("damage_multiplier") {
     override fun onAnyDamage(
-        attacker: LivingEntity,
+        attacker: Player,
         victim: LivingEntity,
         event: EntityDamageByEntityEvent,
         config: JSONConfig

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectIncomingDamageMultiplier.kt

@@ -2,12 +2,12 @@ package com.willfp.reforges.effects.effects
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.effects.Effect
-import org.bukkit.entity.LivingEntity
+import org.bukkit.entity.Player
 import org.bukkit.event.entity.EntityDamageEvent
 
 class EffectIncomingDamageMultiplier : Effect("incoming_damage_multiplier") {
     override fun onDamageWearingArmor(
-        victim: LivingEntity,
+        victim: Player,
         event: EntityDamageEvent,
         config: JSONConfig
     ) {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectKnockbackMultiplier.kt

@@ -2,34 +2,34 @@ package com.willfp.reforges.effects.effects
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.effects.Effect
+import com.willfp.reforges.effects.getEffectAmount
 import org.bukkit.attribute.Attribute
 import org.bukkit.attribute.AttributeModifier
-import org.bukkit.inventory.ItemFlag
+import org.bukkit.entity.Player
-import org.bukkit.inventory.meta.ItemMeta
 
 class EffectKnockbackMultiplier : Effect("knockback_multiplier") {
-    override fun handleEnabling(
+    override fun handleEnable(
-        meta: ItemMeta,
+        player: Player,
         config: JSONConfig
     ) {
-        meta.addAttributeModifier(
+        val attribute = player.getAttribute(Attribute.GENERIC_ATTACK_KNOCKBACK) ?: return
-            Attribute.GENERIC_ATTACK_KNOCKBACK,
+        val uuid = this.getUUID(player.getEffectAmount(this))
+        attribute.removeModifier(AttributeModifier(uuid, this.id, 0.0, AttributeModifier.Operation.MULTIPLY_SCALAR_1))
+        attribute.addModifier(
             AttributeModifier(
-                this.getUUID(1),
+                uuid,
                 this.id,
                 config.getDouble("multiplier") - 1,
                 AttributeModifier.Operation.MULTIPLY_SCALAR_1
             )
         )
-
-        meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES)
     }
 
-    override fun handleDisabling(meta: ItemMeta) {
+    override fun handleDisable(player: Player) {
-        meta.removeAttributeModifier(
+        val attribute = player.getAttribute(Attribute.GENERIC_ATTACK_KNOCKBACK) ?: return
-            Attribute.GENERIC_ATTACK_KNOCKBACK,
+        attribute.removeModifier(
             AttributeModifier(
-                this.getUUID(1),
+                this.getUUID(player.getEffectAmount(this)),
                 this.id,
                 0.0,
                 AttributeModifier.Operation.MULTIPLY_SCALAR_1

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectMovementSpeedMultiplier.kt

@@ -2,34 +2,34 @@ package com.willfp.reforges.effects.effects
 
 import com.willfp.eco.core.config.interfaces.JSONConfig
 import com.willfp.reforges.effects.Effect
+import com.willfp.reforges.effects.getEffectAmount
 import org.bukkit.attribute.Attribute
 import org.bukkit.attribute.AttributeModifier
-import org.bukkit.inventory.ItemFlag
+import org.bukkit.entity.Player
-import org.bukkit.inventory.meta.ItemMeta
 
 class EffectMovementSpeedMultiplier : Effect("movement_speed_multiplier") {
-    override fun handleEnabling(
+    override fun handleEnable(
-        meta: ItemMeta,
+        player: Player,
         config: JSONConfig
     ) {
-        meta.addAttributeModifier(
+        val attribute = player.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED) ?: return
-            Attribute.GENERIC_MOVEMENT_SPEED,
+        val uuid = this.getUUID(player.getEffectAmount(this))
+        attribute.removeModifier(AttributeModifier(uuid, this.id, 0.0, AttributeModifier.Operation.MULTIPLY_SCALAR_1))
+        attribute.addModifier(
             AttributeModifier(
-                this.getUUID(1),
+                uuid,
                 this.id,
                 config.getDouble("multiplier") - 1,
                 AttributeModifier.Operation.MULTIPLY_SCALAR_1
             )
         )
-
-        meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES)
     }
 
-    override fun handleDisabling(meta: ItemMeta) {
+    override fun handleDisable(player: Player) {
-        meta.removeAttributeModifier(
+        val attribute = player.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED) ?: return
-            Attribute.GENERIC_MOVEMENT_SPEED,
+        attribute.removeModifier(
             AttributeModifier(
-                this.getUUID(1),
+                this.getUUID(player.getEffectAmount(this)),
                 this.id,
                 0.0,
                 AttributeModifier.Operation.MULTIPLY_SCALAR_1

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectRewardBlockBreak.kt

@@ -7,13 +7,15 @@ import org.bukkit.block.Block
 import org.bukkit.entity.Player
 import org.bukkit.event.block.BlockBreakEvent
 
-class EffectRewardBlockBreak : Effect("reward_kill") {
+class EffectRewardBlockBreak : Effect("reward_block_break") {
     override fun onBlockBreak(
         player: Player,
         block: Block,
         event: BlockBreakEvent,
         config: JSONConfig
     ) {
-        EconomyHandler.getInstance().depositPlayer(player, config.getDouble("amount"))
+        if (EconomyHandler.isEnabled()) {
+            EconomyHandler.getInstance().depositPlayer(player, config.getDouble("amount"))
+        }
     }
 }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectRewardKill.kt

@@ -8,16 +8,12 @@ import org.bukkit.entity.LivingEntity
 import org.bukkit.entity.Player
 
 class EffectRewardKill : Effect("reward_kill") {
-    override fun onKill(
+    override fun onKill(killer: Player,
-        killer: LivingEntity,
+                        victim: LivingEntity,
-        victim: LivingEntity,
+                        event: EntityDeathByEntityEvent,
-        event: EntityDeathByEntityEvent,
+                        config: JSONConfig) {
-        config: JSONConfig
+        if (EconomyHandler.isEnabled()) {
-    ) {
+            EconomyHandler.getInstance().depositPlayer(killer, config.getDouble("amount"))
-        if (killer !is Player) {
-            return
         }
-
-        EconomyHandler.getInstance().depositPlayer(killer, config.getDouble("amount"))
     }
 }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/gui/ReforgeGUI.kt

@@ -0,0 +1,190 @@
+package com.willfp.reforges.gui
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.config.updating.ConfigUpdater
+import com.willfp.eco.core.drops.DropQueue
+import com.willfp.eco.core.gui.menu.Menu
+import com.willfp.eco.core.gui.slot.FillerMask
+import com.willfp.eco.core.gui.slot.MaskMaterials
+import com.willfp.eco.core.gui.slot.Slot
+import com.willfp.eco.core.items.builder.ItemStackBuilder
+import com.willfp.eco.util.NumberUtils
+import com.willfp.reforges.ReforgesPlugin
+import com.willfp.reforges.reforges.util.ReforgeHandler
+import com.willfp.reforges.reforges.util.ReforgeStatus
+import com.willfp.reforges.reforges.util.ReforgeUtils
+import org.bukkit.Material
+import org.bukkit.entity.Player
+import org.bukkit.inventory.ItemStack
+import kotlin.math.pow
+
+@Suppress("DEPRECATION")
+object ReforgeGUI {
+    @JvmStatic
+    lateinit var menu: Menu
+
+    init {
+        update(ReforgesPlugin.getInstance())
+    }
+
+    @JvmStatic
+    @ConfigUpdater
+    fun update(plugin: EcoPlugin) {
+        val handler = ReforgeHandler(plugin)
+
+        val activatorSlot = Slot.builder(
+            ItemStack(Material.ANVIL)
+        ).apply {
+            setModifier { player, menu, previous ->
+                val meta = previous.itemMeta ?: return@setModifier
+
+                val (status, specialCost) = ReforgeUtils.getStatus(menu.getCaptiveItems(player))
+
+                val cost: Double = when {
+                    status == ReforgeStatus.ALLOW || (status == ReforgeStatus.ALLOW_STONE && specialCost < 0) -> {
+                        val amountOfReforges = ReforgeUtils.getReforges(menu.getCaptiveItems(player)[0])
+                        plugin.configYml.getDouble("reforge.cost") *
+                                plugin.configYml.getDouble("reforge.cost-exponent").pow(amountOfReforges)
+                    }
+                    status == ReforgeStatus.ALLOW_STONE -> {
+                        specialCost
+                    }
+                    else -> 0.0 // Never used, but at least kotlin can shut up
+                }
+
+                var xpCost = plugin.configYml.getInt("reforge.xp-cost")
+                if (status == ReforgeStatus.ALLOW) {
+                    val item = menu.getCaptiveItems(player)[0]
+                    val reforges = ReforgeUtils.getReforges(item)
+                    xpCost *= plugin.configYml.getDouble("reforge.cost-exponent").pow(reforges.toDouble()).toInt()
+                }
+
+                when (status) {
+                    ReforgeStatus.INVALID_ITEM -> {
+                        previous.type = Material.getMaterial(
+                            plugin.configYml.getString("gui.invalid-item.material").uppercase()
+                        )!!
+                        meta.setDisplayName(plugin.configYml.getString("gui.invalid-item.name"))
+                        meta.lore = plugin.configYml.getStrings("gui.invalid-item.lore").map {
+                            it.replace("%cost%", NumberUtils.format(cost))
+                                .replace("%xpcost%", NumberUtils.format(xpCost.toDouble()))
+                        }
+                    }
+                    ReforgeStatus.ALLOW -> {
+                        previous.type = Material.getMaterial(
+                            plugin.configYml.getString("gui.allow.material").uppercase()
+                        )!!
+                        meta.setDisplayName(plugin.configYml.getString("gui.allow.name"))
+                        meta.lore = plugin.configYml.getStrings("gui.allow.lore").map {
+                            it.replace("%cost%", NumberUtils.format(cost))
+                                .replace("%xpcost%", NumberUtils.format(xpCost.toDouble()))
+                        }
+                    }
+                    ReforgeStatus.ALLOW_STONE -> {
+                        previous.type = Material.getMaterial(
+                            plugin.configYml.getString("gui.allow-stone.material").uppercase()
+                        )!!
+                        meta.setDisplayName(plugin.configYml.getString("gui.allow-stone.name"))
+                        meta.lore = plugin.configYml.getStrings("gui.allow-stone.lore").map {
+                            it.replace("%cost%", NumberUtils.format(cost))
+                                .replace("%xpcost%", NumberUtils.format(xpCost.toDouble()))
+                                .replace("%stone%", ReforgeUtils.getReforgeStone(menu.getCaptiveItems(player)[1]).name)
+                        }
+                    }
+                    ReforgeStatus.NO_ITEM -> {
+                        previous.type = Material.getMaterial(
+                            plugin.configYml.getString("gui.no-item.material").uppercase()
+                        )!!
+                        meta.setDisplayName(plugin.configYml.getString("gui.no-item.name"))
+                        meta.lore = plugin.configYml.getStrings("gui.no-item.lore").map {
+                            it.replace("%cost%", NumberUtils.format(cost))
+                                .replace("%xpcost%", NumberUtils.format(xpCost.toDouble()))
+                        }
+                    }
+                }
+
+                previous.itemMeta = meta
+            }
+            onLeftClick(handler::handleReforgeClick)
+        }.build()
+
+        val maskPattern = plugin.configYml.getStrings("gui.mask.pattern", false).toTypedArray()
+
+        val maskMaterials = plugin.configYml.getStrings("gui.mask.materials", false)
+            .mapNotNull { Material.getMaterial(it.uppercase()) }
+            .toTypedArray()
+
+        val allowMaterial =
+            Material.getMaterial(plugin.configYml.getString("gui.show-allowed.allow-material", false).uppercase())!!
+        val denyMaterial =
+            Material.getMaterial(plugin.configYml.getString("gui.show-allowed.deny-material", false).uppercase())!!
+        val closeMaterial =
+            Material.getMaterial(plugin.configYml.getString("gui.close.material", false).toUpperCase())!!
+
+        menu = Menu.builder(plugin.configYml.getInt("gui.rows")).apply {
+            setTitle(plugin.langYml.getString("menu.title"))
+            setMask(FillerMask(MaskMaterials(*maskMaterials), *maskPattern))
+            modfiy { builder ->
+                val slot = Slot.builder(
+                    ItemStackBuilder(Material.BLACK_STAINED_GLASS_PANE)
+                        .setDisplayName("&r")
+                        .build()
+                ).apply {
+                    setModifier { player, menu, previous ->
+                        val status = ReforgeUtils.getStatus(
+                            menu.getCaptiveItems(player)
+                        ).status
+
+                        if (status == ReforgeStatus.ALLOW || status == ReforgeStatus.ALLOW_STONE) {
+                            previous.type = allowMaterial
+                        } else {
+                            previous.type = denyMaterial
+                        }
+                    }
+                }.build()
+
+                val allowedPattern = plugin.configYml.getStrings("gui.show-allowed.pattern")
+                for (i in 1..allowedPattern.size) {
+                    val row = allowedPattern[i - 1]
+                    for (j in 1..9) {
+                        if (row[j - 1] != '0') {
+                            builder.setSlot(i, j, slot)
+                        }
+                    }
+                }
+            }
+            setSlot(
+                plugin.configYml.getInt("gui.item-slot.row"),
+                plugin.configYml.getInt("gui.item-slot.column"),
+                Slot.builder().setCaptive().build()
+            )
+            setSlot(
+                plugin.configYml.getInt("gui.stone-slot.row"),
+                plugin.configYml.getInt("gui.stone-slot.column"),
+                Slot.builder().setCaptive().build()
+            )
+            setSlot(
+                plugin.configYml.getInt("gui.activator-slot.row"),
+                plugin.configYml.getInt("gui.activator-slot.column"),
+                activatorSlot
+            )
+            setSlot(
+                plugin.configYml.getInt("gui.close.location.row"),
+                plugin.configYml.getInt("gui.close.location.column"),
+                Slot.builder(
+                    ItemStackBuilder(closeMaterial)
+                        .setDisplayName(plugin.langYml.getString("menu.close"))
+                        .build()
+                ).onLeftClick { event, _, _ ->
+                    event.whoClicked.closeInventory()
+                }.build()
+            )
+            onClose { event, menu ->
+                DropQueue(event.player as Player)
+                    .addItems(menu.getCaptiveItems(event.player as Player))
+                    .setLocation(event.player.eyeLocation)
+                    .push()
+            }
+        }.build()
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/aureliumskills/AureliumSkillsIntegration.kt

@@ -0,0 +1,17 @@
+package com.willfp.reforges.integrations.aureliumskills
+
+import com.willfp.eco.core.integrations.Integration
+import com.willfp.reforges.effects.Effect
+
+object AureliumSkillsIntegration : Integration {
+    private lateinit var ADD_STAT: Effect
+
+    @JvmStatic
+    fun load() {
+        ADD_STAT = EffectAddStat()
+    }
+
+    override fun getPluginName(): String {
+        return "AureliumSkills"
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/aureliumskills/EffectAddStat.kt

@@ -0,0 +1,29 @@
+package com.willfp.reforges.integrations.aureliumskills
+
+import com.archyx.aureliumskills.api.AureliumAPI
+import com.archyx.aureliumskills.stats.Stats
+import com.willfp.eco.core.config.interfaces.JSONConfig
+import com.willfp.reforges.effects.Effect
+import com.willfp.reforges.effects.getEffectAmount
+import org.bukkit.entity.Player
+
+class EffectAddStat : Effect("add_stat") {
+    override fun handleEnable(
+        player: Player,
+        config: JSONConfig
+    ) {
+        AureliumAPI.addStatModifier(
+            player,
+            this.getNamespacedKey(player.getEffectAmount(this)).key,
+            Stats.valueOf(config.getString("stat", false)),
+            config.getDouble("amount")
+        )
+    }
+
+    override fun handleDisable(player: Player) {
+        AureliumAPI.removeStatModifier(
+            player,
+            this.getNamespacedKey(player.getEffectAmount(this)).key,
+        )
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ecoskills/EcoSkillsIntegration.kt

@@ -0,0 +1,17 @@
+package com.willfp.reforges.integrations.ecoskills
+
+import com.willfp.eco.core.integrations.Integration
+import com.willfp.reforges.effects.Effect
+
+object EcoSkillsIntegration : Integration {
+    private lateinit var ADD_STAT: Effect
+
+    @JvmStatic
+    fun load() {
+        ADD_STAT = EffectAddStat()
+    }
+
+    override fun getPluginName(): String {
+        return "EcoSkills"
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ecoskills/EffectAddStat.kt

@@ -0,0 +1,39 @@
+package com.willfp.reforges.integrations.ecoskills
+
+import com.willfp.eco.core.config.interfaces.JSONConfig
+import com.willfp.ecoskills.api.EcoSkillsAPI
+import com.willfp.ecoskills.api.modifier.PlayerStatModifier
+import com.willfp.ecoskills.stats.Stats
+import com.willfp.reforges.effects.Effect
+import com.willfp.reforges.effects.getEffectAmount
+import org.bukkit.Bukkit
+import org.bukkit.entity.Player
+
+class EffectAddStat : Effect("add_stat") {
+    private val api = EcoSkillsAPI.getInstance()
+
+    override fun handleEnable(
+        player: Player,
+        config: JSONConfig
+    ) {
+        api.addStatModifier(
+            player,
+            PlayerStatModifier(
+                this.getNamespacedKey(player.getEffectAmount(this)),
+                Stats.getByID(config.getString("stat", false)) ?: Stats.WISDOM,
+                config.getInt("amount")
+            )
+        )
+    }
+
+    override fun handleDisable(player: Player) {
+        api.removeStatModifier(
+            player,
+            PlayerStatModifier(
+                this.getNamespacedKey(player.getEffectAmount(this)),
+                Stats.STRENGTH,
+                0
+            )
+        )
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/talismans/TalismansIntegration.kt

@@ -0,0 +1,25 @@
+package com.willfp.reforges.integrations.talismans
+
+import com.willfp.eco.core.integrations.Integration
+import com.willfp.reforges.reforges.meta.ReforgeTarget
+import com.willfp.reforges.reforges.util.ReforgeLookup
+import com.willfp.talismans.talismans.util.TalismanChecks
+import org.bukkit.inventory.ItemStack
+
+object TalismansIntegration : Integration {
+    @JvmStatic
+    fun registerProvider() {
+        ReforgeLookup.registerProvider { player ->
+            val provided = mutableMapOf<ItemStack, ReforgeTarget.Slot>()
+            for (itemStack in TalismanChecks.getTalismanItemsOnPlayer(player, true)) {
+                provided[itemStack] = ReforgeTarget.Slot.ANY
+            }
+
+            provided
+        }
+    }
+
+    override fun getPluginName(): String {
+        return "Talismans"
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ultimateskills/EffectAddAbility.kt

@@ -0,0 +1,38 @@
+package com.willfp.reforges.integrations.ultimateskills
+
+import com.willfp.eco.core.config.interfaces.JSONConfig
+import com.willfp.eco.util.NumberUtils
+import com.willfp.reforges.ReforgesPlugin
+import com.willfp.reforges.effects.Effect
+import mc.ultimatecore.skills.HyperSkills
+import mc.ultimatecore.skills.objects.abilities.Ability
+import org.bukkit.entity.Player
+import org.bukkit.persistence.PersistentDataType
+
+class EffectAddAbility : Effect("add_ultimateskills_ability") {
+    override fun handleEnable(
+        player: Player,
+        config: JSONConfig
+    ) {
+        HyperSkills.getInstance().api.addAbility(
+            player.uniqueId,
+            Ability.valueOf(config.getString("ability", false)),
+            config.getDouble("amount")
+        )
+        player.persistentDataContainer.set(
+            ReforgesPlugin.getInstance().namespacedKeyFactory.create("addAbility"), PersistentDataType.STRING,
+            NumberUtils.format(config.getDouble("amount")) + "::" + config.getString("ability", false)
+        )
+    }
+
+    override fun handleDisable(player: Player) {
+        player.persistentDataContainer.get(ReforgesPlugin.getInstance().namespacedKeyFactory.create("addAbility"), PersistentDataType.STRING)
+            ?.let {
+                HyperSkills.getInstance().api.removeAbility(
+                    player.uniqueId,
+                    Ability.valueOf(it.split("::")[1]),
+                    it.split("::")[0].toDouble()
+                )
+            }
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ultimateskills/EffectAddPerk.kt

@@ -0,0 +1,37 @@
+package com.willfp.reforges.integrations.ultimateskills
+
+import com.willfp.eco.core.config.interfaces.JSONConfig
+import com.willfp.eco.util.NumberUtils
+import com.willfp.reforges.ReforgesPlugin
+import com.willfp.reforges.effects.Effect
+import mc.ultimatecore.skills.HyperSkills
+import mc.ultimatecore.skills.objects.perks.Perk
+import org.bukkit.entity.Player
+import org.bukkit.persistence.PersistentDataType
+
+class EffectAddPerk : Effect("add_ultimateskills_perk") {
+    override fun handleEnable(
+        player: Player,
+        config: JSONConfig
+    ) {
+        HyperSkills.getInstance().api.addPerk(
+            player.uniqueId,
+            Perk.valueOf(config.getString("perk", false)),
+            config.getDouble("amount")
+        )
+        player.persistentDataContainer.set(ReforgesPlugin.getInstance().namespacedKeyFactory.create("addPerk"), PersistentDataType.STRING,
+            NumberUtils.format(config.getDouble("amount")) + "::" + config.getString("perk", false)
+        )
+    }
+
+    override fun handleDisable(player: Player) {
+        player.persistentDataContainer.get(ReforgesPlugin.getInstance().namespacedKeyFactory.create("addPerk"), PersistentDataType.STRING)
+            ?.let {
+                HyperSkills.getInstance().api.removePerk(
+                    player.uniqueId,
+                    Perk.valueOf(it.split("::")[1]),
+                    it.split("::")[0].toDouble()
+                )
+            }
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ultimateskills/UltimateSkillsIntegration.kt

@@ -0,0 +1,19 @@
+package com.willfp.reforges.integrations.ultimateskills
+
+import com.willfp.eco.core.integrations.Integration
+import com.willfp.reforges.effects.Effect
+
+object UltimateSkillsIntegration : Integration {
+    private lateinit var ADD_PERK: Effect
+    private lateinit var ADD_ABILITY: Effect
+
+    @JvmStatic
+    fun load() {
+        ADD_PERK = EffectAddPerk()
+        ADD_ABILITY = EffectAddAbility()
+    }
+
+    override fun getPluginName(): String {
+        return "UltimateSkills"
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/Reforge.kt

@@ -12,10 +12,11 @@ import com.willfp.reforges.effects.ConfiguredEffect
 import com.willfp.reforges.effects.Effects
 import com.willfp.reforges.reforges.meta.ReforgeTarget
 import com.willfp.reforges.reforges.util.ReforgeUtils
+import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
-import org.bukkit.inventory.meta.ItemMeta
 import java.util.*
 
+@Suppress("DEPRECATION")
 class Reforge(
     internal val config: JSONConfig,
     private val plugin: ReforgesPlugin
@@ -43,52 +44,47 @@ class Reforge(
     val stone: ItemStack = SkullBuilder().apply {
         if (config.getBool("stone.enabled")) {
             setSkullTexture(config.getString("stone.texture"))
-            setDisplayName(plugin.configYml.getString("stone.name").replace("%reforge%", name))
+            setDisplayName(plugin.configYml.getString("reforge.stone.name").replace("%reforge%", name))
             addLoreLines(
                 plugin.configYml.getStrings("stone.lore").map { "${Display.PREFIX}${it.replace("%reforge%", name)}" })
         }
     }.build()
 
+    val stonePrice = config.getIntOrNull("stone.price") ?: -1
+
     init {
+        Reforges.addNewReforge(this)
+
         ReforgeUtils.setReforgeStone(stone, this)
 
+        Display.display(stone)
+
         CustomItem(
             plugin.namespacedKeyFactory.create("stone_" + this.id),
             { test -> ReforgeUtils.getReforgeStone(test) == this },
             stone
         ).register()
 
-        if (config.getBool("craftable")) {
+        if (config.getBool("stone.craftable") && config.getBool("stone.enabled")) {
             Recipes.createAndRegisterRecipe(
                 plugin,
                 "stone_" + this.id,
                 stone,
-                config.getStrings("recipe", false)
+                config.getStrings("stone.recipe", false)
             )
         }
     }
 
-    fun handleApplication(itemStack: ItemStack) {
+    fun handleActivation(player: Player) {
-        itemStack.itemMeta = this.handleApplication(itemStack.itemMeta ?: return)
-    }
-
-    fun handleApplication(meta: ItemMeta): ItemMeta {
-        handleRemoval(meta)
         for ((effect, config) in this.effects) {
-            effect.handleEnabling(meta, config)
+            effect.handleEnabling(player, config)
         }
-        return meta
     }
 
-    fun handleRemoval(itemStack: ItemStack) {
+    fun handleDeactivation(player: Player) {
-        itemStack.itemMeta = this.handleRemoval(itemStack.itemMeta ?: return)
-    }
-
-    fun handleRemoval(meta: ItemMeta): ItemMeta {
         for ((effect, _) in this.effects) {
-            effect.handleDisabling(meta)
+            effect.handleDisabling(player)
         }
-        return meta
     }
 
     override fun equals(other: Any?): Boolean {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/MetadatedReforgeStatus.kt

@@ -0,0 +1,3 @@
+package com.willfp.reforges.reforges.util
+
+data class MetadatedReforgeStatus(val status: ReforgeStatus, val cost: Double)

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/ReforgeArgParser.kt

@@ -0,0 +1,36 @@
+package com.willfp.reforges.reforges.util
+
+import com.willfp.eco.core.items.args.LookupArgParser
+import com.willfp.reforges.reforges.Reforge
+import com.willfp.reforges.reforges.Reforges
+import org.bukkit.inventory.ItemStack
+import org.bukkit.inventory.meta.ItemMeta
+import java.util.function.Predicate
+
+class ReforgeArgParser : LookupArgParser {
+    override fun parseArguments(
+        args: Array<String>,
+        meta: ItemMeta
+    ): Predicate<ItemStack>? {
+        var reforge: Reforge? = null
+
+        for (arg in args) {
+            val split = arg.split(":").toTypedArray()
+            if (split.size == 1 || !split[0].equals("reforge", ignoreCase = true)) {
+                continue
+            }
+            val match = Reforges.getByKey(split[1].lowercase()) ?: continue
+            reforge = match
+            break
+        }
+
+        reforge ?: return null
+
+        ReforgeUtils.setReforge(meta, reforge)
+
+        return Predicate { test ->
+            val testMeta = test.itemMeta ?: return@Predicate false
+            reforge == ReforgeUtils.getReforge(testMeta)
+        }
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/WatcherTriggers.kt

@@ -6,7 +6,7 @@ import com.willfp.eco.core.events.PlayerJumpEvent
 import com.willfp.eco.core.integrations.antigrief.AntigriefManager
 import com.willfp.eco.core.integrations.mcmmo.McmmoManager
 import com.willfp.eco.util.NumberUtils
-import com.willfp.reforges.reforges.ReforgeLookup
+import com.willfp.reforges.events.EffectActivateEvent
 import org.bukkit.entity.*
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
@@ -34,10 +34,14 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(player)) {
             for ((key, value) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > value.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (value.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                key.onBlockBreak(player, block, event, value)
+                val aEvent = EffectActivateEvent(player, reforge, key)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    key.onBlockBreak(player, block, event, value)
+                }
             }
         }
     }
@@ -75,11 +79,15 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(shooter)) {
             for ((effect, config) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                effect.onArrowDamage(shooter, victim, arrow, event, config)
+                val aEvent = EffectActivateEvent(shooter, reforge, effect)
-                effect.onAnyDamage(shooter, victim, event, config)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    effect.onArrowDamage(shooter, victim, arrow, event, config)
+                    effect.onAnyDamage(shooter, victim, event, config)
+                }
             }
         }
     }
@@ -122,11 +130,15 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(shooter) union add) {
             for ((effect, config) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                effect.onTridentDamage(shooter, victim, trident, event, config)
+                val aEvent = EffectActivateEvent(shooter, reforge, effect)
-                effect.onAnyDamage(shooter, victim, event, config)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    effect.onTridentDamage(shooter, victim, trident, event, config)
+                    effect.onAnyDamage(shooter, victim, event, config)
+                }
             }
         }
     }
@@ -140,10 +152,14 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(player)) {
             for ((effect, config) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                effect.onJump(player, event, config)
+                val aEvent = EffectActivateEvent(player, reforge, effect)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    effect.onJump(player, event, config)
+                }
             }
         }
     }
@@ -180,11 +196,15 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(attacker)) {
             for ((effect, config) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                effect.onMeleeAttack(attacker, victim, event, config)
+                val aEvent = EffectActivateEvent(attacker, reforge, effect)
-                effect.onAnyDamage(attacker, victim, event, config)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    effect.onMeleeAttack(attacker, victim, event, config)
+                    effect.onAnyDamage(attacker, victim, event, config)
+                }
             }
         }
     }
@@ -220,10 +240,14 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(killer) union add) {
             for ((effect, config) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                effect.onKill(killer, victim, event, config)
+                val aEvent = EffectActivateEvent(killer, reforge, effect)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    (effect as Watcher).onKill(killer, victim, event, config)
+                }
             }
         }
     }
@@ -242,10 +266,14 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(shooter)) {
             for ((effect, config) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                effect.onProjectileLaunch(shooter, event.entity, event, config)
+                val aEvent = EffectActivateEvent(shooter, reforge, effect)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    effect.onProjectileLaunch(shooter, event.entity, event, config)
+                }
             }
         }
     }
@@ -268,10 +296,14 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(victim)) {
             for ((effect, config) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                effect.onFallDamage(victim, event, config)
+                val aEvent = EffectActivateEvent(victim, reforge, effect)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    effect.onFallDamage(victim, event, config)
+                }
             }
         }
     }
@@ -295,10 +327,14 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(shooter) union add) {
             for ((effect, config) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                effect.onProjectileHit(shooter, event, config)
+                val aEvent = EffectActivateEvent(shooter, reforge, effect)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    effect.onProjectileHit(shooter, event, config)
+                }
             }
         }
     }
@@ -313,10 +349,14 @@ class WatcherTriggers(
         val reforge = ReforgeUtils.getReforge(item) ?: return
 
         for ((effect, config) in reforge.effects) {
-            if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+            if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                 continue
             }
-            effect.onDurabilityDamage(event, config)
+            val aEvent = EffectActivateEvent(event.player, reforge, effect)
+            this.plugin.server.pluginManager.callEvent(aEvent)
+            if (!aEvent.isCancelled) {
+                effect.onDurabilityDamage(event, config)
+            }
         }
     }
 
@@ -334,10 +374,14 @@ class WatcherTriggers(
 
         for (reforge in ReforgeLookup.provideReforges(victim)) {
             for ((effect, config) in reforge.effects) {
-                if (NumberUtils.randFloat(0.0, 100.0) > config.getDoubleOrNull("chance") ?: 100.0) {
+                if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
                     continue
                 }
-                effect.onDamageWearingArmor(victim, event, config)
+                val aEvent = EffectActivateEvent(victim, reforge, effect)
+                this.plugin.server.pluginManager.callEvent(aEvent)
+                if (!aEvent.isCancelled) {
+                    effect.onDamageWearingArmor(victim, event, config)
+                }
             }
         }
     }

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

@@ -43,6 +43,10 @@ gui:
       - "100000001"
       - "100000001"
 
+  activator-slot:
+    row: 2
+    column: 5
+
   stone-slot:
     row: 4
     column: 7
@@ -119,6 +123,7 @@ gui:
 reforge:
   cost: 7500
   xp-cost: 0 # In levels
+  use-player-points: false
 
   cost-exponent: 1.15 # (Reforges done ^ cost exponent) * cost
 

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

@@ -10,6 +10,10 @@ depend:
   - ProtocolLib
 softdepend:
   - Vault
+  - EcoSkills
+  - Talismans
+  - AureliumSkills
+  - PlayerPoints
 libraries:
   - 'org.jetbrains.kotlin:kotlin-stdlib:1.5.21'
 

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

@@ -1,61 +1,82 @@
+#
+# A target consists of items and a slot.
+# The slot is either hands, armor, or any.
+# Hands means the reforge will activate on hands, armor
+# means it will only work on armor, and any
+# means it will activate whenever its on the player.
+#
+
+
 pickaxe:
-  - wooden_pickaxe
+  slot: hands
-  - stone_pickaxe
+  items:
-  - iron_pickaxe
+    - wooden_pickaxe
-  - golden_pickaxe
+    - stone_pickaxe
-  - diamond_pickaxe
+    - iron_pickaxe
-  - netherite_pickaxe
+    - golden_pickaxe
+    - diamond_pickaxe
+    - netherite_pickaxe
 axe:
-  - wooden_axe
+  slot: hands
-  - stone_axe
+  items:
-  - iron_axe
+    - wooden_axe
-  - golden_axe
+    - stone_axe
-  - diamond_axe
+    - iron_axe
-  - netherite_axe
+    - golden_axe
+    - diamond_axe
+    - netherite_axe
 melee:
-  - wooden_axe
+  slot: hands
-  - stone_axe
+  items:
-  - iron_axe
+    - wooden_axe
-  - golden_axe
+    - stone_axe
-  - diamond_axe
+    - iron_axe
-  - netherite_axe
+    - golden_axe
-  - wooden_sword
+    - diamond_axe
-  - stone_sword
+    - netherite_axe
-  - iron_sword
+    - wooden_sword
-  - golden_sword
+    - stone_sword
-  - diamond_sword
+    - iron_sword
-  - netherite_sword
+    - golden_sword
+    - diamond_sword
+    - netherite_sword
 trident:
-  - trident
+  slot: hands
+  items:
+    - trident
 bow:
-  - bow
+  slot: hands
-  - crossbow
+  items:
+    - bow
+    - crossbow
 armor:
-  - turtle_helmet
+  slot: armor
-  - leather_helmet
+  items:
-  - chainmail_helmet
+    - turtle_helmet
-  - iron_helmet
+    - leather_helmet
-  - golden_helmet
+    - chainmail_helmet
-  - diamond_helmet
+    - iron_helmet
-  - netherite_helmet
+    - golden_helmet
+    - diamond_helmet
+    - netherite_helmet
 
-  - leather_chestplate
+    - leather_chestplate
-  - chainmail_chestplate
+    - chainmail_chestplate
-  - iron_chestplate
+    - iron_chestplate
-  - golden_chestplate
+    - golden_chestplate
-  - diamond_chestplate
+    - diamond_chestplate
-  - netherite_chestplate
+    - netherite_chestplate
 
-  - leather_leggings
+    - leather_leggings
-  - chainmail_leggings
+    - chainmail_leggings
-  - iron_leggings
+    - iron_leggings
-  - golden_leggings
+    - golden_leggings
-  - diamond_leggings
+    - diamond_leggings
-  - netherite_leggings
+    - netherite_leggings
 
-  - leather_boots
+    - leather_boots
-  - chainmail_boots
+    - chainmail_boots
-  - iron_boots
+    - iron_boots
-  - golden_boots
+    - golden_boots
-  - diamond_boots
+    - diamond_boots
-  - netherite_boots
+    - netherite_boots

gradle.properties

@@ -1,2 +1,2 @@
-version = 2.0.0
+version = 3.7.0
 plugin-name = Reforges