package nl.timfalken.copperkeys; import io.papermc.paper.event.block.BlockBreakBlockEvent; import io.papermc.paper.event.entity.ItemTransportingEntityValidateTargetEvent; import net.kyori.adventure.text.Component; import net.kyori.adventure.text.format.NamedTextColor; import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.Particle; import org.bukkit.Sound; import org.bukkit.advancement.Advancement; import org.bukkit.advancement.AdvancementProgress; import org.bukkit.block.Block; import org.bukkit.block.BlockState; import org.bukkit.block.DoubleChest; import org.bukkit.block.data.Bisected; import org.bukkit.block.data.Openable; import org.bukkit.block.data.type.Door; import org.bukkit.entity.HumanEntity; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.block.Action; import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; import org.bukkit.event.block.BlockBreakEvent; import org.bukkit.event.block.BlockBurnEvent; import org.bukkit.event.block.BlockExplodeEvent; import org.bukkit.event.block.BlockRedstoneEvent; import org.bukkit.event.block.CrafterCraftEvent; import org.bukkit.event.entity.EntityExplodeEvent; import org.bukkit.event.entity.EntityPickupItemEvent; import org.bukkit.event.inventory.CraftItemEvent; import org.bukkit.event.inventory.HopperInventorySearchEvent; import org.bukkit.event.inventory.InventoryClickEvent; import org.bukkit.event.inventory.InventoryCloseEvent; import org.bukkit.event.inventory.InventoryDragEvent; import org.bukkit.event.inventory.InventoryMoveItemEvent; import org.bukkit.event.inventory.InventoryOpenEvent; import org.bukkit.event.inventory.InventoryPickupItemEvent; import org.bukkit.event.inventory.PrepareAnvilEvent; import org.bukkit.event.inventory.PrepareItemCraftEvent; import org.bukkit.event.player.PlayerInteractEvent; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.inventory.AnvilInventory; import org.bukkit.inventory.CraftingInventory; import org.bukkit.inventory.DoubleChestInventory; import org.bukkit.inventory.EquipmentSlot; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.InventoryHolder; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ShapedRecipe; import org.bukkit.inventory.ShapelessRecipe; import org.bukkit.plugin.java.JavaPlugin; import java.io.IOException; import java.io.InputStream; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Set; import java.util.UUID; import java.util.logging.Level; public final class CopperKeysPlugin extends JavaPlugin implements Listener { private LockStore lockStore; private KeyItems keyItems; private NamespacedKey recipeKey; private NamespacedKey copyRecipeKey; private NamespacedKey burglarAdvancementKey; private NamespacedKey oopsAdvancementKey; @Override public void onEnable() { lockStore = new LockStore(this); lockStore.load(); keyItems = new KeyItems(this); recipeKey = new NamespacedKey(this, "blank_key"); copyRecipeKey = new NamespacedKey(this, "copy_key"); burglarAdvancementKey = new NamespacedKey(this, "burglar"); oopsAdvancementKey = new NamespacedKey(this, "oops"); registerRecipes(); registerAdvancements(); var keyNameCommand = getCommand("keyname"); if (keyNameCommand != null) { keyNameCommand.setExecutor(new KeyNameCommand(this)); } else { getLogger().warning("Command 'keyname' missing from plugin.yml"); } getServer().getPluginManager().registerEvents(this, this); getLogger().info("CopperKeys 1.0.7 enabled with event-driven lock handling."); } LockStore lockStore() { return lockStore; } KeyItems keyItems() { return keyItems; } void renameKeyBinding(UUID bindingId, String keyName) { LockRecord updated = lockStore.setKeyName(bindingId, keyName); if (updated == null) { return; } for (Player online : Bukkit.getOnlinePlayers()) { keyItems.applyNameInInventory(online.getInventory(), bindingId); keyItems.applyNameInInventory(online.getEnderChest(), bindingId); online.updateInventory(); } } private void registerRecipes() { Bukkit.removeRecipe(recipeKey); Bukkit.removeRecipe(copyRecipeKey); ShapedRecipe blankRecipe = new ShapedRecipe(recipeKey, keyItems.createBlankKey()); blankRecipe.shape("N ", " N"); blankRecipe.setIngredient('N', Material.COPPER_NUGGET); Bukkit.addRecipe(blankRecipe); // Ingredient match is material-only; PrepareItemCraftEvent validates blank + bound keys. ShapelessRecipe copyRecipe = new ShapelessRecipe(copyRecipeKey, keyItems.createBlankKey()); copyRecipe.addIngredient(Material.CLOCK); copyRecipe.addIngredient(Material.CLOCK); Bukkit.addRecipe(copyRecipe); } private void registerAdvancements() { if (Bukkit.getAdvancement(burglarAdvancementKey) != null && Bukkit.getAdvancement(oopsAdvancementKey) != null) { return; } String burglarJson = readAdvancementJson("advancements/burglar.json", "Burglar"); String oopsJson = readAdvancementJson("advancements/oops.json", "Oops"); if (burglarJson == null || oopsJson == null) { return; } Map definitions = Map.of( burglarAdvancementKey, burglarJson, oopsAdvancementKey, oopsJson ); try { List loaded = Bukkit.getUnsafe().loadAdvancements(definitions, false); if (loaded.size() != definitions.size()) { getLogger().warning("Registered " + loaded.size() + " of " + definitions.size() + " advancements."); } } catch (RuntimeException ex) { getLogger().log(Level.WARNING, "Could not register CopperKeys advancements", ex); } } private String readAdvancementJson(String resourcePath, String label) { try (InputStream in = getResource(resourcePath)) { if (in == null) { getLogger().warning("Missing " + resourcePath + "; " + label + " advancement not registered."); return null; } return new String(in.readAllBytes(), StandardCharsets.UTF_8); } catch (IOException ex) { getLogger().log(Level.WARNING, "Could not read " + label + " advancement", ex); return null; } } private void awardAdvancement(Player player, NamespacedKey key) { Advancement advancement = Bukkit.getAdvancement(key); if (advancement == null) { return; } AdvancementProgress progress = player.getAdvancementProgress(advancement); if (progress.isDone()) { return; } for (String criterion : progress.getRemainingCriteria()) { progress.awardCriteria(criterion); } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onPlayerInteract(PlayerInteractEvent event) { if (event.getAction() != Action.RIGHT_CLICK_BLOCK) { return; } Block clicked = event.getClickedBlock(); if (clicked == null) { return; } LockRecord existing = lockStore.get(BlockKey.of(clicked)); if (existing != null) { Player player = event.getPlayer(); ItemStack used = event.getItem(); UUID heldBinding = keyItems.getBinding(used); boolean holdingMatchingKey = heldBinding != null && heldBinding.equals(existing.bindingId()); if (player.isSneaking() && holdingMatchingKey) { event.setCancelled(true); unlockBlock(player, clicked, existing); return; } // Iron doors/trapdoors do not open by hand in vanilla; toggle them with the matching key. if (isKeyOperatedOpenable(clicked) && holdingMatchingKey) { event.setCancelled(true); toggleKeyOperatedOpenable(clicked); return; } if (clicked.getBlockData() instanceof Openable openable && openable.isOpen()) { // Closing wooden openables is deliberately always allowed. return; } if (!playerHasKey(player, existing.bindingId())) { event.setCancelled(true); denyOpen(player, clicked); } // Already locked: never bind a second key. Allow open/use only when the key check passed. return; } ItemStack used = event.getItem(); if (used == null || !keyItems.isBlank(used) || !isBindable(clicked)) { return; } List members = collectMembers(clicked); for (BlockKey member : members) { if (lockStore.get(member) != null) { event.setCancelled(true); denyOpen(event.getPlayer(), clicked); return; } } LockRecord record = LockRecord.create(UUID.randomUUID(), displayName(clicked), members); lockStore.add(record); Player player = event.getPlayer(); ItemStack bound = used.clone(); bound.setAmount(1); keyItems.bind(bound, record); if (used.getAmount() > 1) { used.setAmount(used.getAmount() - 1); setUsedHandItem(player, event.getHand(), used); var leftover = player.getInventory().addItem(bound); for (ItemStack drop : leftover.values()) { player.getWorld().dropItemNaturally(player.getLocation(), drop); } } else { setUsedHandItem(player, event.getHand(), bound); } event.setCancelled(true); // The binding click itself never opens/toggles the target. player.sendActionBar(Component.text("Key bound to " + record.displayName(), NamedTextColor.GOLD)); } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onInventoryOpen(InventoryOpenEvent event) { LockRecord lock = lockForInventory(event.getInventory()); if (lock == null) { return; } HumanEntity human = event.getPlayer(); if (human instanceof Player player && playerHasKey(player, lock.bindingId())) { return; } event.setCancelled(true); if (human instanceof Player player) { denyOpen(player, blockForInventory(event.getInventory())); } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onInventoryClick(InventoryClickEvent event) { if (event.getInventory() instanceof AnvilInventory anvil && event.getRawSlot() == 2) { handleAnvilResultTake(event, anvil); } LockRecord lock = lockForInventory(event.getView().getTopInventory()); if (lock != null) { HumanEntity human = event.getWhoClicked(); if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) { event.setCancelled(true); if (human instanceof Player player) { lockedMessage(player); } return; } } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onPrepareAnvil(PrepareAnvilEvent event) { AnvilInventory anvil = event.getInventory(); ItemStack first = anvil.getFirstItem(); if (first == null || !keyItems.isKey(first)) { return; } if (keyItems.isBlank(first)) { event.setResult(null); return; } String renameText = anvil.getRenameText(); if (renameText == null || renameText.isBlank()) { return; } String name = sanitizeKeyName(renameText); if (name == null) { event.setResult(null); return; } UUID bindingId = keyItems.getBinding(first); LockRecord lock = bindingId == null ? null : lockStore.get(bindingId); if (lock == null) { event.setResult(null); return; } ItemStack result = first.clone(); keyItems.applyBoundAppearance(result, lock.withKeyName(name)); event.setResult(result); anvil.setRepairCost(1); } private void handleAnvilResultTake(InventoryClickEvent event, AnvilInventory anvil) { ItemStack result = event.getCurrentItem(); if (result == null || !keyItems.isKey(result) || keyItems.isBlank(result)) { return; } String renameText = anvil.getRenameText(); if (renameText == null || renameText.isBlank()) { return; } String name = sanitizeKeyName(renameText); UUID bindingId = keyItems.getBinding(result); if (name == null || bindingId == null || lockStore.get(bindingId) == null) { return; } Bukkit.getScheduler().runTask(this, () -> renameKeyBinding(bindingId, name)); } private static String sanitizeKeyName(String raw) { String name = raw.trim(); if (name.isEmpty()) { return null; } if (name.length() > KeyItems.MAX_KEY_NAME_LENGTH) { return name.substring(0, KeyItems.MAX_KEY_NAME_LENGTH); } return name; } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onInventoryDrag(InventoryDragEvent event) { LockRecord lock = lockForInventory(event.getView().getTopInventory()); if (lock != null) { HumanEntity human = event.getWhoClicked(); if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) { event.setCancelled(true); if (human instanceof Player player) { lockedMessage(player); } return; } } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onInventoryMove(InventoryMoveItemEvent event) { if (lockForInventory(event.getSource()) != null || lockForInventory(event.getDestination()) != null) { event.setCancelled(true); } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onInventoryPickup(InventoryPickupItemEvent event) { if (lockForInventory(event.getInventory()) != null) { event.setCancelled(true); } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onHopperSearch(HopperInventorySearchEvent event) { Inventory found = event.getInventory(); if (found != null && lockForInventory(found) != null) { event.setInventory(null); } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onTransportingEntityTarget(ItemTransportingEntityValidateTargetEvent event) { if (lockStore.get(BlockKey.of(event.getBlock())) != null) { // Copper Golems do not expose an inventory that could contain a key. event.setAllowed(false); } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onRedstone(BlockRedstoneEvent event) { LockRecord lock = lockStore.get(BlockKey.of(event.getBlock())); if (lock == null || !(event.getBlock().getBlockData() instanceof Openable openable)) { return; } // A powered transition can close an already-open lock, but may not open a closed one. if (!openable.isOpen() && event.getNewCurrent() > event.getOldCurrent()) { event.setNewCurrent(event.getOldCurrent()); } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onPlayerBreak(BlockBreakEvent event) { Block block = event.getBlock(); LockRecord lock = lockStore.get(BlockKey.of(block)); if (lock != null && !playerHasKey(event.getPlayer(), lock.bindingId())) { awardAdvancement(event.getPlayer(), burglarAdvancementKey); } handleDestroyed(block); } @EventHandler(priority = EventPriority.MONITOR) public void onForcedBreak(BlockBreakBlockEvent event) { handleDestroyed(event.getBlock()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onBurn(BlockBurnEvent event) { handleDestroyed(event.getBlock()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onBlockExplosion(BlockExplodeEvent event) { for (Block block : event.blockList()) { handleDestroyed(block); } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onEntityExplosion(EntityExplodeEvent event) { for (Block block : event.blockList()) { handleDestroyed(block); } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onInventoryClose(InventoryCloseEvent event) { if (!(event.getPlayer() instanceof Player player)) { return; } // Normalize after the click/close transaction so sync never fights the client mid-click. keyItems.normalizeInventory(player.getInventory()); LockRecord lock = lockForInventory(event.getInventory()); if (lock == null) { return; } if (playerHasKey(player, lock.bindingId())) { return; } if (!keyItems.inventoryHasBinding(event.getInventory(), lock.bindingId())) { return; } awardAdvancement(player, oopsAdvancementKey); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onPickup(EntityPickupItemEvent event) { ItemStack stack = event.getItem().getItemStack(); if (keyItems.normalizeItem(stack)) { event.getItem().setItemStack(stack); } } @EventHandler(priority = EventPriority.MONITOR) public void onJoin(PlayerJoinEvent event) { keyItems.normalizeInventory(event.getPlayer().getInventory()); } @EventHandler(priority = EventPriority.HIGHEST) public void onPrepareCraft(PrepareItemCraftEvent event) { CraftingInventory inv = event.getInventory(); ItemStack clone = keyCloneResult(inv); if (clone != null) { inv.setResult(clone); return; } boolean containsKey = false; for (ItemStack item : inv.getMatrix()) { if (keyItems.isKey(item)) { containsKey = true; break; } } if (!containsKey) { return; } if (inv.getRecipe() instanceof org.bukkit.inventory.CraftingRecipe recipe && recipeKey.equals(recipe.getKey())) { return; } inv.setResult(null); } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onCraftItem(CraftItemEvent event) { ItemStack clone = keyCloneResult(event.getInventory()); if (clone == null || !(event.getWhoClicked() instanceof Player player)) { return; } ItemStack second = clone.clone(); getServer().getScheduler().runTask(this, () -> { HashMap leftover = player.getInventory().addItem(second); for (ItemStack drop : leftover.values()) { player.getWorld().dropItemNaturally(player.getLocation(), drop); } player.updateInventory(); }); } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onCrafterCraft(CrafterCraftEvent event) { if (!(event.getBlock().getState() instanceof org.bukkit.block.Crafter crafter)) { return; } if (recipeKey.equals(event.getRecipe().getKey())) { return; } for (ItemStack item : crafter.getInventory().getContents()) { if (keyItems.isKey(item)) { event.setCancelled(true); return; } } } private ItemStack keyCloneResult(CraftingInventory inventory) { ItemStack blank = null; ItemStack bound = null; for (ItemStack item : inventory.getMatrix()) { if (item == null || item.getType().isAir()) { continue; } if (keyItems.isBlank(item)) { if (blank != null) { return null; } blank = item; } else if (keyItems.isKey(item)) { if (keyItems.getBinding(item) == null || bound != null) { return null; } bound = item; } else { return null; } } if (blank == null || bound == null) { return null; } LockRecord lock = lockStore.get(keyItems.getBinding(bound)); if (lock == null) { return null; } return keyItems.createBoundKey(lock); } private boolean isKeyOperatedOpenable(Block block) { Material type = block.getType(); return type == Material.IRON_DOOR || type == Material.IRON_TRAPDOOR; } private void toggleKeyOperatedOpenable(Block block) { if (!(block.getBlockData() instanceof Openable openable)) { return; } boolean open = !openable.isOpen(); Bisected.Half doorHalf = block.getBlockData() instanceof Door door ? door.getHalf() : null; openable.setOpen(open); block.setBlockData(openable, true); if (doorHalf != null) { Block other = doorHalf == Bisected.Half.BOTTOM ? block.getRelative(0, 1, 0) : block.getRelative(0, -1, 0); if (other.getBlockData() instanceof Door otherDoor) { otherDoor.setOpen(open); other.setBlockData(otherDoor, false); } } Sound sound; if (block.getType() == Material.IRON_TRAPDOOR) { sound = open ? Sound.BLOCK_IRON_TRAPDOOR_OPEN : Sound.BLOCK_IRON_TRAPDOOR_CLOSE; } else { sound = open ? Sound.BLOCK_IRON_DOOR_OPEN : Sound.BLOCK_IRON_DOOR_CLOSE; } block.getWorld().playSound(block.getLocation().add(0.5, 0.5, 0.5), sound, 1.0f, 1.0f); } private void handleDestroyed(Block block) { LockRecord removed = lockStore.removeByBlock(BlockKey.of(block)); if (removed == null) { return; } blankLinkedKeys(removed.bindingId(), block); } private void unlockBlock(Player player, Block block, LockRecord lock) { lockStore.remove(lock.bindingId()); blankLinkedKeys(lock.bindingId(), block); player.sendActionBar(Component.text("Unlocked — all matching keys cleared", NamedTextColor.GOLD)); } private void blankLinkedKeys(UUID bindingId, Block block) { for (Player online : Bukkit.getOnlinePlayers()) { keyItems.blankBindingInInventory(online.getInventory(), bindingId); online.updateInventory(); } BlockState state = block.getState(); if (state instanceof InventoryHolder holder) { keyItems.blankBindingInInventory(holder.getInventory(), bindingId); } } private boolean playerHasKey(Player player, UUID bindingId) { return keyItems.inventoryHasBinding(player.getInventory(), bindingId); } private boolean isBindable(Block block) { BlockState state = block.getState(); return block.getBlockData() instanceof Openable || state instanceof InventoryHolder; } private List collectMembers(Block block) { Set members = new LinkedHashSet<>(); members.add(BlockKey.of(block)); BlockState state = block.getState(); if (state instanceof org.bukkit.block.Chest chest) { Inventory inventory = chest.getInventory(); InventoryHolder holder = inventory.getHolder(); if (holder instanceof DoubleChest doubleChest) { addChestSide(members, doubleChest.getLeftSide()); addChestSide(members, doubleChest.getRightSide()); } } if (block.getBlockData() instanceof Door door) { Block other = door.getHalf() == Bisected.Half.BOTTOM ? block.getRelative(0, 1, 0) : block.getRelative(0, -1, 0); if (other.getBlockData() instanceof Door) { members.add(BlockKey.of(other)); } } return new ArrayList<>(members); } private void addChestSide(Set members, InventoryHolder side) { if (side instanceof BlockState state) { members.add(BlockKey.of(state.getBlock())); } } private LockRecord lockForInventory(Inventory inventory) { InventoryHolder holder = inventory.getHolder(); if (holder instanceof DoubleChest doubleChest) { LockRecord left = lockForSide(doubleChest.getLeftSide()); return left != null ? left : lockForSide(doubleChest.getRightSide()); } if (holder instanceof BlockState state) { return lockStore.get(BlockKey.of(state.getBlock())); } // Some double chest inventories expose their holder through DoubleChestInventory. if (inventory instanceof DoubleChestInventory doubleInventory) { InventoryHolder doubleHolder = doubleInventory.getHolder(); if (doubleHolder instanceof DoubleChest doubleChest) { LockRecord left = lockForSide(doubleChest.getLeftSide()); return left != null ? left : lockForSide(doubleChest.getRightSide()); } } return null; } private LockRecord lockForSide(InventoryHolder side) { if (side instanceof BlockState state) { return lockStore.get(BlockKey.of(state.getBlock())); } return null; } private Block blockForInventory(Inventory inventory) { InventoryHolder holder = inventory.getHolder(); if (holder instanceof DoubleChest doubleChest) { InventoryHolder left = doubleChest.getLeftSide(); if (left instanceof BlockState state) { return state.getBlock(); } InventoryHolder right = doubleChest.getRightSide(); if (right instanceof BlockState state) { return state.getBlock(); } } if (holder instanceof BlockState state) { return state.getBlock(); } if (inventory instanceof DoubleChestInventory doubleInventory && doubleInventory.getHolder() instanceof DoubleChest doubleChest) { InventoryHolder left = doubleChest.getLeftSide(); if (left instanceof BlockState state) { return state.getBlock(); } } return null; } private void setUsedHandItem(Player player, EquipmentSlot hand, ItemStack item) { if (hand == EquipmentSlot.OFF_HAND) { player.getInventory().setItemInOffHand(item); } else { player.getInventory().setItemInMainHand(item); } } private void denyOpen(Player player, Block block) { lockedMessage(player); if (block == null) { return; } Location at = block.getLocation().add(0.5, 0.6, 0.5); block.getWorld().spawnParticle(Particle.SMOKE, at, 16, 0.28, 0.4, 0.28, 0.01); } private void lockedMessage(Player player) { player.sendActionBar(Component.text("Locked — matching key required", NamedTextColor.RED)); } private String displayName(Block block) { return titleCase(block.getType().name()); } private String titleCase(String enumName) { String[] words = enumName.toLowerCase(Locale.ROOT).split("_"); StringBuilder result = new StringBuilder(); for (String word : words) { if (word.isEmpty()) { continue; } if (!result.isEmpty()) { result.append(' '); } result.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1)); } return result.toString(); } }