implement typed limits in regional activity

Author: xGinko

AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/modules/lagpreventions/regionalactivity/BlockFormOrGrow.java

@@ -1,24 +1,28 @@
 package me.xginko.aef.modules.lagpreventions.regionalactivity;
 
+import com.cryptomorin.xseries.XMaterial;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.block.BlockFormEvent;
 import org.bukkit.event.block.BlockSpreadEvent;
 
-public class BlockFormOrGrow extends RegionalActivityModule {
+import java.util.Map;
 
-    private final int limit;
+public class BlockFormOrGrow extends RegionalBlockActivityModule {
 
     public BlockFormOrGrow() {
         super(
                 "block-spread",
                 false,
                 true,
+                2000,
                 1500.0,
                 6000,
                 10000,
                 10.0,
                 120.0,
+                Map.of( XMaterial.ICE, 1000,
+                        XMaterial.SNOW, 1000),
                 """
                 Limits blocks spreading or forming based on world conditions within a\s
                 configurable radius and timeframe to help reduce lag by cancelling burst\s
@@ -33,21 +37,18 @@ public BlockFormOrGrow() {
                 - Mushrooms spreading.\s
                 - Fire spreading."""
         );
-        this.limit = config.getInt(configPath + ".block-form-event-limit", 800,
-                "Maximum number of times a block can form or spread within the configured\n" +
-                        "timeframe before activity will be put on cooldown.");
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onBlockForm(BlockFormEvent event) {
-        if (shouldCancelActivity(event, event.getBlock().getLocation(), limit)) {
+        if (shouldCancelBlockEvent(event)) {
             event.setCancelled(true);
         }
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onBlockSpread(BlockSpreadEvent event) {
-        if (shouldCancelActivity(event, event.getBlock().getLocation(), limit)) {
+        if (shouldCancelBlockEvent(event)) {
             event.setCancelled(true);
         }
     }

AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/modules/lagpreventions/regionalactivity/BlockPhysics.java

@@ -1,23 +1,27 @@
 package me.xginko.aef.modules.lagpreventions.regionalactivity;
 
+import com.cryptomorin.xseries.XMaterial;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.block.BlockPhysicsEvent;
 
-public class BlockPhysics extends RegionalActivityModule {
+import java.util.Map;
 
-    private final int limit;
+public class BlockPhysics extends RegionalBlockActivityModule {
 
     public BlockPhysics() {
         super(
                 "block-physics",
                 false,
                 true,
+                512000,
                 1500.0,
                 18000,
                 20000,
                 10.0,
                 120.0,
+                Map.of( XMaterial.WATER, 256000,
+                        XMaterial.LAVA, 256000),
                 """
                 Limits block physics within a configurable radius and timeframe\s
                 to help reduce lag by cancelling burst activity hotspots.\s
@@ -31,14 +35,11 @@ The event used for this check (BlockPhysicsEvent) is a high frequency event,\s
                 Physics updates that cause other blocks to change their state may not result\s
                 in an event for each of those blocks (usually adjacent)."""
         );
-        this.limit = config.getInt(configPath + ".block-physics-event-limit", 256000,
-                "Maximum number of times a physics check can be performed within the configured\n" +
-                        "timeframe before they will be put on cooldown.");
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onBlockPhysics(BlockPhysicsEvent event) {
-        if (shouldCancelActivity(event, event.getBlock().getLocation(), limit)) {
+        if (shouldCancelBlockEvent(event)) {
             event.setCancelled(true);
         }
     }

AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/modules/lagpreventions/regionalactivity/EntitySpawns.java

@@ -1,23 +1,27 @@
 package me.xginko.aef.modules.lagpreventions.regionalactivity;
 
+import com.cryptomorin.xseries.XEntityType;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.entity.EntitySpawnEvent;
 
-public class EntitySpawns extends RegionalActivityModule {
+import java.util.Map;
 
-    private final int limit;
+public class EntitySpawns extends RegionalEntityActivityModule {
 
     public EntitySpawns() {
         super(
                 "entity-spawn",
                 false,
                 true,
+                6000,
                 1500.0,
                 18000,
                 20000,
                 10.0,
                 120.0,
+                Map.of( XEntityType.WITHER, 50,
+                        XEntityType.WITHER_SKULL, 200),
                 """
                 Limits entity spawning activity within a configurable radius and timeframe\s
                 to help reduce lag by cancelling high activity hotspots.\s
@@ -28,13 +32,11 @@ public EntitySpawns() {
                 - An entity gets spawned naturally, by spawner or other reasons.\s
                 This does not include tile entities."""
         );
-        this.limit = config.getInt(configPath + ".spawn-event-limit", 6000,
-                "Maximum number of entity spawns within configured timeframe.");
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onEntitySpawn(EntitySpawnEvent event) {
-        if (shouldCancelActivity(event, event.getLocation(), limit)) {
+        if (shouldCancelEntityEvent(event)) {
             event.setCancelled(true);
         }
     }

AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/modules/lagpreventions/regionalactivity/EntityTargeting.java

@@ -3,42 +3,37 @@
 import com.cryptomorin.xseries.XEntityType;
 import io.github.thatsmusic99.configurationmaster.api.ConfigSection;
 import me.xginko.aef.utils.LocationUtil;
-import org.bukkit.Location;
-import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
 import org.bukkit.event.entity.EntityTargetEvent;
 import org.bukkit.util.NumberConversions;
 
 import java.util.EnumMap;
 import java.util.Map;
 import java.util.TreeMap;
 
-public class EntityTargeting extends RegionalActivityModule implements Listener {
+public class EntityTargeting extends RegionalEntityActivityModule {
 
-    private final Map<EntityType, Double> limitedTypes = new EnumMap<>(EntityType.class);
+    private final Map<EntityType, Double> typedDistanceLimits = new EnumMap<>(EntityType.class);
     private final double globalMaxDistanceSquared;
-    private final int limit;
     private final boolean globalDistanceEnabled, perTypeDistanceEnabled;
 
     public EntityTargeting() {
         super("entity-targeting",
                 false,
                 true,
+                8000,
                 1500.0,
                 18000,
                 20000,
                 14.0,
                 120.0,
+                Map.of(XEntityType.VILLAGER, 1000),
                 """
                 Limits entities targeting other entities within a configurable radius\s
                 and timeframe to help reduce lag by cancelling burst activity hotspots."""
         );
-        this.limit = config.getInt(configPath + ".entity-target-event-limit", 8000, """
-                Maximum number of times an entity can target another entity within the\s
-                configured timeframe before the area will be put on cooldown.""");
 
         this.globalDistanceEnabled = config.getBoolean(configPath + ".distance-limit.global-limit.enable", false);
         this.globalMaxDistanceSquared = NumberConversions.square(
@@ -66,7 +61,7 @@ public EntityTargeting() {
             try {
                 Double maxDistanceSquared = NumberConversions.square(Double.parseDouble(section.getString(configuredEntity)));
                 EntityType limitedEntity = EntityType.valueOf(configuredEntity);
-                this.limitedTypes.put(limitedEntity, maxDistanceSquared);
+                this.typedDistanceLimits.put(limitedEntity, maxDistanceSquared);
             } catch (NumberFormatException e) {
                 notRecognized(Double.class, configuredEntity);
             } catch (IllegalArgumentException e) {
@@ -77,11 +72,9 @@ public EntityTargeting() {
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onEntityTarget(EntityTargetEvent event) {
-        Entity targetEntity = event.getTarget();
-        if (targetEntity == null) return; // If entity un-targets an entity, it's good for us.
+        if (event.getTarget() == null) return; // If entity un-targets an entity, it's good for us.
 
-        Location location = event.getEntity().getLocation();
-        if (shouldCancelActivity(event, location, limit)) {
+        if (shouldCancelEntityEvent(event)) {
             event.setCancelled(true);
             return;
         }
@@ -92,7 +85,7 @@ private void onEntityTarget(EntityTargetEvent event) {
 
         double targetDistanceSquared;
         try {
-            targetDistanceSquared = event.getEntity().getLocation().distanceSquared(targetEntity.getLocation());
+            targetDistanceSquared = event.getEntity().getLocation().distanceSquared(event.getTarget().getLocation());
         } catch (IllegalArgumentException e) {
             if (logIsEnabled) error("Unable to measure distance between entity and target.", e);
             return;
@@ -103,18 +96,18 @@ private void onEntityTarget(EntityTargetEvent event) {
                 event.setCancelled(true);
                 event.setTarget(null);
                 if (logIsEnabled) info("Cancelled target acquire for entity " + event.getEntityType().name() + " at " +
-                        LocationUtil.toString(location) +
+                        LocationUtil.toString(event.getEntity().getLocation()) +
                         " because target is further than the global limit. Distance: " + Math.sqrt(targetDistanceSquared));
                 return;
             }
         }
 
         if (perTypeDistanceEnabled) {
-            if (limitedTypes.containsKey(event.getEntityType()) && targetDistanceSquared > limitedTypes.get(event.getEntityType())) {
+            if (typedDistanceLimits.containsKey(event.getEntityType()) && targetDistanceSquared > typedDistanceLimits.get(event.getEntityType())) {
                 event.setCancelled(true);
                 event.setTarget(null);
                 if (logIsEnabled) info("Cancelled target acquire for entity " + event.getEntityType().name() + " at " +
-                        LocationUtil.toString(location) +
+                        LocationUtil.toString(event.getEntity().getLocation()) +
                         " because target further than its configured limit. Distance: " + Math.sqrt(targetDistanceSquared));
             }
         }

AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/modules/lagpreventions/regionalactivity/Explosions.java

@@ -8,13 +8,12 @@
 
 public class Explosions extends RegionalActivityModule {
 
-    private final int limit;
-
     public Explosions() {
         super(
                 "explosions",
                 false,
                 true,
+                1000,
                 1500.0,
                 6000,
                 10000,
@@ -30,28 +29,25 @@ public Explosions() {
                 - An entity exploding.\s
                 - An entity making the decision to explode."""
         );
-        this.limit = config.getInt(configPath + ".explode-event-limit", 500,
-                "Maximum number of explode events within the configured timeframe\n" +
-                        "before the region will be put on cooldown.");
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onExplosionPrime(ExplosionPrimeEvent event) {
-        if (shouldCancelActivity(event, event.getEntity().getLocation(), limit)) {
+        if (shouldCancelEvent(event, event.getEntity().getLocation())) {
             event.setCancelled(true);
         }
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onEntityExplode(EntityExplodeEvent event) {
-        if (shouldCancelActivity(event, event.getLocation(), limit)) {
+        if (shouldCancelEvent(event, event.getEntity().getLocation())) {
             event.setCancelled(true);
         }
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onBlockExplode(BlockExplodeEvent event) {
-        if (shouldCancelActivity(event, event.getBlock().getLocation(), limit)) {
+        if (shouldCancelEvent(event, event.getBlock().getLocation())) {
             event.setCancelled(true);
         }
     }

AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/modules/lagpreventions/regionalactivity/LiquidSpread.java

@@ -5,21 +5,23 @@
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.block.BlockFromToEvent;
 
-public class LiquidSpread extends RegionalActivityModule {
+import java.util.Map;
 
-    private final int limit;
-    private final boolean ignoreDragonEgg;
+public class LiquidSpread extends RegionalBlockActivityModule {
 
     public LiquidSpread() {
         super(
                 "liquid-spread",
                 false,
                 true,
+                16000,
                 1500.0,
                 18000,
                 20000,
                 12.0,
                 100.0,
+                Map.of( XMaterial.WATER, 4000,
+                        XMaterial.LAVA, 6000),
                 """
                 Limits liquid spreading within a configurable radius and timeframe\s
                 to help reduce lag by cancelling high activity hotspots.\s
@@ -28,19 +30,13 @@ public LiquidSpread() {
                 \s
                 - A lava block spreading by flowing.\s
                 - A water block spreading by flowing.\s
-                - (optional) A dragon egg is teleporting from one position to another."""
+                - A dragon egg is teleporting from one position to another."""
         );
-        this.limit = config.getInt(configPath + ".liquid-spread-event-limit", 2400,
-                "Maximum number of times liquids are allowed to spread within the configured\n" +
-                        "timeframe before they will be put on cooldown.");
-        this.ignoreDragonEgg = config.getBoolean(configPath + ".ignore-dragon-egg", true);
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onBlockFromTo(BlockFromToEvent event) {
-        if (ignoreDragonEgg && event.getBlock().getType() == XMaterial.DRAGON_EGG.get()) return;
-
-        if (shouldCancelActivity(event, event.getBlock().getLocation(), limit)) {
+        if (shouldCancelBlockEvent(event)) {
             event.setCancelled(true);
         }
     }