Remove reflection-based DualWielding implementation, and update relat…

…ed utilities (#70)

* Remove reflection-based DualWielding implementation, and update related utilities

* Fix checkstyle

* Bring back break sound

* Updated CHANGELOG.

Co-authored-by: Amaury Carrade <[email protected]>

CHANGELOG.md

@@ -13,11 +13,36 @@ _Published one day_
 ### Changed
 
 #### `CraftingRecipes`
+
 - :warning: All recipes are now required to provide names, therefore all helper methods to generate recipes take a
   mandatory name argument. The name is automatically namespaced with the plugin's name.
 - :warning: All helpers that were consuming the now-deprecated `MaterialData` now consume the more flexible `RecipeChoice` instead.
 - All helpers that generate shaped recipes (2x2, 2x2 diagonal, etc.) now return `ShapedRecipe`s explicitely, since there
   is no way those recipes can be anything other than shaped, and hiding this detail is not useful at all.
+
+#### Glow effect
+
+This tool was rewritten to register a namespaced enchantment, avoiding future incompatibilities with other plugins
+registering new enchants.
+
+- :warning: The glow effect is now a QuartzLib component. You still use glow effect as usual (either using `GlowEffect`
+  or through the `ItemStackBuilder`), but you have to load the effect using `loadComponents(GlowEffect.class)` in your
+  plugin's `onEnable`.
+
+#### `DualWielding`
+
+This API was added when Bukkit had no support for dual wielding. As there is support now, we cleaned up all of this
+and removed some things. We kept some useful methods and moved things to other classes for coherence.
+
+- Added `ItemUtils.consumeItemInOffHand`.
+- :warning: Moved `ItemUtils.consumeItem` to `ItemUtils.consumeItemInMainHand`.
+- :warning: Moved `ItemUtils.damageItemInHand` to `ItemUtils.damageItem`.
+- `ItemUtils.damageItem` now returns `true` if the damaged item was broken.
+- :warning: Moved `ItemUtils.breakItemInHand` methods to `InventoryUtils.breakItemInHand`.
+- :warning: Moved `DualWielding` to `InventoryUtils.DualWielding`.
+- :warning: Moved `DualWieldling` methods to `InventoryUtils`.
+- :warning: Removed `DualWieldling.setItemInHand` and `DualWieldling.getItemInHand` (use Bukkit API instead).
+
 
 #### `GlowEffect`
 - :warning: This class is not an enchantment anymore and has been re-implemented. It is now a `QuartzComponent` that

src/main/java/fr/zcraft/quartzlib/tools/items/InventoryUtils.java

@@ -33,10 +33,14 @@
 import fr.zcraft.quartzlib.tools.reflection.Reflection;
 import fr.zcraft.quartzlib.tools.runners.RunTask;
 import java.lang.reflect.InvocationTargetException;
+import org.bukkit.Material;
+import org.bukkit.Sound;
 import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * This class provides various utilities for inventory management.
@@ -118,4 +122,74 @@ public static void updateInventoryLater(final Inventory inventory) {
         });
     }
 
+    /**
+     * Returns which player's hand is holding the specific item.
+     * If dual-wielding is not available, the item is tested against the
+     * player's only hand.
+     *
+     * @param player The player
+     * @param item   The item
+     * @return The hand holding the given item, or null if neither of them is holding it.
+     */
+    public static @Nullable DualWielding getHoldingHand(@NotNull Player player, @NotNull ItemStack item) {
+        if (player.getInventory().getItemInOffHand().equals(item)) {
+            return DualWielding.OFF_HAND;
+        }
+
+        if (player.getInventory().getItemInMainHand().equals(item)) {
+            return DualWielding.MAIN_HAND;
+        }
+
+        return null;
+    }
+
+    /**
+     * Breaks the item currently in the hand of the player.
+     *
+     * @param player The player.
+     * @param hand   The hand to retrieve the item from. This will always be the main hand if
+     *               the Bukkit build don't support dual-wielding.
+     */
+    public static void breakItemInHand(Player player, @NotNull InventoryUtils.DualWielding hand) {
+        final ItemStack item = new ItemStack(Material.AIR);
+
+        switch (hand) {
+            case MAIN_HAND:
+                player.getInventory().setItemInMainHand(item);
+                break;
+            case OFF_HAND:
+                player.getInventory().setItemInOffHand(item);
+                break;
+            default: break;
+        }
+
+        player.playSound(player.getLocation(), Sound.ENTITY_ITEM_BREAK, 0.8f, 1);
+    }
+
+    /**
+     * Breaks the given item if it is found in one of the player's hands.
+     *
+     * @param player The player.
+     * @param item   The item to break.
+     */
+    public static void breakItemInHand(Player player, ItemStack item) {
+        DualWielding hand = getHoldingHand(player, item);
+        if (hand != null) {
+            breakItemInHand(player, hand);
+        }
+    }
+
+    /**
+     * This class provides various utilities for handling dual-wielding.
+     */
+    public enum DualWielding {
+        /**
+         * Represents the main hand of the player.
+         */
+        MAIN_HAND,
+        /**
+         * Represents the off hand of the player.
+         */
+        OFF_HAND;
+    }
 }

