BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

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