Fixed duplicate reforges not working

build.gradle

@@ -29,7 +29,7 @@ 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/' }
     }
 
     jar {

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

@@ -6,7 +6,6 @@ import com.willfp.eco.core.display.DisplayModule;
 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;
@@ -14,11 +13,15 @@ import com.willfp.reforges.effects.Effect;
 import com.willfp.reforges.effects.Effects;
 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;
@@ -75,7 +78,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 +90,8 @@ public class ReforgesPlugin extends EcoPlugin {
         return Arrays.asList(
                 new DiscoverRecipeListener(this),
                 new AntiPlaceListener(),
-                new WatcherTriggers(this)
+                new WatcherTriggers(this),
+                new ReforgeEnableListeners(this)
         );
     }
 
@@ -102,7 +110,7 @@ public class ReforgesPlugin extends EcoPlugin {
 
     @Override
     public String getMinimumEcoVersion() {
-        return "6.8.0";
+        return "6.9.0";
     }
 
     /**

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,8 @@ import com.willfp.reforges.ReforgesPlugin;
 import com.willfp.reforges.reforges.util.Watcher;
 import lombok.AccessLevel;
 import lombok.Getter;
+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;
@@ -59,21 +59,34 @@ public abstract class Effect implements Listener, Watcher {
     /**
      * 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) {
-        // 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/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/meta/ReforgeTarget.java

@@ -21,7 +21,7 @@ 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;
     }
 
     /**
@@ -115,7 +124,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 +142,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/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/ReforgeLookup.java

@@ -0,0 +1,216 @@
+package com.willfp.reforges.reforges.util;
+
+import com.willfp.eco.core.EcoPlugin;
+import com.willfp.reforges.ReforgesPlugin;
+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) {
+                reforge.handleActivation(player);
+            }
+
+            for (Reforge reforge : removed) {
+                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

@@ -100,7 +100,7 @@ public class ReforgeUtils {
      * 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 +120,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 +151,6 @@ public class ReforgeUtils {
             return;
         }
 
-        Reforge previous = getReforge(item);
-
-        if (previous != null) {
-            previous.handleRemoval(item);
-        }
-
         ItemMeta meta = item.getItemMeta();
 
         setReforge(meta, reforge);
@@ -175,15 +169,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 +195,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/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

@@ -91,11 +91,7 @@ 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
 

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,29 @@ 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
+        attribute.addModifier(
-    ) {
-        meta.addAttributeModifier(
-            Attribute.GENERIC_ATTACK_SPEED,
             AttributeModifier(
-                this.getUUID(1),
+                this.getUUID(player.getEffectAmount(this)),
                 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,32 @@ 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,
+        attribute.addModifier(
             AttributeModifier(
-                this.getUUID(1),
+                this.getUUID(player.getEffectAmount(this)),
                 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,32 @@ 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,
+        attribute.addModifier(
             AttributeModifier(
-                this.getUUID(1),
+                this.getUUID(player.getEffectAmount(this)),
                 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

@@ -14,6 +14,8 @@ class EffectRewardBlockBreak : Effect("reward_kill") {
         event: BlockBreakEvent,
         config: JSONConfig
     ) {
+        if (EconomyHandler.isEnabled()) {
             EconomyHandler.getInstance().depositPlayer(player, config.getDouble("amount"))
         }
+    }
 }

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

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

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
@@ -68,27 +69,16 @@ class Reforge(
         }
     }
 
-    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/WatcherTriggers.kt

@@ -6,7 +6,6 @@ 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 org.bukkit.entity.*
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener

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

@@ -1,4 +1,15 @@
+#
+# 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:
+  slot: hands
+  items:
     - wooden_pickaxe
     - stone_pickaxe
     - iron_pickaxe
@@ -6,6 +17,8 @@ pickaxe:
     - diamond_pickaxe
     - netherite_pickaxe
 axe:
+  slot: hands
+  items:
     - wooden_axe
     - stone_axe
     - iron_axe
@@ -13,6 +26,8 @@ axe:
     - diamond_axe
     - netherite_axe
 melee:
+  slot: hands
+  items:
     - wooden_axe
     - stone_axe
     - iron_axe
@@ -26,11 +41,17 @@ melee:
     - diamond_sword
     - netherite_sword
 trident:
+  slot: hands
+  items:
     - trident
 bow:
+  slot: hands
+  items:
     - bow
     - crossbow
 armor:
+  slot: armor
+  items:
     - turtle_helmet
     - leather_helmet
     - chainmail_helmet

gradle.properties

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