Advanced TreeCapitator

[1.5.1] — 2025-06-03

Fixed — Bug Fixes

| # | Bug | Details | |---|-----|---------| | 1 | BFS adds out-of-range blocks to the break-set before checking distance caps | In TreeFinder.findLogs(), logsToBreak.add(current) ran unconditionally at the start of the loop body — before the dist > MAX_DISTANCE and hdist > maxHorizontalDistance checks. A block at the outer edge of the BFS scan (e.g. hdist == maxHorizontalDistance + 1) was enqueued as a neighbour of an in-range block, then added to the break-set when dequeued, even though the check immediately after prevented its own neighbours from being explored. Result: logs slightly beyond max-horizontal-distance were still felled, making the config option unreliable at the boundary. Fixed by moving both distance checks before the logsToBreak.add() call. | | 2 | `cooldownMs` loaded with `(int)` cast before clamping — silent integer overflow | cooldownMs = clamp((int) cfg.getLong("cooldown-ms", 200L), 0, 60_000) cast the raw YAML long to int before clamping. Any value larger than Integer.MAX_VALUE (2 147 483 647) in the config file overflowed to a negative number, which clamp() then floored to 0, silently disabling the per-player cooldown entirely. Fixed by clamping on the long value first: (int) Math.min(Math.max(...), 60_000L). Field type also changed from long to int for consistency; getCooldownMs() now returns int. | | 3 | Hardcoded `MAX_DISTANCE = 30` truncated tall Jungle trees | The 3-D Manhattan BFS safety cap was hardcoded as private static final int MAX_DISTANCE = 30 in TreeFinder. Jungle trees can reach 30+ blocks tall; a player chopping from a non-base position (reducing the vertical budget) or a tree with any horizontal spread would have its top logs excluded from the fell silently. Exposed as max-distance in config.yml with a default of 50. Configurable range: 10 – 200. | | 4 | `getBreakingTrees()` exposed the internal mutable anti-recursion set | The public getter getBreakingTrees() returned the raw ConcurrentHashMap.newKeySet() directly. External code (another plugin or a misbehaving task) could call .add(uuid) to permanently lock a player out of tree felling, or .clear() to disable the anti-recursion guard entirely mid-fell. Fixed by removing the public getter and replacing it with the package-private helpers markFelling(UUID) and unmarkFelling(UUID), used only by TreeCapitatorTask. | | 5 | `isOverworldLog()` did not cover stripped-log variants — `require-leaves` bypass | The method used a hard-coded switch that only listed nine non-stripped log variants (e.g. OAK_LOG). If a server operator added a stripped variant (e.g. STRIPPED_OAK_LOG) to log-types in config.yml, isOverworldLog() returned false (default case), and the require-leaves check was silently skipped. A player-built wall of stripped logs could be felled with a single swing even with require-leaves: true. Fixed by replacing the switch with a Material name-suffix check: any material ending in _LOG or _WOOD returns true. Nether stems (CRIMSON_STEM, WARPED_STEM), hyphae, and BAMBOO_BLOCK end in _STEM, _HYPHAE, or _BLOCK and continue to return false correctly. | | 6 | Leaf durability hits silently discarded by integer truncation | leafBreaks / safeRatio used integer division, dropping the remainder entirely. With the default leaf-durability-ratio: 10, breaking fewer than 10 leaves contributed exactly 0 durability hits — so a small tree with leaves produced no leaf-based durability cost at all. Fixed by resolving the remainder probabilistically: remainder / safeRatio gives the probability of one additional hit, resolved with a ThreadLocalRandom roll, consistent with the existing fractional-hit logic in calcDamage(). | | 7 | `TreeCapitatorEvent` API lacked `@NotNull` annotations | All three public getters (getPlayer(), getLogs(), getLeaves()) and the constructor parameters had no nullability contract. Third-party plugins integrating the API had no IDE or static-analysis guidance about null safety. Added @NotNull (from org.jetbrains:annotations:24.1.0) to all public constructor parameters and return types. org.jetbrains:annotations added to pom.xml as a provided dependency. |

[1.5.0] — 2025-05-21

Fixed — Bug Fixes

