BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

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