BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

CopperKeysPlugin.java 23.1 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
196 Player player = event.getPlayer();
197 ItemStack bound = used.clone();
198 bound.setAmount(1);
199 keyItems.bind(bound, record);
200 if (used.getAmount() > 1) {
201 used.setAmount(used.getAmount() - 1);
202 setUsedHandItem(player, event.getHand(), used);
203 var leftover = player.getInventory().addItem(bound);
204 for (ItemStack drop : leftover.values()) {
205 player.getWorld().dropItemNaturally(player.getLocation(), drop);
206 }
207 } else {
208 setUsedHandItem(player, event.getHand(), bound);
209 }
210 event.setCancelled(true); // The binding click itself never opens/toggles the target.
211 player.sendActionBar(Component.text("Key bound to " + record.displayName(), NamedTextColor.GOLD));
212 }
213
214 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
215 public void onInventoryOpen(InventoryOpenEvent event) {
216 LockRecord lock = lockForInventory(event.getInventory());
217 if (lock == null) {
218 return;
219 }
220 HumanEntity human = event.getPlayer();
221 if (human instanceof Player player && playerHasKey(player, lock.bindingId())) {
222 return;
223 }
224 event.setCancelled(true);
225 if (human instanceof Player player) {
226 denyOpen(player, blockForInventory(event.getInventory()));
227 }
228 }
229
230 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
231 public void onInventoryClick(InventoryClickEvent event) {
232 LockRecord lock = lockForInventory(event.getView().getTopInventory());
233 if (lock != null) {
234 HumanEntity human = event.getWhoClicked();
235 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
236 event.setCancelled(true);
237 if (human instanceof Player player) {
238 lockedMessage(player);
239 }
240 return;
241 }
242 }
243 ItemStack current = event.getCurrentItem();
244 if (current != null && keyItems.normalizeItem(current)) {
245 event.setCurrentItem(current);
246 }
247 }
248
249 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
250 public void onInventoryDrag(InventoryDragEvent event) {
251 LockRecord lock = lockForInventory(event.getView().getTopInventory());
252 if (lock != null) {
253 HumanEntity human = event.getWhoClicked();
254 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
255 event.setCancelled(true);
256 if (human instanceof Player player) {
257 lockedMessage(player);
258 }
259 return;
260 }
261 }
262 }
263
264 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
265 public void onInventoryMove(InventoryMoveItemEvent event) {
266 if (lockForInventory(event.getSource()) != null || lockForInventory(event.getDestination()) != null) {
267 event.setCancelled(true);
268 }
269 }
270
271 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
272 public void onInventoryPickup(InventoryPickupItemEvent event) {
273 if (lockForInventory(event.getInventory()) != null) {
274 event.setCancelled(true);
275 }
276 }
277
278 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
279 public void onHopperSearch(HopperInventorySearchEvent event) {
280 Inventory found = event.getInventory();
281 if (found != null && lockForInventory(found) != null) {
282 event.setInventory(null);
283 }
284 }
285
286 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
287 public void onTransportingEntityTarget(ItemTransportingEntityValidateTargetEvent event) {
288 if (lockStore.get(BlockKey.of(event.getBlock())) != null) {
289 // Copper Golems do not expose an inventory that could contain a key.
290 event.setAllowed(false);
291 }
292 }
293
294 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
295 public void onRedstone(BlockRedstoneEvent event) {
296 LockRecord lock = lockStore.get(BlockKey.of(event.getBlock()));
297 if (lock == null || !(event.getBlock().getBlockData() instanceof Openable openable)) {
298 return;
299 }
300 // A powered transition can close an already-open lock, but may not open a closed one.
301 if (!openable.isOpen() && event.getNewCurrent() > event.getOldCurrent()) {
302 event.setNewCurrent(event.getOldCurrent());
303 }
304 }
305
306 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
307 public void onPlayerBreak(BlockBreakEvent event) {
308 Block block = event.getBlock();
309 LockRecord lock = lockStore.get(BlockKey.of(block));
310 if (lock != null && !playerHasKey(event.getPlayer(), lock.bindingId())) {
311 awardAdvancement(event.getPlayer(), burglarAdvancementKey);
312 }
313 handleDestroyed(block);
314 }
315
316 @EventHandler(priority = EventPriority.MONITOR)
317 public void onForcedBreak(BlockBreakBlockEvent event) {
318 handleDestroyed(event.getBlock());
319 }
320
321 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
322 public void onBurn(BlockBurnEvent event) {
323 handleDestroyed(event.getBlock());
324 }
325
326 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
327 public void onBlockExplosion(BlockExplodeEvent event) {
328 for (Block block : event.blockList()) {
329 handleDestroyed(block);
330 }
331 }
332
333 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
334 public void onEntityExplosion(EntityExplodeEvent event) {
335 for (Block block : event.blockList()) {
336 handleDestroyed(block);
337 }
338 }
339
340 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
341 public void onInventoryClose(InventoryCloseEvent event) {
342 if (!(event.getPlayer() instanceof Player player)) {
343 return;
344 }
345 LockRecord lock = lockForInventory(event.getInventory());
346 if (lock == null) {
347 return;
348 }
349 if (playerHasKey(player, lock.bindingId())) {
350 return;
351 }
352 if (!keyItems.inventoryHasBinding(event.getInventory(), lock.bindingId())) {
353 return;
354 }
355 awardAdvancement(player, oopsAdvancementKey);
356 }
357
358 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
359 public void onPickup(EntityPickupItemEvent event) {
360 ItemStack stack = event.getItem().getItemStack();
361 if (keyItems.normalizeItem(stack)) {
362 event.getItem().setItemStack(stack);
363 }
364 }
365
366 @EventHandler(priority = EventPriority.MONITOR)
367 public void onJoin(PlayerJoinEvent event) {
368 keyItems.normalizeInventory(event.getPlayer().getInventory());
369 }
370
371 @EventHandler(priority = EventPriority.HIGHEST)
372 public void onPrepareCraft(PrepareItemCraftEvent event) {
373 CraftingInventory inv = event.getInventory();
374 ItemStack clone = keyCloneResult(inv);
375 if (clone != null) {
376 inv.setResult(clone);
377 return;
378 }
379
380 boolean containsKey = false;
381 for (ItemStack item : inv.getMatrix()) {
382 if (keyItems.isKey(item)) {
383 containsKey = true;
384 break;
385 }
386 }
387 if (!containsKey) {
388 return;
389 }
390 if (inv.getRecipe() instanceof org.bukkit.inventory.CraftingRecipe recipe
391 && recipeKey.equals(recipe.getKey())) {
392 return;
393 }
394 inv.setResult(null);
395 }
396
397 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
398 public void onCraftItem(CraftItemEvent event) {
399 ItemStack clone = keyCloneResult(event.getInventory());
400 if (clone == null || !(event.getWhoClicked() instanceof Player player)) {
401 return;
402 }
403 ItemStack second = clone.clone();
404 getServer().getScheduler().runTask(this, () -> {
405 HashMap<Integer, ItemStack> leftover = player.getInventory().addItem(second);
406 for (ItemStack drop : leftover.values()) {
407 player.getWorld().dropItemNaturally(player.getLocation(), drop);
408 }
409 });
410 }
411
412 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
413 public void onCrafterCraft(CrafterCraftEvent event) {
414 if (!(event.getBlock().getState() instanceof org.bukkit.block.Crafter crafter)) {
415 return;
416 }
417 if (recipeKey.equals(event.getRecipe().getKey())) {
418 return;
419 }
420 for (ItemStack item : crafter.getInventory().getContents()) {
421 if (keyItems.isKey(item)) {
422 event.setCancelled(true);
423 return;
424 }
425 }
426 }
427
428 private ItemStack keyCloneResult(CraftingInventory inventory) {
429 ItemStack blank = null;
430 ItemStack bound = null;
431 for (ItemStack item : inventory.getMatrix()) {
432 if (item == null || item.getType().isAir()) {
433 continue;
434 }
435 if (keyItems.isBlank(item)) {
436 if (blank != null) {
437 return null;
438 }
439 blank = item;
440 } else if (keyItems.isKey(item)) {
441 if (keyItems.getBinding(item) == null || bound != null) {
442 return null;
443 }
444 bound = item;
445 } else {
446 return null;
447 }
448 }
449 if (blank == null || bound == null) {
450 return null;
451 }
452 LockRecord lock = lockStore.get(keyItems.getBinding(bound));
453 if (lock == null) {
454 return null;
455 }
456 return keyItems.createBoundKey(lock);
457 }
458
459 private void handleDestroyed(Block block) {
460 LockRecord removed = lockStore.removeByBlock(BlockKey.of(block));
461 if (removed == null) {
462 return;
463 }
464 blankLinkedKeys(removed.bindingId(), block);
465 }
466
467 private void unlockBlock(Player player, Block block, LockRecord lock) {
468 lockStore.remove(lock.bindingId());
469 blankLinkedKeys(lock.bindingId(), block);
470 player.sendActionBar(Component.text("Unlocked — all matching keys cleared", NamedTextColor.GOLD));
471 }
472
473 private void blankLinkedKeys(UUID bindingId, Block block) {
474 for (Player online : Bukkit.getOnlinePlayers()) {
475 keyItems.blankBindingInInventory(online.getInventory(), bindingId);
476 }
477 BlockState state = block.getState();
478 if (state instanceof InventoryHolder holder) {
479 keyItems.blankBindingInInventory(holder.getInventory(), bindingId);
480 }
481 }
482
483 private boolean playerHasKey(Player player, UUID bindingId) {
484 return keyItems.inventoryHasBinding(player.getInventory(), bindingId);
485 }
486
487 private boolean isBindable(Block block) {
488 BlockState state = block.getState();
489 return block.getBlockData() instanceof Openable || state instanceof InventoryHolder;
490 }
491
492 private List<BlockKey> collectMembers(Block block) {
493 Set<BlockKey> members = new LinkedHashSet<>();
494 members.add(BlockKey.of(block));
495
496 BlockState state = block.getState();
497 if (state instanceof org.bukkit.block.Chest chest) {
498 Inventory inventory = chest.getInventory();
499 InventoryHolder holder = inventory.getHolder();
500 if (holder instanceof DoubleChest doubleChest) {
501 addChestSide(members, doubleChest.getLeftSide());
502 addChestSide(members, doubleChest.getRightSide());
503 }
504 }
505
506 if (block.getBlockData() instanceof Door door) {
507 Block other = door.getHalf() == Bisected.Half.BOTTOM
508 ? block.getRelative(0, 1, 0)
509 : block.getRelative(0, -1, 0);
510 if (other.getBlockData() instanceof Door) {
511 members.add(BlockKey.of(other));
512 }
513 }
514
515 return new ArrayList<>(members);
516 }
517
518 private void addChestSide(Set<BlockKey> members, InventoryHolder side) {
519 if (side instanceof BlockState state) {
520 members.add(BlockKey.of(state.getBlock()));
521 }
522 }
523
524 private LockRecord lockForInventory(Inventory inventory) {
525 InventoryHolder holder = inventory.getHolder();
526 if (holder instanceof DoubleChest doubleChest) {
527 LockRecord left = lockForSide(doubleChest.getLeftSide());
528 return left != null ? left : lockForSide(doubleChest.getRightSide());
529 }
530 if (holder instanceof BlockState state) {
531 return lockStore.get(BlockKey.of(state.getBlock()));
532 }
533 // Some double chest inventories expose their holder through DoubleChestInventory.
534 if (inventory instanceof DoubleChestInventory doubleInventory) {
535 InventoryHolder doubleHolder = doubleInventory.getHolder();
536 if (doubleHolder instanceof DoubleChest doubleChest) {
537 LockRecord left = lockForSide(doubleChest.getLeftSide());
538 return left != null ? left : lockForSide(doubleChest.getRightSide());
539 }
540 }
541 return null;
542 }
543
544 private LockRecord lockForSide(InventoryHolder side) {
545 if (side instanceof BlockState state) {
546 return lockStore.get(BlockKey.of(state.getBlock()));
547 }
548 return null;
549 }
550
551 private Block blockForInventory(Inventory inventory) {
552 InventoryHolder holder = inventory.getHolder();
553 if (holder instanceof DoubleChest doubleChest) {
554 InventoryHolder left = doubleChest.getLeftSide();
555 if (left instanceof BlockState state) {
556 return state.getBlock();
557 }
558 InventoryHolder right = doubleChest.getRightSide();
559 if (right instanceof BlockState state) {
560 return state.getBlock();
561 }
562 }
563 if (holder instanceof BlockState state) {
564 return state.getBlock();
565 }
566 if (inventory instanceof DoubleChestInventory doubleInventory
567 && doubleInventory.getHolder() instanceof DoubleChest doubleChest) {
568 InventoryHolder left = doubleChest.getLeftSide();
569 if (left instanceof BlockState state) {
570 return state.getBlock();
571 }
572 }
573 return null;
574 }
575
576 private void setUsedHandItem(Player player, EquipmentSlot hand, ItemStack item) {
577 if (hand == EquipmentSlot.OFF_HAND) {
578 player.getInventory().setItemInOffHand(item);
579 } else {
580 player.getInventory().setItemInMainHand(item);
581 }
582 }
583
584 private void denyOpen(Player player, Block block) {
585 lockedMessage(player);
586 if (block == null) {
587 return;
588 }
589 Location at = block.getLocation().add(0.5, 0.6, 0.5);
590 block.getWorld().spawnParticle(Particle.SMOKE, at, 16, 0.28, 0.4, 0.28, 0.01);
591 }
592
593 private void lockedMessage(Player player) {
594 player.sendActionBar(Component.text("Locked — matching key required", NamedTextColor.RED));
595 }
596
597 private String displayName(Block block) {
598 return titleCase(block.getType().name());
599 }
600
601 private String titleCase(String enumName) {
602 String[] words = enumName.toLowerCase(Locale.ROOT).split("_");
603 StringBuilder result = new StringBuilder();
604 for (String word : words) {
605 if (word.isEmpty()) {
606 continue;
607 }
608 if (!result.isEmpty()) {
609 result.append(' ');
610 }
611 result.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1));
612 }
613 return result.toString();
614 }
615}