650/1053

patches/server/Add-EntityDamageItemEvent.patch

@@ -0,0 +1,63 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Tue, 22 Dec 2020 13:52:48 -0800
+Subject: [PATCH] Add EntityDamageItemEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
++++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
+         return (Integer) this.getOrDefault(DataComponents.MAX_DAMAGE, 0);
+     }
+ 
+-    public void hurtAndBreak(int amount, ServerLevel world, @Nullable ServerPlayer player, Consumer<Item> breakCallback) {
++    public void hurtAndBreak(int amount, ServerLevel world, @Nullable LivingEntity player, Consumer<Item> breakCallback) { // Paper - Add EntityDamageItemEvent
+         if (this.isDamageableItem()) {
+             if (player == null || !player.hasInfiniteMaterials()) {
+                 if (amount > 0) {
+                     amount = EnchantmentHelper.processDurabilityChange(world, this, amount);
+                     // CraftBukkit start
+-                    if (player != null) {
+-                        PlayerItemDamageEvent event = new PlayerItemDamageEvent(player.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount);
++                    if (player instanceof ServerPlayer serverPlayer) { // Paper - Add EntityDamageItemEvent
++                        PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount); // Paper - Add EntityDamageItemEvent
+                         event.getPlayer().getServer().getPluginManager().callEvent(event);
+ 
+                         if (amount != event.getDamage() || event.isCancelled()) {
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
+                         }
+ 
+                         amount = event.getDamage();
++                        // Paper start - Add EntityDamageItemEvent
++                    } else if (player != null) {
++                        io.papermc.paper.event.entity.EntityDamageItemEvent event = new io.papermc.paper.event.entity.EntityDamageItemEvent(player.getBukkitLivingEntity(), CraftItemStack.asCraftMirror(this), amount);
++                        if (!event.callEvent()) {
++                            return;
++                        }
++                        amount = event.getDamage();
++                        // Paper end - Add EntityDamageItemEvent
+                     }
+                     // CraftBukkit end
+                     if (amount <= 0) {
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
+                     }
+                 }
+ 
+-                if (player != null && amount != 0) {
+-                    CriteriaTriggers.ITEM_DURABILITY_CHANGED.trigger(player, this, this.getDamageValue() + amount);
++                if (player instanceof ServerPlayer serverPlayer && amount != 0) { // Paper - Add EntityDamageItemEvent
++                    CriteriaTriggers.ITEM_DURABILITY_CHANGED.trigger(serverPlayer, this, this.getDamageValue() + amount); // Paper - Add EntityDamageItemEvent
+                 }
+ 
+                 int j = this.getDamageValue() + amount;
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
+                 entityplayer = null;
+             }
+ 
+-            this.hurtAndBreak(amount, worldserver, entityplayer, (item) -> {
++            this.hurtAndBreak(amount, worldserver, entity, (item) -> { // Paper - Add EntityDamageItemEvent
+                 // CraftBukkit start - Check for item breaking
+                 if (this.count == 1 && entity instanceof net.minecraft.world.entity.player.Player) {
+                     org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerItemBreakEvent((net.minecraft.world.entity.player.Player) entity, this);

patches/server/Add-PlayerItemFrameChangeEvent.patch

@@ -8,9 +8,9 @@ diff --git a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
 +++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
-@@ -0,0 +0,0 @@ package net.minecraft.world.entity.decoration;
+@@ -0,0 +0,0 @@
+ package net.minecraft.world.entity.decoration;
  
- import com.mojang.logging.LogUtils;
  import javax.annotation.Nullable;
 +import io.papermc.paper.event.player.PlayerItemFrameChangeEvent; // Paper - Add PlayerItemFrameChangeEvent
  import net.minecraft.core.BlockPos;

patches/server/Add-back-EntityPortalExitEvent.patch

@@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 16 May 2021 09:39:46 -0700
+Subject: [PATCH] Add back EntityPortalExitEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         if (world instanceof ServerLevel worldserver) {
+             if (!this.isRemoved()) {
+                 // CraftBukkit start
+-                Location to = new Location(teleportTarget.newLevel().getWorld(), teleportTarget.pos().x, teleportTarget.pos().y, teleportTarget.pos().z, teleportTarget.yRot(), teleportTarget.xRot());
++                Location to = new Location(teleportTarget.newLevel().getWorld(), teleportTarget.pos().x, teleportTarget.pos().y, teleportTarget.pos().z, teleportTarget.yRot(), this.getXRot()); // Paper - use getXRot (doesn't respect DimensionTransition pitch)
+                 // Paper start - gateway-specific teleport event
+                 final EntityTeleportEvent teleEvent;
+                 if (this.portalProcess != null && this.portalProcess.isSamePortal(((net.minecraft.world.level.block.EndGatewayBlock) net.minecraft.world.level.block.Blocks.END_GATEWAY)) && this.level.getBlockEntity(this.portalProcess.getEntryPosition()) instanceof net.minecraft.world.level.block.entity.TheEndGatewayBlockEntity theEndGatewayBlockEntity) {
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                     return null;
+                 }
+                 to = teleEvent.getTo();
+-                teleportTarget = new DimensionTransition(((CraftWorld) to.getWorld()).getHandle(), CraftLocation.toVec3D(to), teleportTarget.speed(), to.getYaw(), to.getPitch(), teleportTarget.missingRespawnBlock(), teleportTarget.postDimensionTransition(), teleportTarget.cause());
++                // Paper start - Call EntityPortalExitEvent
++                CraftEntity bukkitEntity = this.getBukkitEntity();
++                Vec3 velocity = teleportTarget.speed();
++                org.bukkit.event.entity.EntityPortalExitEvent event = new org.bukkit.event.entity.EntityPortalExitEvent(
++                    bukkitEntity,
++                    bukkitEntity.getLocation(), to.clone(),
++                    bukkitEntity.getVelocity(), org.bukkit.craftbukkit.util.CraftVector.toBukkit(velocity)
++                );
++                event.callEvent();
++                if (this.isRemoved()) {
++                    return null;
++                }
++
++                if (!event.isCancelled() && event.getTo() != null) {
++                    to = event.getTo().clone();
++                    velocity = org.bukkit.craftbukkit.util.CraftVector.toNMS(event.getAfter());
++                }
++                teleportTarget = new DimensionTransition(((CraftWorld) to.getWorld()).getHandle(), CraftLocation.toVec3D(to), velocity, to.getYaw(), to.getPitch(), teleportTarget.missingRespawnBlock(), teleportTarget.postDimensionTransition(), teleportTarget.cause());
++                // Paper end - Call EntityPortalExitEvent
+                 // CraftBukkit end
+                 ServerLevel worldserver1 = teleportTarget.newLevel();
+                 List<Entity> list = this.getPassengers();

patches/server/Add-critical-damage-API.patch

@@ -32,30 +32,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/player/Player.java
 +++ b/src/main/java/net/minecraft/world/entity/player/Player.java
 @@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-                         }
- 
-                         f += this.getItemInHand(InteractionHand.MAIN_HAND).getItem().getAttackDamageBonus(this, f);
--                        boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround() && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity && !this.isSprinting();
-+                        boolean flag2 = flag && this.fallDistance > 0.0F && !this.onGround() && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffects.BLINDNESS) && !this.isPassenger() && target instanceof LivingEntity && !this.isSprinting(); // Paper - Add critical damage API; diff on change
  
                      flag2 = flag2 && !this.level().paperConfig().entities.behavior.disablePlayerCrits; // Paper - Toggleable player crits
                      if (flag2) {
-@@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
++                        damagesource = damagesource.critical(true); // Paper start - critical damage API
+                         f *= 1.5F;
                      }
  
-                         Vec3 vec3d = target.getDeltaMovement();
--                        boolean flag5 = target.hurt(this.damageSources().playerAttack(this), f);
-+                        boolean flag5 = target.hurt(this.damageSources().playerAttack(this).critical(flag2), f); // Paper - add critical damage API
- 
-                         if (flag5) {
-                             if (i > 0) {
 @@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
+                                     float f7 = this.getEnchantedDamage(entityliving2, f6, damagesource) * f2;
  
-                                     if (entityliving != this && entityliving != target && !this.isAlliedTo((Entity) entityliving) && (!(entityliving instanceof ArmorStand) || !((ArmorStand) entityliving).isMarker()) && this.distanceToSqr((Entity) entityliving) < 9.0D) {
                                      // CraftBukkit start - Only apply knockback if the damage hits
--                                        if (entityliving.hurt(this.damageSources().playerAttack(this).sweep(), f4)) {
+-                                    if (entityliving2.hurt(this.damageSources().playerAttack(this).sweep(), f7)) {
-+                                        if (entityliving.hurt(this.damageSources().playerAttack(this).sweep().critical(flag2), f4)) { // Paper - add critical damage API
++                                    if (entityliving2.hurt(this.damageSources().playerAttack(this).sweep().critical(flag2), f7)) { // Paper - add critical damage API
-                                             entityliving.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.SWEEP_ATTACK); // CraftBukkit // Paper - knockback events
+                                         entityliving2.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.SWEEP_ATTACK); // CraftBukkit // Paper - knockback events
                                      }
                                      // CraftBukkit end
 diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
@@ -63,7 +53,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
 +++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
 @@ -0,0 +0,0 @@ public abstract class AbstractArrow extends Projectile {
-             }
+             entityliving.setLastHurtMob(entity);
          }
  
 +        if (this.isCritArrow()) damagesource = damagesource.critical(); // Paper - add critical damage API

patches/server/Add-more-Campfire-API.patch

@@ -11,7 +11,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class CampfireBlockEntity extends BlockEntity implements Clearable {
      public final int[] cookingProgress;
      public final int[] cookingTime;
-     private final RecipeManager.CachedCheck<Container, CampfireCookingRecipe> quickCheck;
+     private final RecipeManager.CachedCheck<SingleRecipeInput, CampfireCookingRecipe> quickCheck;
 +    public final boolean[] stopCooking; // Paper - Add more Campfire API
  
      public CampfireBlockEntity(BlockPos pos, BlockState state) {
@@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                } // Paper - Add more Campfire API
  
                  if (campfire.cookingProgress[i] >= campfire.cookingTime[i]) {
-                     SimpleContainer inventorysubcontainer = new SimpleContainer(new ItemStack[]{itemstack});
+                     SingleRecipeInput singlerecipeinput = new SingleRecipeInput(itemstack);
 @@ -0,0 +0,0 @@ public class CampfireBlockEntity extends BlockEntity implements Clearable {
              System.arraycopy(aint, 0, this.cookingTime, 0, Math.min(this.cookingTime.length, aint.length));
          }

patches/server/Do-not-run-close-logic-for-inventories-on-chunk-unlo.patch

@@ -31,7 +31,7 @@ diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/ma
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
+@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
          this.connection.send(new ClientboundContainerClosePacket(this.containerMenu.containerId));
          this.doCloseContainer();
      }

patches/server/Ensure-valid-vehicle-status.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/ma
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
+@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
              }
          }
  

patches/server/Improve-and-expand-AsyncCatcher.patch

@@ -200,7 +200,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        org.spigotmc.AsyncCatcher.catchOp("play sound"); // Paper
          if (!(entity instanceof CraftEntity craftEntity) || entity.getWorld() != this || sound == null || category == null) return;
  
-         ClientboundSoundEntityPacket packet = new ClientboundSoundEntityPacket(Holder.direct(SoundEvent.createVariableRangeEvent(new ResourceLocation(sound))), net.minecraft.sounds.SoundSource.valueOf(category.name()), craftEntity.getHandle(), volume, pitch, seed);
+         ClientboundSoundEntityPacket packet = new ClientboundSoundEntityPacket(Holder.direct(SoundEvent.createVariableRangeEvent(ResourceLocation.parse(sound))), net.minecraft.sounds.SoundSource.valueOf(category.name()), craftEntity.getHandle(), volume, pitch, seed);
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java

patches/server/Only-write-chunk-data-to-disk-if-it-serializes-witho.patch

@@ -79,8 +79,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          // Paper start - Chunk save reattempt
                  return;
 @@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable {
-         }
+     public RegionStorageInfo info() {
- 
+         return this.info;
      }
 +
 +    // Paper start - don't write garbage data to disk if writing serialization fails

patches/server/Option-to-prevent-data-components-copy-in-smithing-r.patch

@@ -25,8 +25,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.base = base;
          this.addition = addition;
 @@ -0,0 +0,0 @@ public class SmithingTransformRecipe implements SmithingRecipe {
-     public ItemStack assemble(Container inventory, HolderLookup.Provider lookup) {
+     public ItemStack assemble(SmithingRecipeInput input, HolderLookup.Provider lookup) {
-         ItemStack itemstack = inventory.getItem(1).transmuteCopy(this.result.getItem(), this.result.getCount());
+         ItemStack itemstack = input.base().transmuteCopy(this.result.getItem(), this.result.getCount());
  
 +        if (this.copyDataComponents) { // Paper - Option to prevent data components copy
          itemstack.applyComponents(this.result.getComponentsPatch());

patches/server/Prevent-excessive-velocity-through-repeated-crits.patch

@@ -13,7 +13,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 +    protected long lastJumpTime = 0L; // Paper - Prevent excessive velocity through repeated crits
-     protected void jumpFromGround() {
+     @VisibleForTesting
+     public void jumpFromGround() {
          float f = this.getJumpPower();
  
          if (f > 1.0E-5F) {

patches/server/Remove-client-side-code-using-deprecated-for-removal.patch

@@ -13,18 +13,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class Util {
          }
  
-         public void openUrl(URL url) {
+         public void openUri(URI uri) {
 -            try {
 -                Process process = AccessController.doPrivileged(
--                    (PrivilegedExceptionAction<Process>)(() -> Runtime.getRuntime().exec(this.getOpenUrlArguments(url)))
+-                    (PrivilegedExceptionAction<Process>)(() -> Runtime.getRuntime().exec(this.getOpenUriArguments(uri)))
 -                );
 -                process.getInputStream().close();
 -                process.getErrorStream().close();
 -                process.getOutputStream().close();
 -            } catch (IOException | PrivilegedActionException var3) {
--                Util.LOGGER.error("Couldn't open url '{}'", url, var3);
+-                Util.LOGGER.error("Couldn't open location '{}'", uri, var3);
 -            }
 +            throw new IllegalStateException("This method is not useful on dedicated servers."); // Paper - Fix warnings on build by removing client-only code
          }
  
-         public void openUri(URI uri) {
+         public void openFile(File file) {

patches/server/Sanitize-ResourceLocation-error-logging.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/resources/ResourceLocation.java b/src/m
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/resources/ResourceLocation.java
 +++ b/src/main/java/net/minecraft/resources/ResourceLocation.java
-@@ -0,0 +0,0 @@ public class ResourceLocation implements Comparable<ResourceLocation> {
+@@ -0,0 +0,0 @@ public final class ResourceLocation implements Comparable<ResourceLocation> {
  
      private static String assertValidNamespace(String namespace, String path) {
          if (!isValidNamespace(namespace)) {
@@ -17,7 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          } else {
              return namespace;
          }
-@@ -0,0 +0,0 @@ public class ResourceLocation implements Comparable<ResourceLocation> {
+@@ -0,0 +0,0 @@ public final class ResourceLocation implements Comparable<ResourceLocation> {
  
      private static String assertValidPath(String namespace, String path) {
          if (!isValidPath(path)) {

patches/server/don-t-attempt-to-teleport-dead-entities.patch

@@ -14,6 +14,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          // No clean way to break out of ticking once the entity has been copied to a new world, so instead we move the portalling later in the tick cycle
 -        if (!(this instanceof ServerPlayer)) {
 +        if (!(this instanceof ServerPlayer) && this.isAlive()) { // Paper - don't attempt to teleport dead entities
-             this.handleNetherPortal();
+             this.handlePortal();
          }
      }

patches/unapplied/server/Add-EntityDamageItemEvent.patch

@@ -1,65 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Tue, 22 Dec 2020 13:52:48 -0800
-Subject: [PATCH] Add EntityDamageItemEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/ItemStack.java
-+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
-@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
-         return (Integer) this.getOrDefault(DataComponents.MAX_DAMAGE, 0);
-     }
- 
--    public void hurtAndBreak(int amount, RandomSource random, @Nullable ServerPlayer player, Runnable breakCallback) {
-+    public void hurtAndBreak(int amount, RandomSource random, @Nullable LivingEntity player, Runnable breakCallback) { // Paper - Add EntityDamageItemEvent
-         if (this.isDamageableItem()) {
-             int j;
- 
-@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
- 
-                 amount -= k;
-                 // CraftBukkit start
--                if (player != null) {
--                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(player.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount);
-+                if (player instanceof ServerPlayer serverPlayer) { // Paper - Add EntityDamageItemEvent
-+                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount); // Paper - Add EntityDamageItemEvent
-                     event.getPlayer().getServer().getPluginManager().callEvent(event);
- 
-                     if (amount != event.getDamage() || event.isCancelled()) {
-@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
-                     }
- 
-                     amount = event.getDamage();
-+                    // Paper start - Add EntityDamageItemEvent
-+                } else if (player != null) {
-+                    io.papermc.paper.event.entity.EntityDamageItemEvent event = new io.papermc.paper.event.entity.EntityDamageItemEvent(player.getBukkitLivingEntity(), CraftItemStack.asCraftMirror(this), amount);
-+                    if (!event.callEvent()) {
-+                        return;
-+                    }
-+                    amount = event.getDamage();
-+                    // Paper end - Add EntityDamageItemEvent
-                 }
-                 // CraftBukkit end
-                 if (amount <= 0) {
-@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
-                 }
-             }
- 
--            if (player != null && amount != 0) {
--                CriteriaTriggers.ITEM_DURABILITY_CHANGED.trigger(player, this, this.getDamageValue() + amount);
-+            if (player instanceof ServerPlayer serverPlayer && amount != 0) { // Paper - Add EntityDamageItemEvent
-+                CriteriaTriggers.ITEM_DURABILITY_CHANGED.trigger(serverPlayer, this, this.getDamageValue() + amount); // Paper - Add EntityDamageItemEvent
-             }
- 
-             j = this.getDamageValue() + amount;
-@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
-                 entityplayer = null;
-             }
- 
--            this.hurtAndBreak(amount, randomsource, entityplayer, () -> {
-+            this.hurtAndBreak(amount, randomsource, entity, () -> { // Paper - Add EntityDamageItemEvent
-                 entity.broadcastBreakEvent(slot);
-                 Item item = this.getItem();
-                 // CraftBukkit start - Check for item breaking

patches/unapplied/server/Add-back-EntityPortalExitEvent.patch

@@ -1,50 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Sun, 16 May 2021 09:39:46 -0700
-Subject: [PATCH] Add back EntityPortalExitEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-             } else {
-                 // CraftBukkit start
-                 worldserver = shapedetectorshape.world;
-+                // Paper start - Call EntityPortalExitEvent
-+                Vec3 position = shapedetectorshape.pos;
-+                float yaw = shapedetectorshape.yRot;
-+                float pitch = this.getXRot(); // Keep entity pitch as per moveTo line below
-+                Vec3 velocity = shapedetectorshape.speed;
-+                CraftEntity bukkitEntity = this.getBukkitEntity();
-+                org.bukkit.event.entity.EntityPortalExitEvent event = new org.bukkit.event.entity.EntityPortalExitEvent(bukkitEntity,
-+                    bukkitEntity.getLocation(), new Location(worldserver.getWorld(), position.x, position.y, position.z, yaw, pitch),
-+                    bukkitEntity.getVelocity(), org.bukkit.craftbukkit.util.CraftVector.toBukkit(shapedetectorshape.speed));
-+                event.callEvent();
-+                if (this.isRemoved()) {
-+                    return null;
-+                }
-+
-+                if (!event.isCancelled() && event.getTo() != null) {
-+                    worldserver = ((CraftWorld) event.getTo().getWorld()).getHandle();
-+                    position = CraftLocation.toVec3D(event.getTo());
-+                    yaw = event.getTo().getYaw();
-+                    pitch = event.getTo().getPitch();
-+                    velocity = org.bukkit.craftbukkit.util.CraftVector.toNMS(event.getAfter());
-+                }
-+                // Paper end - Call EntityPortalExitEvent
-                 if (worldserver == this.level) {
-                     // SPIGOT-6782: Just move the entity if a plugin changed the world to the one the entity is already in
-                     this.moveTo(shapedetectorshape.pos.x, shapedetectorshape.pos.y, shapedetectorshape.pos.z, shapedetectorshape.yRot, shapedetectorshape.xRot);
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
- 
-                 if (entity != null) {
-                     entity.restoreFrom(this);
--                    entity.moveTo(shapedetectorshape.pos.x, shapedetectorshape.pos.y, shapedetectorshape.pos.z, shapedetectorshape.yRot, entity.getXRot());
--                    entity.setDeltaMovement(shapedetectorshape.speed);
-+                    entity.moveTo(position.x, position.y, position.z, yaw, pitch); // Paper - EntityPortalExitEvent
-+                    entity.setDeltaMovement(velocity); // Paper - EntityPortalExitEvent
-                     // CraftBukkit start - Don't spawn the new entity if the current entity isn't spawned
-                     if (this.inWorld) {
-                         worldserver.addDuringTeleport(entity);

patches/unapplied/server/Clear-bucket-NBT-after-dispense.patch

@@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Fri, 13 Aug 2021 15:00:06 -0700
-Subject: [PATCH] Clear bucket NBT after dispense
-
-
-diff --git a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
-+++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
-@@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
-                     Item item = Items.BUCKET;
-                     stack.shrink(1);
-                     if (stack.isEmpty()) {
--                        stack.setItem(Items.BUCKET);
--                        stack.setCount(1);
-+                        stack = new ItemStack(item); // Paper - Clear bucket NBT after dispense
-                     } else if (pointer.blockEntity().addItem(new ItemStack(item)) < 0) {
-                         this.defaultDispenseItemBehavior.dispense(pointer, new ItemStack(item));
-                     }