BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

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