support BlockCanBuildEvent using Reflection

Author: xGinko

AnarchyExploitFixesLegacy/src/main/java/me/xginko/aef/modules/chunklimits/BlockLimit.java

@@ -8,7 +8,9 @@
 import me.xginko.aef.modules.AEFModule;
 import me.xginko.aef.utils.LocationUtil;
 import me.xginko.aef.utils.WorldUtil;
+import me.xginko.aef.utils.models.Lazy;
 import me.xginko.aef.utils.permissions.AEFPermission;
+import me.xginko.aef.utils.reflection.ReflectionUtil;
 import org.bukkit.Chunk;
 import org.bukkit.Location;
 import org.bukkit.Material;
@@ -18,10 +20,13 @@
 import org.bukkit.event.HandlerList;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockCanBuildEvent;
 import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
+import java.lang.invoke.MethodHandle;
 import java.time.Duration;
 import java.util.EnumMap;
 import java.util.Map;
@@ -185,12 +190,45 @@ public void disable() {
         }
     }
 
-    private void sendPlayerNotification(Player player, Material block, int existing, int limit) {
-        if (notifyPlayer) player.sendMessage(
-                AnarchyExploitFixes.translation(player.getLocale()).chunklimits_block_limit_exceeded
-                        .replace("%block%", block.name())
-                        .replace("%existing%", Integer.toString(existing))
-                        .replace("%limit%", Integer.toString(limit)));
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    private void onBlockCanBuild(BlockCanBuildEvent event) {
+        if (!event.isBuildable() || !blockLimits.containsKey(event.getMaterial())) {
+            return;
+        }
+
+        Player player = getPlayer(event);
+        if (player == null) return;
+
+        if (AnarchyExploitFixes.permissions().permissionValue(player, AEFPermission.BYPASS_CHUNK_LIMITS_BLOCK_LIMIT.node()).toBoolean()) {
+            logger().debug("Ignoring {} for player '{}' because they have bypass permission: {}",
+                    event.getEventName(),
+                    player.getName(),
+                    AEFPermission.BYPASS_CHUNK_LIMITS_BLOCK_LIMIT.node());
+            return;
+        }
+
+        int materialCount = getMaterialCountForChunk(event.getBlock().getType(), event.getBlock().getChunk());
+        int limit = blockLimits.get(event.getMaterial());
+
+        if (materialCount <= limit) {
+            logger().debug("Allowing player '{}' to place {} at location {} => count={} limit={}",
+                    player.getName(),
+                    event.getMaterial(),
+                    LocationUtil.toString(event.getBlock().getLocation()),
+                    materialCount,
+                    limit);
+            return;
+        }
+
+        event.setBuildable(false);
+
+        sendPlayerNotification(player, event.getMaterial(), materialCount, limit);
+        logger().info("Preventing player '{}' from placing {} at location {} => count={} limit={}",
+                player.getName(),
+                event.getBlock().getType(),
+                LocationUtil.toString(event.getBlock().getLocation()),
+                materialCount,
+                limit);
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
@@ -302,4 +340,32 @@ private int getMaterialCountForChunk(Material blockType, Chunk chunk) {
 
         return cachedMaterialCount;
     }
+
+    private void sendPlayerNotification(Player player, Material block, int existing, int limit) {
+        if (notifyPlayer) player.sendMessage(
+                AnarchyExploitFixes.translation(player.getLocale()).chunklimits_block_limit_exceeded
+                        .replace("%block%", block.name())
+                        .replace("%existing%", Integer.toString(existing))
+                        .replace("%limit%", Integer.toString(limit)));
+    }
+
+    private @Nullable Player getPlayer(@NotNull BlockCanBuildEvent event) {
+        if (BLOCK_CAN_BUILD_PLAYER_FIELD.get() == null) {
+            return null;
+        }
+
+        try {
+            return (Player) BLOCK_CAN_BUILD_PLAYER_FIELD.get().invoke(event);
+        } catch (Throwable t) {
+            return null;
+        }
+    }
+
+    private static final Lazy<@Nullable MethodHandle> BLOCK_CAN_BUILD_PLAYER_FIELD = Lazy.of(() -> {
+        try {
+            return ReflectionUtil.findMethod(BlockCanBuildEvent.class, "getPlayer", Player.class);
+        } catch (Throwable t) {
+            return null;
+        }
+    });
 }