Add show-limit-messages config option to silence limit notifications

New option (default true, current behaviour). When false, block placements
and entity spawns over the limit are still blocked but no hit-limit message
is sent to players. Guards all four notification sites: block hit-limit,
hanging place, entity limit notify, and the spawn tellPlayers broadcast.

Fixes #65

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015dbJyrv2uxHfTmiWkqGUJB

Author: tastybento

src/main/java/world/bentobox/limits/Settings.java

@@ -49,6 +49,7 @@ enum GeneralGroup {
     private final List<String> gameModes;
     private final boolean logLimitsOnJoin;
     private final boolean asyncGolums;
+    private final boolean showLimitMessages;
     private static final List<EntityType> DISALLOWED = Arrays.asList(
             EntityType.TNT,
             EntityType.EVOKER_FANGS,
@@ -95,6 +96,8 @@ public Settings(Limits addon) {
         logLimitsOnJoin = addon.getConfig().getBoolean("log-limits-on-join", true);
         // Async Golums
         asyncGolums = addon.getConfig().getBoolean("async-golums", true);
+        // Show or suppress the "hit the limit" player notifications
+        showLimitMessages = addon.getConfig().getBoolean("show-limit-messages", true);
 
         addon.log("Entity limits:");
         envLimits.forEach((env, m) -> m.entrySet().stream()
@@ -258,6 +261,13 @@ public boolean isAsyncGolums() {
         return asyncGolums;
     }
 
+    /**
+     * @return true if players should be told when they hit a limit; false to limit silently
+     */
+    public boolean isShowLimitMessages() {
+        return showLimitMessages;
+    }
+
     public Map<GeneralGroup, Integer> getGeneral() {
         return general;
     }

src/main/java/world/bentobox/limits/listeners/BlockLimitsListener.java

@@ -305,9 +305,11 @@ public void onBlock(BlockMultiPlaceEvent e) {
 
     private void notify(Cancellable e, User user, int limit, Material m) {
         if (limit > -1) {
-            user.notify("block-limits.hit-limit",
-                    "[material]", Util.prettifyText(m.toString()),
-                    TextVariables.NUMBER, String.valueOf(limit));
+            if (addon.getSettings().isShowLimitMessages()) {
+                user.notify("block-limits.hit-limit",
+                        "[material]", Util.prettifyText(m.toString()),
+                        TextVariables.NUMBER, String.valueOf(limit));
+            }
             e.setCancelled(true);
         }
     }

src/main/java/world/bentobox/limits/listeners/EntityLimitListener.java

@@ -148,6 +148,9 @@ public void onBlock(HangingPlaceEvent hangingPlaceEvent) {
             AtLimitResult res = atLimit(island, hangingPlaceEvent.getEntity());
             if (res.hit()) {
                 hangingPlaceEvent.setCancelled(true);
+                if (!addon.getSettings().isShowLimitMessages()) {
+                    return;
+                }
                 if (res.getTypelimit() != null) {
                     User.getInstance(player).notify("block-limits.hit-limit", "[material]",
                             Util.prettifyText(hangingPlaceEvent.getEntity().getType().toString()),
@@ -229,6 +232,9 @@ private EntityType spawnEggType(ItemStack item) {
     }
 
     private void notifyEntityLimit(Player player, EntityType type, AtLimitResult res) {
+        if (!addon.getSettings().isShowLimitMessages()) {
+            return;
+        }
         if (res.getTypelimit() != null) {
             User.getInstance(player).notify(ENTITY_LIMIT_HIT, ENTITY_PLACEHOLDER,
                     Util.prettifyText(type.toString()), TextVariables.NUMBER,
@@ -548,6 +554,9 @@ private boolean isWither(Block block) {
     }
 
     private void tellPlayers(Location location, Entity entity, SpawnReason spawnReason, AtLimitResult res) {
+        if (!addon.getSettings().isShowLimitMessages()) {
+            return;
+        }
         if (spawnReason.equals(SpawnReason.SPAWNER) || spawnReason.equals(SpawnReason.NATURAL)
                 || spawnReason.equals(SpawnReason.INFECTION) || spawnReason.equals(SpawnReason.NETHER_PORTAL)
                 || spawnReason.equals(SpawnReason.REINFORCEMENTS) || spawnReason.equals(SpawnReason.SLIME_SPLIT)) {

src/main/resources/config.yml

@@ -30,6 +30,10 @@ log-limits-on-join: true
 # Use async checks for snowmen and iron golums. Set to false if you see problems.
 async-golums: true
 
+# Show players a message when they hit a limit. Set to false to enforce limits
+# silently - placements and spawns are still blocked, but no message is sent.
+show-limit-messages: true
+
 # General block limiting
 # Use this section to limit how many blocks can be added to an island.
 # 0 means the item will be blocked from placement completely.

src/test/java/world/bentobox/limits/SettingsTest.java

@@ -103,6 +103,18 @@ void testAsyncGolumsDefaultsTrue() {
         assertTrue(settings.isAsyncGolums());
     }
 
+    @Test
+    void testShowLimitMessagesDefaultsTrue() {
+        assertTrue(settings.isShowLimitMessages());
+    }
+
+    @Test
+    void testShowLimitMessagesDisabled() {
+        config.set("show-limit-messages", false);
+        Settings s = new Settings(addon);
+        assertFalse(s.isShowLimitMessages());
+    }
+
     @Test
     void testGetGeneralEmpty() {
         // Default config.yml does not have ANIMALS or MOBS entries in entitylimits

src/test/java/world/bentobox/limits/listeners/BlockLimitsListenerTest.java

@@ -91,6 +91,9 @@ class BlockLimitsListenerTest {
     @Mock
     private Limits addon;
 
+    @Mock
+    private world.bentobox.limits.Settings limitsSettings;
+
     @Mock
     private World world;
 
@@ -135,6 +138,8 @@ void setUp() throws Exception {
         doAnswer(invocation -> null).when(addon).log(anyString());
         doAnswer(invocation -> null).when(addon).logError(anyString());
         when(addon.isCoveredGameMode(anyString())).thenReturn(true);
+        when(addon.getSettings()).thenReturn(limitsSettings);
+        when(limitsSettings.isShowLimitMessages()).thenReturn(true);
         when(addon.inGameModeWorld(any(World.class))).thenReturn(false);
         // Override to true for our test world so event handlers don't bail early
         when(addon.inGameModeWorld(world)).thenReturn(true);
@@ -403,6 +408,48 @@ void testBlockPlaceAtLimitCancelsEvent() {
         assertTrue(event.isCancelled());
     }
 
+    @Test
+    void testBlockPlaceAtLimitNotifiesWhenMessagesEnabled() {
+        IslandBlockCount ibc = new IslandBlockCount("test-island-id", "BSkyBlock");
+        for (int i = 0; i < 10; i++) {
+            ibc.add(Environment.NORMAL, Material.HOPPER.getKey());
+        }
+        listener.setIsland("test-island-id", ibc);
+        Notifier notifier = mock(Notifier.class);
+        when(plugin.getNotifier()).thenReturn(notifier);
+
+        Block block = mockBlock(Material.HOPPER, blockLocation);
+        BlockState replacedState = mock(BlockState.class);
+        BlockPlaceEvent event = new BlockPlaceEvent(block, replacedState, block, new ItemStack(Material.HOPPER), player, true, EquipmentSlot.HAND);
+
+        listener.onBlock(event);
+
+        assertTrue(event.isCancelled());
+        verify(notifier).notify(any(), anyString());
+    }
+
+    @Test
+    void testBlockPlaceAtLimitSilentWhenMessagesDisabled() {
+        when(limitsSettings.isShowLimitMessages()).thenReturn(false);
+        IslandBlockCount ibc = new IslandBlockCount("test-island-id", "BSkyBlock");
+        for (int i = 0; i < 10; i++) {
+            ibc.add(Environment.NORMAL, Material.HOPPER.getKey());
+        }
+        listener.setIsland("test-island-id", ibc);
+        Notifier notifier = mock(Notifier.class);
+        when(plugin.getNotifier()).thenReturn(notifier);
+
+        Block block = mockBlock(Material.HOPPER, blockLocation);
+        BlockState replacedState = mock(BlockState.class);
+        BlockPlaceEvent event = new BlockPlaceEvent(block, replacedState, block, new ItemStack(Material.HOPPER), player, true, EquipmentSlot.HAND);
+
+        listener.onBlock(event);
+
+        // Still enforced, just silent
+        assertTrue(event.isCancelled());
+        verify(notifier, never()).notify(any(), anyString());
+    }
+
     @Test
     void testBlockPlaceUnlimitedMaterialAllowed() {
         Block block = mockBlock(Material.DIRT, blockLocation);