From b6fc4d1a0e4b78d7a747060b3169d99b45ae574b Mon Sep 17 00:00:00 2001 From: happyc0der Date: Fri, 30 Oct 2026 01:42:42 -0400 Subject: [PATCH] fix: relic inventory dupe and drag-in storage, autosave relics, silent mob-drop checks - RelicInventoryListener.onInventoryClick: a shift-click whose stack only partly fit into the player's inventory added the part that fit but took nothing out of the relic inventory (ItemUtils.consumeItem only ran when everything fit), duplicating those relics. Now the amount that actually moved is removed and the slot is written back; "Your inventory is full!" is shown only when something was left over. - New onInventoryDrag: dragging items into the relic inventory bypassed the click guard, so any item could be stored there permanently. Drags that touch the top (relic) inventory are cancelled. - RelicInventoryManager: relic inventories were only saved in SlimeFrame.onDisable, so a crash lost every relic earned since the last restart. A once-a-minute task saves when the YAML changed, through a temp file that is moved over the old one. - AdvancedMobDropListener.canDrop called canUse(p, true) on every registered Slimefun mob drop, before checking that it is an AdvancedMobDrop, so each kill sent a no-permission/not-researched message per locked drop of that mob, on top of Slimefun's own MobDropListener. It now returns early for non-AdvancedMobDrop items and checks silently. Co-Authored-By: Claude Opus 5.5 --- .../core/managers/RelicInventoryManager.java | 27 ++++++++++- .../listeners/AdvancedMobDropListener.java | 19 ++++---- .../listeners/RelicInventoryListener.java | 46 +++++++++++++------ 3 files changed, 66 insertions(+), 26 deletions(-) diff --git a/src/main/java/me/voper/slimeframe/core/managers/RelicInventoryManager.java b/src/main/java/me/voper/slimeframe/core/managers/RelicInventoryManager.java index 7595251..f1e7213 100644 --- a/src/main/java/me/voper/slimeframe/core/managers/RelicInventoryManager.java +++ b/src/main/java/me/voper/slimeframe/core/managers/RelicInventoryManager.java @@ -2,9 +2,15 @@ import java.io.File; import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.AtomicMoveNotSupportedException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardCopyOption; import java.util.HashMap; import java.util.Map; import java.util.UUID; +import java.util.logging.Level; import javax.annotation.Nonnull; @@ -20,11 +26,13 @@ public class RelicInventoryManager { private static final String CONFIG_PREFIX = "inventories."; private static final String FILE_NAME = "relics-inventories.yml"; + private static final long AUTOSAVE_TICKS = 20L * 60; private final SlimeFrame plugin; private final Map relicInventories = new HashMap<>(); private File file; private FileConfiguration configFile; + private String lastSaved = ""; public RelicInventoryManager(SlimeFrame plugin) { this.plugin = plugin; @@ -40,6 +48,10 @@ public void setup() { } } this.configFile = YamlConfiguration.loadConfiguration(file); + this.lastSaved = configFile.saveToString(); + // Relics used to be saved only in onDisable, so a crash lost every relic earned since the last restart. + // Check once a minute and write only when something changed. + plugin.getServer().getScheduler().runTaskTimer(plugin, this::saveConfig, AUTOSAVE_TICKS, AUTOSAVE_TICKS); } public void saveConfig() { @@ -51,10 +63,21 @@ public void saveConfig() { } } + String data = configFile.saveToString(); + if (data.equals(lastSaved)) return; + // Write a temp file and swap it in, so a crash mid-write cannot leave a truncated file + Path target = file.toPath(); + Path tmp = target.resolveSibling(FILE_NAME + ".tmp"); try { - configFile.save(file); + Files.writeString(tmp, data, StandardCharsets.UTF_8); + try { + Files.move(tmp, target, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE); + } catch (AtomicMoveNotSupportedException e) { + Files.move(tmp, target, StandardCopyOption.REPLACE_EXISTING); + } + lastSaved = data; } catch (IOException e) { - e.printStackTrace(); + plugin.getLogger().log(Level.WARNING, "Could not save " + FILE_NAME, e); } } diff --git a/src/main/java/me/voper/slimeframe/implementation/listeners/AdvancedMobDropListener.java b/src/main/java/me/voper/slimeframe/implementation/listeners/AdvancedMobDropListener.java index b2a4804..0b72b88 100644 --- a/src/main/java/me/voper/slimeframe/implementation/listeners/AdvancedMobDropListener.java +++ b/src/main/java/me/voper/slimeframe/implementation/listeners/AdvancedMobDropListener.java @@ -45,20 +45,19 @@ public void onEntityKill(EntityDeathEvent e) { private boolean canDrop(Player p, ItemStack item, EntityType entity) { SlimefunItem sfItem = SlimefunItem.getByItem(item); - if (sfItem == null) return false; - if (!sfItem.canUse(p, true)) return false; + // Only SlimeFrame's own drops are handled here, and a locked one is withheld silently. This used to call + // canUse(p, true) on every registered mob drop, so each kill sent a message per locked drop of that mob + // (on top of Slimefun's own MobDropListener). + if (!(sfItem instanceof AdvancedMobDrop advancedMobDrop)) return false; - if (sfItem instanceof AdvancedMobDrop advancedMobDrop) { + // Will be handled by the Slimefun RandomMobDrop listener + if (advancedMobDrop.getMobDropChance() != 0) return false; - // Will be handled by the Slimefun RandomMobDrop listener - if (advancedMobDrop.getMobDropChance() != 0) return false; + if (!sfItem.canUse(p, false)) return false; - int random = ThreadLocalRandom.current().nextInt(100); + int random = ThreadLocalRandom.current().nextInt(100); - return advancedMobDrop.getMobDropChance(entity) > random; - } - - return false; + return advancedMobDrop.getMobDropChance(entity) > random; } } diff --git a/src/main/java/me/voper/slimeframe/implementation/listeners/RelicInventoryListener.java b/src/main/java/me/voper/slimeframe/implementation/listeners/RelicInventoryListener.java index e315440..33545e9 100644 --- a/src/main/java/me/voper/slimeframe/implementation/listeners/RelicInventoryListener.java +++ b/src/main/java/me/voper/slimeframe/implementation/listeners/RelicInventoryListener.java @@ -8,11 +8,10 @@ import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.event.inventory.InventoryDragEvent; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.ItemStack; -import io.github.thebusybiscuit.slimefun4.libraries.dough.items.ItemUtils; - import me.voper.slimeframe.SlimeFrame; import me.voper.slimeframe.core.managers.RelicInventoryManager; import me.voper.slimeframe.implementation.items.relics.RelicInventory; @@ -41,25 +40,44 @@ public void onInventoryClick(InventoryClickEvent e) { ItemStack currentItem = e.getCurrentItem(); if (currentItem == null || currentItem.getType() == Material.AIR) return; ItemStack clone = currentItem.clone(); + if (!e.isShiftClick()) clone.setAmount(1); + int wanted = clone.getAmount(); - int consume = 1; - if (!e.isShiftClick()) { - clone.setAmount(1); - } else { - consume = clone.getAmount(); - } - + // Take out only what actually fit. Nothing used to be removed when part of a shift-clicked stack was + // left over, so the part that did fit was duplicated. The slot is written back explicitly. HashMap nonAddedItems = p.getInventory().addItem(clone); - if (nonAddedItems.isEmpty()) { - ItemUtils.consumeItem(currentItem, consume, false); -// currentItem.setAmount(currentItem.getAmount() - 1); - } else { - p.sendMessage(ChatColor.RED + "Your inventory is full!"); + int moved = wanted - nonAddedItems.values().stream().mapToInt(ItemStack::getAmount).sum(); + if (moved > 0) { + int rest = currentItem.getAmount() - moved; + if (rest > 0) { + ItemStack remaining = currentItem.clone(); + remaining.setAmount(rest); + clickedInventory.setItem(e.getSlot(), remaining); + } else { + clickedInventory.setItem(e.getSlot(), null); + } } + if (moved < wanted) p.sendMessage(ChatColor.RED + "Your inventory is full!"); return; } if (e.isShiftClick()) e.setCancelled(true); } + // The relic inventory only gives relics out. Dragging used to bypass the click guard, so any item could be + // stored there (a 54-slot backpack that opens anywhere and is kept on death). + @EventHandler(ignoreCancelled = true) + public void onInventoryDrag(InventoryDragEvent e) { + if (!(e.getWhoClicked() instanceof Player p)) return; + Inventory relicInventory = relicInventoryManager.getRelicInventory(p).getInventory(); + if (!e.getInventory().equals(relicInventory)) return; + int topSize = e.getView().getTopInventory().getSize(); + for (int rawSlot : e.getRawSlots()) { + if (rawSlot < topSize) { + e.setCancelled(true); + return; + } + } + } + }