BlueGit

timfa copper-key

Files

copper-key / src / main / java / nl / timfalken / copperkeys / CopperKeysPlugin.java

CopperKeysPlugin.java

CopperKeysPlugin.java 22.7 KiB Download Raw
1package nl.timfalken.copperkeys;
2
3import io.papermc.paper.event.block.BlockBreakBlockEvent;
4import io.papermc.paper.event.entity.ItemTransportingEntityValidateTargetEvent;
5import net.kyori.adventure.text.Component;
6import net.kyori.adventure.text.format.NamedTextColor;
7import org.bukkit.Bukkit;
8import org.bukkit.Location;
9import org.bukkit.Material;
10import org.bukkit.NamespacedKey;
11import org.bukkit.Particle;
12import org.bukkit.advancement.Advancement;
13import org.bukkit.advancement.AdvancementProgress;
14import org.bukkit.block.Block;
15import org.bukkit.block.BlockState;
16import org.bukkit.block.DoubleChest;
17import org.bukkit.block.data.Bisected;
18import org.bukkit.block.data.Openable;
19import org.bukkit.block.data.type.Door;
20import org.bukkit.entity.HumanEntity;
21import org.bukkit.entity.Player;
22import org.bukkit.event.EventHandler;
23import org.bukkit.event.block.Action;
24import org.bukkit.event.EventPriority;
25import org.bukkit.event.Listener;
26import org.bukkit.event.block.BlockBreakEvent;
27import org.bukkit.event.block.BlockBurnEvent;
28import org.bukkit.event.block.BlockExplodeEvent;
29import org.bukkit.event.block.BlockRedstoneEvent;
30import org.bukkit.event.block.CrafterCraftEvent;
31import org.bukkit.event.entity.EntityExplodeEvent;
32import org.bukkit.event.entity.EntityPickupItemEvent;
33import org.bukkit.event.inventory.CraftItemEvent;
34import org.bukkit.event.inventory.HopperInventorySearchEvent;
35import org.bukkit.event.inventory.InventoryClickEvent;
36import org.bukkit.event.inventory.InventoryCloseEvent;
37import org.bukkit.event.inventory.InventoryDragEvent;
38import org.bukkit.event.inventory.InventoryMoveItemEvent;
39import org.bukkit.event.inventory.InventoryOpenEvent;
40import org.bukkit.event.inventory.InventoryPickupItemEvent;
41import org.bukkit.event.inventory.PrepareItemCraftEvent;
42import org.bukkit.event.player.PlayerInteractEvent;
43import org.bukkit.event.player.PlayerJoinEvent;
44import org.bukkit.inventory.CraftingInventory;
45import org.bukkit.inventory.DoubleChestInventory;
46import org.bukkit.inventory.EquipmentSlot;
47import org.bukkit.inventory.Inventory;
48import org.bukkit.inventory.InventoryHolder;
49import org.bukkit.inventory.ItemStack;
50import org.bukkit.inventory.ShapedRecipe;
51import org.bukkit.inventory.ShapelessRecipe;
52import org.bukkit.plugin.java.JavaPlugin;
53
54import java.io.IOException;
55import java.io.InputStream;
56import java.nio.charset.StandardCharsets;
57import java.util.HashMap;
58import java.util.ArrayList;
59import java.util.LinkedHashSet;
60import java.util.List;
61import java.util.Locale;
62import java.util.Set;
63import java.util.UUID;
64import java.util.logging.Level;
65
66public final class CopperKeysPlugin extends JavaPlugin implements Listener {
67 private LockStore lockStore;
68 private KeyItems keyItems;
69 private NamespacedKey recipeKey;
70 private NamespacedKey copyRecipeKey;
71 private NamespacedKey burglarAdvancementKey;
72 private NamespacedKey oopsAdvancementKey;
73
74 @Override
75 public void onEnable() {
76 lockStore = new LockStore(this);
77 lockStore.load();
78 keyItems = new KeyItems(this);
79 recipeKey = new NamespacedKey(this, "blank_key");
80 copyRecipeKey = new NamespacedKey(this, "copy_key");
81 burglarAdvancementKey = new NamespacedKey(this, "burglar");
82 oopsAdvancementKey = new NamespacedKey(this, "oops");
83
84 registerRecipes();
85 registerAdvancement(burglarAdvancementKey, "advancements/burglar.json", "Burglar");
86 registerAdvancement(oopsAdvancementKey, "advancements/oops.json", "Oops");
87 getServer().getPluginManager().registerEvents(this, this);
88 getLogger().info("CopperKeys 1.0.0 enabled with event-driven lock handling.");
89 }
90
91 LockStore lockStore() {
92 return lockStore;
93 }
94
95 private void registerRecipes() {
96 Bukkit.removeRecipe(recipeKey);
97 Bukkit.removeRecipe(copyRecipeKey);
98
99 ShapedRecipe blankRecipe = new ShapedRecipe(recipeKey, keyItems.createBlankKey());
100 blankRecipe.shape("N ", " N");
101 blankRecipe.setIngredient('N', Material.COPPER_NUGGET);
102 Bukkit.addRecipe(blankRecipe);
103
104 // Ingredient match is material-only; PrepareItemCraftEvent validates blank + bound keys.
105 ShapelessRecipe copyRecipe = new ShapelessRecipe(copyRecipeKey, keyItems.createBlankKey());
106 copyRecipe.addIngredient(Material.CLOCK);
107 copyRecipe.addIngredient(Material.CLOCK);
108 Bukkit.addRecipe(copyRecipe);
109 }
110
111 private void registerAdvancement(NamespacedKey key, String resourcePath, String label) {
112 if (Bukkit.getAdvancement(key) != null) {
113 return;
114 }
115 try (InputStream in = getResource(resourcePath)) {
116 if (in == null) {
117 getLogger().warning("Missing " + resourcePath + "; " + label + " advancement not registered.");
118 return;
119 }
120 String json = new String(in.readAllBytes(), StandardCharsets.UTF_8);
121 @SuppressWarnings("deprecation")
122 Advancement loaded = Bukkit.getUnsafe().loadAdvancement(key, json);
123 if (loaded == null) {
124 getLogger().warning("Could not register " + label + " advancement.");
125 }
126 } catch (IOException | RuntimeException ex) {
127 getLogger().log(Level.WARNING, "Could not register " + label + " advancement", ex);
128 }
129 }
130
131 private void awardAdvancement(Player player, NamespacedKey key) {
132 Advancement advancement = Bukkit.getAdvancement(key);
133 if (advancement == null) {
134 return;
135 }
136 AdvancementProgress progress = player.getAdvancementProgress(advancement);
137 if (progress.isDone()) {
138 return;
139 }
140 for (String criterion : progress.getRemainingCriteria()) {
141 progress.awardCriteria(criterion);
142 }
143 }
144
145 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
146 public void onPlayerInteract(PlayerInteractEvent event) {
147 if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
148 return;
149 }
150 Block clicked = event.getClickedBlock();
151 if (clicked == null) {
152 return;
153 }
154
155 LockRecord existing = lockStore.get(BlockKey.of(clicked));
156 if (existing != null) {
157 Player player = event.getPlayer();
158 if (player.isSneaking()) {
159 ItemStack used = event.getItem();
160 UUID heldBinding = keyItems.getBinding(used);
161 if (heldBinding != null && heldBinding.equals(existing.bindingId())) {
162 event.setCancelled(true);
163 unlockBlock(player, clicked, existing);
164 return;
165 }
166 }
167 if (clicked.getBlockData() instanceof Openable openable && openable.isOpen()) {
168 // Closing is deliberately always allowed.
169 return;
170 }
171 if (!playerHasKey(player, existing.bindingId())) {
172 event.setCancelled(true);
173 denyOpen(player, clicked);
174 }
175 // Already locked: never bind a second key. Allow open/use only when the key check passed.
176 return;
177 }
178
179 ItemStack used = event.getItem();
180 if (used == null || !keyItems.isBlank(used) || !isBindable(clicked)) {
181 return;
182 }
183
184 List<BlockKey> members = collectMembers(clicked);
185 for (BlockKey member : members) {
186 if (lockStore.get(member) != null) {
187 event.setCancelled(true);
188 denyOpen(event.getPlayer(), clicked);
189 return;
190 }
191 }
192
193 LockRecord record = new LockRecord(UUID.randomUUID(), displayName(clicked), members);
194 lockStore.add(record);
195 keyItems.bind(used, record);
196 setUsedHandItem(event.getPlayer(), event.getHand(), used);
197 event.setCancelled(true); // The binding click itself never opens/toggles the target.
198 event.getPlayer().sendActionBar(Component.text("Key bound to " + record.displayName(), NamedTextColor.GOLD));
199 }
200
201 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
202 public void onInventoryOpen(InventoryOpenEvent event) {
203 LockRecord lock = lockForInventory(event.getInventory());
204 if (lock == null) {
205 return;
206 }
207 HumanEntity human = event.getPlayer();
208 if (human instanceof Player player && playerHasKey(player, lock.bindingId())) {
209 return;
210 }
211 event.setCancelled(true);
212 if (human instanceof Player player) {
213 denyOpen(player, blockForInventory(event.getInventory()));
214 }
215 }
216
217 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
218 public void onInventoryClick(InventoryClickEvent event) {
219 LockRecord lock = lockForInventory(event.getView().getTopInventory());
220 if (lock != null) {
221 HumanEntity human = event.getWhoClicked();
222 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
223 event.setCancelled(true);
224 if (human instanceof Player player) {
225 lockedMessage(player);
226 }
227 return;
228 }
229 }
230 ItemStack current = event.getCurrentItem();
231 if (current != null && keyItems.normalizeItem(current)) {
232 event.setCurrentItem(current);
233 }
234 }
235
236 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
237 public void onInventoryDrag(InventoryDragEvent event) {
238 LockRecord lock = lockForInventory(event.getView().getTopInventory());
239 if (lock != null) {
240 HumanEntity human = event.getWhoClicked();
241 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
242 event.setCancelled(true);
243 if (human instanceof Player player) {
244 lockedMessage(player);
245 }
246 return;
247 }
248 }
249 }
250
251 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
252 public void onInventoryMove(InventoryMoveItemEvent event) {
253 if (lockForInventory(event.getSource()) != null || lockForInventory(event.getDestination()) != null) {
254 event.setCancelled(true);
255 }
256 }
257
258 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
259 public void onInventoryPickup(InventoryPickupItemEvent event) {
260 if (lockForInventory(event.getInventory()) != null) {
261 event.setCancelled(true);
262 }
263 }
264
265 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
266 public void onHopperSearch(HopperInventorySearchEvent event) {
267 Inventory found = event.getInventory();
268 if (found != null && lockForInventory(found) != null) {
269 event.setInventory(null);
270 }
271 }
272
273 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
274 public void onTransportingEntityTarget(ItemTransportingEntityValidateTargetEvent event) {
275 if (lockStore.get(BlockKey.of(event.getBlock())) != null) {
276 // Copper Golems do not expose an inventory that could contain a key.
277 event.setAllowed(false);
278 }
279 }
280
281 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
282 public void onRedstone(BlockRedstoneEvent event) {
283 LockRecord lock = lockStore.get(BlockKey.of(event.getBlock()));
284 if (lock == null || !(event.getBlock().getBlockData() instanceof Openable openable)) {
285 return;
286 }
287 // A powered transition can close an already-open lock, but may not open a closed one.
288 if (!openable.isOpen() && event.getNewCurrent() > event.getOldCurrent()) {
289 event.setNewCurrent(event.getOldCurrent());
290 }
291 }
292
293 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
294 public void onPlayerBreak(BlockBreakEvent event) {
295 Block block = event.getBlock();
296 LockRecord lock = lockStore.get(BlockKey.of(block));
297 if (lock != null && !playerHasKey(event.getPlayer(), lock.bindingId())) {
298 awardAdvancement(event.getPlayer(), burglarAdvancementKey);
299 }
300 handleDestroyed(block);
301 }
302
303 @EventHandler(priority = EventPriority.MONITOR)
304 public void onForcedBreak(BlockBreakBlockEvent event) {
305 handleDestroyed(event.getBlock());
306 }
307
308 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
309 public void onBurn(BlockBurnEvent event) {
310 handleDestroyed(event.getBlock());
311 }
312
313 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
314 public void onBlockExplosion(BlockExplodeEvent event) {
315 for (Block block : event.blockList()) {
316 handleDestroyed(block);
317 }
318 }
319
320 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
321 public void onEntityExplosion(EntityExplodeEvent event) {
322 for (Block block : event.blockList()) {
323 handleDestroyed(block);
324 }
325 }
326
327 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
328 public void onInventoryClose(InventoryCloseEvent event) {
329 if (!(event.getPlayer() instanceof Player player)) {
330 return;
331 }
332 LockRecord lock = lockForInventory(event.getInventory());
333 if (lock == null) {
334 return;
335 }
336 if (playerHasKey(player, lock.bindingId())) {
337 return;
338 }
339 if (!keyItems.inventoryHasBinding(event.getInventory(), lock.bindingId())) {
340 return;
341 }
342 awardAdvancement(player, oopsAdvancementKey);
343 }
344
345 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
346 public void onPickup(EntityPickupItemEvent event) {
347 ItemStack stack = event.getItem().getItemStack();
348 if (keyItems.normalizeItem(stack)) {
349 event.getItem().setItemStack(stack);
350 }
351 }
352
353 @EventHandler(priority = EventPriority.MONITOR)
354 public void onJoin(PlayerJoinEvent event) {
355 keyItems.normalizeInventory(event.getPlayer().getInventory());
356 }
357
358 @EventHandler(priority = EventPriority.HIGHEST)
359 public void onPrepareCraft(PrepareItemCraftEvent event) {
360 CraftingInventory inv = event.getInventory();
361 ItemStack clone = keyCloneResult(inv);
362 if (clone != null) {
363 inv.setResult(clone);
364 return;
365 }
366
367 boolean containsKey = false;
368 for (ItemStack item : inv.getMatrix()) {
369 if (keyItems.isKey(item)) {
370 containsKey = true;
371 break;
372 }
373 }
374 if (!containsKey) {
375 return;
376 }
377 if (inv.getRecipe() instanceof org.bukkit.inventory.CraftingRecipe recipe
378 && recipeKey.equals(recipe.getKey())) {
379 return;
380 }
381 inv.setResult(null);
382 }
383
384 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
385 public void onCraftItem(CraftItemEvent event) {
386 ItemStack clone = keyCloneResult(event.getInventory());
387 if (clone == null || !(event.getWhoClicked() instanceof Player player)) {
388 return;
389 }
390 ItemStack second = clone.clone();
391 getServer().getScheduler().runTask(this, () -> {
392 HashMap<Integer, ItemStack> leftover = player.getInventory().addItem(second);
393 for (ItemStack drop : leftover.values()) {
394 player.getWorld().dropItemNaturally(player.getLocation(), drop);
395 }
396 });
397 }
398
399 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
400 public void onCrafterCraft(CrafterCraftEvent event) {
401 if (!(event.getBlock().getState() instanceof org.bukkit.block.Crafter crafter)) {
402 return;
403 }
404 if (recipeKey.equals(event.getRecipe().getKey())) {
405 return;
406 }
407 for (ItemStack item : crafter.getInventory().getContents()) {
408 if (keyItems.isKey(item)) {
409 event.setCancelled(true);
410 return;
411 }
412 }
413 }
414
415 private ItemStack keyCloneResult(CraftingInventory inventory) {
416 ItemStack blank = null;
417 ItemStack bound = null;
418 for (ItemStack item : inventory.getMatrix()) {
419 if (item == null || item.getType().isAir()) {
420 continue;
421 }
422 if (keyItems.isBlank(item)) {
423 if (blank != null) {
424 return null;
425 }
426 blank = item;
427 } else if (keyItems.isKey(item)) {
428 if (keyItems.getBinding(item) == null || bound != null) {
429 return null;
430 }
431 bound = item;
432 } else {
433 return null;
434 }
435 }
436 if (blank == null || bound == null) {
437 return null;
438 }
439 LockRecord lock = lockStore.get(keyItems.getBinding(bound));
440 if (lock == null) {
441 return null;
442 }
443 return keyItems.createBoundKey(lock);
444 }
445
446 private void handleDestroyed(Block block) {
447 LockRecord removed = lockStore.removeByBlock(BlockKey.of(block));
448 if (removed == null) {
449 return;
450 }
451 blankLinkedKeys(removed.bindingId(), block);
452 }
453
454 private void unlockBlock(Player player, Block block, LockRecord lock) {
455 lockStore.remove(lock.bindingId());
456 blankLinkedKeys(lock.bindingId(), block);
457 player.sendActionBar(Component.text("Unlocked — all matching keys cleared", NamedTextColor.GOLD));
458 }
459
460 private void blankLinkedKeys(UUID bindingId, Block block) {
461 for (Player online : Bukkit.getOnlinePlayers()) {
462 keyItems.blankBindingInInventory(online.getInventory(), bindingId);
463 }
464 BlockState state = block.getState();
465 if (state instanceof InventoryHolder holder) {
466 keyItems.blankBindingInInventory(holder.getInventory(), bindingId);
467 }
468 }
469
470 private boolean playerHasKey(Player player, UUID bindingId) {
471 return keyItems.inventoryHasBinding(player.getInventory(), bindingId);
472 }
473
474 private boolean isBindable(Block block) {
475 BlockState state = block.getState();
476 return block.getBlockData() instanceof Openable || state instanceof InventoryHolder;
477 }
478
479 private List<BlockKey> collectMembers(Block block) {
480 Set<BlockKey> members = new LinkedHashSet<>();
481 members.add(BlockKey.of(block));
482
483 BlockState state = block.getState();
484 if (state instanceof org.bukkit.block.Chest chest) {
485 Inventory inventory = chest.getInventory();
486 InventoryHolder holder = inventory.getHolder();
487 if (holder instanceof DoubleChest doubleChest) {
488 addChestSide(members, doubleChest.getLeftSide());
489 addChestSide(members, doubleChest.getRightSide());
490 }
491 }
492
493 if (block.getBlockData() instanceof Door door) {
494 Block other = door.getHalf() == Bisected.Half.BOTTOM
495 ? block.getRelative(0, 1, 0)
496 : block.getRelative(0, -1, 0);
497 if (other.getBlockData() instanceof Door) {
498 members.add(BlockKey.of(other));
499 }
500 }
501
502 return new ArrayList<>(members);
503 }
504
505 private void addChestSide(Set<BlockKey> members, InventoryHolder side) {
506 if (side instanceof BlockState state) {
507 members.add(BlockKey.of(state.getBlock()));
508 }
509 }
510
511 private LockRecord lockForInventory(Inventory inventory) {
512 InventoryHolder holder = inventory.getHolder();
513 if (holder instanceof DoubleChest doubleChest) {
514 LockRecord left = lockForSide(doubleChest.getLeftSide());
515 return left != null ? left : lockForSide(doubleChest.getRightSide());
516 }
517 if (holder instanceof BlockState state) {
518 return lockStore.get(BlockKey.of(state.getBlock()));
519 }
520 // Some double chest inventories expose their holder through DoubleChestInventory.
521 if (inventory instanceof DoubleChestInventory doubleInventory) {
522 InventoryHolder doubleHolder = doubleInventory.getHolder();
523 if (doubleHolder instanceof DoubleChest doubleChest) {
524 LockRecord left = lockForSide(doubleChest.getLeftSide());
525 return left != null ? left : lockForSide(doubleChest.getRightSide());
526 }
527 }
528 return null;
529 }
530
531 private LockRecord lockForSide(InventoryHolder side) {
532 if (side instanceof BlockState state) {
533 return lockStore.get(BlockKey.of(state.getBlock()));
534 }
535 return null;
536 }
537
538 private Block blockForInventory(Inventory inventory) {
539 InventoryHolder holder = inventory.getHolder();
540 if (holder instanceof DoubleChest doubleChest) {
541 InventoryHolder left = doubleChest.getLeftSide();
542 if (left instanceof BlockState state) {
543 return state.getBlock();
544 }
545 InventoryHolder right = doubleChest.getRightSide();
546 if (right instanceof BlockState state) {
547 return state.getBlock();
548 }
549 }
550 if (holder instanceof BlockState state) {
551 return state.getBlock();
552 }
553 if (inventory instanceof DoubleChestInventory doubleInventory
554 && doubleInventory.getHolder() instanceof DoubleChest doubleChest) {
555 InventoryHolder left = doubleChest.getLeftSide();
556 if (left instanceof BlockState state) {
557 return state.getBlock();
558 }
559 }
560 return null;
561 }
562
563 private void setUsedHandItem(Player player, EquipmentSlot hand, ItemStack item) {
564 if (hand == EquipmentSlot.OFF_HAND) {
565 player.getInventory().setItemInOffHand(item);
566 } else {
567 player.getInventory().setItemInMainHand(item);
568 }
569 }
570
571 private void denyOpen(Player player, Block block) {
572 lockedMessage(player);
573 if (block == null) {
574 return;
575 }
576 Location at = block.getLocation().add(0.5, 0.6, 0.5);
577 block.getWorld().spawnParticle(Particle.SMOKE, at, 16, 0.28, 0.4, 0.28, 0.01);
578 }
579
580 private void lockedMessage(Player player) {
581 player.sendActionBar(Component.text("Locked — matching key required", NamedTextColor.RED));
582 }
583
584 private String displayName(Block block) {
585 return titleCase(block.getType().name());
586 }
587
588 private String titleCase(String enumName) {
589 String[] words = enumName.toLowerCase(Locale.ROOT).split("_");
590 StringBuilder result = new StringBuilder();
591 for (String word : words) {
592 if (word.isEmpty()) {
593 continue;
594 }
595 if (!result.isEmpty()) {
596 result.append(' ');
597 }
598 result.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1));
599 }
600 return result.toString();
601 }
602}