| # | Bug | Details | |---|-----|---------| | 1 | `Enchantment.getByKey()` silently returned `null` on Paper 1.21+ | DurabilityHandler.getUnbreakingLevel() used the deprecated Enchantment.getByKey(NamespacedKey.minecraft("unbreaking")) lookup. On Paper 1.21+ this returns null if the registry isn't fully initialised, causing the method to always return 0 — i.e. Unbreaking was completely ignored and axes lost durability as if they had no enchantment. Fixed by using the stable constant Enchantment.UNBREAKING. | | 2 | Player offline during 1-tick scheduling delay caused unsafe state | TreeCapitatorTask ran 1 tick after BlockBreakEvent. If the player disconnected in that window, player.getInventory() and player.playSound() were called on an invalid player. Fixed by adding an isOnline() guard at the top of doFell(). | | 3 | `disabledPlayers` set accumulated stale UUIDs indefinitely | When a player used /atc toggle to disable felling and then quit the server, their UUID was never removed from disabledPlayers. On re-join, felling remained disabled without the player having toggled it again. Fixed by handling PlayerQuitEvent and clearing all per-player state (disabledPlayers, cooldowns, breakingTrees). | | 4 | Cooldown was consumed even when `TreeCapitatorEvent` was cancelled | The cooldown timestamp was written in onBlockBreak() before the task ran. If a third-party plugin cancelled TreeCapitatorEvent (e.g. an economy plugin denying the action), the player was still forced to wait out the full cooldown. Fixed by refunding (removing) the cooldown entry inside doFell() immediately after a cancellation is detected. | | 5 | `TreeCapitatorEvent` Javadoc incorrectly stated "excludes origin" | The @param logs Javadoc said the set excluded the origin block. In reality trimmedLogs always includes the origin. Third-party plugins that relied on the documented behaviour miscounted tree size and produced incorrect reward calculations. Corrected the Javadoc; no runtime behaviour changed. | | 6 | Unbreaking durability calculation was deterministic (did not match vanilla) | calcDamage() multiplied hits by the expected-value probability 1/(level+1), producing the same result every time. Vanilla Minecraft rolls each hit independently: each has a 1/(level+1) chance to deal damage. With Unbreaking III chopping 20 logs, the plugin always applied exactly 5 durability; vanilla would apply anywhere from 0 to 20. Fixed by replacing the formula with a per-hit ThreadLocalRandom roll matching the vanilla mechanic. | | 7 | Sound effect played at player location instead of the tree | player.playSound(player.getLocation(), ...) meant the wood-break sound originated from the player rather than the tree. Players nearby heard nothing; the audio source felt disconnected from the visual effect. Fixed by using world.playSound(startBlock.getLocation(), ...) so the sound radiates from the felled tree's base and all nearby players can hear it. |

Added — New Features

| Feature | Details | |---------|---------| | `max-horizontal-distance` is now configurable | Previously MAX_HORIZONTAL_DISTANCE = 8 was a hardcoded constant in TreeFinder. It is now exposed as max-horizontal-distance in config.yml (default: 8). Modpack trees with unusually wide canopies can increase this; densely planted farms can decrease it to prevent cross-tree BFS merging. |

Changed — Code Improvements

- Cooldown cleanup interval is now dynamic: entries are removed after max(5 s, 10 × cooldown-ms) instead of a flat 60 seconds. With the default 200 ms cooldown this reduces the time stale entries linger from 60 s to 2 s. - Config.getMaxHorizontalDistance() added; TreeFinder.findLogs() now accepts this as a parameter instead of reading a static field. - AdvancedTreeCapitator.getCooldowns() added to allow TreeCapitatorTask to refund cooldowns without reflection. - All per-player state is now cleared in PlayerQuitEvent in addition to each task's finally block.

[1.4.0] — 2026-05-14

Fixed

