More more more more more more patches

patches/server/Add-BlockBreakBlockEvent.patch

@@ -30,7 +30,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    // Paper end
  
-     public static void dropResources(BlockState state, Level world, BlockPos pos, @Nullable BlockEntity blockEntity, Entity entity, ItemStack stack) {
+     public static void dropResources(BlockState state, Level world, BlockPos pos, @Nullable BlockEntity blockEntity, Entity entity, ItemStack tool) {
          if (world instanceof ServerLevel) {
 diff --git a/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java b/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/server/Add-Channel-initialization-listeners.patch

@@ -146,8 +146,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
 +++ b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
 @@ -0,0 +0,0 @@ public class ServerConnectionListener {
-                     pending.add((Connection) object); // Paper
-                     channel.pipeline().addLast("packet_handler", (ChannelHandler) object);
+                     pending.add(object); // Paper
+                     channelpipeline.addLast("packet_handler", (ChannelHandler) object);
                      ((Connection) object).setListener(new ServerHandshakePacketListenerImpl(ServerConnectionListener.this.server, (Connection) object));
 +                    io.papermc.paper.network.ChannelInitializeListenerHolder.callListeners(channel); // Paper
                  }

patches/server/Add-ElderGuardianAppearanceEvent.patch

@@ -21,9 +21,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          // CraftBukkit end
          MobEffect mobeffectlist = mobeffect.getEffect();
          List<ServerPlayer> list = worldserver.getPlayers((entityplayer) -> {
--            return entityplayer.gameMode.isSurvival() && (entity == null || !entity.isAlliedTo((Entity) entityplayer)) && vec3d.closerThan(entityplayer.position(), d0) && (!entityplayer.hasEffect(mobeffectlist) || entityplayer.getEffect(mobeffectlist).getAmplifier() < mobeffect.getAmplifier() || entityplayer.getEffect(mobeffectlist).getDuration() < i);
+-            return entityplayer.gameMode.isSurvival() && (entity == null || !entity.isAlliedTo((Entity) entityplayer)) && vec3d.closerThan(entityplayer.position(), d0) && (!entityplayer.hasEffect(mobeffectlist) || entityplayer.getEffect(mobeffectlist).getAmplifier() < mobeffect.getAmplifier() || entityplayer.getEffect(mobeffectlist).endsWithin(i - 1));
 +            // Paper start
-+            boolean condition = entityplayer.gameMode.isSurvival() && (entity == null || !entity.isAlliedTo((Entity) entityplayer)) && vec3d.closerThan(entityplayer.position(), d0) && (!entityplayer.hasEffect(mobeffectlist) || entityplayer.getEffect(mobeffectlist).getAmplifier() < mobeffect.getAmplifier() || entityplayer.getEffect(mobeffectlist).getDuration() < i);
++            boolean condition = entityplayer.gameMode.isSurvival() && (entity == null || !entity.isAlliedTo((Entity) entityplayer)) && vec3d.closerThan(entityplayer.position(), d0) && (!entityplayer.hasEffect(mobeffectlist) || entityplayer.getEffect(mobeffectlist).getAmplifier() < mobeffect.getAmplifier() || entityplayer.getEffect(mobeffectlist).endsWithin(i - 1));
 +            if (condition) {
 +                return playerPredicate == null || playerPredicate.test(entityplayer); // Only test the player AFTER it is true
 +            } else {

patches/server/Add-EntityInsideBlockEvent.patch

@@ -74,7 +74,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
 +        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
          CraftEventFactory.blockDamage = world.getWorld().getBlockAt(pos.getX(), pos.getY(), pos.getZ()); // CraftBukkit
-         entity.hurt(DamageSource.CACTUS, 1.0F);
+         entity.hurt(world.damageSources().cactus(), 1.0F);
          CraftEventFactory.blockDamage = null; // CraftBukkit
 diff --git a/src/main/java/net/minecraft/world/level/block/CampfireBlock.java b/src/main/java/net/minecraft/world/level/block/CampfireBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -87,7 +87,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
          if ((Boolean) state.getValue(CampfireBlock.LIT) && entity instanceof LivingEntity && !EnchantmentHelper.hasFrostWalker((LivingEntity) entity)) {
              org.bukkit.craftbukkit.event.CraftEventFactory.blockDamage = CraftBlock.at(world, pos); // CraftBukkit
-             entity.hurt(DamageSource.IN_FIRE, (float) this.fireDamage);
+             entity.hurt(world.damageSources().inFire(), (float) this.fireDamage);
 diff --git a/src/main/java/net/minecraft/world/level/block/CropBlock.java b/src/main/java/net/minecraft/world/level/block/CropBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/CropBlock.java
@@ -121,7 +121,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
 +        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
-         if (world instanceof ServerLevel && !entity.isPassenger() && !entity.isVehicle() && entity.canChangeDimensions() && Shapes.joinIsNotEmpty(Shapes.create(entity.getBoundingBox().move((double) (-pos.getX()), (double) (-pos.getY()), (double) (-pos.getZ()))), state.getShape(world, pos), BooleanOp.AND)) {
+         if (world instanceof ServerLevel && entity.canChangeDimensions() && Shapes.joinIsNotEmpty(Shapes.create(entity.getBoundingBox().move((double) (-pos.getX()), (double) (-pos.getY()), (double) (-pos.getZ()))), state.getShape(world, pos), BooleanOp.AND)) {
              ResourceKey<Level> resourcekey = world.getTypeKey() == LevelStem.END ? Level.OVERWORLD : Level.END; // CraftBukkit - SPIGOT-6152: send back to main overworld in custom ends
              ServerLevel worldserver = ((ServerLevel) world).getServer().getLevel(resourcekey);
 diff --git a/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java b/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
@@ -193,7 +193,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
 +        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
-         if (!entity.isPassenger() && !entity.isVehicle() && entity.canChangeDimensions()) {
+         if (entity.canChangeDimensions()) {
              // CraftBukkit start - Entity in portal
              EntityPortalEnterEvent event = new EntityPortalEnterEvent(entity.getBukkitEntity(), new org.bukkit.Location(world.getWorld(), pos.getX(), pos.getY(), pos.getZ()));
 diff --git a/src/main/java/net/minecraft/world/level/block/PowderSnowBlock.java b/src/main/java/net/minecraft/world/level/block/PowderSnowBlock.java

patches/server/Add-PlayerKickEvent-causes.patch

@@ -92,7 +92,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
-         if (this.clientIsFloating && !this.player.isSleeping() && !this.player.isPassenger()) {
+         if (this.clientIsFloating && !this.player.isSleeping() && !this.player.isPassenger() && !this.player.isDeadOrDying()) {
              if (++this.aboveGroundTickCount > 80) {
                  ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked for floating too long!", this.player.getName().getString());
 -                this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingPlayer); // Paper - use configurable kick message
@@ -314,8 +314,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -            this.disconnect(Component.translatable("multiplayer.disconnect.out_of_order_chat"));
 +            this.disconnect(Component.translatable("multiplayer.disconnect.out_of_order_chat"), org.bukkit.event.player.PlayerKickEvent.Cause.OUT_OF_ORDER_CHAT); // Paper - kick event ca
              return Optional.empty();
-         } else if (this.player.isRemoved() || this.player.getChatVisibility() == ChatVisiblity.HIDDEN) { // CraftBukkit - dead men tell no tales
-             this.send(new ClientboundSystemChatPacket(PaperAdventure.asAdventure(Component.translatable("chat.disabled.options").withStyle(ChatFormatting.RED)), false)); // Paper - Adventure
+         } else {
+             Optional<LastSeenMessages> optional = this.unpackAndApplyLastSeen(acknowledgment);
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
  
              if (optional.isEmpty()) {

patches/server/Add-PlayerTradeEvent-and-PlayerPurchaseEvent.patch

@@ -99,7 +99,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            stack.shrink(slot.getMaxStackSize());
 +                        } else {
 +                        // Paper end
-                         slot.set(stack.split(slot.getMaxStackSize()));
+                         slot.setByPlayer(stack.split(slot.getMaxStackSize()));
 +                        } // Paper
                      } else {
 +                        // Paper start - dont set slot if only check
@@ -107,7 +107,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            stack.shrink(stack.getCount());
 +                        } else {
 +                        // Paper end
-                         slot.set(stack.split(stack.getCount()));
+                         slot.setByPlayer(stack.split(stack.getCount()));
 +                        } // Paper
                      }
  
@@ -143,7 +143,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 +            if (slot != 2) { // Paper - moved down for slot 2
              if (itemstack1.isEmpty()) {
-                 slot1.set(ItemStack.EMPTY);
+                 slot1.setByPlayer(ItemStack.EMPTY);
              } else {
 @@ -0,0 +0,0 @@ public class MerchantMenu extends AbstractContainerMenu {
              }

patches/server/Add-Unix-domain-socket-support.patch

@@ -10,22 +10,6 @@ This will be possible as of the Minecraft 1.17 Java version bump.
 Tested-by: Mariell Hoversholm <proximyst@proximyst.com>
 Reviewed-by: Mariell Hoversholm <proximyst@proximyst.com>
 
-diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/Connection.java
-+++ b/src/main/java/net/minecraft/network/Connection.java
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     // Spigot Start
-     public SocketAddress getRawAddress()
-     {
-+        // Paper start - this can be nullable in the case of a Unix domain socket, so if it is, fake something
-+        if (this.channel.remoteAddress() == null) {
-+            return new java.net.InetSocketAddress(java.net.InetAddress.getLoopbackAddress(), 0);
-+        }
-+        // Paper end
-         return this.channel.remoteAddress();
-     }
-     // Spigot End
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
@@ -106,6 +90,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
      }
  
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+     // Spigot Start
+     public SocketAddress getRawAddress()
+     {
++        // Paper start - this can be nullable in the case of a Unix domain socket, so if it is, fake something
++        if (connection.channel.remoteAddress() == null) {
++            return new java.net.InetSocketAddress(java.net.InetAddress.getLoopbackAddress(), 0);
++        }
++        // Paper end
+         return this.connection.channel.remoteAddress();
+     }
+     // Spigot End
 diff --git a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java

patches/server/Add-Wandering-Trader-spawn-rate-config-options.patch

@@ -70,10 +70,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  if (!world.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING)) {
                      return 0;
                  } else {
-                     int i = this.spawnChance;
+@@ -0,0 +0,0 @@ public class WanderingTraderSpawner implements CustomSpawner {
  
--                    this.spawnChance = Mth.clamp(this.spawnChance + 25, (int) 25, (int) 75);
--                    this.serverLevelData.setWanderingTraderSpawnChance(this.spawnChance);
+                     this.spawnChance = Mth.clamp(this.spawnChance + 25, 25, 75);
+                     this.serverLevelData.setWanderingTraderSpawnChance(this.spawnChance);
 +                    this.spawnChance = Mth.clamp(i + world.paperConfig().entities.spawning.wanderingTrader.spawnChanceFailureIncrement, world.paperConfig().entities.spawning.wanderingTrader.spawnChanceMin, world.paperConfig().entities.spawning.wanderingTrader.spawnChanceMax);
 +                    //this.serverLevelData.setWanderingTraderSpawnChance(this.spawnChance); // Paper - We don't need to save this value to disk if it gets set back to a hardcoded value anyways
                      if (this.random.nextInt(100) > i) {

patches/server/Add-a-bunch-of-missing-forceDrop-toggles.patch

@@ -9,11 +9,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/ai/behavior/WorkAtComposter.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/behavior/WorkAtComposter.java
 @@ -0,0 +0,0 @@ public class WorkAtComposter extends WorkAtPoi {
-                 ItemStack itemstack = inventorysubcontainer.addItem(new ItemStack(Items.BREAD, j));
- 
-                 if (!itemstack.isEmpty()) {
+                 simpleContainer.removeItemType(Items.WHEAT, m);
+                 ItemStack itemStack = simpleContainer.addItem(new ItemStack(Items.BREAD, l));
+                 if (!itemStack.isEmpty()) {
 +                    entity.forceDrops = true; // Paper
-                     entity.spawnAtLocation(itemstack, 0.5F);
+                     entity.spawnAtLocation(itemStack, 0.5F);
 +                    entity.forceDrops = false; // Paper
                  }
  

patches/server/Add-config-for-mobs-immune-to-default-effects.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/ma
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
          if (this.getMobType() == MobType.UNDEAD) {
              MobEffect mobeffectlist = effect.getEffect();
  

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

@@ -9,9 +9,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/damagesource/DamageSource.java
 +++ b/src/main/java/net/minecraft/world/damagesource/DamageSource.java
 @@ -0,0 +0,0 @@ public class DamageSource {
-         return this;
+     public Holder<DamageType> typeHolder() {
+         return this.type;
      }
-     // CraftBukkit end
++
 +    // Paper start - add critical damage API
 +    private boolean critical;
 +    public boolean isCritical() {
@@ -25,9 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return this;
 +    }
 +    // Paper end
- 
-     public static DamageSource fallingBlock(Entity attacker) {
-         return (new EntityDamageSource("fallingBlock", attacker)).damageHelmet();
+ }
 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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/player/Player.java
@@ -45,8 +44,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      }
  
                      Vec3 vec3d = target.getDeltaMovement();
--                    boolean flag5 = target.hurt(DamageSource.playerAttack(this), f);
-+                    boolean flag5 = target.hurt(DamageSource.playerAttack(this).critical(flag2), f); // Paper - add critical damage API
+-                    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) {
@@ -54,9 +53,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                                  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(DamageSource.playerAttack(this).sweep(), f4)) {
-+                                    if (entityliving.hurt(DamageSource.playerAttack(this).sweep().critical(flag2), f4)) { // Paper - add critical damage API
-                                     entityliving.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this); // Paper
+-                                    if (entityliving.hurt(this.damageSources().playerAttack(this).sweep(), f4)) {
++                                    if (entityliving.hurt(this.damageSources().playerAttack(this).sweep().critical(flag2), f4)) { // Paper - add critical damage API
+                                     entityliving.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this); // Pa
                                      }
                                      // 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
@@ -90,12 +89,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -            return CraftEventFactory.callEntityDamageEvent(damager, entity, cause, modifiers, modifierFunctions, cancelled);
 +            return CraftEventFactory.callEntityDamageEvent(damager, entity, cause, modifiers, modifierFunctions, cancelled, source.isCritical()); // Paper - add critical damage API
-         } else if (source == DamageSource.OUT_OF_WORLD) {
+         } else if (sourceType == DamageTypes.OUT_OF_WORLD) {
              EntityDamageEvent event = new EntityDamageByBlockEvent(null, entity.getBukkitEntity(), DamageCause.VOID, modifiers, modifierFunctions);
              event.setCancelled(cancelled);
 @@ -0,0 +0,0 @@ public class CraftEventFactory {
              } else {
-                 throw new IllegalStateException(String.format("Unhandled damage of %s by %s from %s", entity, damager.getHandle(), source.msgId));
+                 throw new IllegalStateException(String.format("Unhandled damage of %s by %s from %s", entity, damager.getHandle(), source.getMsgId()));
              }
 -            EntityDamageEvent event = new EntityDamageByEntityEvent(damager, entity.getBukkitEntity(), cause, modifiers, modifierFunctions);
 +            EntityDamageEvent event = new EntityDamageByEntityEvent(damager, entity.getBukkitEntity(), cause, modifiers, modifierFunctions, source.isCritical()); // Paper - add critical damage API
@@ -110,7 +109,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            return CraftEventFactory.callEntityDamageEvent(null, entity, cause, modifiers, modifierFunctions, cancelled, source.isCritical()); // Paper - add critical damage API
          }
  
-         throw new IllegalStateException(String.format("Unhandled damage of %s from %s", entity, source.msgId));
+         throw new IllegalStateException(String.format("Unhandled damage of %s from %s", entity, source.getMsgId()));
      }
  
 +    @Deprecated // Paper - Add critical damage API

patches/server/Add-dropLeash-variable-to-EntityUnleashEvent.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/n
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
 +++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements Targeting {
              return InteractionResult.PASS;
          } else if (this.getLeashHolder() == player) {
              // CraftBukkit start - fire PlayerUnleashEntityEvent
@@ -23,10 +23,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              // CraftBukkit end
 -            this.dropLeash(true, !player.getAbilities().instabuild);
 +            this.dropLeash(true, event.isDropLeash()); // Paper - drop leash variable
+             this.gameEvent(GameEvent.ENTITY_INTERACT, player);
              return InteractionResult.sidedSuccess(this.level.isClientSide);
          } else {
-             InteractionResult enuminteractionresult = this.checkAndHandleImportantInteractions(player, hand);
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements Targeting {
  
          if (this.leashHolder != null) {
              if (!this.isAlive() || !this.leashHolder.isAlive()) {
@@ -40,7 +40,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
          }
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements Targeting {
          boolean flag1 = super.startRiding(entity, force);
  
          if (flag1 && this.isLeashed()) {
@@ -54,7 +54,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
          return flag1;
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements Targeting {
      @Override
      protected void removeAfterChangingDimensions() {
          super.removeAfterChangingDimensions();
@@ -105,21 +105,21 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/decoration/LeashFenceKnotEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/decoration/LeashFenceKnotEntity.java
 @@ -0,0 +0,0 @@ public class LeashFenceKnotEntity extends HangingEntity {
-                         entityinsentient = (Mob) iterator.next();
-                         if (entityinsentient.isLeashed() && entityinsentient.getLeashHolder() == this) {
+ 
+                         if (entityinsentient1.isLeashed() && entityinsentient1.getLeashHolder() == this) {
                              // CraftBukkit start
--                            if (CraftEventFactory.callPlayerUnleashEntityEvent(entityinsentient, player, hand).isCancelled()) {
+-                            if (CraftEventFactory.callPlayerUnleashEntityEvent(entityinsentient1, player, hand).isCancelled()) {
 +                            // Paper start - drop leash variable
-+                            org.bukkit.event.player.PlayerUnleashEntityEvent event = CraftEventFactory.callPlayerUnleashEntityEvent(entityinsentient, player, hand, !player.getAbilities().instabuild);
++                            org.bukkit.event.player.PlayerUnleashEntityEvent event = CraftEventFactory.callPlayerUnleashEntityEvent(entityinsentient1, player, hand, !player.getAbilities().instabuild);
 +                            if (event.isCancelled()) {
 +                                // Paper end
                                  die = false;
                                  continue;
                              }
--                            entityinsentient.dropLeash(true, !player.getAbilities().instabuild); // false -> survival mode boolean
-+                            entityinsentient.dropLeash(true, event.isDropLeash()); // false -> survival mode boolean // Paper - drop leash variable
+-                            entityinsentient1.dropLeash(true, !player.getAbilities().instabuild); // false -> survival mode boolean
++                            entityinsentient1.dropLeash(true, event.isDropLeash()); // false -> survival mode boolean // Paper - drop leash variable
                              // CraftBukkit end
-                         }
+                             flag1 = true;
                          }
 diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/server/Add-option-to-fix-items-merging-through-walls.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-@@ -0,0 +0,0 @@ public class ItemEntity extends Entity {
+@@ -0,0 +0,0 @@ public class ItemEntity extends Entity implements TraceableEntity {
                  ItemEntity entityitem = (ItemEntity) iterator.next();
  
                  if (entityitem.isMergable()) {

patches/server/Add-recipe-to-cook-events.patch

@@ -29,7 +29,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    Optional<CampfireCookingRecipe> recipe = campfire.quickCheck.getRecipeFor( inventorysubcontainer, world);
 +                    ItemStack itemstack1 = (ItemStack) recipe.map((recipecampfire) -> {
 +                        // Paper end
-                         return recipecampfire.assemble(inventorysubcontainer);
+                         return recipecampfire.assemble(inventorysubcontainer, world.registryAccess());
                      }).orElse(itemstack);
  
 @@ -0,0 +0,0 @@ public class CampfireBlockEntity extends BlockEntity implements Clearable {

patches/server/Cache-DataFixerUpper-Rewrite-Rules-on-demand.patch

@@ -51,4 +51,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            if (versionKey < minDataFixPrecacheVersion) continue; // Paper
              final Schema schema = schemas.get(versionKey);
              for (final String typeName : schema.types()) {
-                 final CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
+                 if (!requiredTypeNames.contains(typeName)) {

patches/server/Change-EnderEye-target-without-changing-other-things.patch

@@ -47,8 +47,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public void setTargetLocation(Location location, boolean update) {
 +        // Paper end
          Preconditions.checkArgument(getWorld().equals(location.getWorld()), "Cannot target EnderSignal across worlds");
--        this.getHandle().signalTo(new BlockPos(location.getX(), location.getY(), location.getZ()));
-+        this.getHandle().signalTo(new BlockPos(location.getX(), location.getY(), location.getZ()), update); // Paper
+-        this.getHandle().signalTo(BlockPos.containing(location.getX(), location.getY(), location.getZ()));
++        this.getHandle().signalTo(BlockPos.containing(location.getX(), location.getY(), location.getZ()), update); // Paper
      }
  
      @Override

patches/server/Climbing-should-not-bypass-cramming-gamerule.patch

@@ -48,7 +48,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/ma
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
                  return;
              }
              // Paper end - don't run getEntities if we're not going to use its result
@@ -57,7 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              if (!list.isEmpty()) {
                  // Paper - moved up
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
+@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
          return !this.isRemoved() && this.collides; // CraftBukkit
      }