BlueGit

timfa copper-key

Files

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

CopperKeysPlugin.java

CopperKeysPlugin.java 15.1 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.Material;
9import org.bukkit.NamespacedKey;
10import org.bukkit.block.Block;
11import org.bukkit.block.BlockState;
12import org.bukkit.block.DoubleChest;
13import org.bukkit.block.data.Bisected;
14import org.bukkit.block.data.Openable;
15import org.bukkit.block.data.type.Door;
16import org.bukkit.entity.HumanEntity;
17import org.bukkit.entity.Player;
18import org.bukkit.event.EventHandler;
19import org.bukkit.event.block.Action;
20import org.bukkit.event.EventPriority;
21import org.bukkit.event.Listener;
22import org.bukkit.event.block.BlockBreakEvent;
23import org.bukkit.event.block.BlockBurnEvent;
24import org.bukkit.event.block.BlockExplodeEvent;
25import org.bukkit.event.block.BlockRedstoneEvent;
26import org.bukkit.event.block.CrafterCraftEvent;
27import org.bukkit.event.entity.EntityExplodeEvent;
28import org.bukkit.event.entity.EntityPickupItemEvent;
29import org.bukkit.event.inventory.HopperInventorySearchEvent;
30import org.bukkit.event.inventory.InventoryClickEvent;
31import org.bukkit.event.inventory.InventoryDragEvent;
32import org.bukkit.event.inventory.InventoryMoveItemEvent;
33import org.bukkit.event.inventory.InventoryOpenEvent;
34import org.bukkit.event.inventory.InventoryPickupItemEvent;
35import org.bukkit.event.inventory.PrepareItemCraftEvent;
36import org.bukkit.event.player.PlayerInteractEvent;
37import org.bukkit.event.player.PlayerJoinEvent;
38import org.bukkit.inventory.CraftingInventory;
39import org.bukkit.inventory.DoubleChestInventory;
40import org.bukkit.inventory.EquipmentSlot;
41import org.bukkit.inventory.Inventory;
42import org.bukkit.inventory.InventoryHolder;
43import org.bukkit.inventory.ItemStack;
44import org.bukkit.inventory.ShapedRecipe;
45import org.bukkit.plugin.java.JavaPlugin;
46
47import java.util.ArrayList;
48import java.util.LinkedHashSet;
49import java.util.List;
50import java.util.Locale;
51import java.util.Set;
52import java.util.UUID;
53
54public final class CopperKeysPlugin extends JavaPlugin implements Listener {
55 private LockStore lockStore;
56 private KeyItems keyItems;
57 private NamespacedKey recipeKey;
58
59 @Override
60 public void onEnable() {
61 lockStore = new LockStore(this);
62 lockStore.load();
63 keyItems = new KeyItems(this);
64 recipeKey = new NamespacedKey(this, "blank_key");
65
66 registerRecipe();
67 getServer().getPluginManager().registerEvents(this, this);
68 getLogger().info("CopperKeys 1.0.0 enabled with event-driven lock handling.");
69 }
70
71 LockStore lockStore() {
72 return lockStore;
73 }
74
75 private void registerRecipe() {
76 Bukkit.removeRecipe(recipeKey);
77 ShapedRecipe recipe = new ShapedRecipe(recipeKey, keyItems.createBlankKey());
78 recipe.shape("N ", " N");
79 recipe.setIngredient('N', Material.COPPER_NUGGET);
80 Bukkit.addRecipe(recipe);
81 }
82
83 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
84 public void onPlayerInteract(PlayerInteractEvent event) {
85 if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
86 return;
87 }
88 Block clicked = event.getClickedBlock();
89 if (clicked == null) {
90 return;
91 }
92
93 LockRecord existing = lockStore.get(BlockKey.of(clicked));
94 if (existing != null) {
95 if (clicked.getBlockData() instanceof Openable openable && openable.isOpen()) {
96 // Closing is deliberately always allowed.
97 return;
98 }
99 if (!playerHasKey(event.getPlayer(), existing.bindingId())) {
100 event.setCancelled(true);
101 lockedMessage(event.getPlayer());
102 }
103 // Already locked: never bind a second key. Allow open/use only when the key check passed.
104 return;
105 }
106
107 ItemStack used = event.getItem();
108 if (used == null || !keyItems.isBlank(used) || !isBindable(clicked)) {
109 return;
110 }
111
112 List<BlockKey> members = collectMembers(clicked);
113 for (BlockKey member : members) {
114 if (lockStore.get(member) != null) {
115 event.setCancelled(true);
116 lockedMessage(event.getPlayer());
117 return;
118 }
119 }
120
121 LockRecord record = new LockRecord(UUID.randomUUID(), displayName(clicked), members);
122 lockStore.add(record);
123 keyItems.bind(used, record);
124 setUsedHandItem(event.getPlayer(), event.getHand(), used);
125 event.setCancelled(true); // The binding click itself never opens/toggles the target.
126 event.getPlayer().sendActionBar(Component.text("Key bound to " + record.displayName(), NamedTextColor.GOLD));
127 }
128
129 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
130 public void onInventoryOpen(InventoryOpenEvent event) {
131 LockRecord lock = lockForInventory(event.getInventory());
132 if (lock == null) {
133 return;
134 }
135 HumanEntity human = event.getPlayer();
136 if (human instanceof Player player && playerHasKey(player, lock.bindingId())) {
137 return;
138 }
139 event.setCancelled(true);
140 if (human instanceof Player player) {
141 lockedMessage(player);
142 }
143 }
144
145 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
146 public void onInventoryClick(InventoryClickEvent event) {
147 LockRecord lock = lockForInventory(event.getView().getTopInventory());
148 if (lock != null) {
149 HumanEntity human = event.getWhoClicked();
150 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
151 event.setCancelled(true);
152 if (human instanceof Player player) {
153 lockedMessage(player);
154 }
155 return;
156 }
157 }
158 ItemStack current = event.getCurrentItem();
159 if (current != null && keyItems.normalizeItem(current)) {
160 event.setCurrentItem(current);
161 }
162 }
163
164 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
165 public void onInventoryDrag(InventoryDragEvent event) {
166 LockRecord lock = lockForInventory(event.getView().getTopInventory());
167 if (lock != null) {
168 HumanEntity human = event.getWhoClicked();
169 if (!(human instanceof Player player) || !playerHasKey(player, lock.bindingId())) {
170 event.setCancelled(true);
171 if (human instanceof Player player) {
172 lockedMessage(player);
173 }
174 return;
175 }
176 }
177 }
178
179 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
180 public void onInventoryMove(InventoryMoveItemEvent event) {
181 if (lockForInventory(event.getSource()) != null || lockForInventory(event.getDestination()) != null) {
182 event.setCancelled(true);
183 }
184 }
185
186 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
187 public void onInventoryPickup(InventoryPickupItemEvent event) {
188 if (lockForInventory(event.getInventory()) != null) {
189 event.setCancelled(true);
190 }
191 }
192
193 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
194 public void onHopperSearch(HopperInventorySearchEvent event) {
195 Inventory found = event.getInventory();
196 if (found != null && lockForInventory(found) != null) {
197 event.setInventory(null);
198 }
199 }
200
201 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
202 public void onTransportingEntityTarget(ItemTransportingEntityValidateTargetEvent event) {
203 if (lockStore.get(BlockKey.of(event.getBlock())) != null) {
204 // Copper Golems do not expose an inventory that could contain a key.
205 event.setAllowed(false);
206 }
207 }
208
209 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
210 public void onRedstone(BlockRedstoneEvent event) {
211 LockRecord lock = lockStore.get(BlockKey.of(event.getBlock()));
212 if (lock == null || !(event.getBlock().getBlockData() instanceof Openable openable)) {
213 return;
214 }
215 // A powered transition can close an already-open lock, but may not open a closed one.
216 if (!openable.isOpen() && event.getNewCurrent() > event.getOldCurrent()) {
217 event.setNewCurrent(event.getOldCurrent());
218 }
219 }
220
221 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
222 public void onPlayerBreak(BlockBreakEvent event) {
223 handleDestroyed(event.getBlock());
224 }
225
226 @EventHandler(priority = EventPriority.MONITOR)
227 public void onForcedBreak(BlockBreakBlockEvent event) {
228 handleDestroyed(event.getBlock());
229 }
230
231 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
232 public void onBurn(BlockBurnEvent event) {
233 handleDestroyed(event.getBlock());
234 }
235
236 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
237 public void onBlockExplosion(BlockExplodeEvent event) {
238 for (Block block : event.blockList()) {
239 handleDestroyed(block);
240 }
241 }
242
243 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
244 public void onEntityExplosion(EntityExplodeEvent event) {
245 for (Block block : event.blockList()) {
246 handleDestroyed(block);
247 }
248 }
249
250 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
251 public void onPickup(EntityPickupItemEvent event) {
252 ItemStack stack = event.getItem().getItemStack();
253 if (keyItems.normalizeItem(stack)) {
254 event.getItem().setItemStack(stack);
255 }
256 }
257
258 @EventHandler(priority = EventPriority.MONITOR)
259 public void onJoin(PlayerJoinEvent event) {
260 keyItems.normalizeInventory(event.getPlayer().getInventory());
261 }
262
263 @EventHandler(priority = EventPriority.HIGHEST)
264 public void onPrepareCraft(PrepareItemCraftEvent event) {
265 CraftingInventory inv = event.getInventory();
266 boolean containsKey = false;
267 for (ItemStack item : inv.getMatrix()) {
268 if (keyItems.isKey(item)) {
269 containsKey = true;
270 break;
271 }
272 }
273 if (!containsKey) {
274 return;
275 }
276 if (!(inv.getRecipe() instanceof org.bukkit.inventory.CraftingRecipe recipe)
277 || !recipeKey.equals(recipe.getKey())) {
278 inv.setResult(null);
279 }
280 }
281
282 @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
283 public void onCrafterCraft(CrafterCraftEvent event) {
284 if (!(event.getBlock().getState() instanceof org.bukkit.block.Crafter crafter)) {
285 return;
286 }
287 if (recipeKey.equals(event.getRecipe().getKey())) {
288 return;
289 }
290 for (ItemStack item : crafter.getInventory().getContents()) {
291 if (keyItems.isKey(item)) {
292 event.setCancelled(true);
293 return;
294 }
295 }
296 }
297
298 private void handleDestroyed(Block block) {
299 LockRecord removed = lockStore.removeByBlock(BlockKey.of(block));
300 if (removed == null) {
301 return;
302 }
303 for (Player player : Bukkit.getOnlinePlayers()) {
304 keyItems.blankBindingInInventory(player.getInventory(), removed.bindingId());
305 }
306 }
307
308 private boolean playerHasKey(Player player, UUID bindingId) {
309 return keyItems.inventoryHasBinding(player.getInventory(), bindingId);
310 }
311
312 private boolean isBindable(Block block) {
313 BlockState state = block.getState();
314 return block.getBlockData() instanceof Openable || state instanceof InventoryHolder;
315 }
316
317 private List<BlockKey> collectMembers(Block block) {
318 Set<BlockKey> members = new LinkedHashSet<>();
319 members.add(BlockKey.of(block));
320
321 BlockState state = block.getState();
322 if (state instanceof org.bukkit.block.Chest chest) {
323 Inventory inventory = chest.getInventory();
324 InventoryHolder holder = inventory.getHolder();
325 if (holder instanceof DoubleChest doubleChest) {
326 addChestSide(members, doubleChest.getLeftSide());
327 addChestSide(members, doubleChest.getRightSide());
328 }
329 }
330
331 if (block.getBlockData() instanceof Door door) {
332 Block other = door.getHalf() == Bisected.Half.BOTTOM
333 ? block.getRelative(0, 1, 0)
334 : block.getRelative(0, -1, 0);
335 if (other.getBlockData() instanceof Door) {
336 members.add(BlockKey.of(other));
337 }
338 }
339
340 return new ArrayList<>(members);
341 }
342
343 private void addChestSide(Set<BlockKey> members, InventoryHolder side) {
344 if (side instanceof BlockState state) {
345 members.add(BlockKey.of(state.getBlock()));
346 }
347 }
348
349 private LockRecord lockForInventory(Inventory inventory) {
350 InventoryHolder holder = inventory.getHolder();
351 if (holder instanceof DoubleChest doubleChest) {
352 LockRecord left = lockForSide(doubleChest.getLeftSide());
353 return left != null ? left : lockForSide(doubleChest.getRightSide());
354 }
355 if (holder instanceof BlockState state) {
356 return lockStore.get(BlockKey.of(state.getBlock()));
357 }
358 // Some double chest inventories expose their holder through DoubleChestInventory.
359 if (inventory instanceof DoubleChestInventory doubleInventory) {
360 InventoryHolder doubleHolder = doubleInventory.getHolder();
361 if (doubleHolder instanceof DoubleChest doubleChest) {
362 LockRecord left = lockForSide(doubleChest.getLeftSide());
363 return left != null ? left : lockForSide(doubleChest.getRightSide());
364 }
365 }
366 return null;
367 }
368
369 private LockRecord lockForSide(InventoryHolder side) {
370 if (side instanceof BlockState state) {
371 return lockStore.get(BlockKey.of(state.getBlock()));
372 }
373 return null;
374 }
375
376 private void setUsedHandItem(Player player, EquipmentSlot hand, ItemStack item) {
377 if (hand == EquipmentSlot.OFF_HAND) {
378 player.getInventory().setItemInOffHand(item);
379 } else {
380 player.getInventory().setItemInMainHand(item);
381 }
382 }
383
384 private void lockedMessage(Player player) {
385 player.sendActionBar(Component.text("Locked — matching key required", NamedTextColor.RED));
386 }
387
388 private String displayName(Block block) {
389 return titleCase(block.getType().name());
390 }
391
392 private String titleCase(String enumName) {
393 String[] words = enumName.toLowerCase(Locale.ROOT).split("_");
394 StringBuilder result = new StringBuilder();
395 for (String word : words) {
396 if (word.isEmpty()) {
397 continue;
398 }
399 if (!result.isEmpty()) {
400 result.append(' ');
401 }
402 result.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1));
403 }
404 return result.toString();
405 }
406}