Ajout du hammer et de la builder wand

src/main/java/fr/openmc/core/items/usable/AbstractHammer.java

@@ -0,0 +1,118 @@
+package fr.openmc.core.items.usable;
+
+import fr.openmc.core.features.city.ProtectionsManager;
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.RayTraceResult;
+
+public abstract class AbstractHammer extends CustomUsableItem {
+
+    private final Material vanillaMaterial;
+    private final int radius;
+    private final int depth;
+    private static final float MAX_HARDNESS = 41.0f;
+
+    protected AbstractHammer(String namespacedId,
+                             Material vanillaMaterial,
+                             int radius,
+                             int depth) {
+        super(namespacedId);
+        this.vanillaMaterial = vanillaMaterial;
+        this.radius = radius;
+        this.depth  = depth;
+    }
+
+    @Override
+    public ItemStack getVanilla() {
+        return ItemStack.of(vanillaMaterial);
+    }
+
+    @Override
+    public void onBlockBreak(Player player, BlockBreakEvent event) {
+        if (player.getGameMode() != GameMode.SURVIVAL)
+            return;
+
+        ItemStack tool = player.getInventory().getItemInMainHand();
+        if (tool == null || tool.getType().isAir())
+            return;
+
+        Block broken = event.getBlock();
+        BlockFace face = getDestroyedBlockFace(player).getOppositeFace();
+
+        breakArea(player, broken, face, tool, radius, depth);
+    }
+
+    private static void breakArea(Player player,
+                                  Block origin,
+                                  BlockFace face,
+                                  ItemStack tool,
+                                  int radius,
+                                  int depth) {
+
+        Material targetType = origin.getType();
+        if (targetType.isAir()) return;
+        if (targetType.getHardness() > MAX_HARDNESS) return;
+
+        World world = origin.getWorld();
+        int baseX = origin.getX();
+        int baseY = origin.getY();
+        int baseZ = origin.getZ();
+
+        IntTriConsumer apply;
+        switch (face) {
+            case NORTH:
+            case SOUTH:
+                apply = (x, y, z) -> work(world, player, tool, baseX + x, baseY + y, baseZ + z, targetType);
+                break;
+            case EAST:
+            case WEST:
+                apply = (x,y,z) -> work(world, player, tool, baseX + z, baseY + y, baseZ + x, targetType);
+                break;
+            case UP:
+            case DOWN:
+                apply = (x, y, z) -> work(world, player, tool, baseX + x, baseY + z, baseZ + y, targetType);
+                break;
+            default:
+                return;
+        }
+
+        for (int dx = -radius; dx <= radius; dx++) {
+            for (int dy = -radius; dy <= radius; dy++) {
+                for (int dz = -depth; dz <= depth; dz++) {
+                    if (dx == 0 && dy == 0 && dz == 0) continue;
+                    apply.accept(dx, dy, dz);
+                }
+            }
+        }
+    }
+
+    private static void work(World world,
+                             Player player,
+                             ItemStack tool,
+                             int x, int y, int z,
+                             Material targetType) {
+        Block b = world.getBlockAt(x, y, z);
+        if (b.getType() != targetType) return;
+        if (b.getType().getHardness() > MAX_HARDNESS) return;
+        if (!ProtectionsManager.canInteract(player, b.getLocation())) return;
+        b.breakNaturally(tool);
+    }
+
+    private static BlockFace getDestroyedBlockFace(Player player) {
+        Location eye = player.getEyeLocation();
+        RayTraceResult result = eye.getWorld().rayTraceBlocks(
+                eye, eye.getDirection(), 10, FluidCollisionMode.NEVER);
+        return result != null && result.getHitBlockFace() != null
+                ? result.getHitBlockFace()
+                : BlockFace.SELF;
+    }
+
+    @FunctionalInterface
+    private interface IntTriConsumer {
+        void accept(int x, int y, int z);
+    }
+}

src/main/java/fr/openmc/core/items/usable/CustomUsableItem.java

