Implement support for different spawner types

Author: tastybento

pom.xml

@@ -50,12 +50,12 @@
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-        <java.version>17</java.version>
+        <java.version>21</java.version>
         <!-- Non-minecraft related dependencies -->
         <powermock.version>2.0.9</powermock.version>
         <!-- More visible way how to change dependency versions -->
         <spigot.version>1.21.3-R0.1-SNAPSHOT</spigot.version>
-        <bentobox.version>2.7.1-SNAPSHOT</bentobox.version>
+        <bentobox.version>3.2.4-SNAPSHOT</bentobox.version>
         <!-- Warps addon version -->
         <warps.version>1.12.0</warps.version>
         <!-- Visit addon version -->

src/main/java/world/bentobox/level/LevelsManager.java

@@ -30,7 +30,6 @@
 import world.bentobox.level.events.IslandLevelCalculatedEvent;
 import world.bentobox.level.events.IslandPreLevelEvent;
 import world.bentobox.level.objects.IslandLevels;
-import world.bentobox.level.objects.LevelsData;
 import world.bentobox.level.objects.TopTenData;
 import world.bentobox.level.util.CachedData;
 
@@ -67,38 +66,6 @@ public LevelsManager(Level addon) {
 
     }
 
-    public void migrate() {
-        Database<LevelsData> oldDb = new Database<>(addon, LevelsData.class);
-        oldDb.loadObjects().forEach(ld -> {
-            try {
-                UUID owner = UUID.fromString(ld.getUniqueId());
-                // Step through each world
-                ld.getLevels().keySet().stream()
-                        // World
-                        .map(Bukkit::getWorld).filter(Objects::nonNull)
-                        // Island
-                        .map(w -> addon.getIslands().getIsland(w, owner)).filter(Objects::nonNull).forEach(i -> {
-                            // Make new database entry
-                            World w = i.getWorld();
-                            IslandLevels il = new IslandLevels(i.getUniqueId());
-                            il.setInitialLevel(ld.getInitialLevel(w));
-                            il.setLevel(ld.getLevel(w));
-                            il.setMdCount(ld.getMdCount(w));
-                            il.setPointsToNextLevel(ld.getPointsToNextLevel(w));
-                            il.setUwCount(ld.getUwCount(w));
-                            // Save it
-                            handler.saveObjectAsync(il);
-                        });
-                // Now delete the old database entry
-                oldDb.deleteID(ld.getUniqueId());
-            } catch (Exception e) {
-                addon.logError("Could not migrate level data database! " + e.getMessage());
-                e.printStackTrace();
-                return;
-            }
-        });
-    }
-
     /**
      * Add an island to a top ten
      * 

src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java

@@ -2,14 +2,15 @@
 
 import java.text.ParseException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.EnumMap;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Queue;
 import java.util.Set;
 import java.util.UUID;
@@ -31,9 +32,9 @@
 import org.bukkit.block.ShulkerBox;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.type.Slab;
+import org.bukkit.entity.EntityType;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.BlockStateMeta;
-import org.bukkit.scheduler.BukkitTask;
 
 import com.bgsoftware.wildstacker.api.WildStackerAPI;
 import com.bgsoftware.wildstacker.api.objects.StackedBarrel;
@@ -55,19 +56,6 @@
 public class IslandLevelCalculator {
     private static final String LINE_BREAK = "==================================";
     public static final long MAX_AMOUNT = 10000000;
-    private static final List<Material> CHESTS = Arrays.asList(Material.CHEST, Material.CHEST_MINECART,
-            Material.TRAPPED_CHEST, Material.SHULKER_BOX, Material.BLACK_SHULKER_BOX, Material.BLUE_SHULKER_BOX,
-            Material.BROWN_SHULKER_BOX, Material.CYAN_SHULKER_BOX, Material.GRAY_SHULKER_BOX,
-            Material.GREEN_SHULKER_BOX, Material.LIGHT_BLUE_SHULKER_BOX, Material.LIGHT_GRAY_SHULKER_BOX,
-            Material.LIME_SHULKER_BOX, Material.MAGENTA_SHULKER_BOX, Material.ORANGE_SHULKER_BOX,
-            Material.PINK_SHULKER_BOX, Material.PURPLE_SHULKER_BOX, Material.RED_SHULKER_BOX, Material.RED_SHULKER_BOX,
-            Material.WHITE_SHULKER_BOX, Material.YELLOW_SHULKER_BOX, Material.COMPOSTER, Material.BARREL,
-            Material.DISPENSER, Material.DROPPER, Material.SMOKER, Material.BLAST_FURNACE, Material.BUNDLE,
-            Material.RED_BUNDLE, Material.BLACK_BUNDLE, Material.BLUE_BUNDLE, Material.BROWN_BUNDLE,
-            Material.CYAN_BUNDLE, Material.GRAY_BUNDLE, Material.GREEN_BUNDLE, Material.LIGHT_BLUE_BUNDLE,
-            Material.LIGHT_GRAY_BUNDLE, Material.LIME_BUNDLE, Material.MAGENTA_BUNDLE, Material.ORANGE_BUNDLE,
-            Material.PINK_BUNDLE, Material.PURPLE_BUNDLE, Material.RED_BUNDLE, Material.WHITE_BUNDLE,
-            Material.YELLOW_BUNDLE);
     private static final int CHUNKS_TO_SCAN = 100;
     private final Level addon;
     private final Queue<Pair<Integer, Integer>> chunksToCheck;
@@ -82,7 +70,7 @@ public class IslandLevelCalculator {
     private final int seaHeight;
     private final List<Location> stackedBlocks = new ArrayList<>();
     private final Set<Chunk> chestBlocks = new HashSet<>();
-    private BukkitTask finishTask;
+    private final Map<Location, Boolean> spawners = new HashMap<>();
 
     /**
      * Constructor to get the level for an island
@@ -163,6 +151,29 @@ private void checkBlock(Material mat, boolean belowSeaLevel) {
         }
     }
 
+    /**
+     * Adds value to the results based on the material and whether the block is
+     * below sea level or not
+     * 
+     * @param mat           - material of the block
+     * @param belowSeaLevel - true if below sea level
+     */
+    private void checkSpawner(EntityType et, boolean belowSeaLevel) {
+        if (limitCount(Material.SPAWNER) == 0) {
+            return;
+        }
+        Integer count = addon.getBlockConfig().getValue(island.getWorld(), et);
+        if (count != null) {
+            if (belowSeaLevel) {
+                results.underWaterBlockCount.addAndGet(count);
+                results.uwCount.add(et);
+            } else {
+                results.rawBlockCount.addAndGet(count);
+                results.mdCount.add(et);
+            }
+        }
+    }
+
     /**
      * Get a set of all the chunks in island
      * 
@@ -231,31 +242,22 @@ private List<String> getReport() {
 
         reportLines.add(
                 "Blocks not counted because they exceeded limits: " + String.format("%,d", results.ofCount.size()));
-        Iterable<Multiset.Entry<Material>> entriesSortedByCount = results.ofCount.entrySet();
-        Iterator<Entry<Material>> it = entriesSortedByCount.iterator();
+        Iterable<Multiset.Entry<Object>> entriesSortedByCount = results.ofCount.entrySet();
+        Iterator<Entry<Object>> it = entriesSortedByCount.iterator();
         while (it.hasNext()) {
-            Entry<Material> type = it.next();
-            Integer limit = addon.getBlockConfig().getBlockLimits().get(type.getElement());
+
+            Entry<Object> type = it.next();
+            Material m = type.getElement() instanceof Material mat ? mat : Material.SPAWNER;
+            Integer limit = addon.getBlockConfig().getBlockLimits().get(m);
             String explain = ")";
             if (limit == null) {
-                Material generic = type.getElement();
-                limit = addon.getBlockConfig().getBlockLimits().get(generic);
+                limit = addon.getBlockConfig().getBlockLimits().get(m);
                 explain = " - All types)";
             }
-            reportLines.add(type.getElement().toString() + ": " + String.format("%,d", type.getCount())
+            reportLines.add(Util.prettifyText(m.name()) + ": " + String.format("%,d", type.getCount())
                     + " blocks (max " + limit + explain);
         }
         reportLines.add(LINE_BREAK);
-        reportLines.add("Blocks on island that are not in config.yml");
-        reportLines.add("Total number = " + String.format("%,d", results.ncCount.size()));
-        entriesSortedByCount = results.ncCount.entrySet();
-        it = entriesSortedByCount.iterator();
-        while (it.hasNext()) {
-            Entry<Material> type = it.next();
-            reportLines.add(type.getElement().toString() + ": " + String.format("%,d", type.getCount()) + " blocks");
-        }
-        reportLines.add(LINE_BREAK);
-
         return reportLines;
     }
 
@@ -454,6 +456,8 @@ private void scanAsync(ChunkPair cp) {
                     BlockData blockData = cp.chunkSnapshot.getBlockData(x, y, z);
                     Material m = blockData.getMaterial();
                     boolean belowSeaLevel = seaHeight > 0 && y <= seaHeight;
+                    Location loc = new Location(cp.world, (double) x + cp.chunkSnapshot.getX() * 16, y,
+                            (double) z + cp.chunkSnapshot.getZ() * 16);
                     // Slabs can be doubled, so check them twice
                     if (Tag.SLABS.isTagged(m)) {
                         Slab slab = (Slab) blockData;
@@ -464,22 +468,26 @@ private void scanAsync(ChunkPair cp) {
                     // Hook for Wild Stackers (Blocks and Spawners Only) - this has to use the real
                     // chunk
                     if (addon.isStackersEnabled() && (m.equals(Material.CAULDRON) || m.equals(Material.SPAWNER))) {
-                        stackedBlocks.add(new Location(cp.world, (double) x + cp.chunkSnapshot.getX() * 16, y,
-                                (double) z + cp.chunkSnapshot.getZ() * 16));
+                        stackedBlocks.add(loc);
                     }
 
                     if (addon.isUltimateStackerEnabled() && !m.isAir()) {
-                        Location l = new Location(cp.chunk.getWorld(), x, y, z);
-                        UltimateStackerCalc.addStackers(m, l, results, belowSeaLevel, limitCount(m));
+                        UltimateStackerCalc.addStackers(m, loc, results, belowSeaLevel, limitCount(m));
                     }
 
                     // Scan chests
-                    if (addon.getSettings().isIncludeChests() && CHESTS.contains(m)) {
-
+                    if (addon.getSettings().isIncludeChests() && blockData instanceof Container) {
                         chestBlocks.add(cp.chunk);
                     }
-                    // Add the value of the block's material
-                    checkBlock(m, belowSeaLevel);
+
+                    // Spawners
+                    if (m == Material.SPAWNER) {
+                        // Stash the spawner because the type cannot be obtained from the chunk snapshot
+                        this.spawners.put(loc, belowSeaLevel);
+                    } else {
+                        // Add the value of the block's material
+                        checkBlock(m, belowSeaLevel);
+                    }
                 }
             }
         }
@@ -520,16 +528,23 @@ public CompletableFuture<Boolean> scanNextChunk() {
         return result;
     }
 
-    private Collection<String> sortedReport(int total, Multiset<Material> materialCount) {
+    private Collection<String> sortedReport(int total, Multiset<Object> uwCount) {
         Collection<String> result = new ArrayList<>();
-        Iterable<Multiset.Entry<Material>> entriesSortedByCount = Multisets.copyHighestCountFirst(materialCount)
+        Iterable<Multiset.Entry<Object>> entriesSortedByCount = Multisets.copyHighestCountFirst(uwCount)
                 .entrySet();
-        for (Entry<Material> en : entriesSortedByCount) {
-            Material type = en.getElement();
-
-            int value = getValue(type);
+        for (Entry<Object> en : entriesSortedByCount) {
+
+            int value = 0;
+            String name = "";
+            if (en.getElement() instanceof Material md) {
+                value = Objects.requireNonNullElse(addon.getBlockConfig().getValue(island.getWorld(), md), 0);
+                name = Util.prettifyText(md.name());
+            } else if (en.getElement() instanceof EntityType et) {
+                name = Util.prettifyText(et.name());
+                value = Objects.requireNonNullElse(addon.getBlockConfig().getValue(island.getWorld(), et), 0);
+            }
 
-            result.add(type.toString() + ":" + String.format("%,d", en.getCount()) + " blocks x " + value + " = "
+            result.add(name + " :" + String.format("%,d", en.getCount()) + " blocks x " + value + " = "
                     + (value * en.getCount()));
             total += (value * en.getCount());
 
@@ -616,15 +631,32 @@ public void scanIsland(Pipeliner pipeliner) {
                 pipeliner.getInProcessQueue().remove(this);
                 BentoBox.getInstance().log("Completed Level scan.");
                 // Chunk finished
-                // This was the last chunk. Handle stacked blocks, then chests and exit
-                handleStackedBlocks().thenCompose(v -> handleChests()).thenRun(() -> {
+                // This was the last chunk. Handle stacked blocks, spawners, chests and exit
+                handleStackedBlocks().thenCompose(v -> handleSpawners()).thenCompose(v -> handleChests())
+                        .thenRun(() -> {
                     this.tidyUp();
                     this.getR().complete(getResults());
                 });
             }
         });
     }
 
+    private CompletableFuture<Void> handleSpawners() {
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        for (Map.Entry<Location, Boolean> en : this.spawners.entrySet()) {
+            CompletableFuture<Void> future = Util.getChunkAtAsync(en.getKey()).thenAccept(c -> {
+                if (en.getKey().getBlock().getType() == Material.SPAWNER) {
+                    CreatureSpawner cs = (CreatureSpawner) en.getKey().getBlock().getState();
+                    checkSpawner(cs.getSpawnedType(), en.getValue());
+                }
+            });
+            futures.add(future);
+        }
+        // Return a CompletableFuture that completes when all futures are done
+        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
+
+    }
+
     private CompletableFuture<Void> handleChests() {
         List<CompletableFuture<Void>> futures = new ArrayList<>();
         for (Chunk v : chestBlocks) {

src/main/java/world/bentobox/level/calculators/Results.java

@@ -25,10 +25,10 @@ public enum Result {
         TIMEOUT
     }
     List<String> report;
-    final Multiset<Material> mdCount = HashMultiset.create();
-    final Multiset<Material> uwCount = HashMultiset.create();
-    final Multiset<Material> ncCount = HashMultiset.create();
-    final Multiset<Material> ofCount = HashMultiset.create();
+    final Multiset<Object> mdCount = HashMultiset.create();
+    final Multiset<Object> uwCount = HashMultiset.create();
+    final Multiset<Object> ncCount = HashMultiset.create();
+    final Multiset<Object> ofCount = HashMultiset.create();
     // AtomicLong and AtomicInteger must be used because they are changed by multiple concurrent threads
     AtomicLong rawBlockCount = new AtomicLong(0);
     AtomicLong underWaterBlockCount = new AtomicLong(0);
@@ -130,13 +130,13 @@ public String toString() {
     /**
      * @return the mdCount
      */
-    public Multiset<Material> getMdCount() {
+    public Multiset<Object> getMdCount() {
         return mdCount;
     }
     /**
      * @return the uwCount
      */
-    public Multiset<Material> getUwCount() {
+    public Multiset<Object> getUwCount() {
         return uwCount;
     }
     /**