- [CRITICAL] Forced Java 21 requirement — The pom.xml compile target has been lowered from Java 21 to Java 17. Previously the plugin threw UnsupportedClassVersionError on any server running Java 17 (Paper 1.20.x, Purpur, Pufferfish, most shared hosting providers). No source changes were needed because the code does not use any Java 21-specific APIs. - [CRITICAL] Protection plugin bypass — Extra log blocks (every block other than the origin) were broken with breakNaturally() without first firing a BlockBreakEvent, meaning WorldGuard, GriefPrevention, Lands, and Residence had no opportunity to intervene. A dedicated BlockBreakEvent is now fired for each extra block before it is broken; if any protection plugin cancels that event, the block is silently skipped. - [CRITICAL] Missing anti-recursion guard — The protection-plugin fix above fires BlockBreakEvent programmatically, which caused the plugin's own listener to trigger again for each block, creating an infinite loop. A breakingTrees Set<UUID> now marks any player whose felling session is currently in progress; the listener returns immediately if the player's UUID is already present. The set is always cleared inside a finally block so a player can never get permanently stuck. - [MEDIUM] BFS linking two nearby trees — The 26-direction BFS could follow diagonal log connections to merge two adjacent trees into one oversized fell. A new MAX_HORIZONTAL_DISTANCE = 8 constant (Manhattan X+Z distance from the origin block) causes BFS to skip any candidate block beyond that threshold. The value of 8 is wide enough to accommodate Big Oak and Dark Oak canopies without bridging two separate trunks. - [MEDIUM] No config value validation — Values such as max-blocks: -1 or damage-multiplier: -100 were loaded directly into fields, producing undefined behaviour (negative BFS limits, inverted durability). clamp() and clampDouble() helpers have been added to Config.reload(); all numeric values are now constrained to a valid range (e.g. max-blocks → [1, 1000], damage-multiplier → [0.1, 10.0]).

Clarified (not a bug)