@@ -3,6 +3,7 @@
 import fr.openmc.core.items.CustomItem;
 import org.bukkit.entity.Player;
 import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
 
 public abstract class CustomUsableItem extends CustomItem {
@@ -14,6 +15,7 @@ public abstract class CustomUsableItem extends CustomItem {
      */
     protected CustomUsableItem(String name) {
         super(name);
+        CustomUsableItemRegistry.register(this);
     }
 
     /**
@@ -40,6 +42,8 @@ public void onLeftClick(Player player, PlayerInteractEvent event) {}
      */
     public void onSneakClick(Player player, PlayerInteractEvent event) {}
 
+    public void onBlockBreak(Player player, BlockBreakEvent event) {}
+
     /**
      * Handles the interaction with the item.
      *
@@ -58,4 +62,8 @@ public final void handleInteraction(Player player, PlayerInteractEvent event) {
         }
     }
 
+    public final void handleBlockBreak(Player player, BlockBreakEvent event) {
+        onBlockBreak(player, event);
+    }
+
 }

src/main/java/fr/openmc/core/items/usable/CustomUsableItemRegistry.java

@@ -1,6 +1,9 @@
 package fr.openmc.core.items.usable;
 
 import dev.lone.itemsadder.api.CustomStack;
+import fr.openmc.core.items.usable.items.DiamondHammer;
+import fr.openmc.core.items.usable.items.IronHammer;
+import fr.openmc.core.items.usable.items.NetheriteHammer;
 import org.bukkit.inventory.ItemStack;
 
 import java.util.HashMap;
@@ -14,8 +17,10 @@ public class CustomUsableItemRegistry {
      * Initializes the registry and registers all custom usable items.
      * This constructor should be called once during server startup.
      */
-    public static void init() {
-        // register here
+    public CustomUsableItemRegistry() {
+        new IronHammer();
+        new DiamondHammer();
+        new NetheriteHammer();
     }
 
     /**

src/main/java/fr/openmc/core/items/usable/items/DiamondHammer.java

@@ -0,0 +1,17 @@
+package fr.openmc.core.items.usable.items;
+
+import fr.openmc.core.items.usable.AbstractHammer;
+import org.bukkit.Material;
+
+public class DiamondHammer extends AbstractHammer {
+
+    public DiamondHammer() {
+        super(
+                "omc_items:diamond_hammer",
+                Material.DIAMOND_PICKAXE,
+                1,
+                1
+        );
+    }
+
+}

src/main/java/fr/openmc/core/items/usable/items/IronHammer.java

@@ -0,0 +1,17 @@
+package fr.openmc.core.items.usable.items;
+
+import fr.openmc.core.items.usable.AbstractHammer;
+import org.bukkit.Material;
+
+public class IronHammer extends AbstractHammer {
+
+    public IronHammer() {
+        super(
+                "omc_items:iron_hammer",
+                Material.IRON_PICKAXE,
+                1,
+                0
+        );
+    }
+
+}

src/main/java/fr/openmc/core/items/usable/items/NetheriteHammer.java

@@ -0,0 +1,17 @@
+package fr.openmc.core.items.usable.items;
+
+import fr.openmc.core.items.usable.AbstractHammer;
+import org.bukkit.Material;
+
+public class NetheriteHammer extends AbstractHammer {
+
+    public NetheriteHammer() {
+        super(
+                "omc_items:netherite_hammer",
+                Material.NETHERITE_PICKAXE,
+                1,
+                2
+        );
+    }
+
+}

src/main/java/fr/openmc/core/listeners/BlockBreakListener.java

@@ -0,0 +1,28 @@
+package fr.openmc.core.listeners;
+
+import fr.openmc.core.features.city.ProtectionsManager;
+import fr.openmc.core.items.usable.CustomUsableItem;
+import fr.openmc.core.items.usable.CustomUsableItemRegistry;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.inventory.ItemStack;
+
+public class BlockBreakListener implements Listener {
+
+    @EventHandler
+    public void onBlockBreak(BlockBreakEvent event) {
+        Player player = event.getPlayer();
+        if (event.isCancelled()) return;
+        if (event.getBlock() == null) return;
+        ProtectionsManager.verify(player, event, event.getBlock().getLocation());
+
+        ItemStack itemInHand = player.getInventory().getItemInMainHand();
+        CustomUsableItem usableItem = CustomUsableItemRegistry.getByItemStack(itemInHand);
+
+        if (usableItem != null)
+            usableItem.handleBlockBreak(player, event);
+    }
+
+}