fix: wind charge PVP protection, copper golem trust, and visualization improvements

- Add wind charge knockback and damage protection in PVP-safe claims
- Treat copper golems as animals requiring container trust
- Fix visualization surface detection to always search from world surface downward for consistent results
- Add leaves to transparent block list for better visualization placement
- Replace sendMessage with sendRateLimitedErrorMessage for PVP messages to reduce spam
- Version bump to 17.0.10

Author: castledking

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>com.griefprevention</groupId>
     <artifactId>GriefPrevention</artifactId>
-    <version>17.0.8</version>
+    <version>17.0.10</version>
 
     <name>GriefPrevention</name>
     <description>The official self-service anti-griefing Bukkit plugin for Minecraft servers since 2011.</description>

src/main/java/com/griefprevention/visualization/impl/FakeBlockVisualization.java

@@ -283,13 +283,17 @@ protected void onElementAdded(@NotNull IntVector location, @NotNull BlockData fa
 
     /**
      * Find a location that should be visible to players. This causes the visualization to "cling" to the ground.
+     * Always searches from the world surface downward to ensure consistent results regardless of player position.
      *
      * @param vector the {@link IntVector} of the display location
      * @return the located {@link Block}
      */
     protected @NotNull Block getVisibleLocation(@NotNull IntVector vector)
     {
-        Block start = vector.toBlock(world);
+        // Always start from the highest block at this X,Z to ensure consistent surface detection
+        // regardless of whether the player is underground or on the surface
+        int highestY = world.getHighestBlockYAt(vector.x(), vector.z());
+        Block start = world.getBlockAt(vector.x(), highestY, vector.z());
         return snapToSurface(start);
     }
 
@@ -301,6 +305,7 @@ protected void onElementAdded(@NotNull IntVector location, @NotNull BlockData fa
         Block column = start;
 
         // Step upward until we reach an open cell (air/liquid depending on context).
+        // This handles cases where getHighestBlockYAt returns a block below overhangs.
         while (!isTransparent(column) && column.getY() < maxY)
         {
             column = column.getRelative(BlockFace.UP);
@@ -456,7 +461,8 @@ protected boolean isTransparent(@NotNull Block block)
                 || Tag.FENCE_GATES.isTagged(blockMaterial)
                 || Tag.SIGNS.isTagged(blockMaterial)
                 || Tag.WALLS.isTagged(blockMaterial)
-                || Tag.WALL_SIGNS.isTagged(blockMaterial))
+                || Tag.WALL_SIGNS.isTagged(blockMaterial)
+                || Tag.LEAVES.isTagged(blockMaterial))
             return true;
 
         return block.getType().isTransparent();

src/main/java/me/ryanhamshire/GriefPrevention/EntityDamageHandler.java

@@ -42,6 +42,7 @@
 import org.bukkit.event.entity.EntityCombustEvent;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityKnockbackByEntityEvent;
 import org.bukkit.event.entity.EntityTargetEvent;
 import org.bukkit.event.entity.PotionSplashEvent;
 import org.bukkit.event.vehicle.VehicleDamageEvent;
@@ -117,6 +118,46 @@ public void onEntityCombustByEntity(@NotNull EntityCombustByEntityEvent event) {
         this.handleEntityDamageEvent(new EntityDamageInstance(event), false);
     }
 
+    // Handle wind charge knockback - wind charges deal knockback separately from damage
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.LOWEST)
+    public void onEntityKnockbackByEntity(@NotNull EntityKnockbackByEntityEvent event) {
+        // Only handle wind charge knockback on players
+        if (!(event.getEntity() instanceof Player defender))
+            return;
+
+        Entity source = event.getSourceEntity();
+        if (source == null)
+            return;
+
+        // Check if the source is a wind charge
+        String sourceTypeName = source.getType().name();
+        if (!sourceTypeName.contains("WIND_CHARGE"))
+            return;
+
+        // Get the player who threw the wind charge
+        Player attacker = null;
+        if (source instanceof Projectile projectile && projectile.getShooter() instanceof Player shooter) {
+            attacker = shooter;
+        }
+
+        // Allow self-knockback (e.g., for movement tricks)
+        if (attacker == null || attacker == defender)
+            return;
+
+        // Only protect when PVP rules are enabled for this world
+        if (!instance.pvpRulesApply(defender.getWorld()))
+            return;
+
+        // Check if defender is in a PVP-protected claim
+        PlayerData defenderData = dataStore.getPlayerData(defender.getUniqueId());
+        Claim claim = dataStore.getClaimAt(defender.getLocation(), false, defenderData.lastClaim);
+        if (claim != null && instance.claimIsPvPSafeZone(claim)) {
+            defenderData.lastClaim = claim;
+            event.setCancelled(true);
+            GriefPrevention.sendRateLimitedErrorMessage(attacker, Messages.CantFightWhileImmune);
+        }
+    }
+
     private void handleEntityDamageEvent(@NotNull EntityDamageInstance event, boolean sendMessages) {
         // monsters are never protected
         if (isHostile(event.damaged()))
@@ -171,6 +212,25 @@ private void handleEntityDamageEvent(@NotNull EntityDamageInstance event, boolea
             }
         }
 
