feat: update spawner loot generation logic and add world spawner unloading functionality

Author: ptthanh02

build.gradle.kts

@@ -10,7 +10,7 @@ allprojects {
     apply(plugin = "maven-publish")
 
     group = "github.nighter"
-    version = "1.6.5"
+    version = "1.6.6"
 
     repositories {
         mavenCentral()

core/src/main/java/github/nighter/smartspawner/spawner/data/SpawnerManager.java

@@ -151,6 +151,33 @@ public Set<SpawnerData> getSpawnersInWorld(String worldName) {
         return worldIndex.get(worldName);
     }
 
+    /**
+     * Removes all spawners belonging to a world from in-memory indexes.
+     * Used when a world unloads so runtime memory only contains active worlds.
+     *
+     * @param worldName world being unloaded
+     * @return IDs of removed spawners for deferred reloading
+     */
+    public Set<String> unloadSpawnersInWorld(String worldName) {
+        Set<SpawnerData> worldSpawners = worldIndex.get(worldName);
+        if (worldSpawners == null || worldSpawners.isEmpty()) {
+            return Collections.emptySet();
+        }
+
+        Set<String> removedSpawnerIds = new HashSet<>();
+        Set<SpawnerData> snapshot = new HashSet<>(worldSpawners);
+
+        for (SpawnerData spawner : snapshot) {
+            spawner.removeHologram();
+            removedSpawnerIds.add(spawner.getSpawnerId());
+            spawners.remove(spawner.getSpawnerId());
+            locationIndex.entrySet().removeIf(entry -> entry.getValue() == spawner);
+        }
+
+        worldIndex.remove(worldName);
+        return removedSpawnerIds;
+    }
+
     public void initializeWithoutLoading() {
         // Clear existing data
         spawners.clear();

core/src/main/java/github/nighter/smartspawner/spawner/data/WorldEventHandler.java

@@ -97,11 +97,12 @@ public void onWorldUnload(WorldUnloadEvent event) {
         // Remove world from processed set
         processedWorlds.remove(worldName);
 
+        // Flush pending changes before removing runtime references.
+        // Storage handlers save modified spawners by resolving them from SpawnerManager.
+        plugin.getSpawnerStorage().flushChanges();
+
         // Unload spawners from this world
         unloadSpawnersFromWorld(worldName);
-
-        // Save any pending changes before unloading
-        plugin.getSpawnerStorage().flushChanges();
     }
 
     /**
@@ -126,9 +127,20 @@ public void attemptInitialSpawnerLoad() {
             SpawnerData spawner = entry.getValue();
 
             if (spawner != null) {
-                // Successfully loaded spawner
-                plugin.getSpawnerManager().addSpawnerToIndexes(spawnerId, spawner);
-                loadedCount++;
+                String worldName = spawner.getSpawnerLocation() != null && spawner.getSpawnerLocation().getWorld() != null
+                        ? spawner.getSpawnerLocation().getWorld().getName()
+                        : null;
+
+                if (worldName != null && Bukkit.getWorld(worldName) != null) {
+                    plugin.getSpawnerManager().addSpawnerToIndexes(spawnerId, spawner);
+                    loadedCount++;
+                } else {
+                    PendingSpawnerData pending = loadPendingSpawnerFromFile(spawnerId);
+                    if (pending != null) {
+                        pendingSpawners.put(spawnerId, pending);
+                        pendingCount++;
+                    }
+                }
             } else {
                 // Spawner couldn't be loaded, likely due to missing world
                 // Store as pending for later loading
@@ -186,19 +198,16 @@ private void loadPendingSpawnersForWorld(String worldName) {
      * Unload all spawners from a specific world
      */
     private void unloadSpawnersFromWorld(String worldName) {
-        Set<SpawnerData> worldSpawners = plugin.getSpawnerManager().getSpawnersInWorld(worldName);
-
-        if (worldSpawners != null && !worldSpawners.isEmpty()) {
-            int unloadedCount = 0;
-
-            for (SpawnerData spawner : new HashSet<>(worldSpawners)) {
-                // Remove hologram and cleanup
-                spawner.removeHologram();
-                unloadedCount++;
-            }
+        Set<String> unloadedSpawnerIds = plugin.getSpawnerManager().unloadSpawnersInWorld(worldName);
+        if (unloadedSpawnerIds.isEmpty()) {
+            return;
+        }
 
-            logger.info("Unloaded " + unloadedCount + " spawners from world: " + worldName);
+        for (String spawnerId : unloadedSpawnerIds) {
+            pendingSpawners.put(spawnerId, new PendingSpawnerData(worldName));
         }
+
+        logger.info("Unloaded " + unloadedSpawnerIds.size() + " spawners from world: " + worldName);
     }
 
     /**
@@ -210,7 +219,10 @@ private PendingSpawnerData loadPendingSpawnerFromFile(String spawnerId) {
             if (locationString != null) {
                 String[] locParts = locationString.split(",");
                 if (locParts.length >= 1) {
-                    return new PendingSpawnerData(locParts[0]);
+                    String worldName = locParts[0].trim();
+                    if (!worldName.isEmpty()) {
+                        return new PendingSpawnerData(worldName);
+                    }
                 }
             }
         } catch (Exception e) {

core/src/main/java/github/nighter/smartspawner/spawner/lootgen/SpawnerLootGenerator.java

@@ -407,12 +407,13 @@ public void preGenerateLoot(SpawnerData spawner, LootGenerationCallback callback
 
             final int minMobs;
             final int maxMobs;
-            final boolean atCapacity;
+            final boolean itemStorageFull;
 
             try {
                 int usedSlots = spawner.getVirtualInventory().getUsedSlots();
                 int maxSlots = spawner.getMaxSpawnerLootSlots();
-                atCapacity = usedSlots >= maxSlots && spawner.getSpawnerExp() >= spawner.getMaxStoredExp();
+                itemStorageFull = usedSlots >= maxSlots;
+                boolean atCapacity = itemStorageFull && spawner.getSpawnerExp() >= spawner.getMaxStoredExp();
 
                 if (atCapacity) {
                     callback.onLootGenerated(Collections.emptyList(), 0);
@@ -426,16 +427,28 @@ public void preGenerateLoot(SpawnerData spawner, LootGenerationCallback callback
             }
 
             Scheduler.runTaskAsync(() -> {
-                LootResult loot = generateLoot(minMobs, maxMobs, spawner);
+                LootResult loot;
+                if (itemStorageFull) {
+                    loot = generateExperienceOnlyLoot(minMobs, maxMobs, spawner);
+                } else {
+                    loot = generateLoot(minMobs, maxMobs, spawner);
+                }
+
                 callback.onLootGenerated(
-                    loot.items() != null ? new ArrayList<>(loot.items()) : Collections.emptyList(),
-                    loot.experience()
+                        loot.items() != null ? new ArrayList<>(loot.items()) : Collections.emptyList(),
+                        loot.experience()
                 );
             });
         } finally {
             spawner.getLootGenerationLock().unlock();
         }
     }
+
+    private LootResult generateExperienceOnlyLoot(int minMobs, int maxMobs, SpawnerData spawner) {
+        int mobCount = random.nextInt(maxMobs - minMobs + 1) + minMobs;
+        int totalExperience = spawner.getEntityExperienceValue() * mobCount;
+        return new LootResult(Collections.emptyList(), totalExperience);
+    }
 
     /**
      * Adds pre-generated loot to spawner instantly when timer expires.
@@ -493,14 +506,12 @@ public void addPreGeneratedLoot(SpawnerData spawner, List<ItemStack> items, int
                     return;
                 }
 
-                final boolean capacityCheck;
-                
                 try {
                     int usedSlots = spawner.getVirtualInventory().getUsedSlots();
                     int maxSlots = spawner.getMaxSpawnerLootSlots();
-                    capacityCheck = usedSlots >= maxSlots && spawner.getSpawnerExp() >= spawner.getMaxStoredExp();
-                    
-                    if (capacityCheck) {
+                    boolean isCompletelyFull = usedSlots >= maxSlots && spawner.getSpawnerExp() >= spawner.getMaxStoredExp();
+
+                    if (isCompletelyFull) {
                         return;
                     }
                 } finally {
@@ -530,8 +541,22 @@ public void addPreGeneratedLoot(SpawnerData spawner, List<ItemStack> items, int
                         }
 
                         if (!validItems.isEmpty()) {
-                            spawner.addItemsAndUpdateSellValue(validItems);
-                            changed = true;
+                            int usedSlots = spawner.getVirtualInventory().getUsedSlots();
+                            int maxSlots = spawner.getMaxSpawnerLootSlots();
+
+                            if (usedSlots < maxSlots) {
+                                List<ItemStack> itemsToAdd = validItems;
+
+                                int totalRequiredSlots = calculateRequiredSlots(itemsToAdd, spawner.getVirtualInventory());
+                                if (totalRequiredSlots > maxSlots) {
+                                    itemsToAdd = limitItemsToAvailableSlots(itemsToAdd, spawner);
+                                }
+
+                                if (!itemsToAdd.isEmpty()) {
+                                    spawner.addItemsAndUpdateSellValue(itemsToAdd);
+                                    changed = true;
+                                }
+                            }
                         }
                     }