Replace PlayerDamageListener with EnvironmentalListener and PvpListener

Removed PlayerDamageListener and introduced two new listeners, EnvironmentalListener and PvpListener to manage entity damage. EnvironmentalListener prevents dangerous bucket dumps and block ignitions. PvpListener handles entity damages, potion splash events, area effect cloud applications and fishing events, all with distinct conditions and responses for better PvP management.

src/main/java/me/youhavetrouble/preventstabby/PreventStabby.java

@@ -6,7 +6,8 @@ import me.youhavetrouble.preventstabby.hooks.PlaceholderApiHook;
 import me.youhavetrouble.preventstabby.hooks.WorldGuardHook;
 import me.youhavetrouble.preventstabby.data.PlayerListener;
 import me.youhavetrouble.preventstabby.data.PlayerManager;
-import me.youhavetrouble.preventstabby.listeners.PlayerDamageListener;
+import me.youhavetrouble.preventstabby.listeners.EnvironmentalListener;
+import me.youhavetrouble.preventstabby.listeners.PvpListener;
 import me.youhavetrouble.preventstabby.listeners.UtilListener;
 import me.youhavetrouble.preventstabby.util.*;
 import org.bstats.bukkit.Metrics;
@@ -35,8 +36,9 @@ public final class PreventStabby extends JavaPlugin {
         // Register listeners TODO
         getServer().getPluginManager().registerEvents(new UtilListener(), this);
         getServer().getPluginManager().registerEvents(new PlayerListener(), this);
+        getServer().getPluginManager().registerEvents(new EnvironmentalListener(this), this);
 
-        getServer().getPluginManager().registerEvents(new PlayerDamageListener(this), this);
+        getServer().getPluginManager().registerEvents(new PvpListener(this), this);
 
         // Register command
         PluginCommand pvpCommand = getCommand("pvp");

src/main/java/me/youhavetrouble/preventstabby/listeners/EnvironmentalListener.java

@@ -0,0 +1,76 @@
+package me.youhavetrouble.preventstabby.listeners;
+
+import me.youhavetrouble.preventstabby.PreventStabby;
+import me.youhavetrouble.preventstabby.config.ConfigCache;
+import me.youhavetrouble.preventstabby.data.DamageCheckResult;
+import me.youhavetrouble.preventstabby.data.Target;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.player.PlayerBucketEmptyEvent;
+import org.bukkit.util.BoundingBox;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class EnvironmentalListener implements Listener {
+
+    private final PreventStabby plugin;
+    private final Set<Material> dangerousBuckets = new HashSet<>();
+
+    public EnvironmentalListener(PreventStabby plugin) {
+        this.plugin = plugin;
+        dangerousBuckets.add(Material.LAVA_BUCKET);
+        dangerousBuckets.add(Material.PUFFERFISH_BUCKET);
+        dangerousBuckets.add(Material.POWDER_SNOW_BUCKET);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onDangerousBucketDump(PlayerBucketEmptyEvent event) {
+        ConfigCache config = plugin.getConfigCache();
+        if (!config.lava_and_fire_stopper_enabled) return;
+        if (!dangerousBuckets.contains(event.getBucket())) return;
+        Location location = event.getBlockClicked().getLocation();
+        Player placer = event.getPlayer();
+        double radius = config.lava_and_fire_stopper_radius;
+
+        BoundingBox boundingBox = BoundingBox.of(location.toVector(), radius, radius, radius);
+        for (Entity victim : location.getWorld().getNearbyEntities(boundingBox)) {
+            if (victim == placer) continue;
+            DamageCheckResult result = plugin.getPlayerManager().canDamage(placer, victim);
+            if (!result.ableToDamage()) {
+                event.setCancelled(true);
+                break;
+            }
+        }
+
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onBlockIgnite(BlockIgniteEvent event) {
+        ConfigCache config = plugin.getConfigCache();
+        if (!config.lava_and_fire_stopper_enabled) return;
+        Entity igniter = event.getIgnitingEntity();
+        if (igniter == null) return;
+        Target igniterTarget = Target.getTarget(igniter);
+        if (igniterTarget == null) return;
+        Location location = event.getBlock().getLocation();
+        double radius = config.lava_and_fire_stopper_radius;
+
+        BoundingBox boundingBox = BoundingBox.of(location.toVector(), radius, radius, radius);
+        for (Entity victim : location.getWorld().getNearbyEntities(boundingBox)) {
+            if (victim.getUniqueId() == igniterTarget.playerUuid) continue;
+            DamageCheckResult result = plugin.getPlayerManager().canDamage(igniterTarget.playerUuid, victim.getUniqueId(), igniterTarget.classifier);
+            if (!result.ableToDamage()) {
+                event.setCancelled(true);
+                break;
+            }
+        }
+    }
+
+}

src/main/java/me/youhavetrouble/preventstabby/listeners/PlayerDamageListener.java

@@ -1,32 +0,0 @@
-package me.youhavetrouble.preventstabby.listeners;
-
-import me.youhavetrouble.preventstabby.PreventStabby;
-import me.youhavetrouble.preventstabby.data.DamageCheckResult;
-import org.bukkit.entity.Entity;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-
-public class PlayerDamageListener implements Listener {
-
-    private final PreventStabby plugin;
-
-    public PlayerDamageListener(PreventStabby plugin) {
-        this.plugin = plugin;
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onEntityDamageEvent(EntityDamageByEntityEvent event) {
-        Entity attacker = event.getDamager();
-        Entity victim = event.getEntity();
-
-        DamageCheckResult result = plugin.getPlayerManager().canDamage(attacker, victim);
-        if (!result.ableToDamage()) {
-            event.setCancelled(true);
-        }
-        plugin.getPlayerManager().handleDamageCheck(result);
-
-    }
-
-}

src/main/java/me/youhavetrouble/preventstabby/listeners/PvpListener.java

@@ -0,0 +1,96 @@
+package me.youhavetrouble.preventstabby.listeners;
+
+import me.youhavetrouble.preventstabby.PreventStabby;
+import me.youhavetrouble.preventstabby.data.DamageCheckResult;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.AreaEffectCloudApplyEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.PotionSplashEvent;
+import org.bukkit.event.player.PlayerFishEvent;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+public class PvpListener implements Listener {
+
+    private final PreventStabby plugin;
+
+    public PvpListener(PreventStabby plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onEntityDamage(EntityDamageByEntityEvent event) {
+        Entity attacker = event.getDamager();
+        Entity victim = event.getEntity();
+
+        DamageCheckResult result = plugin.getPlayerManager().canDamage(attacker, victim);
+        if (!result.ableToDamage()) {
+            event.setCancelled(true);
+        }
+        plugin.getPlayerManager().handleDamageCheck(result);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPotionSplash(PotionSplashEvent event) {
+        if (!(event.getEntity().getShooter() instanceof Player thrower)) return;
+        boolean harmful = false;
+        for (PotionEffect effect : event.getPotion().getEffects()) {
+            if (!PotionEffectType.Category.HARMFUL.equals(effect.getType().getEffectCategory())) continue;
+            harmful = true;
+            break;
+        }
+        if (!harmful) return;
+        for (LivingEntity victim : event.getAffectedEntities()) {
+            if (thrower == victim) continue;
+            DamageCheckResult result = plugin.getPlayerManager().canDamage(thrower, victim);
+            if (!result.ableToDamage()) {
+                event.setIntensity(victim, 0);
+            }
+            plugin.getPlayerManager().handleDamageCheck(result);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPotionCloudEffectApply(AreaEffectCloudApplyEvent event) {
+        if (!(event.getEntity().getSource() instanceof Player thrower)) return;
+        boolean harmful = false;
+        for (PotionEffect effect : event.getEntity().getBasePotionType().getPotionEffects()) {
+            if (!PotionEffectType.Category.HARMFUL.equals(effect.getType().getEffectCategory())) continue;
+            harmful = true;
+            break;
+        }
+        if (!harmful) return;
+        event.getAffectedEntities().removeIf(victim -> {
+            if (thrower == victim) return false;
+            boolean shouldRemoveFromAffected = false;
+            DamageCheckResult result = plugin.getPlayerManager().canDamage(thrower, victim);
+            if (!result.ableToDamage()) {
+                shouldRemoveFromAffected = true;
+            }
+            plugin.getPlayerManager().handleDamageCheck(result);
+            return shouldRemoveFromAffected;
+        });
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onFish(PlayerFishEvent event) {
+        if (event.getCaught() instanceof Item) return;
+        if (plugin.getConfigCache().allow_fishing_rod_pull) return;
+        Player attacker = event.getPlayer();
+        Entity victim = event.getCaught();
+        if (victim == null) return;
+        if (attacker == victim) return;
+        DamageCheckResult result = plugin.getPlayerManager().canDamage(attacker, victim);
+        if (!result.ableToDamage()) {
+            event.setCancelled(true);
+        }
+        plugin.getPlayerManager().handleDamageCheck(result);
+    }
+
+}