Download File

# GriefPrevention3D v18.3.3 **Wiki:** https://github.com/castledking/GriefPrevention3D/wiki ## Overview This maintenance release restores claim knockback protection on Canvas servers. Canvas is a Paper fork and provides Paper's cancellable knockback events, but GP3D detects it as its own platform. The knockback listener recognized only `PAPER` and `SPIGOT`, so it declared itself unsupported when the detected platform was `CANVAS` and was never registered. The issue was reported through sulfur cubes: an untrusted player could punch a cube holding a block and move it around another player's claim despite both of the relevant settings being enabled. The same registration gap affected every protection handled by the platform knockback listener, not only sulfur cubes. ## Canvas now uses the Paper knockback path GP3D has separate listener implementations for the two event APIs exposed by supported Bukkit servers: - Paper and Paper-compatible servers use `EntityKnockbackByEntityEvent` and `EntityPushedByEntityAttackEvent` from the Paper API. - Spigot uses Bukkit's `EntityKnockbackByEntityEvent`. Canvas includes the Paper events and fires them from the sulfur cube's custom knockback path. GP3D now maps `CANVAS` to the Paper implementation, checks that the required Paper event classes exist, and registers `PaperKnockbackProtectionHandler` just as it does on Paper. This restores cancellation for player-caused knockback against: - non-hostile creatures protected by container trust, including sulfur cubes; - armor stands and hanging entities protected by build trust; - players covered by GP3D's PvP-safe claim rules or fresh-spawn immunity; and - projectile and attack-driven knockback routed through the same Paper events. Paper and Spigot retain their existing native listener implementations. Unsupported platforms remain rejected before a platform-specific handler class is loaded, preserving the universal JAR's older-server class-loading behavior. ## Why this appeared as sulfur cube theft A sulfur cube containing a block is already immune to direct player health damage in Minecraft 26.2. Punching it applies the cube's special knockback instead. On Canvas, that knockback event was available but GP3D had no listener registered to cancel it, allowing the cube to be moved despite the claim denial. Once a cube is moved outside the protected claim, the block it carries can be retrieved where the original claim no longer supplies a denial. This is why the incident can look like the cube was killed and its block stolen even though the vulnerable regular-combat path is movement rather than health damage. The normal creature-damage handler is unchanged. With `GriefPrevention.Claims.ProtectCreatures: true`, direct damage to an empty sulfur cube in a claim still requires container trust. A block-holding cube remains immune to player damage at the game level. ## Configuration and scope No configuration, permission, message, command, or claim-data changes are required. Existing settings remain authoritative: ```yaml GriefPrevention: Claims: PreventTheft: true ProtectCreatures: true ``` Both values already default to `true`. This patch covers punch, projectile, and other player-caused movement which fires the platform knockback events. Walking directly into a block-holding sulfur cube uses Minecraft's body-collision movement path and does not fire the same cancellable attack event; that separate path is not changed in this release. ## Verification The regression test records the platform selection directly. It failed before the fix because Canvas resolved to `UNSUPPORTED`, then passed after Canvas was mapped to the Paper knockback API. Additional assertions keep the existing Paper and Spigot selections from regressing. The full `./gradlew check` pipeline passes: **436 tests, 0 failures, 0 errors** — 247 in the Bukkit plugin, 136 in the shared core, 51 on the Fabric platform, and 2 in the Fabric bootstrap. This also includes the universal JAR audit, Java 8 legacy class loading, shaded-core isolation, and the Fabric boot smoke test against the generated universal JAR. The Canvas 26.2 API was inspected to confirm that both Paper event classes required by the selected handler are present. Live-server verification should reproduce the original case with an untrusted player punching a block-holding sulfur cube inside another player's claim and confirm that the cube does not receive the denied knockback. ## Files Changed ```text M gradle.properties M pom.xml M src/main/java/com/griefprevention/platform/knockback/KnockbackProtectionListener.java A src/test/java/com/griefprevention/platform/knockback/KnockbackProtectionListenerTest.java ```