BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

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