- Double durability damage (analyst report #2) — The audit report claimed that breakNaturally(tool) automatically reduces the tool's durability in the player's inventory, causing damage to be applied twice alongside DurabilityHandler. After reviewing the Paper API source: Block.breakNaturally(ItemStack) uses the ItemStack only to determine drop calculations (Fortune, Silk Touch) and does not modify the item in the player's inventory. DurabilityHandler remains the sole source of durability loss. No double damage occurs.

Changed

- Lowered the supported api-version from Paper 1.21 to Paper 1.20.4+, broadening compatibility without requiring any 1.21-specific API. - Added Javadoc to TreeFinder, TreeCapitatorTask, and Config.

Not Fixed (planned v1.5.0)

- Folia incompatibility — The plugin schedules work with BukkitScheduler.runTask(), which is incompatible with Folia's region-based threading model. A proper fix requires migrating to RegionScheduler / GlobalRegionScheduler and is planned for v1.5.0. ---

[1.3.0] — 2026-04-25

Fixed

- `PALE_OAK_LOG` bypassed `require-leaves` check — isOverworldLog() was missing PALE_OAK_LOG from its switch statement, meaning Pale Oak trees were treated the same as Nether stems (no-leaf bypass). With require-leaves: true, a Pale Oak log structure built by a player would be incorrectly felled. Added PALE_OAK_LOG to the overworld log list so it is correctly guarded. - Fragile reference-equality trim check — The condition that decided whether leaves should be broken used trimmedLogs == logsToBreak (Java reference equality) instead of an explicit boolean. While this happened to work correctly, it was subtle and error-prone. Replaced with a dedicated wasTrimmed boolean flag for clarity and safety.

Added

- `TreeCapitatorEvent` (Plugin API) — A new cancellable Bukkit event fired just before any tree is felled. Other plugins can now listen to TreeCapitatorEvent to: - Cancel the felling via event.setCancelled(true). - Inspect the full set of logs and leaves that will be broken. - Grant custom rewards (economy, XP, quests) based on event.getLogs().size(). - `leaf-durability-ratio` config option (default: 10) — Controls how many leaf blocks count as one durability hit when break-leaves: true. Previously hardcoded to 1/10, this is now fully configurable. Set to 1 to make every leaf cost a durability point; set higher to reduce tool wear from leaf breaking. - `MUSHROOM_STEM` support — Added a commented-out entry in config.yml for MUSHROOM_STEM, enabling huge-mushroom felling. Uncomment to activate.

Refactored (God Class split)

- `TreeFinder` (new class) — Extracted all BFS log-finding and leaf-scanning logic from TreeCapitatorTask into a dedicated utility class. isOverworldLog() and isLeaf() helpers moved here. - `DurabilityHandler` (new class) — Extracted all durability calculation and application logic (getRemaining, calcMaxExtraBreaks, applyDamage) into a dedicated utility class. - TreeCapitatorTask is now a lean orchestrator: BFS → leaves → trim → event → break → durability → effects. ---

[1.2.5] — 2026-04-17

Fixed

* Nether stems, Warped stems, and Bamboo Block now work correctly with require-leaves: true.

Improved

* Highly optimized BFS: uses ArrayDeque, scans leaves only once, adds Manhattan distance, and uses HashSet. * Cleaner, more maintainable code. ---

[1.2.4] — 2026-04-04

Fixed

- Large trees (Jungle Giant, Dark Oak) could not be felled — When a tree exceeded max-blocks (default: 100), the plugin aborted the entire felling operation and only the single broken log was harvested. This made giant Jungle trees (200-500 blocks) and large Dark Oaks impossible to chop efficiently. The plugin now performs a **partial chop** — it breaks logs up to the configured max-blocks limit instead of doing nothing. The remaining logs can be harvested with additional chops. - Off-by-one in max-blocks check — Changed from > to >= so the limit is correctly enforced at exactly max-blocks. - Big Oak trees not fully harvested — The BFS search for logs was limited to 6 directions (face-adjacent only), causing the capitator to miss logs that are only diagonally adjacent. Big Oak trees have irregular structures where some logs only touch at corners. The search is now 26-direction (3×3×3 cube) to catch all connected logs. ---

[1.2.3] — 2026-03-27

Added

- `require-leaves` option (default: true) — Before felling, the plugin now checks that the log cluster has at least one adjacent leaf block. If none are found, the capitator does nothing. This prevents accidental activation on player-built log structures such as house walls, cabin roofs, or log-block decorations. Set to false to restore the old behaviour.

Fixed

- Durability did not limit felling — Tool durability was calculated and applied after all blocks were already broken. A nearly-broken axe (1 durability remaining) could silently fell a 100-log tree and would simply be destroyed at the end. The task now calculates the maximum number of extra logs the remaining durability permits before breaking any blocks, and trims the set accordingly. Unbreaking level is respected in this pre-check as well. ---

[1.2.2] — 2026-03-16

Fixed

- Critical Item Swap Bug — Fixed a bug where switching items during a tree felling task (0.05s delay) could overwrite a new item in the player's hand with the old axe, potentially causing item loss. The task now tracks the specific inventory slot and verifies the tool's identity before applying durability changes. - Leaf Durability — Added durability loss for leaf felling. Every 10 leaves broken now counts as 1 tool hit to ensure balancing when break-leaves is enabled.

Changelog — Advanced TreeCapitator

All notable changes to this project are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). ---

[1.2.1] — 2025-03-10

Fixed

- Plugin was completely non-functional. The BFS task read block.getType() one tick after the block-break event fired — at that point the block is already AIR, so the search found nothing and no extra logs were cut. The block Material is now captured inside the event handler (while the block still exists) and passed to the task. - Tool durability changes were silently discarded because the modified ItemStack was never written back to the player's hand. Added setItemInMainHand(tool) after updating the item meta. - Enchantment.UNBREAKING resolved via Enchantment.getByKey(NamespacedKey) with a try-catch fallback, fixing compatibility across all Paper 1.21.x patch builds. - Leaf blocks adjacent to a log in a cardinal direction were skipped during the 26-dir leaf scan because the log-BFS visited set had already claimed them. Leaf collection now deduplicates with its own LinkedHashSet, independent of the log BFS. - Event priority reverted to NORMAL (was incorrectly HIGH) so protection-plugin cancellations at NORMAL priority are still respected. ---

Changelog — Advanced TreeCapitator

All notable changes to this project will be documented in this file. ---

[1.2.0] — 2025-03-10

Added

- Per-player toggle (/atc toggle) — each player can enable or disable tree felling independently without affecting others - Tab completion for the /atc command - README.md with full installation guide, permissions table, and usage notes - CHANGELOG.md (this file)

Fixed

