BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

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