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.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.PrepareItemCraftEvent; import org.bukkit.event.player.PlayerInteractEvent; import org.bukkit.event.player.PlayerJoinEvent; 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.HashMap; import java.util.ArrayList; import java.util.LinkedHashSet; import java.util.List; import java.util.Locale; 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(); registerAdvancement(burglarAdvancementKey, "advancements/burglar.json", "Burglar"); registerAdvancement(oopsAdvancementKey, "advancements/oops.json", "Oops"); getServer().getPluginManager().registerEvents(this, this); getLogger().info("CopperKeys 1.0.0 enabled with event-driven lock handling."); } LockStore lockStore() { return lockStore; } 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 registerAdvancement(NamespacedKey key, String resourcePath, String label) { if (Bukkit.getAdvancement(key) != null) { return; } try (InputStream in = getResource(resourcePath)) { if (in == null) { getLogger().warning("Missing " + resourcePath + "; " + label + " advancement not registered."); return; } String json = new String(in.readAllBytes(), StandardCharsets.UTF_8); @SuppressWarnings("deprecation") Advancement loaded = Bukkit.getUnsafe().loadAdvancement(key, json); if (loaded == null) { getLogger().warning("Could not register " + label + " advancement."); } } catch (IOException | RuntimeException ex) { getLogger().log(Level.WARNING, "Could not register " + label + " advancement", ex); } } 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) { if (clicked.getBlockData() instanceof Openable openable && openable.isOpen()) { // Closing is deliberately always allowed. return; } if (!playerHasKey(event.getPlayer(), existing.bindingId())) { event.setCancelled(true); denyOpen(event.getPlayer(), 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 = new LockRecord(UUID.randomUUID(), displayName(clicked), members); lockStore.add(record); keyItems.bind(used, record); setUsedHandItem(event.getPlayer(), event.getHand(), used); event.setCancelled(true); // The binding click itself never opens/toggles the target. event.getPlayer().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) { 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; } } ItemStack current = event.getCurrentItem(); if (current != null && keyItems.normalizeItem(current)) { event.setCurrentItem(current); } } @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; } 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); } }); } @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 void handleDestroyed(Block block) { LockRecord removed = lockStore.removeByBlock(BlockKey.of(block)); if (removed == null) { return; } for (Player player : Bukkit.getOnlinePlayers()) { keyItems.blankBindingInInventory(player.getInventory(), removed.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(); } }