From 3aec8630bba3a6eaa0425cf6cb620ca9bd84c4ec Mon Sep 17 00:00:00 2001 From: Jake Potrebic Date: Thu, 15 Dec 2022 08:49:49 -0800 Subject: [PATCH] Add BlockLockCheckEvent (#7840) --- .../api/0420-Add-BlockLockCheckEvent.patch | 242 ++++++++++++++++++ .../server/0948-Add-BlockLockCheckEvent.patch | 70 +++++ 2 files changed, 312 insertions(+) create mode 100644 patches/api/0420-Add-BlockLockCheckEvent.patch create mode 100644 patches/server/0948-Add-BlockLockCheckEvent.patch diff --git a/patches/api/0420-Add-BlockLockCheckEvent.patch b/patches/api/0420-Add-BlockLockCheckEvent.patch new file mode 100644 index 0000000000..10465344b9 --- /dev/null +++ b/patches/api/0420-Add-BlockLockCheckEvent.patch @@ -0,0 +1,242 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Jake Potrebic +Date: Sat, 21 May 2022 20:59:56 -0700 +Subject: [PATCH] Add BlockLockCheckEvent + + +diff --git a/src/main/java/io/papermc/paper/block/LockableTileState.java b/src/main/java/io/papermc/paper/block/LockableTileState.java +new file mode 100644 +index 0000000000000000000000000000000000000000..f309961e0e96b6baacc4fe6d80dabd6c7c5d2e1d +--- /dev/null ++++ b/src/main/java/io/papermc/paper/block/LockableTileState.java +@@ -0,0 +1,11 @@ ++package io.papermc.paper.block; ++ ++import org.bukkit.Nameable; ++import org.bukkit.block.Lockable; ++import org.bukkit.block.TileState; ++ ++/** ++ * Interface for tile entities that are lockable. ++ */ ++public interface LockableTileState extends TileState, Lockable, Nameable { ++} +diff --git a/src/main/java/io/papermc/paper/event/block/BlockLockCheckEvent.java b/src/main/java/io/papermc/paper/event/block/BlockLockCheckEvent.java +new file mode 100644 +index 0000000000000000000000000000000000000000..d298ebecaa6e0a4cdc273e326d1976d27efe0e32 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/event/block/BlockLockCheckEvent.java +@@ -0,0 +1,187 @@ ++package io.papermc.paper.event.block; ++ ++import com.google.common.base.Preconditions; ++import io.papermc.paper.block.LockableTileState; ++import net.kyori.adventure.sound.Sound; ++import net.kyori.adventure.text.Component; ++import org.bukkit.Nameable; ++import org.bukkit.block.Block; ++import org.bukkit.block.BlockState; ++import org.bukkit.block.Lockable; ++import org.bukkit.block.TileState; ++import org.bukkit.entity.Player; ++import org.bukkit.event.HandlerList; ++import org.bukkit.event.block.BlockEvent; ++import org.bukkit.inventory.ItemStack; ++import org.jetbrains.annotations.NotNull; ++import org.jetbrains.annotations.Nullable; ++ ++import java.util.Objects; ++ ++/** ++ * Called when the server tries to check the lock on a lockable tile entity. ++ * @see #setResult(Result) to change behavior ++ */ ++public class BlockLockCheckEvent extends BlockEvent { ++ ++ private static final HandlerList HANDLER_LIST = new HandlerList(); ++ ++ private final LockableTileState state; ++ private final Player player; ++ private ItemStack itemStack; ++ private Result result = Result.DEFAULT; ++ private Component lockedMessage; ++ private Sound lockedSound; ++ ++ public BlockLockCheckEvent(final @NotNull Block block, final @NotNull LockableTileState state, final @NotNull Player player, final @NotNull Component lockedMessage, final @NotNull Sound lockedSound) { ++ super(block); ++ this.state = state; ++ this.player = player; ++ this.lockedMessage = lockedMessage; ++ this.lockedSound = lockedSound; ++ } ++ ++ /** ++ * Gets the snapshot {@link LockableTileState} of the tile entity ++ * whose lock is being checked. ++ * ++ * @return the snapshot block state. ++ */ ++ public @NotNull LockableTileState getBlockState() { ++ return this.state; ++ } ++ ++ /** ++ * Get the player involved this lock check. ++ * ++ * @return the player ++ */ ++ public @NotNull Player getPlayer() { ++ return this.player; ++ } ++ ++ /** ++ * Gets the itemstack that will be used as the key itemstack. Initially ++ * this will be the item in the player's main hand but an override can be set ++ * with {@link #setKeyItem(ItemStack)}. Use {@link #isUsingCustomKeyItemStack()} ++ * to check if a custom key stack has been set. ++ * ++ * @return the item being used as the key item ++ * @see #isUsingCustomKeyItemStack() ++ */ ++ public @NotNull ItemStack getKeyItem() { ++ return Objects.requireNonNullElseGet(this.itemStack, this.player.getInventory()::getItemInMainHand); ++ } ++ ++ /** ++ * Sets the itemstack that will be used as the key item. ++ * ++ * @param stack the stack to use as a key (or null to fall back to the player's main hand item) ++ * @see #resetKeyItem() to clear a custom key item ++ */ ++ public void setKeyItem(@NotNull ItemStack stack) { ++ Preconditions.checkNotNull(stack, "stack is null"); ++ this.itemStack = stack; ++ } ++ ++ /** ++ * Reset the key stack to the default (the player's main hand). ++ */ ++ public void resetKeyItem() { ++ this.itemStack = null; ++ } ++ ++ /** ++ * Checks if a custom key stack has been set. ++ * ++ * @return true if a custom key itemstack has been set ++ */ ++ public boolean isUsingCustomKeyItemStack() { ++ return this.itemStack != null; ++ } ++ ++ /** ++ * Gets the result of this event. ++ * ++ * @return the result ++ * @see #setResult(Result) ++ */ ++ public @NotNull Result getResult() { ++ return this.result; ++ } ++ ++ /** ++ * Gets the result of this event. {@link org.bukkit.event.Event.Result#DEFAULT} is the default ++ * allowing the vanilla logic to check the lock of this block. Set to {@link org.bukkit.event.Event.Result#ALLOW} ++ * or {@link org.bukkit.event.Event.Result#DENY} to override that behavior. ++ *

++ * Setting this to {@link org.bukkit.event.Event.Result#ALLOW} bypasses the spectator check. ++ * ++ * @param result the result of this event ++ */ ++ public void setResult(@NotNull Result result) { ++ this.result = result; ++ } ++ ++ /** ++ * Shorthand method to set the {@link #getResult()} to {@link org.bukkit.event.Event.Result#DENY}, ++ * the locked message and locked sound. ++ * ++ * @param lockedMessage the message to show if locked (or null for none) ++ * @param lockedSound the sound to play if locked (or null for none) ++ */ ++ public void denyWithMessageAndSound(@Nullable Component lockedMessage, @Nullable Sound lockedSound) { ++ this.result = Result.DENY; ++ this.lockedMessage = lockedMessage; ++ this.lockedSound = lockedSound; ++ } ++ ++ /** ++ * Gets the locked message that will be sent if the ++ * player cannot open the block. ++ * ++ * @return the locked message (or null if none) ++ */ ++ public @Nullable Component getLockedMessage() { ++ return this.lockedMessage; ++ } ++ ++ /** ++ * Sets the locked message that will be sent if the ++ * player cannot open the block. ++ * ++ * @param lockedMessage the locked message (or null for none) ++ */ ++ public void setLockedMessage(@Nullable Component lockedMessage) { ++ this.lockedMessage = lockedMessage; ++ } ++ ++ /** ++ * Gets the locked sound that will play if the ++ * player cannot open the block. ++ * ++ * @return the locked sound (or null if none) ++ */ ++ public @Nullable Sound getLockedSound() { ++ return this.lockedSound; ++ } ++ ++ /** ++ * Sets the locked sound that will play if the ++ * player cannot open the block. ++ * ++ * @param lockedSound the locked sound (or null for none) ++ */ ++ public void setLockedSound(@Nullable Sound lockedSound) { ++ this.lockedSound = lockedSound; ++ } ++ ++ @Override ++ public @NotNull HandlerList getHandlers() { ++ return HANDLER_LIST; ++ } ++ ++ public static @NotNull HandlerList getHandlerList() { ++ return HANDLER_LIST; ++ } ++} +diff --git a/src/main/java/org/bukkit/block/Beacon.java b/src/main/java/org/bukkit/block/Beacon.java +index 78475fc6faff0f295828d7b53792001d51aa2889..c86e18508c3df72bf1d67b226bf02af00d66ce98 100644 +--- a/src/main/java/org/bukkit/block/Beacon.java ++++ b/src/main/java/org/bukkit/block/Beacon.java +@@ -11,7 +11,7 @@ import org.jetbrains.annotations.Nullable; + /** + * Represents a captured state of a beacon. + */ +-public interface Beacon extends TileState, Lockable, Nameable { ++public interface Beacon extends io.papermc.paper.block.LockableTileState { // Paper + + /** + * Returns the list of players within the beacon's range of effect. +diff --git a/src/main/java/org/bukkit/block/Container.java b/src/main/java/org/bukkit/block/Container.java +index bc06199f0a1cc43e0bdfd5b11fa170badd46e180..a67ee0cb0cd2cbab8dab375e2fe44168c250bcb7 100644 +--- a/src/main/java/org/bukkit/block/Container.java ++++ b/src/main/java/org/bukkit/block/Container.java +@@ -8,7 +8,7 @@ import org.jetbrains.annotations.NotNull; + /** + * Represents a captured state of a container block. + */ +-public interface Container extends TileState, BlockInventoryHolder, Lockable, Nameable { ++public interface Container extends io.papermc.paper.block.LockableTileState, BlockInventoryHolder { // Paper + + /** + * Gets the inventory of the block represented by this block state. diff --git a/patches/server/0948-Add-BlockLockCheckEvent.patch b/patches/server/0948-Add-BlockLockCheckEvent.patch new file mode 100644 index 0000000000..d8e6c59f8b --- /dev/null +++ b/patches/server/0948-Add-BlockLockCheckEvent.patch @@ -0,0 +1,70 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Jake Potrebic +Date: Sat, 21 May 2022 20:59:45 -0700 +Subject: [PATCH] Add BlockLockCheckEvent + + +diff --git a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java +index a782994e2e53f2c4212c2d59ce740ebf00a826b0..3444c1a2e7f1dd938e42cdf0668e43be273b9116 100644 +--- a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java ++++ b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java +@@ -69,17 +69,44 @@ public abstract class BaseContainerBlockEntity extends BlockEntity implements Co + protected abstract Component getDefaultName(); + + public boolean canOpen(Player player) { +- return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName()); ++ return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName(), this); // Paper + } + ++ @Deprecated @io.papermc.paper.annotation.DoNotUse // Paper + public static boolean canUnlock(Player player, LockCode lock, Component containerName) { ++ // Paper start ++ return canUnlock(player, lock, containerName, null); ++ } ++ public static boolean canUnlock(Player player, LockCode lock, Component containerName, @Nullable BlockEntity blockEntity) { ++ if (player instanceof net.minecraft.server.level.ServerPlayer serverPlayer && blockEntity != null && blockEntity.getLevel() != null) { ++ final org.bukkit.block.Block block = org.bukkit.craftbukkit.block.CraftBlock.at(blockEntity.getLevel(), blockEntity.getBlockPos()); ++ net.kyori.adventure.text.Component lockedMessage = net.kyori.adventure.text.Component.translatable("container.isLocked", io.papermc.paper.adventure.PaperAdventure.asAdventure(containerName)); ++ net.kyori.adventure.sound.Sound lockedSound = net.kyori.adventure.sound.Sound.sound(org.bukkit.Sound.BLOCK_CHEST_LOCKED, net.kyori.adventure.sound.Sound.Source.BLOCK, 1.0F, 1.0F); ++ final io.papermc.paper.event.block.BlockLockCheckEvent event = new io.papermc.paper.event.block.BlockLockCheckEvent(block, (io.papermc.paper.block.LockableTileState) block.getState(), serverPlayer.getBukkitEntity(), lockedMessage, lockedSound); ++ event.callEvent(); ++ if (event.getResult() == org.bukkit.event.Event.Result.ALLOW) { ++ return true; ++ } else if (event.getResult() == org.bukkit.event.Event.Result.DENY || (!player.isSpectator() && !lock.unlocksWith(event.isUsingCustomKeyItemStack() ? org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getKeyItem()) : player.getMainHandItem()))) { ++ if (event.getLockedMessage() != null) { ++ event.getPlayer().sendActionBar(event.getLockedMessage()); ++ } ++ if (event.getLockedSound() != null) { ++ event.getPlayer().playSound(event.getLockedSound()); ++ } ++ return false; ++ } else { ++ return true; ++ } ++ } else { // logic below is replaced by logic above ++ // Paper end + if (!player.isSpectator() && !lock.unlocksWith(player.getMainHandItem())) { +- player.displayClientMessage(Component.translatable("container.isLocked", containerName), true); ++ player.displayClientMessage(Component.translatable("container.isLocked", containerName), true); // Paper - diff on change + player.playNotifySound(SoundEvents.CHEST_LOCKED, SoundSource.BLOCKS, 1.0F, 1.0F); + return false; + } else { + return true; + } ++ } // Paper + } + + @Nullable +diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java +index 49ca1d45bb4b3ddafc1d5952ff9830ba69b745e2..928625b5ab054ffa412be8a438f58291cc7a3cc0 100644 +--- a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java ++++ b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java +@@ -444,7 +444,7 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name + @Nullable + @Override + public AbstractContainerMenu createMenu(int syncId, Inventory inv, Player player) { +- return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName()) ? new BeaconMenu(syncId, inv, this.dataAccess, ContainerLevelAccess.create(this.level, this.getBlockPos())) : null; ++ return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName(), this) ? new BeaconMenu(syncId, inv, this.dataAccess, ContainerLevelAccess.create(this.level, this.getBlockPos())) : null; // Paper + } + + @Override