Add option to count stackable plants as a single plant

New config option stacked-plants-count-as-one (default false, current
behaviour). When enabled, a column of SUGAR_CANE or BAMBOO counts as one
plant toward the limit no matter how tall it grows: segments sitting on
the same plant are not counted at placement or growth, the break cascade
does not decrement stems, and the recount applies the same rule so live
counts and recounts agree. BAMBOO_SAPLING normalises to BAMBOO so a stem
above a sapling still reads as the same plant.

Fixes #53

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 stackedPlantsCountAsOne;
     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);
+        // Count a stackable plant column (sugar cane, bamboo) as a single plant
+        stackedPlantsCountAsOne = addon.getConfig().getBoolean("stacked-plants-count-as-one", false);
 
         addon.log("Entity limits:");
         envLimits.forEach((env, m) -> m.entrySet().stream()
@@ -258,6 +261,14 @@ public boolean isAsyncGolums() {
         return asyncGolums;
     }
 
+    /**
+     * @return true if a column of stackable plants (sugar cane, bamboo) counts as one
+     *         plant; false if every segment counts (default)
+     */
+    public boolean isStackedPlantsCountAsOne() {
+        return stackedPlantsCountAsOne;
+    }
+
     public Map<GeneralGroup, Integer> getGeneral() {
         return general;
     }

src/main/java/world/bentobox/limits/calculators/RecountCalculator.java

@@ -160,13 +160,20 @@ private void scanAsync(Environment env, Chunk chunk) {
     }
 
     private void scanColumn(Environment env, ChunkSnapshot chunkSnapshot, int x, int z, int minY, int maxY) {
+        boolean stackedAsOne = addon.getSettings().isStackedPlantsCountAsOne();
+        NamespacedKey below = null;
         for (int y = minY; y < maxY; y++) {
             BlockData blockData = chunkSnapshot.getBlockData(x, y, z);
             if (Tag.SLABS.isTagged(blockData.getMaterial())
                     && ((Slab) blockData).getType().equals(Slab.Type.DOUBLE)) {
                 checkBlock(env, blockData);
             }
-            checkBlock(env, blockData);
+            NamespacedKey key = bll.fixMaterial(blockData);
+            // Stacked-plants-as-one: segments sitting on the same plant are not counted
+            if (!(stackedAsOne && BlockLimitsListener.STACKABLE.contains(key) && key.equals(below))) {
+                checkBlock(env, blockData);
+            }
+            below = key;
         }
     }
 

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

@@ -65,7 +65,8 @@ public class BlockLimitsListener implements Listener {
     private static final List<NamespacedKey> DO_NOT_COUNT = List.of(Material.LAVA.getKey(), Material.WATER.getKey(),
             Material.AIR.getKey(), Material.FIRE.getKey(), Material.END_PORTAL.getKey(),
             Material.NETHER_PORTAL.getKey());
-    private static final List<NamespacedKey> STACKABLE = List.of(Material.SUGAR_CANE.getKey(), Material.BAMBOO.getKey());
+    /** Plants that grow as a vertical column on top of themselves. */
+    public static final List<NamespacedKey> STACKABLE = List.of(Material.SUGAR_CANE.getKey(), Material.BAMBOO.getKey());
 
     /*
      * Materials added in Minecraft 1.21.9 ("Copper Age"). Resolved by name so the
@@ -269,7 +270,9 @@ private void handleBreak(Block b) {
             return;
         }
         Material mat = b.getType();
-        if (STACKABLE.contains(b.getType().getKey())) {
+        // When stacked plants count as one, only the base segment was ever counted,
+        // so the stems above must not be decremented here.
+        if (!addon.getSettings().isStackedPlantsCountAsOne() && STACKABLE.contains(b.getType().getKey())) {
             Block block = b;
             while (block.getRelative(BlockFace.UP).getType().equals(mat)
                     && block.getY() < b.getWorld().getMaxHeight()) {
@@ -405,6 +408,11 @@ public void onBlock(BlockFromToEvent e) {
         }
     }
 
+    /** True if the given material normalises to the same stackable plant key. */
+    private static boolean isSamePlant(Material below, NamespacedKey plantKey) {
+        return VARIANT_MAP.getOrDefault(below, below).getKey().equals(plantKey);
+    }
+
     /**
      * Map variant materials to their canonical form.
      */
@@ -430,6 +438,12 @@ private int process(Block b, BlockData blockData, boolean add) {
         if (DO_NOT_COUNT.contains(fixMaterial(blockData)) || !addon.inGameModeWorld(b.getWorld())) {
             return -1;
         }
+        // Stacked-plants-as-one: a segment sitting on the same plant is not counted,
+        // limited, or decremented — only the base segment represents the plant.
+        if (addon.getSettings().isStackedPlantsCountAsOne() && STACKABLE.contains(fixMaterial(blockData))
+                && isSamePlant(b.getRelative(BlockFace.DOWN).getType(), fixMaterial(blockData))) {
+            return -1;
+        }
         Environment env = envOf(b.getWorld());
         return addon.getIslands().getIslandAt(b.getLocation()).map(i -> {
             String id = i.getUniqueId();

src/main/resources/config.yml

@@ -42,6 +42,12 @@ async-golums: true
 blocklimits:
   HOPPER: 10
 
+# Count stackable plants (SUGAR_CANE, BAMBOO) as a single plant no matter how tall
+# they grow. When false (default), every segment of the plant counts toward the limit.
+# Run a recount (/<gamemode> limits recount) after changing this so stored counts
+# match the new counting rule.
+stacked-plants-count-as-one: false
+
 # Override block limits in the nether for this game mode.
 # Uncomment and add entries to set nether-only limits.
 #blocklimits-nether:

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

@@ -103,6 +103,18 @@ void testAsyncGolumsDefaultsTrue() {
         assertTrue(settings.isAsyncGolums());
     }
 
+    @Test
+    void testStackedPlantsCountAsOneDefaultsFalse() {
+        assertFalse(settings.isStackedPlantsCountAsOne());
+    }
+
+    @Test
+    void testStackedPlantsCountAsOneEnabled() {
+        config.set("stacked-plants-count-as-one", true);
+        Settings s = new Settings(addon);
+        assertTrue(s.isStackedPlantsCountAsOne());
+    }
+
     @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);
+        // Limits settings: stacked-plants-count-as-one defaults to false (mock default)
+        when(addon.getSettings()).thenReturn(limitsSettings);
         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);
@@ -919,6 +924,61 @@ void testEntityChangeBlockFarmlandRemovesCropAbove() {
         assertEquals(1, ibc.getBlockCount(Material.DIRT.getKey()));
     }
 
+    // --- Stacked plants count as one (#53) ---
+
+    @Test
+    void testStackedPlantSegmentNotCountedWhenEnabled() {
+        when(limitsSettings.isStackedPlantsCountAsOne()).thenReturn(true);
+        Block below = mockBlock(Material.SUGAR_CANE, new Location(world, 100, 64, 100));
+        Block block = mockBlock(Material.SUGAR_CANE, blockLocation);
+        when(block.getRelative(BlockFace.DOWN)).thenReturn(below);
+
+        BlockState replacedState = mock(BlockState.class);
+        BlockPlaceEvent event = new BlockPlaceEvent(block, replacedState, block,
+                new ItemStack(Material.SUGAR_CANE), player, true, EquipmentSlot.HAND);
+        listener.onBlock(event);
+
+        assertFalse(event.isCancelled());
+        IslandBlockCount ibc = listener.getIsland("test-island-id");
+        assertTrue(ibc == null || ibc.getBlockCount(Material.SUGAR_CANE.getKey()) == 0);
+    }
+
+    @Test
+    void testStackedPlantBaseCountedWhenEnabled() {
+        when(limitsSettings.isStackedPlantsCountAsOne()).thenReturn(true);
+        Block block = mockBlock(Material.SUGAR_CANE, blockLocation);
+        // Below is AIR from the mockBlock helper — this is the base segment
+
+        BlockState replacedState = mock(BlockState.class);
+        BlockPlaceEvent event = new BlockPlaceEvent(block, replacedState, block,
+                new ItemStack(Material.SUGAR_CANE), player, true, EquipmentSlot.HAND);
+        listener.onBlock(event);
+
+        assertEquals(1, listener.getIsland("test-island-id").getBlockCount(Material.SUGAR_CANE.getKey()));
+    }
+
+    @Test
+    void testStackedPlantBreakBaseDecrementsOnlyOneWhenEnabled() {
+        when(limitsSettings.isStackedPlantsCountAsOne()).thenReturn(true);
+        // Only the base was ever counted
+        IslandBlockCount ibc = new IslandBlockCount("test-island-id", "BSkyBlock");
+        ibc.add(Environment.NORMAL, Material.SUGAR_CANE.getKey());
+        listener.setIsland("test-island-id", ibc);
+
+        when(world.getMaxHeight()).thenReturn(320);
+        Block bottomBlock = mockBlock(Material.SUGAR_CANE, new Location(world, 100, 65, 100));
+        when(bottomBlock.getY()).thenReturn(65);
+        Block midBlock = mockBlock(Material.SUGAR_CANE, new Location(world, 100, 66, 100));
+        when(midBlock.getY()).thenReturn(66);
+        when(bottomBlock.getRelative(BlockFace.UP)).thenReturn(midBlock);
+
+        BlockBreakEvent event = new BlockBreakEvent(bottomBlock, player);
+        listener.onBlock(event);
+
+        // Exactly the one counted base is removed; the stem walk must not run
+        assertEquals(0, listener.getIsland("test-island-id").getBlockCount(Material.SUGAR_CANE.getKey()));
+    }
+
     // --- Block cascade tests ---
 
     @Test