BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

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