src/main/java/fr/zcraft/quartzlib/tools/items/ItemUtils.java

@@ -47,6 +47,7 @@
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.Damageable;
 import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.inventory.meta.PotionMeta;
 import org.bukkit.potion.Potion;
@@ -67,16 +68,30 @@ private ItemUtils() {
     }
 
     /**
-     * Simulates the player consuming the itemstack in its hand, depending on
-     * his game mode. This decreases the ItemStack's size by one, and replaces
+     * Simulates the player consuming the ItemStack in their main hand, depending on
+     * their game mode. This decreases the ItemStack's size by one, and replaces
      * it with air if nothing is left.
      *
      * @param player The player that will consume the stack.
-     * @return The updated stack.
+     * @return The updated ItemStack.
      */
-    public static ItemStack consumeItem(Player player) {
-        ItemStack newStack = consumeItem(player, player.getItemInHand());
-        player.setItemInHand(newStack);
+    public static ItemStack consumeItemInMainHand(Player player) {
+        ItemStack newStack = consumeItem(player, player.getInventory().getItemInMainHand());
+        player.getInventory().setItemInMainHand(newStack);
+        return newStack;
+    }
+
+    /**
+     * Simulates the player consuming the ItemStack in their main hand, depending on
+     * their game mode. This decreases the ItemStack's size by one, and replaces
+     * it with air if nothing is left.
+     *
+     * @param player The player that will consume the stack.
+     * @return The updated ItemStack.
+     */
+    public static ItemStack consumeItemInOffHand(Player player) {
+        ItemStack newStack = consumeItem(player, player.getInventory().getItemInOffHand());
+        player.getInventory().setItemInOffHand(newStack);
         return newStack;
     }
 
@@ -182,48 +197,32 @@ public static boolean hasDisplayName(ItemStack stack, String displayName) {
      * @param player The player that is using the item.
      * @param item   The item in the player's hand.
      * @param factor The amount of damage taken.
+     * @return `true` if the damaged item was broken, `false` otherwise.
      */
-    public static void damageItemInHand(Player player, ItemStack item, int factor) {
-        if (player == null) {
-            throw new IllegalArgumentException("Player can't be null.");
-        }
+    public static boolean damageItem(@NotNull Player player, @NotNull ItemStack item, int factor) {
         if (player.getGameMode() == GameMode.CREATIVE) {
-            return;
+            return false;
         }
 
-        short newDurability = item.getDurability();
+        ItemMeta meta = item.getItemMeta();
+
+        if (!(meta instanceof Damageable)) {
+            return false;
+        }
+
+        int newDurability = ((Damageable) meta).getDamage();
         newDurability += newDurability(item.getEnchantmentLevel(Enchantment.DURABILITY)) * factor;
 
         if (newDurability >= item.getType().getMaxDurability()) {
-            breakItemInHand(player, item);
+            InventoryUtils.breakItemInHand(player, item);
+            player.updateInventory();
+            return true;
         } else {
-            item.setDurability(newDurability);
-            //player.getInventory().setItemInHand(item);
+            ((Damageable) meta).setDamage(newDurability);
+            item.setItemMeta(meta);
+            player.updateInventory();
+            return false;
         }
-
-        player.updateInventory();
-    }
-
-    /**
-     * Breaks the item currently in the hand of the player.
-     *
-     * @param player The player.
-     * @param hand   The hand to retrieve the item from. This will always be the main hand if
-     *               the Bukkit build don't support dual-wielding.
-     */
-    public static void breakItemInHand(Player player, DualWielding hand) {
-        DualWielding.setItemInHand(player, hand, new ItemStack(Material.AIR));
-        //player.playSound(player.getLocation(), Sound.ITEM_BREAK, 0.8f, 1);
-    }
-
-    /**
-     * Breaks the given item if it is found in one of the player's hands.
-     *
-     * @param player The player.
-     * @param item   The item to break.
-     */
-    public static void breakItemInHand(Player player, ItemStack item) {
-        breakItemInHand(player, DualWielding.getHoldingHand(player, item));
     }
 
     /**