BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

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