BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

CopperKeysPlugin.java 24.8 KiB Download Raw
1package nl.timfalken.copperkeys;
2
3import io.papermc.paper.event.block.BlockBreakBlockEvent;
4import io.papermc.paper.event.entity.ItemTransportingEntityValidateTargetEvent;
5import net.kyori.adventure.text.Component;
6import net.kyori.adventure.text.format.NamedTextColor;
7import org.bukkit.Bukkit;
8import org.bukkit.Location;
9import org.bukkit.Material;
10import org.bukkit.NamespacedKey;
11import org.bukkit.Particle;
12import org.bukkit.Sound;
13import org.bukkit.advancement.Advancement;
14import org.bukkit.advancement.AdvancementProgress;
15import org.bukkit.block.Block;
16import org.bukkit.block.BlockState;
17import org.bukkit.block.DoubleChest;
18import org.bukkit.block.data.Bisected;
19import org.bukkit.block.data.Openable;
20import org.bukkit.block.data.type.Door;
21import org.bukkit.entity.HumanEntity;
22import org.bukkit.entity.Player;
23import org.bukkit.event.EventHandler;
24import org.bukkit.event.block.Action;
25import org.bukkit.event.EventPriority;
26import org.bukkit.event.Listener;
27import org.bukkit.event.block.BlockBreakEvent;
28import org.bukkit.event.block.BlockBurnEvent;
29import org.bukkit.event.block.BlockExplodeEvent;
30import org.bukkit.event.block.BlockRedstoneEvent;
31import org.bukkit.event.block.CrafterCraftEvent;
32import org.bukkit.event.entity.EntityExplodeEvent;
33import org.bukkit.event.entity.EntityPickupItemEvent;
34import org.bukkit.event.inventory.CraftItemEvent;
35import org.bukkit.event.inventory.HopperInventorySearchEvent;
36import org.bukkit.event.inventory.InventoryClickEvent;
37import org.bukkit.event.inventory.InventoryCloseEvent;
38import org.bukkit.event.inventory.InventoryDragEvent;
39import org.bukkit.event.inventory.InventoryMoveItemEvent;
40import org.bukkit.event.inventory.InventoryOpenEvent;
41import org.bukkit.event.inventory.InventoryPickupItemEvent;
42import org.bukkit.event.inventory.PrepareItemCraftEvent;
43import org.bukkit.event.player.PlayerInteractEvent;
44import org.bukkit.event.player.PlayerJoinEvent;
45import org.bukkit.inventory.CraftingInventory;
46import org.bukkit.inventory.DoubleChestInventory;
47import org.bukkit.inventory.EquipmentSlot;
48import org.bukkit.inventory.Inventory;
49import org.bukkit.inventory.InventoryHolder;
50import org.bukkit.inventory.ItemStack;
51import org.bukkit.inventory.ShapedRecipe;
52import org.bukkit.inventory.ShapelessRecipe;
53import org.bukkit.plugin.java.JavaPlugin;
54
55import java.io.IOException;
56import java.io.InputStream;
57import java.nio.charset.StandardCharsets;
58import java.util.HashMap;
59import java.util.ArrayList;
60import java.util.LinkedHashSet;
61import java.util.List;
62import java.util.Locale;
63import java.util.Set;
64import java.util.UUID;
65import java.util.logging.Level;
66
67public final class CopperKeysPlugin extends JavaPlugin implements Listener {
68 private LockStore lockStore;
69 private KeyItems keyItems;
70 private NamespacedKey recipeKey;
71 private NamespacedKey copyRecipeKey;
72 private NamespacedKey burglarAdvancementKey;
73 private NamespacedKey oopsAdvancementKey;
74
75 @Override
76 public void onEnable() {
77 lockStore = new LockStore(this);
78 lockStore.load();
79 keyItems = new KeyItems(this);
80 recipeKey = new NamespacedKey(this, "blank_key");
81 copyRecipeKey = new NamespacedKey(this, "copy_key");
82 burglarAdvancementKey = new NamespacedKey(this, "burglar");
83 oopsAdvancementKey = new NamespacedKey(this, "oops");
84
85 registerRecipes();
86 registerAdvancement(burglarAdvancementKey, "advancements/burglar.json", "Burglar");
87 registerAdvancement(oopsAdvancementKey, "advancements/oops.json", "Oops");
88 getServer().getPluginManager().registerEvents(this, this);
89 getLogger().info("CopperKeys 1.0.0 enabled with event-driven lock handling.");
90 }
91
92 LockStore lockStore() {
93 return lockStore;
94 }
95
96 private void registerRecipes() {
97 Bukkit.removeRecipe(recipeKey);
98 Bukkit.removeRecipe(copyRecipeKey);
99
100 ShapedRecipe blankRecipe = new ShapedRecipe(recipeKey, keyItems.createBlankKey());
101 blankRecipe.shape("N ", " N");
102 blankRecipe.setIngredient('N', Material.COPPER_NUGGET);
103 Bukkit.addRecipe(blankRecipe);
104
105 // Ingredient match is material-only; PrepareItemCraftEvent validates blank + bound keys.
106 ShapelessRecipe copyRecipe = new ShapelessRecipe(copyRecipeKey, keyItems.createBlankKey());
107 copyRecipe.addIngredient(Material.CLOCK);
108 copyRecipe.addIngredient(Material.CLOCK);
109 Bukkit.addRecipe(copyRecipe);
110 }
111
112 private void registerAdvancement(NamespacedKey key, String resourcePath, String label) {
113 if (Bukkit.getAdvancement(key) != null) {
114 return;
115 }
116 try (InputStream in = getResource(resourcePath)) {
117 if (in == null) {
118 getLogger().warning("Missing " + resourcePath + "; " + label + " advancement not registered.");
119 return;
120 }
121 String json = new String(in.readAllBytes(), StandardCharsets.UTF_8);
122 @SuppressWarnings("deprecation")
123 Advancement loaded = Bukkit.getUnsafe().loadAdvancement(key, json);
124 if (loaded == null) {
125 getLogger().warning("Could not register " + label + " advancement.");
126 }
127 } catch (IOException | RuntimeException ex) {
128 getLogger().log(Level.WARNING, "Could not register " + label + " advancement", ex);
129 }
130 }
131
132 private void awardAdvancement(Player player, NamespacedKey key) {
133 Advancement advancement = Bukkit.getAdvancement(key);
134 if (advancement == null) {
135 return;
136 }
137 AdvancementProgress progress = player.getAdvancementProgress(advancement);
138 if (progress.isDone()) {
139 return;
140 }
141 for (String criterion : progress.getRemainingCriteria()) {
142 progress.awardCriteria(criterion);
143 }
144 }
145
146 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
147 public void onPlayerInteract(PlayerInteractEvent event) {
148 if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
149 return;
150 }
151 Block clicked = event.getClickedBlock();
152 if (clicked == null) {
153 return;
154 }
155
156 LockRecord existing = lockStore.get(BlockKey.of(clicked));
157 if (existing != null) {
158 Player player = event.getPlayer();
159 ItemStack used = event.getItem();
160 UUID heldBinding = keyItems.getBinding(used);
161 boolean holdingMatchingKey = heldBinding != null && heldBinding.equals(existing.bindingId());
162
163 if (player.isSneaking() && holdingMatchingKey) {
164 event.setCancelled(true);
165 unlockBlock(player, clicked, existing);
166 return;
167 }
168
169 // Iron doors/trapdoors do not open by hand in vanilla; toggle them with the matching key.
170 if (isKeyOperatedOpenable(clicked) && holdingMatchingKey) {
171 event.setCancelled(true);
172 toggleKeyOperatedOpenable(clicked);
173 return;
174 }
175
176 if (clicked.getBlockData() instanceof Openable openable && openable.isOpen()) {
177 // Closing wooden openables is deliberately always allowed.
178 return;
179 }
180 if (!playerHasKey(player, existing.bindingId())) {
181 event.setCancelled(true);
182 denyOpen(player, clicked);
183 }
184 // Already locked: never bind a second key. Allow open/use only when the key check passed.
185 return;
186 }
187
188 ItemStack used = event.getItem();
189 if (used == null || !keyItems.isBlank(used) || !isBindable(clicked)) {
190 return;
191 }
192
193 List<BlockKey> members = collectMembers(clicked);
194 for (BlockKey member : members) {
195 if (lockStore.get(member) != null) {
196 event.setCancelled(true);
197 denyOpen(event.getPlayer(), clicked);
198 return;
199 }
200 }
201
202 LockRecord record = new LockRecord(UUID.randomUUID(), displayName(clicked), members);
203 lockStore.add(record);
204
205 Player player = event.getPlayer();
206 ItemStack bound = used.clone();
207 bound.setAmount(1);
208 keyItems.bind(bound, record);
209 if (used.getAmount() > 1) {
210 used.setAmount(used.getAmount() - 1);
211 setUsedHandItem(player, event.getHand(), used);
212 var leftover = player.getInventory().addItem(bound);
213 for (ItemStack drop : leftover.values()) {
214 player.getWorld().dropItemNaturally(player.getLocation(), drop);
215 }
216 } else {
217 setUsedHandItem(player, event.getHand(), bound);
218 }
219 event.setCancelled(true); // The binding click itself never opens/toggles the target.
220 player.sendActionBar(Component.text("Key bound to " + record.displayName(), NamedTextColor.GOLD));
221 }
222
223 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
224 public void onInventoryOpen(InventoryOpenEvent event) {
225 LockRecord lock = lockForInventory(event.getInventory());
226 if (lock == null) {
227 return;
228 }
229 HumanEntity human = event.getPlayer();
230 if (human instanceof Player player && playerHasKey(player, lock.bindingId())) {
231 return;
232 }
233 event.setCancelled(true);
234 if (human instanceof Player player) {
235 denyOpen(player, blockForInventory(event.getInventory()));
236 }
237 }
238
239 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
240 public void onInventoryClick(InventoryClickEvent event) {
241 LockRecord lock = lockForInventory(event.getView().getTopInventory());
242 if (lock != null) {
243 HumanEntity human = event.getWhoClicked();
244 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
245 event.setCancelled(true);
246 if (human instanceof Player player) {
247 lockedMessage(player);
248 }
249 return;
250 }
251 }
252 ItemStack current = event.getCurrentItem();
253 if (current != null && keyItems.normalizeItem(current)) {
254 event.setCurrentItem(current);
255 }
256 }
257
258 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
259 public void onInventoryDrag(InventoryDragEvent event) {
260 LockRecord lock = lockForInventory(event.getView().getTopInventory());
261 if (lock != null) {
262 HumanEntity human = event.getWhoClicked();
263 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
264 event.setCancelled(true);
265 if (human instanceof Player player) {
266 lockedMessage(player);
267 }
268 return;
269 }
270 }
271 }
272
273 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
274 public void onInventoryMove(InventoryMoveItemEvent event) {
275 if (lockForInventory(event.getSource()) != null || lockForInventory(event.getDestination()) != null) {
276 event.setCancelled(true);
277 }
278 }
279
280 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
281 public void onInventoryPickup(InventoryPickupItemEvent event) {
282 if (lockForInventory(event.getInventory()) != null) {
283 event.setCancelled(true);
284 }
285 }
286
287 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
288 public void onHopperSearch(HopperInventorySearchEvent event) {
289 Inventory found = event.getInventory();
290 if (found != null && lockForInventory(found) != null) {
291 event.setInventory(null);
292 }
293 }
294
295 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
296 public void onTransportingEntityTarget(ItemTransportingEntityValidateTargetEvent event) {
297 if (lockStore.get(BlockKey.of(event.getBlock())) != null) {
298 // Copper Golems do not expose an inventory that could contain a key.
299 event.setAllowed(false);
300 }
301 }
302
303 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
304 public void onRedstone(BlockRedstoneEvent event) {
305 LockRecord lock = lockStore.get(BlockKey.of(event.getBlock()));
306 if (lock == null || !(event.getBlock().getBlockData() instanceof Openable openable)) {
307 return;
308 }
309 // A powered transition can close an already-open lock, but may not open a closed one.
310 if (!openable.isOpen() && event.getNewCurrent() > event.getOldCurrent()) {
311 event.setNewCurrent(event.getOldCurrent());
312 }
313 }
314
315 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
316 public void onPlayerBreak(BlockBreakEvent event) {
317 Block block = event.getBlock();
318 LockRecord lock = lockStore.get(BlockKey.of(block));
319 if (lock != null && !playerHasKey(event.getPlayer(), lock.bindingId())) {
320 awardAdvancement(event.getPlayer(), burglarAdvancementKey);
321 }
322 handleDestroyed(block);
323 }
324
325 @EventHandler(priority = EventPriority.MONITOR)
326 public void onForcedBreak(BlockBreakBlockEvent event) {
327 handleDestroyed(event.getBlock());
328 }
329
330 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
331 public void onBurn(BlockBurnEvent event) {
332 handleDestroyed(event.getBlock());
333 }
334
335 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
336 public void onBlockExplosion(BlockExplodeEvent event) {
337 for (Block block : event.blockList()) {
338 handleDestroyed(block);
339 }
340 }
341
342 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
343 public void onEntityExplosion(EntityExplodeEvent event) {
344 for (Block block : event.blockList()) {
345 handleDestroyed(block);
346 }
347 }
348
349 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
350 public void onInventoryClose(InventoryCloseEvent event) {
351 if (!(event.getPlayer() instanceof Player player)) {
352 return;
353 }
354 LockRecord lock = lockForInventory(event.getInventory());
355 if (lock == null) {
356 return;
357 }
358 if (playerHasKey(player, lock.bindingId())) {
359 return;
360 }
361 if (!keyItems.inventoryHasBinding(event.getInventory(), lock.bindingId())) {
362 return;
363 }
364 awardAdvancement(player, oopsAdvancementKey);
365 }
366
367 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
368 public void onPickup(EntityPickupItemEvent event) {
369 ItemStack stack = event.getItem().getItemStack();
370 if (keyItems.normalizeItem(stack)) {
371 event.getItem().setItemStack(stack);
372 }
373 }
374
375 @EventHandler(priority = EventPriority.MONITOR)
376 public void onJoin(PlayerJoinEvent event) {
377 keyItems.normalizeInventory(event.getPlayer().getInventory());
378 }
379
380 @EventHandler(priority = EventPriority.HIGHEST)
381 public void onPrepareCraft(PrepareItemCraftEvent event) {
382 CraftingInventory inv = event.getInventory();
383 ItemStack clone = keyCloneResult(inv);
384 if (clone != null) {
385 inv.setResult(clone);
386 return;
387 }
388
389 boolean containsKey = false;
390 for (ItemStack item : inv.getMatrix()) {
391 if (keyItems.isKey(item)) {
392 containsKey = true;
393 break;
394 }
395 }
396 if (!containsKey) {
397 return;
398 }
399 if (inv.getRecipe() instanceof org.bukkit.inventory.CraftingRecipe recipe
400 && recipeKey.equals(recipe.getKey())) {
401 return;
402 }
403 inv.setResult(null);
404 }
405
406 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
407 public void onCraftItem(CraftItemEvent event) {
408 ItemStack clone = keyCloneResult(event.getInventory());
409 if (clone == null || !(event.getWhoClicked() instanceof Player player)) {
410 return;
411 }
412 ItemStack second = clone.clone();
413 getServer().getScheduler().runTask(this, () -> {
414 HashMap<Integer, ItemStack> leftover = player.getInventory().addItem(second);
415 for (ItemStack drop : leftover.values()) {
416 player.getWorld().dropItemNaturally(player.getLocation(), drop);
417 }
418 });
419 }
420
421 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
422 public void onCrafterCraft(CrafterCraftEvent event) {
423 if (!(event.getBlock().getState() instanceof org.bukkit.block.Crafter crafter)) {
424 return;
425 }
426 if (recipeKey.equals(event.getRecipe().getKey())) {
427 return;
428 }
429 for (ItemStack item : crafter.getInventory().getContents()) {
430 if (keyItems.isKey(item)) {
431 event.setCancelled(true);
432 return;
433 }
434 }
435 }
436
437 private ItemStack keyCloneResult(CraftingInventory inventory) {
438 ItemStack blank = null;
439 ItemStack bound = null;
440 for (ItemStack item : inventory.getMatrix()) {
441 if (item == null || item.getType().isAir()) {
442 continue;
443 }
444 if (keyItems.isBlank(item)) {
445 if (blank != null) {
446 return null;
447 }
448 blank = item;
449 } else if (keyItems.isKey(item)) {
450 if (keyItems.getBinding(item) == null || bound != null) {
451 return null;
452 }
453 bound = item;
454 } else {
455 return null;
456 }
457 }
458 if (blank == null || bound == null) {
459 return null;
460 }
461 LockRecord lock = lockStore.get(keyItems.getBinding(bound));
462 if (lock == null) {
463 return null;
464 }
465 return keyItems.createBoundKey(lock);
466 }
467
468 private boolean isKeyOperatedOpenable(Block block) {
469 Material type = block.getType();
470 return type == Material.IRON_DOOR || type == Material.IRON_TRAPDOOR;
471 }
472
473 private void toggleKeyOperatedOpenable(Block block) {
474 if (!(block.getBlockData() instanceof Openable openable)) {
475 return;
476 }
477 boolean open = !openable.isOpen();
478 Bisected.Half doorHalf = block.getBlockData() instanceof Door door ? door.getHalf() : null;
479
480 openable.setOpen(open);
481 block.setBlockData(openable, true);
482
483 if (doorHalf != null) {
484 Block other = doorHalf == Bisected.Half.BOTTOM
485 ? block.getRelative(0, 1, 0)
486 : block.getRelative(0, -1, 0);
487 if (other.getBlockData() instanceof Door otherDoor) {
488 otherDoor.setOpen(open);
489 other.setBlockData(otherDoor, false);
490 }
491 }
492
493 Sound sound;
494 if (block.getType() == Material.IRON_TRAPDOOR) {
495 sound = open ? Sound.BLOCK_IRON_TRAPDOOR_OPEN : Sound.BLOCK_IRON_TRAPDOOR_CLOSE;
496 } else {
497 sound = open ? Sound.BLOCK_IRON_DOOR_OPEN : Sound.BLOCK_IRON_DOOR_CLOSE;
498 }
499 block.getWorld().playSound(block.getLocation().add(0.5, 0.5, 0.5), sound, 1.0f, 1.0f);
500 }
501
502 private void handleDestroyed(Block block) {
503 LockRecord removed = lockStore.removeByBlock(BlockKey.of(block));
504 if (removed == null) {
505 return;
506 }
507 blankLinkedKeys(removed.bindingId(), block);
508 }
509
510 private void unlockBlock(Player player, Block block, LockRecord lock) {
511 lockStore.remove(lock.bindingId());
512 blankLinkedKeys(lock.bindingId(), block);
513 player.sendActionBar(Component.text("Unlocked — all matching keys cleared", NamedTextColor.GOLD));
514 }
515
516 private void blankLinkedKeys(UUID bindingId, Block block) {
517 for (Player online : Bukkit.getOnlinePlayers()) {
518 keyItems.blankBindingInInventory(online.getInventory(), bindingId);
519 }
520 BlockState state = block.getState();
521 if (state instanceof InventoryHolder holder) {
522 keyItems.blankBindingInInventory(holder.getInventory(), bindingId);
523 }
524 }
525
526 private boolean playerHasKey(Player player, UUID bindingId) {
527 return keyItems.inventoryHasBinding(player.getInventory(), bindingId);
528 }
529
530 private boolean isBindable(Block block) {
531 BlockState state = block.getState();
532 return block.getBlockData() instanceof Openable || state instanceof InventoryHolder;
533 }
534
535 private List<BlockKey> collectMembers(Block block) {
536 Set<BlockKey> members = new LinkedHashSet<>();
537 members.add(BlockKey.of(block));
538
539 BlockState state = block.getState();
540 if (state instanceof org.bukkit.block.Chest chest) {
541 Inventory inventory = chest.getInventory();
542 InventoryHolder holder = inventory.getHolder();
543 if (holder instanceof DoubleChest doubleChest) {
544 addChestSide(members, doubleChest.getLeftSide());
545 addChestSide(members, doubleChest.getRightSide());
546 }
547 }
548
549 if (block.getBlockData() instanceof Door door) {
550 Block other = door.getHalf() == Bisected.Half.BOTTOM
551 ? block.getRelative(0, 1, 0)
552 : block.getRelative(0, -1, 0);
553 if (other.getBlockData() instanceof Door) {
554 members.add(BlockKey.of(other));
555 }
556 }
557
558 return new ArrayList<>(members);
559 }
560
561 private void addChestSide(Set<BlockKey> members, InventoryHolder side) {
562 if (side instanceof BlockState state) {
563 members.add(BlockKey.of(state.getBlock()));
564 }
565 }
566
567 private LockRecord lockForInventory(Inventory inventory) {
568 InventoryHolder holder = inventory.getHolder();
569 if (holder instanceof DoubleChest doubleChest) {
570 LockRecord left = lockForSide(doubleChest.getLeftSide());
571 return left != null ? left : lockForSide(doubleChest.getRightSide());
572 }
573 if (holder instanceof BlockState state) {
574 return lockStore.get(BlockKey.of(state.getBlock()));
575 }
576 // Some double chest inventories expose their holder through DoubleChestInventory.
577 if (inventory instanceof DoubleChestInventory doubleInventory) {
578 InventoryHolder doubleHolder = doubleInventory.getHolder();
579 if (doubleHolder instanceof DoubleChest doubleChest) {
580 LockRecord left = lockForSide(doubleChest.getLeftSide());
581 return left != null ? left : lockForSide(doubleChest.getRightSide());
582 }
583 }
584 return null;
585 }
586
587 private LockRecord lockForSide(InventoryHolder side) {
588 if (side instanceof BlockState state) {
589 return lockStore.get(BlockKey.of(state.getBlock()));
590 }
591 return null;
592 }
593
594 private Block blockForInventory(Inventory inventory) {
595 InventoryHolder holder = inventory.getHolder();
596 if (holder instanceof DoubleChest doubleChest) {
597 InventoryHolder left = doubleChest.getLeftSide();
598 if (left instanceof BlockState state) {
599 return state.getBlock();
600 }
601 InventoryHolder right = doubleChest.getRightSide();
602 if (right instanceof BlockState state) {
603 return state.getBlock();
604 }
605 }
606 if (holder instanceof BlockState state) {
607 return state.getBlock();
608 }
609 if (inventory instanceof DoubleChestInventory doubleInventory
610 && doubleInventory.getHolder() instanceof DoubleChest doubleChest) {
611 InventoryHolder left = doubleChest.getLeftSide();
612 if (left instanceof BlockState state) {
613 return state.getBlock();
614 }
615 }
616 return null;
617 }
618
619 private void setUsedHandItem(Player player, EquipmentSlot hand, ItemStack item) {
620 if (hand == EquipmentSlot.OFF_HAND) {
621 player.getInventory().setItemInOffHand(item);
622 } else {
623 player.getInventory().setItemInMainHand(item);
624 }
625 }
626
627 private void denyOpen(Player player, Block block) {
628 lockedMessage(player);
629 if (block == null) {
630 return;
631 }
632 Location at = block.getLocation().add(0.5, 0.6, 0.5);
633 block.getWorld().spawnParticle(Particle.SMOKE, at, 16, 0.28, 0.4, 0.28, 0.01);
634 }
635
636 private void lockedMessage(Player player) {
637 player.sendActionBar(Component.text("Locked — matching key required", NamedTextColor.RED));
638 }
639
640 private String displayName(Block block) {
641 return titleCase(block.getType().name());
642 }
643
644 private String titleCase(String enumName) {
645 String[] words = enumName.toLowerCase(Locale.ROOT).split("_");
646 StringBuilder result = new StringBuilder();
647 for (String word : words) {
648 if (word.isEmpty()) {
649 continue;
650 }
651 if (!result.isEmpty()) {
652 result.append(' ');
653 }
654 result.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1));
655 }
656 return result.toString();
657 }
658}