Optimized VirtualInventory and SpawnLoot

ptthanh02 · ptthanh02 · commit e476d6a819f4 · 2025-03-19T16:37:57.000+07:00
diff --git a/core/src/main/java/github/nighter/smartspawner/language/LanguageManager.java b/core/src/main/java/github/nighter/smartspawner/language/LanguageManager.java
@@ -181,7 +181,7 @@ public enum MessageType {
         put("messages.spawner-protected.sound", "block.note_block.pling");
 
         // Selling Items from Spawner
-        put("messages.sell-all.message", "&#d6e7edYou sold a total of &#3287A9%amount% items&#d6e7ed for&a %price%$ &#d6e7ed!");
+        put("messages.sell-all.message", "&#d6e7edYou sold a total of &#3287A9%amount% items&#d6e7ed for&a $%price% &#d6e7ed!");
         put("messages.sell-all.prefix", true);
         put("messages.sell-all.type", "CHAT");
         put("messages.sell-all.sound", "block.note_block.bell");
@@ -191,7 +191,7 @@ public enum MessageType {
         put("messages.no-items.type", "CHAT");
         put("messages.no-items.sound", "block.note_block.pling");
 
-        put("messages.sell-all-tax.message", "&#d6e7edYou have sold &#3287A9%amount% items&#d6e7ed. Original price: &a%gross%$&#d6e7ed, After tax (&#ff6b6b-%tax%%&#d6e7ed): &a%price%$");
+        put("messages.sell-all-tax.message", "&#d6e7edYou have sold &#3287A9%amount% items&#d6e7ed. Original price: &a$%gross%&#d6e7ed, After tax (&#ff6b6b-%tax%%&#d6e7ed): &a$%price%");
         put("messages.sell-all-tax.prefix", true);
         put("messages.sell-all-tax.type", "CHAT");
         put("messages.sell-all-tax.sound", "block.note_block.bell");
diff --git a/core/src/main/java/github/nighter/smartspawner/spawner/lootgen/SpawnerLootGenerator.java b/core/src/main/java/github/nighter/smartspawner/spawner/lootgen/SpawnerLootGenerator.java
@@ -234,6 +234,7 @@ public void loadConfigurations() {
         }
     }
 
+    // Modify the generateLoot method:
     public LootResult generateLoot(EntityType entityType, int minMobs, int maxMobs, SpawnerData spawner) {
         String entityName = entityType.name().toLowerCase();
         EntityLootConfig config = entityLootConfigs.get(entityName);
@@ -243,38 +244,70 @@ public LootResult generateLoot(EntityType entityType, int minMobs, int maxMobs,
         }
 
         int mobCount = random.nextInt(maxMobs - minMobs + 1) + minMobs;
-        List<ItemStack> totalLoot = new ArrayList<>();
         int totalExperience = config.experience * mobCount;
-
         boolean allowEquipment = spawner.isAllowEquipmentItems();
 
-        // Pre-filter items based on equipment permission
-        List<LootItem> validItems = config.possibleItems.stream()
-                .filter(item -> allowEquipment ||
-                        (item.minDurability == null && item.maxDurability == null))
-                .collect(Collectors.toList());
+        // Pre-filter items only once
+        List<LootItem> validItems = allowEquipment ? config.possibleItems :
+                config.possibleItems.stream()
+                        .filter(item -> item.minDurability == null && item.maxDurability == null)
+                        .collect(Collectors.toList());
 
         if (validItems.isEmpty()) {
             return new LootResult(Collections.emptyList(), totalExperience);
         }
 
-        // Process each mob individually for accurate drop rates
-        for (int i = 0; i < mobCount; i++) {
-            for (LootItem lootItem : validItems) {
+        // Use a Map to consolidate identical drops instead of List
+        Map<ItemStack, Integer> consolidatedLoot = new HashMap<>();
+
+        // Process mobs in batch rather than individually
+        for (LootItem lootItem : validItems) {
+            // Calculate the probability for the entire mob batch at once
+            int successfulDrops = 0;
+
+            // Calculate binomial distribution - how many mobs will drop this item
+            for (int i = 0; i < mobCount; i++) {
                 if (random.nextDouble() * 100 <= lootItem.chance) {
-                    int amount = random.nextInt(lootItem.maxAmount - lootItem.minAmount + 1) + lootItem.minAmount;
-                    if (amount > 0) {
-                        ItemStack item = lootItem.createItemStack(random, effectNameCache, romanNumeralCache);
-                        if (item != null) {
-                            item.setAmount(amount);
-                            totalLoot.add(item);
-                        }
+                    successfulDrops++;
+                }
+            }
+
+            if (successfulDrops > 0) {
+                // Create item just once per loot type
+                ItemStack prototype = lootItem.createItemStack(random, effectNameCache, romanNumeralCache);
+                if (prototype != null) {
+                    // Total amount across all mobs
+                    int totalAmount = 0;
+                    for (int i = 0; i < successfulDrops; i++) {
+                        totalAmount += random.nextInt(lootItem.maxAmount - lootItem.minAmount + 1) + lootItem.minAmount;
+                    }
+
+                    if (totalAmount > 0) {
+                        // Add to consolidated map
+                        consolidatedLoot.merge(prototype, totalAmount, Integer::sum);
                     }
                 }
             }
         }
 
-        return new LootResult(totalLoot, totalExperience);
+        // Convert consolidated map to item stacks
+        List<ItemStack> finalLoot = new ArrayList<>(consolidatedLoot.size());
+        for (Map.Entry<ItemStack, Integer> entry : consolidatedLoot.entrySet()) {
+            ItemStack item = entry.getKey().clone();
+            item.setAmount(Math.min(entry.getValue(), item.getMaxStackSize()));
+            finalLoot.add(item);
+
+            // Handle amounts exceeding max stack size
+            int remaining = entry.getValue() - item.getMaxStackSize();
+            while (remaining > 0) {
+                ItemStack extraStack = item.clone();
+                extraStack.setAmount(Math.min(remaining, item.getMaxStackSize()));
+                finalLoot.add(extraStack);
+                remaining -= extraStack.getAmount();
+            }
+        }
+
+        return new LootResult(finalLoot, totalExperience);
     }
 
     public void spawnLootToSpawner(SpawnerData spawner) {
@@ -484,13 +517,15 @@ private List<ItemStack> limitItemsToAvailableSlots(List<ItemStack> items, Spawne
     }
 
     private int calculateSlots(Map<VirtualInventory.ItemSignature, Long> items) {
-        int slots = 0;
-        for (Map.Entry<VirtualInventory.ItemSignature, Long> entry : items.entrySet()) {
-            long amount = entry.getValue();
-            int maxStackSize = entry.getKey().getTemplateRef().getMaxStackSize();
-            slots += (int) Math.ceil((double) amount / maxStackSize);
-        }
-        return slots;
+        // Use a more efficient calculation approach
+        return items.entrySet().stream()
+                .mapToInt(entry -> {
+                    long amount = entry.getValue();
+                    int maxStackSize = entry.getKey().getTemplateRef().getMaxStackSize();
+                    // Use integer division with ceiling function
+                    return (int) ((amount + maxStackSize - 1) / maxStackSize);
+                })
+                .sum();
     }
 
     private int calculateRequiredSlots(List<ItemStack> items, VirtualInventory inventory) {
diff --git a/core/src/main/java/github/nighter/smartspawner/spawner/properties/VirtualInventory.java b/core/src/main/java/github/nighter/smartspawner/spawner/properties/VirtualInventory.java
@@ -1,6 +1,8 @@
 package github.nighter.smartspawner.spawner.properties;
 
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -19,6 +21,16 @@ public class VirtualInventory {
     private static final Comparator<Map.Entry<ItemSignature, Long>> ITEM_COMPARATOR =
             Comparator.comparing(e -> e.getKey().getTemplateRef().getType().name());
 
+    // Add an LRU cache for expensive item operations
+    private static final int ITEM_CACHE_SIZE = 128;
+    private static final Map<ItemStack, ItemSignature> signatureCache =
+            Collections.synchronizedMap(new LinkedHashMap<ItemStack, ItemSignature>(ITEM_CACHE_SIZE, 0.75f, true) {
+                @Override
+                protected boolean removeEldestEntry(Map.Entry<ItemStack, ItemSignature> eldest) {
+                    return size() > ITEM_CACHE_SIZE;
+                }
+            });
+
     public VirtualInventory(int maxSlots) {
         this.maxSlots = maxSlots;
         this.consolidatedItems = new ConcurrentHashMap<>();
@@ -43,19 +55,49 @@ public ItemSignature(ItemStack item) {
             this.hashCode = calculateHashCode();
         }
 
+        // Replace the current calculateHashCode() method with:
         private int calculateHashCode() {
-            return Objects.hash(
-                    template.getType(),
-                    template.getDurability(),
-                    template.getItemMeta() != null ? template.getItemMeta().toString() : null
-            );
+            // Use a faster hash algorithm and cache more item properties
+            int result = 31 * template.getType().ordinal(); // Using ordinal() instead of name() hashing
+            result = 31 * result + (int)template.getDurability();
+
+            // Only access ItemMeta when needed
+            if (template.hasItemMeta()) {
+                ItemMeta meta = template.getItemMeta();
+                // Extract only the essential meta properties that determine similarity
+                result = 31 * result + (meta.hasDisplayName() ? meta.getDisplayName().hashCode() : 0);
+                result = 31 * result + (meta.hasLore() ? meta.getLore().hashCode() : 0);
+                result = 31 * result + (meta.hasEnchants() ? meta.getEnchants().hashCode() : 0);
+            }
+            return result;
         }
 
         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
             if (!(o instanceof ItemSignature)) return false;
             ItemSignature that = (ItemSignature) o;
+
+            // First compare cheap properties
+            if (template.getType() != that.template.getType() ||
+                    template.getDurability() != that.template.getDurability()) {
+                return false;
+            }
+
+            // Only check ItemMeta if types match
+            boolean thisHasMeta = template.hasItemMeta();
+            boolean thatHasMeta = that.template.hasItemMeta();
+
+            if (thisHasMeta != thatHasMeta) {
+                return false;
+            }
+
+            // If both have no meta, they're similar enough
+            if (!thisHasMeta) {
+                return true;
+            }
+
+            // For complex items, fall back to isSimilar but only as a last resort
             return template.isSimilar(that.template);
         }
 
@@ -79,27 +121,43 @@ public String getMaterialName() {
         }
     }
 
+    public static ItemSignature getSignature(ItemStack item) {
+        // First try to get from cache
+        ItemSignature cachedSig = signatureCache.get(item);
+        if (cachedSig != null) {
+            return cachedSig;
+        }
+
+        // Create new signature and cache it
+        ItemSignature newSig = new ItemSignature(item);
+        signatureCache.put(item.clone(), newSig);
+        return newSig;
+    }
+
     // Add items in bulk with minimal operations
     public void addItems(List<ItemStack> items) {
         if (items.isEmpty()) return;
 
-        // Process items in a single batch
-        boolean updated = false;
+        // Pre-allocate space for batch processing
+        Map<ItemSignature, Long> itemBatch = new HashMap<>(items.size());
+
+        // Consolidate all items first
         for (ItemStack item : items) {
             if (item == null || item.getAmount() <= 0) continue;
-
-            ItemSignature sig = new ItemSignature(item);
-            consolidatedItems.merge(sig, (long) item.getAmount(), Long::sum);
-            updated = true;
+            ItemSignature sig = getSignature(item); // Use cached signature
+            itemBatch.merge(sig, (long) item.getAmount(), Long::sum);
         }
 
-        if (updated) {
+        // Apply all changes in one operation
+        if (!itemBatch.isEmpty()) {
+            for (Map.Entry<ItemSignature, Long> entry : itemBatch.entrySet()) {
+                consolidatedItems.merge(entry.getKey(), entry.getValue(), Long::sum);
+            }
             displayCacheDirty = true;
             metricsCacheDirty = true;
-            sortedEntriesCache = null; // Invalidate sorted entries cache
+            sortedEntriesCache = null;
         }
     }
-
     // Remove items in bulk with minimal operations
     public boolean removeItems(List<ItemStack> items) {
         if (items.isEmpty()) return true;
diff --git a/core/src/main/resources/messages/en_US.yml b/core/src/main/resources/messages/en_US.yml
@@ -173,7 +173,7 @@ messages:
   # Selling Items from Spawner
   #---------------------------------------------------
   sell-all:
-    message: "&#d6e7edYou sold a total of &#3287A9%amount% items&#d6e7ed for&a %price%$ &#d6e7ed!"
+    message: "&#d6e7edYou sold a total of &#3287A9%amount% items&#d6e7ed for&a $%price% &#d6e7ed!"
     prefix: true
     type: CHAT
     sound: block.note_block.bell
@@ -185,7 +185,7 @@ messages:
     sound: block.note_block.pling
 
   sell-all-tax:
-    message: "&#d6e7edYou have sold &#3287A9%amount% items&#d6e7ed. Original price: &a%gross%$&#d6e7ed, After tax (&#ff6b6b%tax%%&#d6e7ed): &a%price%$"
+    message: "&#d6e7edYou have sold &#3287A9%amount% items&#d6e7ed. Original price: &a$%gross%&#d6e7ed, After tax (&#ff6b6b%tax%%&#d6e7ed): &a$%price%"
     prefix: true
     type: CHAT
     sound: block.note_block.bell
diff --git a/core/src/main/resources/messages/vi_VN.yml b/core/src/main/resources/messages/vi_VN.yml
@@ -173,13 +173,13 @@ messages:
   # Bán vật phẩm từ Spawner
   #---------------------------------------------------
   sell-all:
-    message: "&#d6e7edBạn đã bán tổng cộng &#3287A9%amount% vật phẩm&#d6e7ed với giá &a%price%$&#d6e7ed!"
+    message: "&#d6e7edBạn đã bán tổng cộng &#3287A9%amount% vật phẩm&#d6e7ed với giá &a$%price%&#d6e7ed!"
     prefix: true
     type: CHAT
     sound: block.note_block.bell
 
   sell-all-tax:
-    message: "&#d6e7edBạn đã bán &#3287A9%amount% vật phẩm&#d6e7ed. Giá gốc: &a%gross%$&#d6e7ed, Sau thuế (&#ff6b6b-%tax%%&#d6e7ed): &a%price%$"
+    message: "&#d6e7edBạn đã bán &#3287A9%amount% vật phẩm&#d6e7ed. Giá gốc: &a$%gross%&#d6e7ed, Sau thuế (&#ff6b6b-%tax%%&#d6e7ed): &a$%price%"
     prefix: true
     type: CHAT
     sound: block.note_block.bell
