BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

f55596d1 History
CopperKeysPlugin.java 28.5 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.Sound;
13import org.bukkit.advancement.Advancement;
14import org.bukkit.advancement.AdvancementProgress;
15import org.bukkit.block.Block;
16import org.bukkit.block.BlockState;
17import org.bukkit.block.DoubleChest;
18import org.bukkit.block.data.Bisected;
19import org.bukkit.block.data.Openable;
20import org.bukkit.block.data.type.Door;
21import org.bukkit.entity.HumanEntity;
22import org.bukkit.entity.Player;
23import org.bukkit.event.EventHandler;
24import org.bukkit.event.block.Action;
25import org.bukkit.event.EventPriority;
26import org.bukkit.event.Listener;
27import org.bukkit.event.block.BlockBreakEvent;
28import org.bukkit.event.block.BlockBurnEvent;
29import org.bukkit.event.block.BlockExplodeEvent;
30import org.bukkit.event.block.BlockRedstoneEvent;
31import org.bukkit.event.block.CrafterCraftEvent;
32import org.bukkit.event.entity.EntityExplodeEvent;
33import org.bukkit.event.entity.EntityPickupItemEvent;
34import org.bukkit.event.inventory.CraftItemEvent;
35import org.bukkit.event.inventory.HopperInventorySearchEvent;
36import org.bukkit.event.inventory.InventoryClickEvent;
37import org.bukkit.event.inventory.InventoryCloseEvent;
38import org.bukkit.event.inventory.InventoryDragEvent;
39import org.bukkit.event.inventory.InventoryMoveItemEvent;
40import org.bukkit.event.inventory.InventoryOpenEvent;
41import org.bukkit.event.inventory.InventoryPickupItemEvent;
42import org.bukkit.event.inventory.PrepareAnvilEvent;
43import org.bukkit.event.inventory.PrepareItemCraftEvent;
44import org.bukkit.event.player.PlayerInteractEvent;
45import org.bukkit.event.player.PlayerJoinEvent;
46import org.bukkit.inventory.AnvilInventory;
47import org.bukkit.inventory.CraftingInventory;
48import org.bukkit.inventory.DoubleChestInventory;
49import org.bukkit.inventory.EquipmentSlot;
50import org.bukkit.inventory.Inventory;
51import org.bukkit.inventory.InventoryHolder;
52import org.bukkit.inventory.ItemStack;
53import org.bukkit.inventory.ShapedRecipe;
54import org.bukkit.inventory.ShapelessRecipe;
55import org.bukkit.plugin.java.JavaPlugin;
56
57import java.io.IOException;
58import java.io.InputStream;
59import java.nio.charset.StandardCharsets;
60import java.util.ArrayList;
61import java.util.HashMap;
62import java.util.LinkedHashSet;
63import java.util.List;
64import java.util.Locale;
65import java.util.Map;
66import java.util.Set;
67import java.util.UUID;
68import java.util.logging.Level;
69
70public final class CopperKeysPlugin extends JavaPlugin implements Listener {
71 private LockStore lockStore;
72 private KeyItems keyItems;
73 private NamespacedKey recipeKey;
74 private NamespacedKey copyRecipeKey;
75 private NamespacedKey burglarAdvancementKey;
76 private NamespacedKey oopsAdvancementKey;
77
78 @Override
79 public void onEnable() {
80 lockStore = new LockStore(this);
81 lockStore.load();
82 keyItems = new KeyItems(this);
83 recipeKey = new NamespacedKey(this, "blank_key");
84 copyRecipeKey = new NamespacedKey(this, "copy_key");
85 burglarAdvancementKey = new NamespacedKey(this, "burglar");
86 oopsAdvancementKey = new NamespacedKey(this, "oops");
87
88 registerRecipes();
89 registerAdvancements();
90 var keyNameCommand = getCommand("keyname");
91 if (keyNameCommand != null) {
92 keyNameCommand.setExecutor(new KeyNameCommand(this));
93 } else {
94 getLogger().warning("Command 'keyname' missing from plugin.yml");
95 }
96 getServer().getPluginManager().registerEvents(this, this);
97 getLogger().info("CopperKeys 1.0.7 enabled with event-driven lock handling.");
98 }
99
100 LockStore lockStore() {
101 return lockStore;
102 }
103
104 KeyItems keyItems() {
105 return keyItems;
106 }
107
108 void renameKeyBinding(UUID bindingId, String keyName) {
109 LockRecord updated = lockStore.setKeyName(bindingId, keyName);
110 if (updated == null) {
111 return;
112 }
113 for (Player online : Bukkit.getOnlinePlayers()) {
114 keyItems.applyNameInInventory(online.getInventory(), bindingId);
115 keyItems.applyNameInInventory(online.getEnderChest(), bindingId);
116 online.updateInventory();
117 }
118 }
119
120 private void registerRecipes() {
121 Bukkit.removeRecipe(recipeKey);
122 Bukkit.removeRecipe(copyRecipeKey);
123
124 ShapedRecipe blankRecipe = new ShapedRecipe(recipeKey, keyItems.createBlankKey());
125 blankRecipe.shape("N ", " N");
126 blankRecipe.setIngredient('N', Material.COPPER_NUGGET);
127 Bukkit.addRecipe(blankRecipe);
128
129 // Ingredient match is material-only; PrepareItemCraftEvent validates blank + bound keys.
130 ShapelessRecipe copyRecipe = new ShapelessRecipe(copyRecipeKey, keyItems.createBlankKey());
131 copyRecipe.addIngredient(Material.CLOCK);
132 copyRecipe.addIngredient(Material.CLOCK);
133 Bukkit.addRecipe(copyRecipe);
134 }
135
136 private void registerAdvancements() {
137 if (Bukkit.getAdvancement(burglarAdvancementKey) != null
138 && Bukkit.getAdvancement(oopsAdvancementKey) != null) {
139 return;
140 }
141
142 String burglarJson = readAdvancementJson("advancements/burglar.json", "Burglar");
143 String oopsJson = readAdvancementJson("advancements/oops.json", "Oops");
144 if (burglarJson == null || oopsJson == null) {
145 return;
146 }
147
148 Map<NamespacedKey, String> definitions = Map.of(
149 burglarAdvancementKey, burglarJson,
150 oopsAdvancementKey, oopsJson
151 );
152
153 try {
154 List<Advancement> loaded = Bukkit.getUnsafe().loadAdvancements(definitions, false);
155 if (loaded.size() != definitions.size()) {
156 getLogger().warning("Registered " + loaded.size() + " of " + definitions.size() + " advancements.");
157 }
158 } catch (RuntimeException ex) {
159 getLogger().log(Level.WARNING, "Could not register CopperKeys advancements", ex);
160 }
161 }
162
163 private String readAdvancementJson(String resourcePath, String label) {
164 try (InputStream in = getResource(resourcePath)) {
165 if (in == null) {
166 getLogger().warning("Missing " + resourcePath + "; " + label + " advancement not registered.");
167 return null;
168 }
169 return new String(in.readAllBytes(), StandardCharsets.UTF_8);
170 } catch (IOException ex) {
171 getLogger().log(Level.WARNING, "Could not read " + label + " advancement", ex);
172 return null;
173 }
174 }
175
176 private void awardAdvancement(Player player, NamespacedKey key) {
177 Advancement advancement = Bukkit.getAdvancement(key);
178 if (advancement == null) {
179 return;
180 }
181 AdvancementProgress progress = player.getAdvancementProgress(advancement);
182 if (progress.isDone()) {
183 return;
184 }
185 for (String criterion : progress.getRemainingCriteria()) {
186 progress.awardCriteria(criterion);
187 }
188 }
189
190 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
191 public void onPlayerInteract(PlayerInteractEvent event) {
192 if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
193 return;
194 }
195 Block clicked = event.getClickedBlock();
196 if (clicked == null) {
197 return;
198 }
199
200 LockRecord existing = lockStore.get(BlockKey.of(clicked));
201 if (existing != null) {
202 Player player = event.getPlayer();
203 ItemStack used = event.getItem();
204 UUID heldBinding = keyItems.getBinding(used);
205 boolean holdingMatchingKey = heldBinding != null && heldBinding.equals(existing.bindingId());
206
207 if (player.isSneaking() && holdingMatchingKey) {
208 event.setCancelled(true);
209 unlockBlock(player, clicked, existing);
210 return;
211 }
212
213 // Iron doors/trapdoors do not open by hand in vanilla; toggle them with the matching key.
214 if (isKeyOperatedOpenable(clicked) && holdingMatchingKey) {
215 event.setCancelled(true);
216 toggleKeyOperatedOpenable(clicked);
217 return;
218 }
219
220 if (clicked.getBlockData() instanceof Openable openable && openable.isOpen()) {
221 // Closing wooden openables is deliberately always allowed.
222 return;
223 }
224 if (!playerHasKey(player, existing.bindingId())) {
225 event.setCancelled(true);
226 denyOpen(player, clicked);
227 }
228 // Already locked: never bind a second key. Allow open/use only when the key check passed.
229 return;
230 }
231
232 ItemStack used = event.getItem();
233 if (used == null || !keyItems.isBlank(used) || !isBindable(clicked)) {
234 return;
235 }
236
237 List<BlockKey> members = collectMembers(clicked);
238 for (BlockKey member : members) {
239 if (lockStore.get(member) != null) {
240 event.setCancelled(true);
241 denyOpen(event.getPlayer(), clicked);
242 return;
243 }
244 }
245
246 LockRecord record = LockRecord.create(UUID.randomUUID(), displayName(clicked), members);
247 lockStore.add(record);
248
249 Player player = event.getPlayer();
250 ItemStack bound = used.clone();
251 bound.setAmount(1);
252 keyItems.bind(bound, record);
253 if (used.getAmount() > 1) {
254 used.setAmount(used.getAmount() - 1);
255 setUsedHandItem(player, event.getHand(), used);
256 var leftover = player.getInventory().addItem(bound);
257 for (ItemStack drop : leftover.values()) {
258 player.getWorld().dropItemNaturally(player.getLocation(), drop);
259 }
260 } else {
261 setUsedHandItem(player, event.getHand(), bound);
262 }
263 event.setCancelled(true); // The binding click itself never opens/toggles the target.
264 player.sendActionBar(Component.text("Key bound to " + record.displayName(), NamedTextColor.GOLD));
265 }
266
267 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
268 public void onInventoryOpen(InventoryOpenEvent event) {
269 LockRecord lock = lockForInventory(event.getInventory());
270 if (lock == null) {
271 return;
272 }
273 HumanEntity human = event.getPlayer();
274 if (human instanceof Player player && playerHasKey(player, lock.bindingId())) {
275 return;
276 }
277 event.setCancelled(true);
278 if (human instanceof Player player) {
279 denyOpen(player, blockForInventory(event.getInventory()));
280 }
281 }
282
283 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
284 public void onInventoryClick(InventoryClickEvent event) {
285 if (event.getInventory() instanceof AnvilInventory anvil && event.getRawSlot() == 2) {
286 handleAnvilResultTake(event, anvil);
287 }
288
289 LockRecord lock = lockForInventory(event.getView().getTopInventory());
290 if (lock != null) {
291 HumanEntity human = event.getWhoClicked();
292 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
293 event.setCancelled(true);
294 if (human instanceof Player player) {
295 lockedMessage(player);
296 }
297 return;
298 }
299 }
300 }
301
302 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
303 public void onPrepareAnvil(PrepareAnvilEvent event) {
304 AnvilInventory anvil = event.getInventory();
305 ItemStack first = anvil.getFirstItem();
306 if (first == null || !keyItems.isKey(first)) {
307 return;
308 }
309 if (keyItems.isBlank(first)) {
310 event.setResult(null);
311 return;
312 }
313
314 String renameText = anvil.getRenameText();
315 if (renameText == null || renameText.isBlank()) {
316 return;
317 }
318 String name = sanitizeKeyName(renameText);
319 if (name == null) {
320 event.setResult(null);
321 return;
322 }
323
324 UUID bindingId = keyItems.getBinding(first);
325 LockRecord lock = bindingId == null ? null : lockStore.get(bindingId);
326 if (lock == null) {
327 event.setResult(null);
328 return;
329 }
330
331 ItemStack result = first.clone();
332 keyItems.applyBoundAppearance(result, lock.withKeyName(name));
333 event.setResult(result);
334 anvil.setRepairCost(1);
335 }
336
337 private void handleAnvilResultTake(InventoryClickEvent event, AnvilInventory anvil) {
338 ItemStack result = event.getCurrentItem();
339 if (result == null || !keyItems.isKey(result) || keyItems.isBlank(result)) {
340 return;
341 }
342 String renameText = anvil.getRenameText();
343 if (renameText == null || renameText.isBlank()) {
344 return;
345 }
346 String name = sanitizeKeyName(renameText);
347 UUID bindingId = keyItems.getBinding(result);
348 if (name == null || bindingId == null || lockStore.get(bindingId) == null) {
349 return;
350 }
351 Bukkit.getScheduler().runTask(this, () -> renameKeyBinding(bindingId, name));
352 }
353
354 private static String sanitizeKeyName(String raw) {
355 String name = raw.trim();
356 if (name.isEmpty()) {
357 return null;
358 }
359 if (name.length() > KeyItems.MAX_KEY_NAME_LENGTH) {
360 return name.substring(0, KeyItems.MAX_KEY_NAME_LENGTH);
361 }
362 return name;
363 }
364
365 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
366 public void onInventoryDrag(InventoryDragEvent event) {
367 LockRecord lock = lockForInventory(event.getView().getTopInventory());
368 if (lock != null) {
369 HumanEntity human = event.getWhoClicked();
370 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
371 event.setCancelled(true);
372 if (human instanceof Player player) {
373 lockedMessage(player);
374 }
375 return;
376 }
377 }
378 }
379
380 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
381 public void onInventoryMove(InventoryMoveItemEvent event) {
382 if (lockForInventory(event.getSource()) != null || lockForInventory(event.getDestination()) != null) {
383 event.setCancelled(true);
384 }
385 }
386
387 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
388 public void onInventoryPickup(InventoryPickupItemEvent event) {
389 if (lockForInventory(event.getInventory()) != null) {
390 event.setCancelled(true);
391 }
392 }
393
394 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
395 public void onHopperSearch(HopperInventorySearchEvent event) {
396 Inventory found = event.getInventory();
397 if (found != null && lockForInventory(found) != null) {
398 event.setInventory(null);
399 }
400 }
401
402 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
403 public void onTransportingEntityTarget(ItemTransportingEntityValidateTargetEvent event) {
404 if (lockStore.get(BlockKey.of(event.getBlock())) != null) {
405 // Copper Golems do not expose an inventory that could contain a key.
406 event.setAllowed(false);
407 }
408 }
409
410 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
411 public void onRedstone(BlockRedstoneEvent event) {
412 LockRecord lock = lockStore.get(BlockKey.of(event.getBlock()));
413 if (lock == null || !(event.getBlock().getBlockData() instanceof Openable openable)) {
414 return;
415 }
416 // A powered transition can close an already-open lock, but may not open a closed one.
417 if (!openable.isOpen() && event.getNewCurrent() > event.getOldCurrent()) {
418 event.setNewCurrent(event.getOldCurrent());
419 }
420 }
421
422 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
423 public void onPlayerBreak(BlockBreakEvent event) {
424 Block block = event.getBlock();
425 LockRecord lock = lockStore.get(BlockKey.of(block));
426 if (lock != null && !playerHasKey(event.getPlayer(), lock.bindingId())) {
427 awardAdvancement(event.getPlayer(), burglarAdvancementKey);
428 }
429 handleDestroyed(block);
430 }
431
432 @EventHandler(priority = EventPriority.MONITOR)
433 public void onForcedBreak(BlockBreakBlockEvent event) {
434 handleDestroyed(event.getBlock());
435 }
436
437 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
438 public void onBurn(BlockBurnEvent event) {
439 handleDestroyed(event.getBlock());
440 }
441
442 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
443 public void onBlockExplosion(BlockExplodeEvent event) {
444 for (Block block : event.blockList()) {
445 handleDestroyed(block);
446 }
447 }
448
449 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
450 public void onEntityExplosion(EntityExplodeEvent event) {
451 for (Block block : event.blockList()) {
452 handleDestroyed(block);
453 }
454 }
455
456 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
457 public void onInventoryClose(InventoryCloseEvent event) {
458 if (!(event.getPlayer() instanceof Player player)) {
459 return;
460 }
461 // Normalize after the click/close transaction so sync never fights the client mid-click.
462 keyItems.normalizeInventory(player.getInventory());
463
464 LockRecord lock = lockForInventory(event.getInventory());
465 if (lock == null) {
466 return;
467 }
468 if (playerHasKey(player, lock.bindingId())) {
469 return;
470 }
471 if (!keyItems.inventoryHasBinding(event.getInventory(), lock.bindingId())) {
472 return;
473 }
474 awardAdvancement(player, oopsAdvancementKey);
475 }
476
477 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
478 public void onPickup(EntityPickupItemEvent event) {
479 ItemStack stack = event.getItem().getItemStack();
480 if (keyItems.normalizeItem(stack)) {
481 event.getItem().setItemStack(stack);
482 }
483 }
484
485 @EventHandler(priority = EventPriority.MONITOR)
486 public void onJoin(PlayerJoinEvent event) {
487 keyItems.normalizeInventory(event.getPlayer().getInventory());
488 }
489
490 @EventHandler(priority = EventPriority.HIGHEST)
491 public void onPrepareCraft(PrepareItemCraftEvent event) {
492 CraftingInventory inv = event.getInventory();
493 ItemStack clone = keyCloneResult(inv);
494 if (clone != null) {
495 inv.setResult(clone);
496 return;
497 }
498
499 boolean containsKey = false;
500 for (ItemStack item : inv.getMatrix()) {
501 if (keyItems.isKey(item)) {
502 containsKey = true;
503 break;
504 }
505 }
506 if (!containsKey) {
507 return;
508 }
509 if (inv.getRecipe() instanceof org.bukkit.inventory.CraftingRecipe recipe
510 && recipeKey.equals(recipe.getKey())) {
511 return;
512 }
513 inv.setResult(null);
514 }
515
516 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
517 public void onCraftItem(CraftItemEvent event) {
518 ItemStack clone = keyCloneResult(event.getInventory());
519 if (clone == null || !(event.getWhoClicked() instanceof Player player)) {
520 return;
521 }
522 ItemStack second = clone.clone();
523 getServer().getScheduler().runTask(this, () -> {
524 HashMap<Integer, ItemStack> leftover = player.getInventory().addItem(second);
525 for (ItemStack drop : leftover.values()) {
526 player.getWorld().dropItemNaturally(player.getLocation(), drop);
527 }
528 player.updateInventory();
529 });
530 }
531
532 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
533 public void onCrafterCraft(CrafterCraftEvent event) {
534 if (!(event.getBlock().getState() instanceof org.bukkit.block.Crafter crafter)) {
535 return;
536 }
537 if (recipeKey.equals(event.getRecipe().getKey())) {
538 return;
539 }
540 for (ItemStack item : crafter.getInventory().getContents()) {
541 if (keyItems.isKey(item)) {
542 event.setCancelled(true);
543 return;
544 }
545 }
546 }
547
548 private ItemStack keyCloneResult(CraftingInventory inventory) {
549 ItemStack blank = null;
550 ItemStack bound = null;
551 for (ItemStack item : inventory.getMatrix()) {
552 if (item == null || item.getType().isAir()) {
553 continue;
554 }
555 if (keyItems.isBlank(item)) {
556 if (blank != null) {
557 return null;
558 }
559 blank = item;
560 } else if (keyItems.isKey(item)) {
561 if (keyItems.getBinding(item) == null || bound != null) {
562 return null;
563 }
564 bound = item;
565 } else {
566 return null;
567 }
568 }
569 if (blank == null || bound == null) {
570 return null;
571 }
572 LockRecord lock = lockStore.get(keyItems.getBinding(bound));
573 if (lock == null) {
574 return null;
575 }
576 return keyItems.createBoundKey(lock);
577 }
578
579 private boolean isKeyOperatedOpenable(Block block) {
580 Material type = block.getType();
581 return type == Material.IRON_DOOR || type == Material.IRON_TRAPDOOR;
582 }
583
584 private void toggleKeyOperatedOpenable(Block block) {
585 if (!(block.getBlockData() instanceof Openable openable)) {
586 return;
587 }
588 boolean open = !openable.isOpen();
589 Bisected.Half doorHalf = block.getBlockData() instanceof Door door ? door.getHalf() : null;
590
591 openable.setOpen(open);
592 block.setBlockData(openable, true);
593
594 if (doorHalf != null) {
595 Block other = doorHalf == Bisected.Half.BOTTOM
596 ? block.getRelative(0, 1, 0)
597 : block.getRelative(0, -1, 0);
598 if (other.getBlockData() instanceof Door otherDoor) {
599 otherDoor.setOpen(open);
600 other.setBlockData(otherDoor, false);
601 }
602 }
603
604 Sound sound;
605 if (block.getType() == Material.IRON_TRAPDOOR) {
606 sound = open ? Sound.BLOCK_IRON_TRAPDOOR_OPEN : Sound.BLOCK_IRON_TRAPDOOR_CLOSE;
607 } else {
608 sound = open ? Sound.BLOCK_IRON_DOOR_OPEN : Sound.BLOCK_IRON_DOOR_CLOSE;
609 }
610 block.getWorld().playSound(block.getLocation().add(0.5, 0.5, 0.5), sound, 1.0f, 1.0f);
611 }
612
613 private void handleDestroyed(Block block) {
614 LockRecord removed = lockStore.removeByBlock(BlockKey.of(block));
615 if (removed == null) {
616 return;
617 }
618 blankLinkedKeys(removed.bindingId(), block);
619 }
620
621 private void unlockBlock(Player player, Block block, LockRecord lock) {
622 lockStore.remove(lock.bindingId());
623 blankLinkedKeys(lock.bindingId(), block);
624 player.sendActionBar(Component.text("Unlocked — all matching keys cleared", NamedTextColor.GOLD));
625 }
626
627 private void blankLinkedKeys(UUID bindingId, Block block) {
628 for (Player online : Bukkit.getOnlinePlayers()) {
629 keyItems.blankBindingInInventory(online.getInventory(), bindingId);
630 online.updateInventory();
631 }
632 BlockState state = block.getState();
633 if (state instanceof InventoryHolder holder) {
634 keyItems.blankBindingInInventory(holder.getInventory(), bindingId);
635 }
636 }
637
638 private boolean playerHasKey(Player player, UUID bindingId) {
639 return keyItems.inventoryHasBinding(player.getInventory(), bindingId);
640 }
641
642 private boolean isBindable(Block block) {
643 BlockState state = block.getState();
644 return block.getBlockData() instanceof Openable || state instanceof InventoryHolder;
645 }
646
647 private List<BlockKey> collectMembers(Block block) {
648 Set<BlockKey> members = new LinkedHashSet<>();
649 members.add(BlockKey.of(block));
650
651 BlockState state = block.getState();
652 if (state instanceof org.bukkit.block.Chest chest) {
653 Inventory inventory = chest.getInventory();
654 InventoryHolder holder = inventory.getHolder();
655 if (holder instanceof DoubleChest doubleChest) {
656 addChestSide(members, doubleChest.getLeftSide());
657 addChestSide(members, doubleChest.getRightSide());
658 }
659 }
660
661 if (block.getBlockData() instanceof Door door) {
662 Block other = door.getHalf() == Bisected.Half.BOTTOM
663 ? block.getRelative(0, 1, 0)
664 : block.getRelative(0, -1, 0);
665 if (other.getBlockData() instanceof Door) {
666 members.add(BlockKey.of(other));
667 }
668 }
669
670 return new ArrayList<>(members);
671 }
672
673 private void addChestSide(Set<BlockKey> members, InventoryHolder side) {
674 if (side instanceof BlockState state) {
675 members.add(BlockKey.of(state.getBlock()));
676 }
677 }
678
679 private LockRecord lockForInventory(Inventory inventory) {
680 InventoryHolder holder = inventory.getHolder();
681 if (holder instanceof DoubleChest doubleChest) {
682 LockRecord left = lockForSide(doubleChest.getLeftSide());
683 return left != null ? left : lockForSide(doubleChest.getRightSide());
684 }
685 if (holder instanceof BlockState state) {
686 return lockStore.get(BlockKey.of(state.getBlock()));
687 }
688 // Some double chest inventories expose their holder through DoubleChestInventory.
689 if (inventory instanceof DoubleChestInventory doubleInventory) {
690 InventoryHolder doubleHolder = doubleInventory.getHolder();
691 if (doubleHolder instanceof DoubleChest doubleChest) {
692 LockRecord left = lockForSide(doubleChest.getLeftSide());
693 return left != null ? left : lockForSide(doubleChest.getRightSide());
694 }
695 }
696 return null;
697 }
698
699 private LockRecord lockForSide(InventoryHolder side) {
700 if (side instanceof BlockState state) {
701 return lockStore.get(BlockKey.of(state.getBlock()));
702 }
703 return null;
704 }
705
706 private Block blockForInventory(Inventory inventory) {
707 InventoryHolder holder = inventory.getHolder();
708 if (holder instanceof DoubleChest doubleChest) {
709 InventoryHolder left = doubleChest.getLeftSide();
710 if (left instanceof BlockState state) {
711 return state.getBlock();
712 }
713 InventoryHolder right = doubleChest.getRightSide();
714 if (right instanceof BlockState state) {
715 return state.getBlock();
716 }
717 }
718 if (holder instanceof BlockState state) {
719 return state.getBlock();
720 }
721 if (inventory instanceof DoubleChestInventory doubleInventory
722 && doubleInventory.getHolder() instanceof DoubleChest doubleChest) {
723 InventoryHolder left = doubleChest.getLeftSide();
724 if (left instanceof BlockState state) {
725 return state.getBlock();
726 }
727 }
728 return null;
729 }
730
731 private void setUsedHandItem(Player player, EquipmentSlot hand, ItemStack item) {
732 if (hand == EquipmentSlot.OFF_HAND) {
733 player.getInventory().setItemInOffHand(item);
734 } else {
735 player.getInventory().setItemInMainHand(item);
736 }
737 }
738
739 private void denyOpen(Player player, Block block) {
740 lockedMessage(player);
741 if (block == null) {
742 return;
743 }
744 Location at = block.getLocation().add(0.5, 0.6, 0.5);
745 block.getWorld().spawnParticle(Particle.SMOKE, at, 16, 0.28, 0.4, 0.28, 0.01);
746 }
747
748 private void lockedMessage(Player player) {
749 player.sendActionBar(Component.text("Locked — matching key required", NamedTextColor.RED));
750 }
751
752 private String displayName(Block block) {
753 return titleCase(block.getType().name());
754 }
755
756 private String titleCase(String enumName) {
757 String[] words = enumName.toLowerCase(Locale.ROOT).split("_");
758 StringBuilder result = new StringBuilder();
759 for (String word : words) {
760 if (word.isEmpty()) {
761 continue;
762 }
763 if (!result.isEmpty()) {
764 result.append(' ');
765 }
766 result.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1));
767 }
768 return result.toString();
769 }
770}