+        // Handle wind charge damage - wind charges are projectiles that deal knockback and damage
+        // When PVP rules are enabled for the world, protect players in claims from wind charge attacks
+        String damagerTypeName = damageSource != null ? damageSource.getType().name() : "";
+        if (damagerTypeName.contains("WIND_CHARGE") && event.damaged() instanceof Player defender) {
+            if (attacker != null && attacker != defender && instance.pvpRulesApply(defender.getWorld())) {
+                // Check if defender is in a protected claim
+                PlayerData defenderData = dataStore.getPlayerData(defender.getUniqueId());
+                Claim claim = dataStore.getClaimAt(defender.getLocation(), false, defenderData.lastClaim);
+                if (claim != null && instance.claimIsPvPSafeZone(claim)) {
+                    defenderData.lastClaim = claim;
+                    event.setCancelled(true);
+                    if (sendMessages) {
+                        GriefPrevention.sendRateLimitedErrorMessage(attacker, Messages.CantFightWhileImmune);
+                    }
+                    return;
+                }
+            }
+        }
+
         // Specific handling for PVP-enabled situations.
         if (instance.pvpRulesApply(event.damaged().getWorld())) {
             if (event.damaged() instanceof Player defender) {
@@ -378,9 +438,8 @@ private boolean handlePvpDamageByPlayer(
             if (attackerData.pvpImmune || defenderData.pvpImmune) {
                 event.setCancelled(true);
                 if (sendMessages)
-                    GriefPrevention.sendMessage(
+                    GriefPrevention.sendRateLimitedErrorMessage(
                             attacker,
-                            TextMode.Err,
                             attackerData.pvpImmune ? Messages.CantFightWhileImmune : Messages.ThatPlayerPvPImmune);
                 return true;
             }
@@ -397,7 +456,7 @@ private boolean handlePvpDamageByPlayer(
         Consumer<Messages> cancelHandler = message -> {
             event.setCancelled(true);
             if (sendMessages)
-                GriefPrevention.sendMessage(attacker, TextMode.Err, message);
+                GriefPrevention.sendRateLimitedErrorMessage(attacker, message);
         };
         // Return whether PVP is handled by a claim at the attacker or defender's
         // locations.
@@ -472,7 +531,7 @@ private boolean handlePvpPetDamageByPlayer(
         if (attackerData.pvpImmune) {
             event.setCancelled(true);
             if (sendMessages)
-                GriefPrevention.sendMessage(attacker, TextMode.Err, Messages.CantFightWhileImmune);
+                GriefPrevention.sendRateLimitedErrorMessage(attacker, Messages.CantFightWhileImmune);
             return true;
         }
 
@@ -1091,7 +1150,7 @@ public void onPotionSplash(@NotNull PotionSplashEvent event) {
                     Consumer<Messages> cancelHandler = message -> {
                         event.setIntensity(affected, 0);
                         if (messagedPlayer.compareAndSet(false, true))
-                            GriefPrevention.sendMessage(thrower, TextMode.Err, message);
+                            GriefPrevention.sendRateLimitedErrorMessage(thrower, message);
                     };
                     if (handlePvpInClaim(thrower, affectedPlayer, thrower.getLocation(), playerData,
                             () -> cancelHandler.accept(Messages.CantFightWhileImmune))) {

src/main/java/me/ryanhamshire/GriefPrevention/PlayerEventHandler.java

@@ -1326,8 +1326,8 @@ public void onPlayerInteractEntity(PlayerInteractEntityEvent event)
              }
          }
 
-         //if the entity is an animal, apply container rules
-         if ((instance.config_claims_preventTheft && (entity instanceof Animals || entity instanceof Fish)) || (entity.getType() == EntityType.VILLAGER && instance.config_claims_villagerTradingRequiresTrust))
+         //if the entity is an animal or copper golem, apply container rules
+         if ((instance.config_claims_preventTheft && (entity instanceof Animals || entity instanceof Fish || entity.getType().name().equals("COPPER_GOLEM"))) || (entity.getType() == EntityType.VILLAGER && instance.config_claims_villagerTradingRequiresTrust))
          {
              //if the entity is in a claim
              Claim claim = this.dataStore.getClaimAt(entity.getLocation(), false, null);
@@ -1352,7 +1352,7 @@ public void onPlayerInteractEntity(PlayerInteractEntityEvent event)
          }
 
          ItemStack itemInHand = instance.getItemInHand(player, event.getHand());
-
+ 
         //if preventing theft, prevent leashing claimed creatures and boats
         if (instance.config_claims_preventTheft && itemInHand.getType() == Material.LEAD)
         {