- @EventHandler was missing ignoreCancelled = true and priority = EventPriority.HIGH — now correctly respects cancellation from other plugins - Leaf detection upgraded to 26-direction (3×3×3) scan when break-leaves: true — diagonal leaves on Dark Oak and Jungle trees are now always caught - When a tree exceeded max-blocks, breakCount was reset to 1 but damage was still calculated — now the task returns early with no extra block breaks or damage when the limit is hit - Tool durability now uses extraBreaks + 1 (including the origin block) for an accurate damage total

Changed

- In-game messages translated to English for Modrinth release - Logger startup message now includes the plugin version - onDisable() clears both cooldowns and disabledPlayers - Config comments rewritten in English with explicit Fortune/Silk Touch notes - maven-compiler-plugin bumped to 3.13.0 - Version: 1.1.0 → 1.2.0 ---

[1.1.0]

Fixed (internal, per [FIX #x] comments)

- [FIX #1] enabled flag is now checked at the top of the event handler - [FIX #2] /atc reload command handler registered correctly - [FIX #3] Permission check advancedtreecapitator.use applied - [FIX #4] break-leaves now actually breaks leaves - [FIX #5] Particle effect now renders correctly - [FIX #6] Periodic cooldown map cleanup to prevent memory leak - [FIX #8] Cooldown is configurable via cooldown-ms instead of being hardcoded - [FIX #9] Unbreaking enchantment respected; Pale Oak, Nether stems, and Bamboo added to default config ---

[1.0.0]

- Initial release

Changelog

All notable changes to Advanced TreeCapitator will be documented in this file. ---

[1.1.0] - 2026-03-10

Fixed

- `enabled` flag was never checked — the plugin would still function even when enabled: false was set in config.yml. A guard check is now placed at the top of onBlockBreak(). - `/atc reload` command had no handler — the command was declared in plugin.yml but the plugin never implemented CommandExecutor, causing the server to return "Unknown command". The plugin now properly implements onCommand() and handles /atc reload. - `advancedtreecapitator.use` permission was never enforced — any player could use the feature regardless of their permissions. A permission check is now performed before processing each block break. - Leaf breaking did nothing — break-leaves: true in config had no effect because the BFS loop collected leaf blocks into a dead branch with no code. Leaves are now properly collected and broken. - Particle effect was commented out — the particle block in TreeCapitatorTask was entirely commented out, so particle-effect: true never produced any visual feedback. Particles now spawn correctly using the Particle.BLOCK API. - `breakCount` did not include the initial block — durability loss was calculated one block short because the starting block (broken by the event itself) was excluded from breakCount. The counter now starts at 1 to account for it.

Added

- Configurable cooldown — a new cooldown-ms option in config.yml (default: 200) replaces the previously hardcoded 100 ms cooldown, giving server admins full control. - Unbreaking enchantment support — axe durability loss now respects the Unbreaking enchantment level using Minecraft's standard probability formula (1 / (level + 1) chance per hit). - Automatic cooldown map cleanup — a repeating task runs every 10 minutes to purge stale entries from the cooldowns ConcurrentHashMap, preventing a memory leak on long-running servers. - Additional log types in default config: - PALE_OAK_LOG (Minecraft 1.21.4+) - CRIMSON_STEM and WARPED_STEM (Nether wood) - BAMBOO_BLOCK (Minecraft 1.20+) ---

[1.0.0] - Initial Release

- BFS-based tree felling on log break. - Configurable axe requirement, sneak requirement, world whitelist/blacklist. - Durability loss on axes with a configurable multiplier. - Sound and particle effect toggles. - Per-player cooldown to prevent spam.

[1.0.0] - 2026-03-10

Added

- Initial release - Tree felling when sneaking with an axe (configurable via require-sneak in config.yml) - Configurable axe durability loss based on number of logs broken (damage-multiplier) - Max block limit to prevent lag (max-blocks) - World whitelist/blacklist support - Reload command /atc reload to apply config changes without restart (requires advancedtreecapitator.admin permission) - Permission nodes: - advancedtreecapitator.use – allows using the fast tree felling feature (default: true) - advancedtreecapitator.admin – allows reloading the configuration (default: op) - Support for all vanilla log types: oak, spruce, birch, jungle, acacia, dark oak, mangrove, cherry - Toggleable particle and sound effects (particle-effect, sound-effect)