Use internals for getting block/entity countstimings/use-internals

For a long time I've been meaning to move some of this logic internally
as this would allow us to avoid hitting systems like block state snapshots
which can create issues as many of the spigot implementations of this
stuff are increasingly broken, leading to unexpected crashes during ticking,
even if the API cannot properly interact with these such states/items,
it's generally more preferable to not crash the server in the course,
and just let those interactions fail more gracefully.

1 files changed, 115 insertions, 0 deletions

diff --git a/patches/api/0448-Add-PlayerShieldDisableEvent.patch b/patches/api/0448-Add-PlayerShieldDisableEvent.patch
new file mode 100644
index 0000000000..29c7daa0e3
--- /dev/null
+++ b/patches/api/0448-Add-PlayerShieldDisableEvent.patch
@@ -0,0 +1,115 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Cryptite <[email protected]>
+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..25c13b01c5630a6de30058532458d779763e4e42
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PlayerShieldDisableEvent.java
+@@ -0,0 +1,92 @@
++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 this.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 this.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;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @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;
++    }
++}