package me.ItemCap; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Set; import java.util.UUID; import java.util.regex.Matcher; import java.util.regex.Pattern; import lombok.Getter; import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.command.CommandSender; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.HandlerList; import org.bukkit.event.Listener; import org.bukkit.event.inventory.InventoryType; import org.bukkit.event.inventory.PrepareItemCraftEvent; import org.bukkit.event.player.AsyncPlayerChatEvent; import org.bukkit.inventory.CraftingInventory; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.persistence.PersistentDataType; import org.bukkit.plugin.java.JavaPlugin; import me.ItemCap.Commands.ChestTrackTestCommand; import me.ItemCap.Commands.ItemCapCommand; import me.ItemCap.Commands.ItemCapTabCompleter; import me.ItemCap.GUIs.AdminGUI.AdminEditGUI; import me.ItemCap.GUIs.AdminGUI.AdminMenuGUI; import me.ItemCap.GUIs.AdminGUI.EffectMenu; import me.ItemCap.GUIs.AdminGUI.ItemSettingsGUI; import me.ItemCap.GUIs.ConfirmGUI; import me.ItemCap.GUIs.GUIManager; import me.ItemCap.GUIs.GuiItemInfo; import me.ItemCap.GUIs.LimiterGUI; import me.ItemCap.Secundary.ChestTracker; import me.ItemCap.Secundary.EffectData; import me.ItemCap.Secundary.ItemOptions; import me.ItemCap.translation.Translations; public class ItemCap extends JavaPlugin { private final Map limitedItems = new HashMap<>(); private final Map craftedCounts = new HashMap<>(); private final Map itemOptions = new HashMap<>(); private final NamespacedKey limitedItemKey = new NamespacedKey(this, "limited-item"); private final Map leakedCoordsMap = new HashMap<>(); private final Map limits = new HashMap<>(); private final Map> itemEffects = new HashMap<>(); private File limitedItemsFile; private YamlConfiguration limitedItemsConfig; @Getter private File itemStatusFile; @Getter private YamlConfiguration itemStatusConfig; private boolean debugEnabled = false; @Getter private boolean trackPickup = true; @Getter private boolean trackDestruction = true; private final Map guiItemInfos = new HashMap<>(); @Getter private LimiterGUI limiterGUI; @Getter private AdminEditGUI adminEditGUI; @Getter private ItemSettingsGUI itemSettingsGUI; @Getter private EffectMenu effectMenu; @Getter private AdminMenuGUI adminMenuGUI; @Getter private ConfirmGUI confirmGUI; @Getter private GUIManager guiManager; private Translations translations; @Getter private NamespacedKey guiItemKey; @Getter private NamespacedKey limitedItemKey2; private final Map pendingEdits = new HashMap<>(); private static class PendingEdit { final Material material; final String type; final String extra; PendingEdit(Material material, String type, String extra) { this.material = material; this.type = type; this.extra = extra; } } public void saveItemEffects() { } public NamespacedKey getLimitedItemKey() { return limitedItemKey2; } @Override public void onEnable() { checkServerCompatibility(); saveDefaultConfig(); setupDataFiles(); loadConfig(); String lang = getConfig().getString("language", "en"); translations = new Translations(this, lang); translations.load(); this.limiterGUI = new LimiterGUI(this); adminEditGUI = new AdminEditGUI(this); this.itemSettingsGUI = new ItemSettingsGUI(this); this.effectMenu = new EffectMenu(this); adminMenuGUI = new AdminMenuGUI(this); this.confirmGUI = new ConfirmGUI(this); guiManager = new GUIManager(this); limitedItemKey2 = new NamespacedKey(this, "limited_item"); guiItemKey = new NamespacedKey(this, "gui-item"); ChestTracker chestTracker = new ChestTracker(this); loadChestData(); getServer().getPluginManager().registerEvents(new ItemListener(this), this); getServer().getPluginManager().registerEvents(chestTracker, this); getServer().getPluginManager().registerEvents(guiManager, this); getServer().getPluginManager().registerEvents(adminEditGUI, this); getServer().getPluginManager().registerEvents(limiterGUI, this); getServer().getPluginManager().registerEvents(new Listener() { @EventHandler public void onAsyncPlayerChat(AsyncPlayerChatEvent e) { UUID id = e.getPlayer().getUniqueId(); if (!pendingEdits.containsKey(id)) return; e.setCancelled(true); PendingEdit edit = pendingEdits.remove(id); Player player = e.getPlayer(); String message = e.getMessage(); Bukkit.getScheduler().runTask(ItemCap.this, () -> handleChatEdit(player, edit, message)); } }, this); getCommand("ItemCap").setExecutor(new ItemCapCommand(this)); getCommand("ItemCap").setTabCompleter(new ItemCapTabCompleter()); getCommand("chesttracktest").setExecutor(new ChestTrackTestCommand(this)); Bukkit.getScheduler().runTaskTimer(this, () -> { for (var world : Bukkit.getWorlds()) { for (var entity : world.getEntitiesByClass(org.bukkit.entity.Item.class)) { ItemStack stack = entity.getItemStack(); if (entity.isDead() || entity.getTicksLived() > 6000) continue; if (stack == null) continue; if (isItemLimited(stack.getType()) && isItemTagged(stack)) { if (entity.getLocation().getY() < -5) { markDestroyed(stack); entity.remove(); getLogger().info("[VoidCleanup] Removed falling limited item: " + stack.getType()); } } } } }, 20L * 30, 20L * 30); Bukkit.getScheduler().runTaskTimer(this, () -> { for (Player player : Bukkit.getOnlinePlayers()) { for (ItemStack item : player.getInventory().getContents()) { if (item == null) continue; Material mat = item.getType(); if (isItemLimited(mat) && isItemTagged(item)) { ItemOptions options = getOptions(mat); if (options != null) { for (EffectData effect : options.getEffects()) { int durationTicks = 20 * 20; org.bukkit.potion.PotionEffect current = player.getPotionEffect(effect.getType()); if (current != null) { if (current.getDuration() > 0 && current.getDuration() > 240) continue; } player.addPotionEffect(new org.bukkit.potion.PotionEffect( effect.getType(), durationTicks, Math.max(0, effect.getAmplifier() - 1), true, false )); } } } } } }, 20L, 20L); getLogger().info("[ItemCap] Plugin was fully enabled."); } @Override public void onDisable() { Bukkit.getScheduler().cancelTasks(this); saveCraftCounts(); } private void setupDataFiles() { limitedItemsFile = new File(getDataFolder(), "LimitedItems.yml"); if (!limitedItemsFile.exists()) saveResource("LimitedItems.yml", false); limitedItemsConfig = YamlConfiguration.loadConfiguration(limitedItemsFile); itemStatusFile = new File(getDataFolder(), "ItemStatus.yml"); if (!itemStatusFile.exists()) { try { itemStatusFile.createNewFile(); } catch (IOException e) { getLogger().severe("Failed to create ItemStatus.yml: " + e.getMessage()); } } itemStatusConfig = YamlConfiguration.loadConfiguration(itemStatusFile); } public void loadChestData() { if (this.itemStatusConfig == null) return; if (!this.itemStatusConfig.contains("chests")) return; ConfigurationSection chestsSection = this.itemStatusConfig.getConfigurationSection("chests"); if (chestsSection == null) return; for (String key : chestsSection.getKeys(false)) { try { ChestTracker tracker = new ChestTracker(this); Material mat = Material.valueOf(chestsSection.getString(key + ".material")); long expiry = chestsSection.getLong(key + ".expiry"); Location loc = tracker.parseLocation(key); if (System.currentTimeMillis() < expiry) tracker.resumeTimer(loc, mat, expiry); } catch (Exception ignored) {} } } public boolean isItemTagged(ItemStack item) { return item != null && item.hasItemMeta() && item.getItemMeta().getPersistentDataContainer().has(limitedItemKey, PersistentDataType.INTEGER); } public void tagAsLimited(ItemStack item) { if (item == null || item.getType() == Material.AIR) return; ItemMeta meta = item.getItemMeta(); if (meta == null) return; meta.getPersistentDataContainer().set(limitedItemKey, PersistentDataType.INTEGER, 1); List lore = meta.hasLore() ? meta.getLore() : new ArrayList<>(); lore.add(ChatColor.LIGHT_PURPLE + "[LIMITED]"); meta.setLore(lore); item.setItemMeta(meta); if (debugEnabled) getLogger().info("[DEBUG] Tagged item: " + item.getType()); } public void loadConfig() { limitedItemsConfig = YamlConfiguration.loadConfiguration(limitedItemsFile); limitedItems.clear(); guiItemInfos.clear(); craftedCounts.clear(); itemOptions.clear(); FileConfiguration config = getConfig(); debugEnabled = limitedItemsConfig.getBoolean("options.debug", false); trackPickup = limitedItemsConfig.getBoolean("options.track-pickup", true); trackDestruction = limitedItemsConfig.getBoolean("options.track-destruction", true); boolean configChanged = false; ConfigurationSection section = limitedItemsConfig.getConfigurationSection("limited-items"); if (section != null) { for (String key : section.getKeys(false)) { try { Material mat = Material.valueOf(key.toUpperCase()); ConfigurationSection itemSection = section.getConfigurationSection(key); if (itemSection == null) itemSection = section.createSection(key); boolean updated = false; if (!itemSection.contains("limit")) { itemSection.set("limit", 1); updated = true; } if (!itemSection.contains("per-player-limit")) {itemSection.set("per-player-limit", -1); updated = true; } if (!itemSection.contains("block-ender")) { itemSection.set("block-ender", false); updated = true; } if (!itemSection.contains("chest-timer")) { itemSection.set("chest-timer", -1); updated = true; } if (!itemSection.contains("slot")) { itemSection.set("slot", "auto"); updated = true; } if (!itemSection.contains("page")) { itemSection.set("page", "auto"); updated = true; } int limit = itemSection.getInt("limit", 1); limitedItems.put(mat, limit); boolean blockEnder = itemSection.getBoolean("block-ender", false); String chestTimerRaw = itemSection.getString("chest-timer", "-1"); List effects = new ArrayList<>(); if (itemSection.isList("effects")) { try { for (Object obj : itemSection.getMapList("effects")) { if (!(obj instanceof Map)) continue; @SuppressWarnings("unchecked") Map map = (Map) obj; Object typeObj = map.get("type"); Object ampObj = map.get("amplifier"); if (typeObj == null) continue; String typeName = String.valueOf(typeObj).toUpperCase(Locale.ROOT); org.bukkit.potion.PotionEffectType pet = org.bukkit.potion.PotionEffectType.getByName(typeName); if (pet == null) { getLogger().warning("[ItemCap] Unknown effect type '" + typeName + "' for item " + mat.name()); continue; } int amplifier = 0; if (ampObj != null) { try { amplifier = Integer.parseInt(String.valueOf(ampObj)); } catch (NumberFormatException ignored) {} } if (amplifier == -1) amplifier = Integer.MAX_VALUE; else if (amplifier == 0) continue; effects.add(new EffectData(pet, amplifier)); } } catch (Exception e) { getLogger().warning("[ItemCap] Failed to parse effects for " + mat.name() + ": " + e.getMessage()); } } int slot; if (itemSection.isInt("slot")) { slot = itemSection.getInt("slot") - 1; if (slot < 0 || slot >= 45) slot = -1; } else { slot = -1; } int page = itemSection.isInt("page") ? Math.max(0, itemSection.getInt("page", 1) - 1) : 0; int perPlayerLimit = itemSection.getInt("per-player-limit", -1); itemOptions.put( mat, new ItemOptions( blockEnder, parseDuration(chestTimerRaw), slot, page, perPlayerLimit, effects ) ); guiItemInfos.put(mat, new GuiItemInfo(mat, slot, page)); if (updated) { try { limitedItemsConfig.save(limitedItemsFile); getLogger().info("[ItemCap] Repaired missing fields for item: " + mat.name()); } catch (IOException e) { getLogger().severe("Failed to save LimitedItems.yml while healing: " + e.getMessage()); } } } catch (IllegalArgumentException ex) { getLogger().warning("Invalid material in config: " + key); } } } loadCraftCounts(); if (configChanged) { saveConfig(); getLogger().info("[ItemCap] Config.yml updated with missing defaults."); } } public long parseDuration(String input) { if (input == null || input.trim().isEmpty() || input.equalsIgnoreCase("-1")) return -1L; if (input.equalsIgnoreCase("0")) return 0L; long totalMillis = 0L; Matcher m = Pattern.compile("(\\d+)([dhms])").matcher(input.toLowerCase(Locale.ROOT)); while (m.find()) { long val = Long.parseLong(m.group(1)); String unit = m.group(2); switch (unit) { case "d" -> totalMillis += val * 86400000L; case "h" -> totalMillis += val * 3600000L; case "m" -> totalMillis += val * 60000L; case "s" -> totalMillis += val * 1000L; } } if (totalMillis == 0L) getLogger().warning("Parsed duration '" + input + "' is 0 ms. Did you mistype the format?"); return totalMillis; } @EventHandler public void onPrepareItemCraft(PrepareItemCraftEvent event) { if (event.getInventory().getType() == InventoryType.WORKBENCH || event.getInventory().getType() == InventoryType.CRAFTING) { CraftingInventory inv = event.getInventory(); ItemStack result = inv.getResult(); if (result != null && result.getType() != Material.AIR) { Material mat = result.getType(); if (isItemLimited(mat)) { Player player = (Player) event.getView().getPlayer(); ItemOptions options = getOptions(mat); int amount = result.getAmount(); if (!isCraftingAllowed(mat, amount)) { inv.setResult(null); return; } int perPlayerLimit = options.getPerPlayerLimit(); if (perPlayerLimit >= 0) { int current = countPlayerTaggedItems(player, mat); if (current + amount > perPlayerLimit) { inv.setResult(null); return; } } ItemStack tagged = result.clone(); tagAsLimited(tagged); inv.setResult(tagged); } } } } public String formatDuration(long ms) { if (ms < 0) return "Disabled"; if (ms == 0) return "0s"; long seconds = ms / 1000; long days = seconds / 86400; seconds %= 86400; long hours = seconds / 3600; seconds %= 3600; long minutes = seconds / 60; seconds %= 60; StringBuilder sb = new StringBuilder(); if (days > 0) sb.append(days).append("d"); if (hours > 0) sb.append(hours).append("h"); if (minutes > 0) sb.append(minutes).append("m"); if (seconds > 0) sb.append(seconds).append("s"); return sb.toString(); } public boolean isItemLimited(Material mat) { return limitedItems.containsKey(mat); } public Set getLimitedItems() { return limitedItems.keySet(); } public GuiItemInfo getGuiItemInfo(Material mat) { return guiItemInfos.getOrDefault(mat, new GuiItemInfo(mat, -1, 0)); } public boolean isCraftingAllowed(Material mat, int amount) { if (!limitedItems.containsKey(mat)) return true; int current = craftedCounts.getOrDefault(mat, 0); return current + amount <= limitedItems.get(mat); } public ItemOptions getOptions(Material mat) { return itemOptions.getOrDefault( mat, new ItemOptions(false, -1L, -1, 0, -1, new ArrayList<>()) ); } public void setOptions(Material mat, ItemOptions options) { itemOptions.put(mat, options); } public List getEffects(Material mat) { return getOptions(mat).getEffects(); } public void addEffectToItem(Material mat, EffectData effect) { ItemOptions opts = getOptions(mat); opts.getEffects().add(effect); setOptions(mat, opts); getLogger().info("Effect " + effect.getType().getName() + " added to " + mat.name()); } public Set getAllItems() { return limits.keySet(); } public List getItemEffects(Material mat) { return itemEffects.getOrDefault(mat, new ArrayList<>()); } public void updateItemEffects(Material mat, List effects) { itemEffects.put(mat, effects); saveItemEffects(); } public void removeEffect(Material mat, String effectName) { List effects = getOptions(mat).getEffects(); effects.removeIf(e -> e.getType().getName().equalsIgnoreCase(effectName)); setOptions(mat, getOptions(mat)); } public void setBlockEnder(Material mat, boolean value) { String path = "limited-items." + mat.name(); ConfigurationSection itemSection = limitedItemsConfig.getConfigurationSection(path); if (itemSection == null) itemSection = limitedItemsConfig.createSection(path); itemSection.set("block-ender", value); try { limitedItemsConfig.save(limitedItemsFile); } catch (IOException e) { getLogger().severe("Failed to save LimitedItems.yml: " + e.getMessage()); } loadConfig(); } public String getMessageLimitReached(Material mat, Player player) { String msg = getOptionalMessage("messages.errors.limit-reached"); if (msg == null) return null; return formatMessage(msg, player, mat, null); } public void debug(String msg) { if (debugEnabled) getLogger().info("[DEBUG] " + msg); } public void reloadPlugin() { reloadConfig(); loadConfig(); try { if (this.limiterGUI != null) HandlerList.unregisterAll(limiterGUI); if (this.adminEditGUI != null) HandlerList.unregisterAll(this.adminEditGUI); if (this.adminMenuGUI != null) HandlerList.unregisterAll(this.adminMenuGUI); } catch (Exception ignored) {} this.limiterGUI = new LimiterGUI(this); this.adminEditGUI = new AdminEditGUI(this); this.itemSettingsGUI = new ItemSettingsGUI(this); this.effectMenu = new EffectMenu(this); this.adminMenuGUI = new AdminMenuGUI(this); getServer().getPluginManager().registerEvents(limiterGUI, this); getLogger().info("[ItemCap] Plugin reloaded (config and GUIs)."); } public void reloadPlugin(CommandSender sender) { reloadPlugin(); sender.sendMessage(ChatColor.GREEN + tr("system.reloaded")); } public void startChatEdit(Player player, Material mat, String type) { startChatEdit(player, mat, type, null); } public void startChatEdit(Player player, Material mat, String type, String extra) { pendingEdits.put(player.getUniqueId(), new PendingEdit(mat, type, extra)); switch (type.toLowerCase()) { case "limit" -> { player.closeInventory(); player.sendMessage(ChatColor.YELLOW + tr("edit.limit").replace("%item%", mat.name())); } case "chest-timer" -> { player.closeInventory(); player.sendMessage(ChatColor.YELLOW + tr("edit.chest-timer").replace("%item%", mat.name())); } case "add-effect" -> { if (extra != null) { player.closeInventory(); player.sendMessage(ChatColor.YELLOW + tr("edit.effect-amp").replace("%effect%", extra)); } else { player.closeInventory(); player.sendMessage(ChatColor.YELLOW + tr("edit.effect-generic")); } } default -> { player.closeInventory(); player.sendMessage(ChatColor.YELLOW + tr("edit.generic")); } } } public boolean hasSpark() { return Bukkit.getPluginManager().isPluginEnabled("spark"); } private void handleChatEdit(Player player, PendingEdit edit, String message) { if (edit == null) return; if (message.equalsIgnoreCase("cancel")) { player.sendMessage(ChatColor.RED + tr("edit.cancelled")); return; } try { switch (edit.type.toLowerCase()) { case "per-player-limit" -> { int value = Integer.parseInt(message); String path = "limited-items." + edit.material.name() + ".per-player-limit"; limitedItemsConfig.set(path, value); limitedItemsConfig.save(limitedItemsFile); loadConfig(); player.sendMessage(ChatColor.GREEN + "Per-player limit for " + edit.material.name() + " set to " + value); getItemSettingsGUI().open(player, edit.material); } case "limit" -> { int limit = Integer.parseInt(message); setItemLimit(edit.material, limit, getEffects(edit.material)); player.sendMessage(ChatColor.GREEN + tr("edit.limit-set").replace("%item%", edit.material.name()).replace("%value%", String.valueOf(limit))); getItemSettingsGUI().open(player, edit.material); } case "chest-timer" -> { setChestTimerRaw(edit.material, message); player.sendMessage(ChatColor.GREEN + tr("edit.chest-set").replace("%item%", edit.material.name()).replace("%raw%", message).replace("%formatted%", formatDuration(parseDuration(message)))); getItemSettingsGUI().open(player, edit.material); } case "add-effect" -> { String effectName = edit.extra; if (effectName == null) { String[] parts = message.split("\\s+"); String eff = parts[0]; org.bukkit.potion.PotionEffectType pet = org.bukkit.potion.PotionEffectType.getByName(eff.toUpperCase(Locale.ROOT)); if (pet == null) { player.sendMessage(ChatColor.RED + tr("edit.unknown-effect").replace("%effect%", eff)); return; } int amp = 1; String ampText = (amp == Integer.MAX_VALUE ? "-1" : String.valueOf(amp)); if (parts.length > 1) amp = Integer.parseInt(parts[1]); if (amp <= 0) { player.sendMessage(ChatColor.RED + tr("edit.invalid-amplifier")); return; } if (amp == -1) amp = Integer.MAX_VALUE; addEffectToItem(edit.material, new EffectData(pet, amp)); setItemLimit(edit.material, getLimit(edit.material), getEffects(edit.material)); player.sendMessage(ChatColor.GREEN + tr("edit.effect-added").replace("%effect%", pet.getName()).replace("%amp%", ampText).replace("%item%", edit.material.name())); getEffectMenu().open(player, edit.material); } else { org.bukkit.potion.PotionEffectType pet = org.bukkit.potion.PotionEffectType.getByName(effectName.toUpperCase(Locale.ROOT)); if (pet == null) { player.sendMessage(ChatColor.RED + tr("edit.unknown-effect").replace("%effect%", effectName)); return; } int amp = Integer.parseInt(message); String ampText = (amp == Integer.MAX_VALUE ? "-1" : String.valueOf(amp)); if (amp == -1) amp = Integer.MAX_VALUE; if (amp <= 0) { player.sendMessage(ChatColor.RED + tr("edit.invalid-amplifier")); return; } addEffectToItem(edit.material, new EffectData(pet, amp)); setItemLimit(edit.material, getLimit(edit.material), getEffects(edit.material)); player.sendMessage(ChatColor.GREEN + tr("edit.effect-added").replace("%effect%", pet.getName()).replace("%amp%", ampText).replace("%item%", edit.material.name())); getEffectMenu().open(player, edit.material); } } default -> { player.sendMessage(ChatColor.RED + tr("edit.unknown-type").replace("%type%", edit.type)); } } } catch (NumberFormatException ex) { player.sendMessage(ChatColor.RED + tr("edit.invalid-number").replace("%error%", ex.getMessage())); } catch (Exception ex) { player.sendMessage(ChatColor.RED + tr("edit.error").replace("%error%", ex.getMessage())); getLogger().warning("Error while applying admin edit: " + ex.getMessage()); } } public void saveCraftCounts() { if (itemStatusConfig == null || itemStatusFile == null) return; itemStatusConfig.set("crafted_counts", null); craftedCounts.forEach((mat, count) -> itemStatusConfig.set("crafted_counts." + mat.name(), count)); try { itemStatusConfig.save(itemStatusFile); } catch (IOException e) { getLogger().severe("Failed to save ItemStatus.yml: " + e.getMessage()); } } public void loadCraftCounts() { if (itemStatusConfig == null) return; craftedCounts.clear(); ConfigurationSection crafted = itemStatusConfig.getConfigurationSection("crafted_counts"); if (crafted != null) { for (String key : crafted.getKeys(false)) { try { Material mat = Material.valueOf(key.toUpperCase(Locale.ROOT)); int count = crafted.getInt(key); craftedCounts.put(mat, count); } catch (IllegalArgumentException ignored) {} } } } public void markCrafted(Material mat, int amount, Player player) { if (!limitedItems.containsKey(mat)) return; int before = craftedCounts.getOrDefault(mat, 0); craftedCounts.put(mat, before + amount); saveCraftCounts(); getLogger().info("Craft Count Updated: " + mat + " +" + amount + " (Total: " + craftedCounts.get(mat) + "/" + limitedItems.get(mat) + ")"); int current = craftedCounts.getOrDefault(mat, 0); int limit = limitedItems.getOrDefault(mat, 1); int remaining = limit - current; debug("Marked crafted: " + mat + " x" + amount + " | Total: " + current + "/" + limit); String path; if (limit == 1) path = "messages.crafted.unique"; else if (remaining == 0) path = "messages.crafted.last"; else path = "messages.crafted.normal"; String msg = getOptionalMessage(path); if (msg != null) { Bukkit.broadcastMessage(formatMessage(msg, player, mat, remaining)); } } public void markDestroyed(ItemStack item) { Material mat = item.getType(); if (!isItemLimited(mat)) return; int current = craftedCounts.getOrDefault(mat, 0); if (current > 0) { craftedCounts.put(mat, current - 1); saveCraftCounts(); } int remaining = getLimit(mat) - getCrafted(mat); String path = getLimit(mat) == 1 ? "messages.destroyed.unique" : "messages.destroyed.despawn"; String msg = getOptionalMessage(path); if (msg != null) { Bukkit.broadcastMessage(formatMessage(msg, null, mat, remaining)); } } public void reloadLimiterGUI() { if (this.limiterGUI != null) { HandlerList.unregisterAll(this.limiterGUI); } this.limiterGUI = new LimiterGUI(this); Bukkit.getPluginManager().registerEvents(this.limiterGUI, this); } public void setItemLimit(Material mat, int limit, List effects) { limitedItems.put(mat, limit); craftedCounts.putIfAbsent(mat, 0); String path = "limited-items." + mat.name(); ConfigurationSection itemSection = limitedItemsConfig.getConfigurationSection(path); if (itemSection == null) itemSection = limitedItemsConfig.createSection(path); itemSection.set("limit", limit); itemSection.set("block-ender", itemSection.getBoolean("block-ender", false)); itemSection.set("chest-timer", itemSection.get("chest-timer", -1)); if (!itemSection.contains("slot")) itemSection.set("slot", "auto"); if (!itemSection.contains("page")) itemSection.set("page", "auto"); if (effects != null && !effects.isEmpty()) { List> serialized = new ArrayList<>(); for (EffectData e : effects) { int amp = e.getAmplifier(); if (amp == Integer.MAX_VALUE) amp = -1; Map map = new LinkedHashMap<>(); map.put("type", e.getType().getName()); map.put("amplifier", amp); serialized.add(map); } itemSection.set("effects", serialized); } else { itemSection.set("effects", null); } try { limitedItemsConfig.save(limitedItemsFile); } catch (IOException e) { getLogger().severe("Failed to save LimitedItems.yml: " + e.getMessage()); } int slot = itemSection.isInt("slot") ? itemSection.getInt("slot", -1) : -1; int page = itemSection.isInt("page") ? Math.max(0, itemSection.getInt("page", 1) - 1) : 0; int perPlayerLimit = itemSection.getInt("per-player-limit", -1); itemOptions.put( mat, new ItemOptions( itemSection.getBoolean("block-ender", false), parseDuration(String.valueOf(itemSection.get("chest-timer", "-1"))), slot, page, perPlayerLimit, effects == null ? new ArrayList<>() : effects ) ); debug("Set new limit for " + mat + ": " + limit); } public void setChestTimerRaw(Material mat, String raw) { String path = "limited-items." + mat.name(); ConfigurationSection itemSection = limitedItemsConfig.getConfigurationSection(path); if (itemSection == null) itemSection = limitedItemsConfig.createSection(path); itemSection.set("chest-timer", raw); try { limitedItemsConfig.save(limitedItemsFile); } catch (IOException e) { getLogger().severe("Failed to save LimitedItems.yml: " + e.getMessage()); } loadConfig(); } public void removeItemLimit(Material mat) { limitedItems.remove(mat); craftedCounts.remove(mat); itemOptions.remove(mat); guiItemInfos.remove(mat); limitedItemsConfig.set("limited-items." + mat.name(), null); try { limitedItemsConfig.save(limitedItemsFile); } catch (IOException e) { getLogger().severe("Failed to save LimitedItems.yml: " + e.getMessage()); } loadConfig(); } public String tr(String key) { return translations.get(key); } public String formatMessage(String msg, Player player, Material mat, Integer amountLeft) { if (msg == null) return ""; if (player != null) { msg = msg.replace("%player%", player.getName()); } if (mat != null) { msg = msg.replace("%item_name%", mat.name()); } if (amountLeft != null) { msg = msg.replace("%amount_left%", String.valueOf(amountLeft)); } return ChatColor.translateAlternateColorCodes('&', msg); } public int countPlayerTaggedItems(Player player, Material mat) { int count = 0; for (ItemStack item : player.getInventory().getContents()) { if (item == null) continue; if (item.getType() == mat && isItemTagged(item)) { count += item.getAmount(); } } return count; } public int getExceededPerPlayerLimit(Player player, ItemStack stack) { if (stack == null || stack.getType() == Material.AIR) return -1; Material mat = stack.getType(); if (!isItemLimited(mat)) return -1; ItemOptions options = getOptions(mat); int perPlayerLimit = options.getPerPlayerLimit(); if (perPlayerLimit < 0) return -1; int incoming = stack.getAmount(); int owned = 0; for (ItemStack item : player.getInventory().getContents()) { if (item == null) continue; if (item.getType() == mat && isItemTagged(item)) { owned += item.getAmount(); } } if (owned + incoming > perPlayerLimit) { return perPlayerLimit; } return -1; } public int getExceededPerPlayerLimitIncludingContainer(Player player, ItemStack stack) { if (stack == null) return -1; if (!(stack.getItemMeta() instanceof org.bukkit.inventory.meta.BlockStateMeta meta)) { return -1; } if (!(meta.getBlockState() instanceof org.bukkit.block.ShulkerBox shulker)) { return -1; } for (ItemStack inside : shulker.getInventory().getContents()) { if (inside == null || inside.getType() == Material.AIR) continue; Material mat = inside.getType(); if (!isItemLimited(mat)) continue; ItemOptions options = getOptions(mat); int perPlayerLimit = options.getPerPlayerLimit(); if (perPlayerLimit < 0) continue; int owned = 0; for (ItemStack invItem : player.getInventory().getContents()) { if (invItem == null) continue; if (invItem.getType() == mat && isItemTagged(invItem)) { owned += invItem.getAmount(); } } int adding = inside.getAmount(); if (owned + adding > perPlayerLimit) { return perPlayerLimit; } } return -1; } public String getOptionalMessage(String path) { if (!getConfig().contains(path)) return null; Object raw = getConfig().get(path); if (raw instanceof Boolean) { if (!(Boolean) raw) return null; } String str = String.valueOf(raw); if (str.equalsIgnoreCase("false")) return "false"; return ChatColor.translateAlternateColorCodes('&', str); } public Material findLimitedInside(ItemStack stack) { if (stack == null) return null; if (isItemLimited(stack.getType()) && isItemTagged(stack)) { return stack.getType(); } ItemMeta meta = stack.getItemMeta(); if (meta == null) return null; if (meta instanceof org.bukkit.inventory.meta.BlockStateMeta bsm && bsm.getBlockState() instanceof org.bukkit.block.ShulkerBox shulker) { for (ItemStack inside : shulker.getInventory().getContents()) { Material found = findLimitedInside(inside); if (found != null) return found; } } if (meta instanceof org.bukkit.inventory.meta.BundleMeta bm) { for (ItemStack inside : bm.getItems()) { Material found = findLimitedInside(inside); if (found != null) return found; } } return null; } public String getLeakedCoords(Material mat) { return leakedCoordsMap.get(mat); } public void setLeakedCoords(Material mat, String coords) { leakedCoordsMap.put(mat, coords); itemStatusConfig.set("leaks." + mat.name(), coords); saveItemsConfig(); } public void clearAllLeakedCoords() { leakedCoordsMap.clear(); itemStatusConfig.set("leaks", null); try { itemStatusConfig.save(itemStatusFile); getLogger().info("Cleared all leaked coordinates and saved."); } catch (IOException e) { getLogger().severe("Failed to save cleared leaks in ItemStatus.yml: " + e.getMessage()); } } public void saveItemsConfig() { try { itemStatusConfig.save(itemStatusFile); } catch (IOException e) { getLogger().severe("Failed to save ItemStatus.yml"); } } public int getCrafted(Material mat) { return craftedCounts.getOrDefault(mat, 0); } public int getLimit(Material mat) { return limitedItems.getOrDefault(mat, 0); } public void resetCraftCount(Material mat) { craftedCounts.put(mat, 0); saveCraftCounts(); leakedCoordsMap.remove(mat); debug("Reset item data for: " + mat); } public void resetAllCraftCounts() { for (Material m : new ArrayList<>(craftedCounts.keySet())) craftedCounts.put(m, 0); saveCraftCounts(); debug("Reset all craft counts."); } public void checkServerCompatibility() { String name = Bukkit.getName().toLowerCase(Locale.ROOT); if (!name.contains("paper") && !name.contains("purpur")) { getLogger().warning("[ItemCap] Unsupported server type detected: " + Bukkit.getName()); getLogger().warning("[ItemCap] This plugin is tested only on Paper/Purpur 1.19.4+."); } String bukkitVersion = Bukkit.getBukkitVersion(); try { String[] parts = bukkitVersion.split("-")[0].split("\\."); int major = Integer.parseInt(parts[1]); int minor = parts.length > 2 ? Integer.parseInt(parts[2]) : 0; if (major < 19 || (major == 19 && minor < 4)) getLogger().severe("[ItemCap] Your server version is too old. Requires 1.20.0 or newer."); } catch (Exception e) { getLogger().warning("[ItemCap] Could not parse server version: " + bukkitVersion); } } }