improve verbosity of blocklimits

xGinko · xGinko · commit 3befe24b39c4 · 2025-10-12T02:31:36.000+02:00
diff --git a/AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/config/Translation.java b/AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/config/Translation.java
@@ -18,7 +18,9 @@ public class Translation {
     public final Component no_permission, invalid_syntax, failed_argument_parse, chat_commandwhitelist_badcommand,
             misc_joinMessage, misc_leaveMessage, misc_MaskedKickMessage,
             misc_enabledConnectionMsgs, misc_disabledConnectionMsgs, misc_enabledFirstJoinMsgs, misc_disabledFirstJoinMsgs,
-            preventions_witherSpawningDisabledInRadius,elytra_disablePacketElytraFly,
+            preventions_witherSpawningDisabledInRadius,
+            chunklimits_block_limit_exceeded,
+            elytra_disablePacketElytraFly,
             elytra_global_YouAreFlyingIn, elytra_global_New, elytra_global_New_UpperCase, elytra_global_Old,
             elytra_global_Old_UpperCase, elytra_global_Speed, elytra_global_DisabledLowTPS, elytra_global_TooFastLowTPS,
             elytra_global_TooFastChunkInfo, elytra_disable_timer, elytra_global_TooFast, elytra_global_DisabledHere,
@@ -81,12 +83,17 @@ public Translation(Locale locale) throws Exception {
                 List.of("<gray>%player% joined the game for the first time. They are %players_num% to join."));
         this.misc_MaskedKickMessage = getTranslation("kicks.masked-kick-message",
                 "<gold>Disconnected");
+
         // Lag Preventions
         this.lagpreventions_stopSpammingLevers = getTranslation("redstone.stop-spamming-levers",
                 "<red>Stop spamming levers.");
         // Disable Wither Spawning at Spawn
         this.preventions_witherSpawningDisabledInRadius = getTranslation("withers.disabled-at-spawn",
                 "<dark_red>Wither spawning is disabled in a radius of %radius% blocks around spawn.");
+
+        this.chunklimits_block_limit_exceeded = getTranslation("chunk-limits.block-limit.block-limit-reached",
+                "<dark_red>You can't place more %block% in this chunk. Existing: %existing% Limit: %limit%.");
+
         /*
             Elytra
         */
diff --git a/AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/modules/chunklimits/BlockLimit.java b/AnarchyExploitFixesFolia/src/main/java/me/xginko/aef/modules/chunklimits/BlockLimit.java
@@ -4,30 +4,40 @@
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import io.github.thatsmusic99.configurationmaster.api.ConfigSection;
+import me.xginko.aef.AnarchyExploitFixes;
 import me.xginko.aef.modules.AEFModule;
+import me.xginko.aef.utils.LocationUtil;
+import net.kyori.adventure.text.TextReplacementConfig;
 import org.bukkit.Chunk;
+import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.HandlerList;
 import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
 import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
+import org.jetbrains.annotations.NotNull;
 
 import java.time.Duration;
 import java.util.EnumMap;
 import java.util.Map;
+import java.util.Objects;
 import java.util.TreeMap;
 
 public class BlockLimit extends AEFModule implements Listener {
 
     private final Map<Material, Integer> blockLimits = new EnumMap<>(Material.class);
     private final long materialCountCacheMillis;
+    private final boolean notifyPlayer;
 
-    private Cache<Chunk, Cache<Material, Boolean>> chunkMaterialCache;
+    private Cache<@NotNull Chunk, Cache<@NotNull Material, Integer>> chunkMaterialCountCache;
 
     public BlockLimit() {
         super("chunk-limits.block-limit", false);
+        this.notifyPlayer = config.getBoolean(configPath + ".notify-player", true,
+                "Send a message to the player when they cant place a block due to chunk limit.");
         this.materialCountCacheMillis = config.getLong(configPath + ".material-count-cache-millis", 1000,
                 "Recommended to not go higher than 5000ms.");
 
@@ -135,14 +145,15 @@ public BlockLimit() {
             }
         }
 
-        ConfigSection section = config.getConfigSection(configPath + ".max-blocks-per-chunk", compatible,
+        ConfigSection limitsSection = config.getConfigSection(configPath + ".max-blocks-per-chunk", compatible,
                 "Attempt to prevent ChunkBan / Client FPS Lag");
-        for (String configuredMaterial : section.getKeys(false)) {
+        for (String configuredMaterial : limitsSection.getKeys(false)) {
+            String configuredMaxAmount = limitsSection.getString(configuredMaterial);
             try {
-                Material blockMaterial = Material.valueOf(configuredMaterial);
-                Integer maxAmountPerChunk = Integer.parseInt(section.getString(configuredMaterial));
-                this.blockLimits.put(blockMaterial, maxAmountPerChunk);
-            } catch (NumberFormatException e) {
+                this.blockLimits.put(
+                        Material.valueOf(configuredMaterial),
+                        Integer.parseInt(Objects.requireNonNull(configuredMaxAmount)));
+            } catch (NumberFormatException | NullPointerException e) {
                 notRecognized(Integer.class, configuredMaterial);
             } catch (IllegalArgumentException e) {
                 notRecognized(Material.class, configuredMaterial);
@@ -152,70 +163,149 @@ public BlockLimit() {
 
     @Override
     public void enable() {
-        chunkMaterialCache = Caffeine.newBuilder().expireAfterWrite(Duration.ofMinutes(1)).build();
+        chunkMaterialCountCache = Caffeine.newBuilder().expireAfterWrite(Duration.ofMinutes(1)).build();
         plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
     @Override
     public void disable() {
         HandlerList.unregisterAll(this);
-        if (chunkMaterialCache != null) {
-            for (Map.Entry<Chunk, Cache<Material, Boolean>> entry : chunkMaterialCache.asMap().entrySet()) {
+        if (chunkMaterialCountCache != null) {
+            for (Map.Entry<@NotNull Chunk, Cache<@NotNull Material, Integer>> entry : chunkMaterialCountCache.asMap().entrySet()) {
                 entry.getValue().invalidateAll();
                 entry.getValue().cleanUp();
             }
-            chunkMaterialCache.invalidateAll();
-            chunkMaterialCache.cleanUp();
-            chunkMaterialCache = null;
+            chunkMaterialCountCache.invalidateAll();
+            chunkMaterialCountCache.cleanUp();
+            chunkMaterialCountCache = null;
         }
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onBlockPlace(BlockPlaceEvent event) {
-        if (blockLimits.containsKey(event.getBlock().getType())
-                && exceedsPerChunkLimit(event.getBlock().getType(), event.getBlock().getChunk())) {
-            event.setCancelled(true);
+        if (!blockLimits.containsKey(event.getBlock().getType())) {
+            return;
         }
+
+        int materialCount = getMaterialCountForChunk(event.getBlock().getType(), event.getBlock().getChunk());
+        int limit = blockLimits.get(event.getBlock().getType());
+
+        if (materialCount <= limit) {
+            logger().debug("Player '{}' may place block {} at location {} => count={} limit={}",
+                    event.getPlayer().getName(),
+                    event.getBlock().getType(),
+                    LocationUtil.toString(event.getBlock().getLocation()),
+                    materialCount,
+                    limit);
+            return;
+        }
+
+        event.setCancelled(true);
+
+        if (notifyPlayer) event.getPlayer().sendMessage(
+                AnarchyExploitFixes.translation(event.getPlayer()).chunklimits_block_limit_exceeded
+                        .replaceText(TextReplacementConfig.builder()
+                                .matchLiteral("%block%")
+                                .replacement(event.getBlock().getType().name())
+                                .build())
+                        .replaceText(TextReplacementConfig.builder()
+                                .matchLiteral("%existing%")
+                                .replacement(Integer.toString(materialCount))
+                                .build())
+                        .replaceText(TextReplacementConfig.builder()
+                                .matchLiteral("%limit%")
+                                .replacement(Integer.toString(limit))
+                                .build()));
+
+        logger().info("Cancelled placement of {} for player '{}' at location {} => count={} limit={}",
+                event.getBlock().getType(),
+                event.getPlayer().getName(),
+                LocationUtil.toString(event.getBlock().getLocation()),
+                materialCount,
+                blockLimits.get(event.getBlock().getType()));
     }
 
+    @SuppressWarnings("deprecation")
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     private void onPlayerInteract(PlayerInteractEvent event) {
-        if (event.getAction().isLeftClick()) return;
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK || event.getClickedBlock() == null) return;
+
+        if (!blockLimits.containsKey(event.getMaterial())) {
+            return;
+        }
+
+        // Ignore interactions like for ex. players wanting to flick a lever
+        if (event.getMaterial().isInteractable() && !event.getPlayer().isSneaking()) {
+            return; // Let BlockPlaceEvent deal with this
+        }
+
+        Location placeLocation = event.getClickedBlock().getRelative(event.getBlockFace()).getLocation();
+        int materialCount = getMaterialCountForChunk(event.getMaterial(), placeLocation.getChunk());
+        int limit = blockLimits.get(event.getMaterial());
 
-        if (blockLimits.containsKey(event.getMaterial())
-                && exceedsPerChunkLimit(event.getMaterial(), event.getPlayer().getChunk())) {
-            event.setCancelled(true);
+        if (materialCount <= limit) {
+            logger().debug("Player '{}' may place block {} at location {} => count={} limit={}",
+                    event.getPlayer().getName(),
+                    event.getMaterial(),
+                    LocationUtil.toString(placeLocation),
+                    materialCount,
+                    limit);
+            return;
         }
+
+        event.setCancelled(true);
+
+        if (notifyPlayer) event.getPlayer().sendMessage(
+                AnarchyExploitFixes.translation(event.getPlayer()).chunklimits_block_limit_exceeded
+                        .replaceText(TextReplacementConfig.builder()
+                                .matchLiteral("%block%")
+                                .replacement(event.getMaterial().name())
+                                .build())
+                        .replaceText(TextReplacementConfig.builder()
+                                .matchLiteral("%existing%")
+                                .replacement(Integer.toString(materialCount))
+                                .build())
+                        .replaceText(TextReplacementConfig.builder()
+                                .matchLiteral("%limit%")
+                                .replacement(Integer.toString(limit))
+                                .build()));
+
+        logger().info("Cancelled placement of {} for player '{}' at location {} => count={} limit={}",
+                event.getMaterial(),
+                event.getPlayer().getName(),
+                LocationUtil.toString(placeLocation),
+                materialCount,
+                blockLimits.get(event.getMaterial()));
     }
 
-    private boolean exceedsPerChunkLimit(Material blockType, Chunk chunk) {
-        final int limit = blockLimits.get(blockType);
-        final int minY = chunk.getWorld().getMinHeight();
-        final int maxY = chunk.getWorld().getMaxHeight();
+    private int getMaterialCountForChunk(Material blockType, Chunk chunk) {
+        Cache<@NotNull Material, Integer> countCache = chunkMaterialCountCache.getIfPresent(chunk);
 
-        Cache<Material, Boolean> exceededCache = chunkMaterialCache.getIfPresent(chunk);
-        if (exceededCache == null) {
-            exceededCache = Caffeine.newBuilder().expireAfterWrite(Duration.ofMillis(materialCountCacheMillis)).build();
+        if (countCache == null) {
+            countCache = Caffeine.newBuilder().expireAfterWrite(Duration.ofMillis(materialCountCacheMillis)).build();
         }
 
-        Boolean exceeded = exceededCache.get(blockType, material -> {
+        Integer cachedMaterialCount = countCache.getIfPresent(blockType);
+
+        if (cachedMaterialCount == null) {
+            int minY = chunk.getWorld().getMinHeight();
+            int maxY = chunk.getWorld().getMaxHeight();
             int count = 0;
+
             for (int x = 0; x < 16; x++) {
                 for (int z = 0; z < 16; z++) {
                     for (int y = minY; y < maxY; y++) {
-                        if (chunk.getBlock(x, y, z).getType() == material) {
+                        if (chunk.getBlock(x, y, z).getType() == blockType) {
                             count++;
-                            if (count > limit) {
-                                return true;
-                            }
                         }
                     }
                 }
             }
-            return false;
-        });
 
-        chunkMaterialCache.put(chunk, exceededCache);
-        return exceeded;
+            cachedMaterialCount = count;
+            countCache.put(blockType, count);
+        }
+
+        return cachedMaterialCount;
     }
 }
diff --git a/AnarchyExploitFixesLegacy/src/main/java/me/xginko/aef/config/Translation.java b/AnarchyExploitFixesLegacy/src/main/java/me/xginko/aef/config/Translation.java
@@ -19,6 +19,7 @@ public class Translation {
     public final String no_permission, invalid_syntax, failed_argument_parse, chat_CommandWhitelist_BadCommand,
             misc_joinMessage, misc_leaveMessage, misc_MaskedKickMessage, withers_SpawningDisabledInRadius,
             misc_enabledConnectionMsgs, misc_disabledConnectionMsgs, misc_enabledFirstJoinMsgs, misc_disabledFirstJoinMsgs,
+            chunklimits_block_limit_exceeded,
             elytra_disablePacketElytraFly, elytra_global_YouAreFlyingIn, elytra_global_New, elytra_global_New_Color, elytra_global_Old,
             elytra_global_Old_Color, elytra_global_Speed, elytra_global_DisabledLowTPS, elytra_global_TooFastLowTPS,
             elytra_global_TooFastChunkInfo, elytra_global_TooFast, elytra_global_DisabledHere, elytra_global_Chunks,
@@ -81,6 +82,10 @@ public Translation(Locale locale) throws Exception {
                 Collections.singletonList("&6%player% joined the game for the first time. They are %players_num% to join."));
         this.misc_MaskedKickMessage = getTranslation("kicks.masked-kick-message",
                 "&6Disconnected");
+
+        this.chunklimits_block_limit_exceeded = getTranslation("chunk-limits.block-limit.block-limit-reached",
+                "&4You can't place more %block% in this chunk. Existing: %existing% Limit: %limit%.");
+
         // Withers
         this.withers_SpawningDisabledInRadius = getTranslation("withers.disabled-at-spawn",
                 "&4Wither spawning is disabled in a radius of %radius% blocks around spawn.");
diff --git a/AnarchyExploitFixesLegacy/src/main/java/me/xginko/aef/modules/chunklimits/BlockLimit.java b/AnarchyExploitFixesLegacy/src/main/java/me/xginko/aef/modules/chunklimits/BlockLimit.java
