some more small fixes

Author: MagicTeaMC

src/main/java/org/milkteamc/autotreechop/events/BlockBreakListener.java

@@ -121,7 +121,7 @@ public void onBlockBreak(BlockBreakEvent event) {
             return;
         }
 
-        // Limits cleared — now check for a pending confirmation.
+        // Limits cleared — check for a pending confirmation first.
         ConfirmationManager confirmationManager = plugin.getConfirmationManager();
         ChopData pending = confirmationManager.consumePendingConfirmation(playerUUID);
 
@@ -145,8 +145,8 @@ public void onBlockBreak(BlockBreakEvent event) {
         // here), then read them on an async thread (snapshots are immutable — thread-safe).
         Map<Long, ChunkSnapshot> snapshots = captureLeafCheckSnapshots(block, config);
 
-        // Clone location and tool now so we have stable values if the async path
-        // later needs them (block reference is live world state — not safe async).
+        // Clone location and tool now so we have stable values for the async path.
+        // The block reference itself is a live world object — not safe to read off-thread.
         Location frozenLocation = location.clone();
         ItemStack frozenTool = tool.clone();
 
@@ -193,15 +193,7 @@ void dispatchChop(
             EffectUtils.showChopEffect(player, block);
         }
 
-        ProtectionHooks hooks = new ProtectionHooks(
-                plugin.isWorldGuardEnabled(),
-                plugin.getWorldGuardHook(),
-                plugin.isResidenceEnabled(),
-                plugin.getResidenceHook(),
-                plugin.isGriefPreventionEnabled(),
-                plugin.getGriefPreventionHook(),
-                plugin.isLandsEnabled(),
-                plugin.getLandsHook());
+        ProtectionHooks hooks = buildProtectionHooks();
 
         plugin.getTreeChopUtils()
                 .chopTree(
@@ -215,6 +207,24 @@ void dispatchChop(
                         hooks);
     }
 
+    /**
+     * Builds a {@link ProtectionHooks} snapshot from the plugin's current hook state.
+     *
+     * <p>Extracted from {@link #dispatchChop} so that the hook wiring lives in one
+     * place and future hook additions only need to be made here.
+     */
+    private ProtectionHooks buildProtectionHooks() {
+        return new ProtectionHooks(
+                plugin.isWorldGuardEnabled(),
+                plugin.getWorldGuardHook(),
+                plugin.isResidenceEnabled(),
+                plugin.getResidenceHook(),
+                plugin.isGriefPreventionEnabled(),
+                plugin.getGriefPreventionHook(),
+                plugin.isLandsEnabled(),
+                plugin.getLandsHook());
+    }
+
     /**
      * Captures {@link ChunkSnapshot}s for all chunks within the leaf-detection radius.
      *
@@ -233,7 +243,7 @@ private Map<Long, ChunkSnapshot> captureLeafCheckSnapshots(Block log, Config con
                 int chunkX = (cx + dx) >> 4;
                 int chunkZ = (cz + dz) >> 4;
                 if (!world.isChunkLoaded(chunkX, chunkZ)) continue;
-                long key = ((long) chunkX << 32) | (chunkZ & 0xFFFFFFFFL);
+                long key = chunkKey(chunkX, chunkZ);
                 snapshots.computeIfAbsent(
                         key, k -> world.getChunkAt(chunkX, chunkZ).getChunkSnapshot(false, false, false));
             }
@@ -266,7 +276,7 @@ private static boolean hasNearbyLeaves(Block log, Config config, Map<Long, Chunk
                     int z = cz + dz;
                     if (y < minY || y >= maxY) continue;
 
-                    long key = ((long) (x >> 4) << 32) | ((z >> 4) & 0xFFFFFFFFL);
+                    long key = chunkKey(x >> 4, z >> 4);
                     ChunkSnapshot snapshot = snapshots.get(key);
                     if (snapshot == null) continue;
 
@@ -278,4 +288,8 @@ private static boolean hasNearbyLeaves(Block log, Config config, Map<Long, Chunk
         }
         return false;
     }
+
+    private static long chunkKey(int chunkX, int chunkZ) {
+        return ((long) chunkX << 32) | (chunkZ & 0xFFFFFFFFL);
+    }
 }

src/main/java/org/milkteamc/autotreechop/utils/TreeChopUtils.java

@@ -66,11 +66,12 @@ private static boolean hasEnoughDurability(ItemStack tool, int blockCount, Confi
 
         int unbreakingLevel = getUnbreakingLevel(tool);
 
+        int damagePerHit = config.isToolDamage() ? config.getToolDamageDecrease() : 1;
         int estimatedDamage;
         if (config.getRespectUnbreaking() && unbreakingLevel > 0) {
-            estimatedDamage = blockCount / (unbreakingLevel + 1);
+            estimatedDamage = (blockCount * damagePerHit) / (unbreakingLevel + 1);
         } else {
-            estimatedDamage = blockCount * config.getToolDamageDecrease();
+            estimatedDamage = blockCount * damagePerHit;
         }
 
         return remainingDurability > estimatedDamage;
@@ -98,7 +99,7 @@ private static void applyToolDamage(ItemStack tool, Player player, int blocksBro
         int newDamage = currentDamage + damageToApply;
 
         if (newDamage >= tool.getType().getMaxDurability()) {
-            player.getInventory().removeItem(tool);
+            player.getInventory().setItemInMainHand(null);
         } else {
             damageableMeta.setDamage(newDamage);
             tool.setItemMeta(damageableMeta);
@@ -116,7 +117,7 @@ private static boolean shouldApplyDurabilityLoss(int unbreakingLevel, Config con
         if (unbreakingLevel <= 0 || !config.getRespectUnbreaking()) {
             return true;
         }
-        return random.nextInt(100) < (100.0 / (unbreakingLevel + 1));
+        return random.nextInt(unbreakingLevel + 1) == 0;
     }
 
     public static boolean isTool(Player player) {
@@ -140,10 +141,6 @@ public static boolean isTool(Player player) {
         return xMat == XMaterial.SHEARS || xMat == XMaterial.FISHING_ROD || xMat == XMaterial.FLINT_AND_STEEL;
     }
 
-    /**
-     * Main entry point for tree chopping
-     * PHASE 1: Synchronous snapshot creation
-     */
     public void chopTree(
             Block block,
             Player player,
@@ -180,14 +177,12 @@ public void chopTree(
         // Mark location as processing
         sessionManager.addTreeChopLocations(playerUUID, Collections.singleton(block.getLocation()));
 
-        // PHASE 1: Synchronous - Capture block snapshot
         try {
             BlockSnapshot treeSnapshot = BlockSnapshotCreator.captureTreeRegion(
                     block, config, connectedBlocks, config.getMaxDiscoveryBlocks());
 
             Location startLocation = block.getLocation().clone();
 
-            // PHASE 2: Asynchronous - Calculate tree structure
             Runnable asyncDiscovery = () -> {
                 try {
                     Set<Location> treeBlocks = BlockDiscoveryUtils.discoverTreeBFS(
@@ -215,10 +210,6 @@ public void chopTree(
         }
     }
 
-    /**
-     * Validate tree and execute chopping
-     * This runs synchronously on the region thread
-     */
     private void validateAndExecuteChop(
             Set<Location> treeBlocks,
             Block originalBlock,
@@ -235,7 +226,6 @@ private void validateAndExecuteChop(
             return;
         }
 
-        // Validation checks
         if (treeBlocks.isEmpty()) {
             sessionManager.clearTreeChopSession(playerUUID);
             return;
@@ -267,10 +257,6 @@ private void validateAndExecuteChop(
         executeTreeChop(treeBlocks, player, tool, config, playerConfig, hooks, originalBlock);
     }
 
-    /**
-     * Execute tree chopping in batches
-     * This runs synchronously with batch processing
-     */
     private void executeTreeChop(
             Set<Location> treeBlocks,
             Player player,
@@ -285,13 +271,10 @@ private void executeTreeChop(
         int totalBlocks = blockList.size();
         UUID playerUUID = player.getUniqueId();
 
-        // Track the LOWEST log of each type for replanting (Y coordinate)
+        Location centerLocation = originalBlock.getLocation().clone();
         Map<Material, Location> logTypesForReplant = new HashMap<>();
-        // Use thread-safe set for actuallyRemovedLogs since it's accessed across batches
         Set<Location> actuallyRemovedLogs = ConcurrentHashMap.newKeySet();
 
-        // CRITICAL: Capture leaf snapshot BEFORE removing logs
-        // This ensures we can see which logs exist for proper leaf orphan detection
         BlockSnapshot leafSnapshot = null;
         if (config.isLeafRemovalEnabled()) {
             try {
@@ -311,7 +294,7 @@ private void executeTreeChop(
                 (location, index) -> {
                     Block block = location.getBlock();
 
-                    // Re-check block type (may have changed)
+                    // Re-check block type (may have changed between phases)
                     if (!BlockDiscoveryUtils.isLog(block.getType(), config)) {
                         return;
                     }
@@ -323,7 +306,7 @@ private void executeTreeChop(
 
                     Material originalLogType = block.getType();
 
-                    // Track the lowest Y coordinate log for each type (for proper replanting)
+                    // Track the lowest-Y log of each type for replanting
                     Location existingLoc = logTypesForReplant.get(originalLogType);
                     if (existingLoc == null || location.getBlockY() < existingLoc.getBlockY()) {
                         logTypesForReplant.put(originalLogType, location.clone());
@@ -355,20 +338,17 @@ private void executeTreeChop(
                     // Handle leaf removal
                     if (config.isLeafRemovalEnabled() && finalLeafSnapshot != null) {
                         long delay = config.getLeafRemovalDelayTicks();
-                        Location leafProcessLocation = originalBlock.getLocation();
 
-                        Runnable leafTask = () -> {
-                            processLeafRemovalWithPreCapturedSnapshot(
-                                    finalLeafSnapshot,
-                                    originalBlock.getLocation(),
-                                    player,
-                                    config,
-                                    playerConfig,
-                                    hooks,
-                                    actuallyRemovedLogs);
-                        };
+                        Runnable leafTask = () -> processLeafRemovalWithPreCapturedSnapshot(
+                                finalLeafSnapshot,
+                                centerLocation,
+                                player,
+                                config,
+                                playerConfig,
+                                hooks,
+                                actuallyRemovedLogs);
 
-                        scheduler.scheduleDelayed(leafProcessLocation, leafTask, delay);
+                        scheduler.scheduleDelayed(centerLocation, leafTask, delay);
                     }
 
                     // Handle replanting
@@ -399,13 +379,6 @@ private void executeTreeChop(
                 });
     }
 
-    /**
-     * Process leaf removal with PRE-CAPTURED snapshot
-     * The snapshot was taken BEFORE logs were removed
-     * PHASE 1: Already done (snapshot captured before log removal)
-     * PHASE 2: Async - Calculate leaves to remove
-     * PHASE 3: Sync - Remove leaves in batches
-     */
     private void processLeafRemovalWithPreCapturedSnapshot(
             BlockSnapshot leafSnapshot,
             Location centerLocation,
@@ -425,36 +398,28 @@ private void processLeafRemovalWithPreCapturedSnapshot(
 
         String playerKey = player.getUniqueId().toString();
 
-        // Check if player already has an active leaf removal session
         if (sessionManager.hasActiveLeafRemovalSession(playerKey)) {
             return;
         }
 
-        // Start a new session
         String sessionId = sessionManager.startLeafRemovalSession(playerKey);
         if (sessionId == null) {
             return;
         }
 
-        // PHASE 2: Asynchronous - Calculate leaves to remove
         Runnable asyncLeafCalculation = () -> {
             try {
-                // Use the provided removedLogs directly
-                // (already contains all actually removed logs from executeTreeChop)
                 Set<Location> leavesToRemove;
                 int radius = config.getLeafRemovalRadius();
 
-                // Choose discovery method based on radius and mode
                 if ("smart".equalsIgnoreCase(config.getLeafRemovalMode())) {
                     leavesToRemove = BlockDiscoveryUtils.discoverLeavesBFS(
                             leafSnapshot, centerLocation, radius, config, removedLogs);
                 } else {
-                    // For "aggressive" or "radius" mode, radial is faster
                     leavesToRemove = BlockDiscoveryUtils.discoverLeavesRadial(
                             leafSnapshot, centerLocation, radius, config, removedLogs);
                 }
 
-                // PHASE 3: Back to sync for removal
                 Runnable removalTask = () ->
                         executeLeafRemoval(leavesToRemove, player, config, playerConfig, hooks, sessionId, playerKey);
 
@@ -470,15 +435,10 @@ private void processLeafRemovalWithPreCapturedSnapshot(
         if (config.isLeafRemovalAsync()) {
             scheduler.runTaskAsync(asyncLeafCalculation);
         } else {
-            // Run synchronously if async is disabled
             asyncLeafCalculation.run();
         }
     }
 
-    /**
-     * Execute leaf removal in batches
-     * This runs synchronously on the region thread
-     */
     private void executeLeafRemoval(
             Set<Location> leavesToRemove,
             Player player,
@@ -501,31 +461,20 @@ private void executeLeafRemoval(
                 0,
                 batchSize,
                 (location, index) -> {
-                    // Check daily limit if counting towards limit
                     if (config.getLeafRemovalCountsTowardsLimit()) {
                         if (!PermissionUtils.hasVipBlock(player, playerConfig, config)
                                 && playerConfig.getDailyBlocksBroken() >= config.getMaxBlocksPerDay()) {
-                            return false; // Stop processing - limit reached
+                            return false;
                         }
                     }
 
                     Block leafBlock = location.getBlock();
-
-                    // Remove the leaf block with all checks
                     removeLeafBlock(leafBlock, player, config, playerConfig, hooks);
-
-                    return true; // Continue processing
+                    return true;
                 },
-                () -> {
-                    // Leaf removal complete - end session
-                    sessionManager.endLeafRemovalSession(sessionId, playerKey);
-                });
+                () -> sessionManager.endLeafRemovalSession(sessionId, playerKey));
     }
 
-    /**
-     * Remove a single leaf block with all necessary checks
-     * This runs synchronously on the region thread
-     */
     private boolean removeLeafBlock(
             Block leafBlock,
             Player player,
@@ -535,26 +484,19 @@ private boolean removeLeafBlock(
 
         Location leafLocation = leafBlock.getLocation();
 
-        // Check if already processing this location
-        if (processingLeafLocations.contains(leafLocation)) {
-            return false;
-        }
-
-        // Re-check if it's still a leaf
-        if (!BlockDiscoveryUtils.isLeafBlock(leafBlock.getType(), config)) {
+        if (!processingLeafLocations.add(leafLocation)) {
             return false;
         }
 
-        // Re-check protection at execution time
-        if (!ProtectionCheckUtils.canModifyBlock(player, leafLocation, hooks)) {
-            return false;
-        }
+        try {
+            if (!BlockDiscoveryUtils.isLeafBlock(leafBlock.getType(), config)) {
+                return false;
+            }
 
-        // Mark as processing
-        processingLeafLocations.add(leafLocation);
+            if (!ProtectionCheckUtils.canModifyBlock(player, leafLocation, hooks)) {
+                return false;
+            }
 
-        try {
-            // Call BlockBreakEvent if enabled
             if (config.isCallBlockBreakEvent()) {
                 BlockBreakEvent breakEvent = new BlockBreakEvent(leafBlock, player);
                 plugin.getServer().getPluginManager().callEvent(breakEvent);
@@ -573,15 +515,13 @@ private boolean removeLeafBlock(
                 leafBlock.setType(XMaterial.AIR.get(), false);
             }
 
-            // Update daily blocks count if needed
             if (config.getLeafRemovalCountsTowardsLimit()) {
                 playerConfig.incrementDailyBlocksBroken();
             }
 
             return true;
 
         } finally {
-            // Always remove from processing set
             processingLeafLocations.remove(leafLocation);
         }
     }