mirrors/papermc
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add PlayerShieldDisableEvent (#9177)

Browse source
This commit is contained in:
Cryptite 2023-12-28 18:27:34 -06:00 committed by GitHub
parent 2c3ccb80f0
commit b2ffb1b02d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 205 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

125
patches/api/0455-Add-PlayerShieldDisableEvent.patch Normal file
View file

@ -0,0 +1,125 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Cryptite <cryptite@gmail.com>
Date: Mon, 1 May 2023 16:22:43 -0500
Subject: [PATCH] Add PlayerShieldDisableEvent
Called whenever a players shield is disabled. This is mainly caused by
attacking players or monsters that carry axes.
The event, while similar to the PlayerItemCooldownEvent, offers other
behaviour and can hence not be implemented as a childtype of said event.
Specifically, cancelling the event prevents the game events from being
sent to the player.
Plugins listening to just the PlayerItemCooldownEvent may not want said
sideeffects, meaning the disable event cannot share a handlerlist with
the cooldown event.
diff --git a/src/main/java/io/papermc/paper/event/player/PlayerShieldDisableEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerShieldDisableEvent.java
new file mode 100644
index 0000000000000000000000000000000000000000..e74f30ca8f41d7ddc15c52dd34bf201805d91d9d
--- /dev/null
+++ b/src/main/java/io/papermc/paper/event/player/PlayerShieldDisableEvent.java
@@ -0,0 +1,102 @@
+package io.papermc.paper.event.player;
+
+import com.google.common.base.Preconditions;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Called whenever a players shield is disabled due to an attack from another entity that was capable of disabling the
+ * shield. This, most commonly, may be another player attacking with an axe.
+ * <p>
+ * Notably, this even is distinct from a {@link PlayerItemCooldownEvent} and will fire prior to the item going on
+ * cooldown.
+ * It follows that, if this event is cancelled, no {@link PlayerItemCooldownEvent} is called as the shield is never
+ * disabled in the first place.
+ */
+public class PlayerShieldDisableEvent extends PlayerEvent implements Cancellable {
+ private static final HandlerList HANDLER_LIST = new HandlerList();
+
+ private final Entity damager;
+ private int cooldown;
+ private boolean cancelled;
+
+ @ApiStatus.Internal
+ public PlayerShieldDisableEvent(@NotNull final Player player, @NotNull final Entity damager, final int cooldown) {
+ super(player);
+ this.damager = damager;
+ this.cooldown = cooldown;
+ }
+
+ /**
+ * Provides the damager that disabled the shield.
+ *
+ * @return the entity instance that damaged the player in a way that caused the shield to be disabled.
+ */
+ @NotNull
+ public Entity getDamager() {
+ return damager;
+ }
+
+ /**
+ * Gets the cooldown the disabled shield will be disabled for in ticks.
+ * <p>
+ * Notably, this value is not final as it might be changed by a {@link PlayerItemCooldownEvent} down the line,
+ * as said event is called if this event is not cancelled.
+ *
+ * @return cooldown in ticks
+ */
+ public int getCooldown() {
+ return cooldown;
+ }
+
+ /**
+ * Sets the cooldown of the shield in ticks.
+ * <p>
+ * Notably, this value is not final as it might be changed by a {@link PlayerItemCooldownEvent} down the line,
+ * as said event is called if this event is not cancelled.
+ *
+ * @param cooldown cooldown in ticks, has to be a positive number
+ */
+ public void setCooldown(int cooldown) {
+ Preconditions.checkArgument(cooldown >= 0, "The cooldown has to be equal to or greater than 0!");
+ this.cooldown = cooldown;
+ }
+
+ /**
+ * Gets the cancellation state of this event. A cancelled event will not
+ * be executed in the server, but will still pass to other plugins
+ *
+ * @return true if this event is cancelled
+ */
+ @Override
+ public boolean isCancelled() {
+ return this.cancelled;
+ }
+
+ /**
+ * Sets the cancellation state of this event. A cancelled event will not
+ * be executed in the server, but will still pass to other plugins.
+ *
+ * @param cancel true if you wish to cancel this event
+ */
+ @Override
+ public void setCancelled(final boolean cancel) {
+ this.cancelled = cancel;
+ }
+
+ @NotNull
+ @Override
+ public HandlerList getHandlers() {
+ return HANDLER_LIST;
+ }
+
+ @NotNull
+ public static HandlerList getHandlerList() {
+ return HANDLER_LIST;
+ }
+}

80
patches/server/1056-Add-PlayerShieldDisableEvent.patch Normal file
View file

@ -0,0 +1,80 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Cryptite <cryptite@gmail.com>
Date: Mon, 1 May 2023 16:22:43 -0500
Subject: [PATCH] Add PlayerShieldDisableEvent
Called whenever a players shield is disabled. This is mainly caused by
attacking players or monsters that carry axes.
The event, while similar to the PlayerItemCooldownEvent, offers other
behaviour and can hence not be implemented as a childtype of said event.
Specifically, cancelling the event prevents the game events from being
sent to the player.
Plugins listening to just the PlayerItemCooldownEvent may not want said
sideeffects, meaning the disable event cannot share a handlerlist with
the cooldown event
diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
index 5af48151159135b869ec4753bbcf79dd257c1570..e0cf7771488ab0065708d68b4e8550b865af0ed4 100644
--- a/src/main/java/net/minecraft/world/entity/Mob.java
+++ b/src/main/java/net/minecraft/world/entity/Mob.java
@@ -1703,7 +1703,11 @@ public abstract class Mob extends LivingEntity implements Targeting {
float f = 0.25F + (float) EnchantmentHelper.getBlockEfficiency(this) * 0.05F;
if (this.random.nextFloat() < f) {
- player.getCooldowns().addCooldown(Items.SHIELD, 100);
+ // Paper start
+ final io.papermc.paper.event.player.PlayerShieldDisableEvent shieldDisableEvent = new io.papermc.paper.event.player.PlayerShieldDisableEvent((org.bukkit.entity.Player) player.getBukkitEntity(), getBukkitEntity(), 100);
+ if (!shieldDisableEvent.callEvent()) return;
+ player.getCooldowns().addCooldown(Items.SHIELD, shieldDisableEvent.getCooldown());
+ // Paper end
this.level().broadcastEntityEvent(player, (byte) 30);
}
}
diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java
index 3e597833b57377b855505b8a0f2744801c791f90..ccc1caafb0ada52c7b99b7358253826f5390843e 100644
--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
@@ -979,7 +979,7 @@ public abstract class Player extends LivingEntity {
protected void blockUsingShield(LivingEntity attacker) {
super.blockUsingShield(attacker);
if (attacker.canDisableShield()) {
- this.disableShield(true);
+ this.disableShield(true, attacker); // Paper
}
}
@@ -1462,7 +1462,14 @@ public abstract class Player extends LivingEntity {
this.attack(target);
}
+ @io.papermc.paper.annotation.DoNotUse // Paper - add player shield disable event
public void disableShield(boolean sprinting) {
+ // Paper start - add player shield disable event
+ disableShield(sprinting, null);
+ }
+
+ public void disableShield(boolean sprinting, @Nullable LivingEntity attacker) {
+ // Paper end - add player shield disable event
float f = 0.25F + (float) EnchantmentHelper.getBlockEfficiency(this) * 0.05F;
if (sprinting) {
@@ -1470,7 +1477,16 @@ public abstract class Player extends LivingEntity {
}
if (this.random.nextFloat() < f) {
- this.getCooldowns().addCooldown(Items.SHIELD, 100);
+ // Paper start - add player shield disable event
+ final org.bukkit.entity.Entity finalAttacker = attacker != null ? attacker.getBukkitEntity() : null;
+ if (finalAttacker != null) {
+ final io.papermc.paper.event.player.PlayerShieldDisableEvent shieldDisableEvent = new io.papermc.paper.event.player.PlayerShieldDisableEvent((org.bukkit.entity.Player) getBukkitEntity(), finalAttacker, 100);
+ if (!shieldDisableEvent.callEvent()) return;
+ this.getCooldowns().addCooldown(Items.SHIELD, shieldDisableEvent.getCooldown());
+ } else {
+ this.getCooldowns().addCooldown(Items.SHIELD, 100);
+ }
+ // Paper end - add player shield disable event
this.stopUsingItem();
this.level().broadcastEntityEvent(this, (byte) 30);
}