Patches!

patches/server/Add-API-for-quit-reason.patch

@@ -18,7 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    if (player != null) player.quitReason = org.bukkit.event.player.PlayerQuitEvent.QuitReason.TIMED_OUT; // Paper - Add API for quit reason
                      this.disconnect(Component.translatable("disconnect.timeout"));
                  } else {
-                     MutableComponent ichatmutablecomponent = Component.translatable("disconnect.genericReason", "Internal Exception: " + throwable);
+                     MutableComponent ichatmutablecomponent = Component.translatable("disconnect.genericReason", "Internal Exception: " + String.valueOf(throwable));
  
 +                    if (player != null) player.quitReason = org.bukkit.event.player.PlayerQuitEvent.QuitReason.ERRONEOUS_STATE; // Paper - Add API for quit reason
                      if (flag) {

patches/server/Add-BlockFailedDispenseEvent.patch

@@ -14,11 +14,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              if (i < 0) {
 +                if (org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFailedDispenseEvent(world, pos)) { // Paper - Add BlockFailedDispenseEvent
                  world.levelEvent(1001, pos, 0);
-                 world.gameEvent(GameEvent.BLOCK_ACTIVATE, pos, GameEvent.Context.of(tileentitydispenser.getBlockState()));
+                 world.gameEvent((Holder) GameEvent.BLOCK_ACTIVATE, pos, GameEvent.Context.of(tileentitydispenser.getBlockState()));
 +                } // Paper - Add BlockFailedDispenseEvent
              } else {
                  ItemStack itemstack = tileentitydispenser.getItem(i);
-                 DispenseItemBehavior idispensebehavior = this.getDispenseMethod(itemstack);
+                 DispenseItemBehavior idispensebehavior = this.getDispenseMethod(world, itemstack);
 diff --git a/src/main/java/net/minecraft/world/level/block/DropperBlock.java b/src/main/java/net/minecraft/world/level/block/DropperBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/DropperBlock.java

patches/server/Add-BlockPreDispenseEvent.patch

@@ -9,7 +9,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/DispenserBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/DispenserBlock.java
 @@ -0,0 +0,0 @@ public class DispenserBlock extends BaseEntityBlock {
-                 DispenseItemBehavior idispensebehavior = this.getDispenseMethod(itemstack);
+                 DispenseItemBehavior idispensebehavior = this.getDispenseMethod(world, itemstack);
  
                  if (idispensebehavior != DispenseItemBehavior.NOOP) {
 +                    if (!org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockPreDispenseEvent(world, pos, itemstack, i)) return; // Paper - Add BlockPreDispenseEvent

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

@@ -127,7 +127,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/network/Connection.java
 @@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
              } else {
-                 this.channel.pipeline().addBefore("encoder", "compress", new CompressionEncoder(compressionThreshold));
+                 this.channel.pipeline().addAfter("prepender", "compress", new CompressionEncoder(compressionThreshold));
              }
 +            this.channel.pipeline().fireUserEventTriggered(io.papermc.paper.network.ConnectionEvent.COMPRESSION_THRESHOLD_SET); // Paper - Add Channel initialization listeners
          } else {

patches/server/Add-EntityBlockStorage-clearEntities.patch

@@ -25,8 +25,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java
 +++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java
 @@ -0,0 +0,0 @@ public class CraftBeehive extends CraftBlockEntityState<BeehiveBlockEntity> impl
-     public CraftBeehive copy() {
-         return new CraftBeehive(this);
+     public CraftBeehive copy(Location location) {
+         return new CraftBeehive(this, location);
      }
 +
 +    // Paper start - Add EntityBlockStorage clearEntities

patches/server/Add-EntityLoadCrossbowEvent.patch

@@ -0,0 +1,68 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Josh Roy <10731363+JRoy@users.noreply.github.com>
+Date: Wed, 7 Oct 2020 12:04:01 -0400
+Subject: [PATCH] Add EntityLoadCrossbowEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/item/CrossbowItem.java b/src/main/java/net/minecraft/world/item/CrossbowItem.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/item/CrossbowItem.java
++++ b/src/main/java/net/minecraft/world/item/CrossbowItem.java
+@@ -0,0 +0,0 @@ public class CrossbowItem extends ProjectileWeaponItem {
+     public void releaseUsing(ItemStack stack, Level world, LivingEntity user, int remainingUseTicks) {
+         int i = this.getUseDuration(stack) - remainingUseTicks;
+         float f = getPowerForTime(i, stack);
+-        if (f >= 1.0F && !isCharged(stack) && tryLoadProjectiles(user, stack)) {
++        // Paper start
++        if (f >= 1.0F && !isCharged(stack)) {
++            final io.papermc.paper.event.entity.EntityLoadCrossbowEvent event = new io.papermc.paper.event.entity.EntityLoadCrossbowEvent(user.getBukkitLivingEntity(), stack.asBukkitMirror(), org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(user.getUsedItemHand()));
++            if (!event.callEvent() || !tryLoadProjectiles(user, stack, event.shouldConsumeItem())) {
++                if (user instanceof ServerPlayer player) player.containerMenu.sendAllDataToRemote();
++                return;
++            }
++        // Paper end - Add EntityLoadCrossbowEvent
+             world.playSound(
+                 null,
+                 user.getX(),
+@@ -0,0 +0,0 @@ public class CrossbowItem extends ProjectileWeaponItem {
+         }
+     }
+ 
+-    private static boolean tryLoadProjectiles(LivingEntity shooter, ItemStack crossbow) {
+-        List<ItemStack> list = draw(crossbow, shooter.getProjectile(crossbow), shooter);
++    @io.papermc.paper.annotation.DoNotUse // Paper - Add EntityLoadCrossbowEvent
++    private static boolean tryLoadProjectiles(LivingEntity shooter, ItemStack crossbow)  {
++        // Paper start - Add EntityLoadCrossbowEvent
++        return CrossbowItem.tryLoadProjectiles(shooter, crossbow, true);
++    }
++    private static boolean tryLoadProjectiles(LivingEntity shooter, ItemStack crossbow, boolean consume) {
++        List<ItemStack> list = draw(crossbow, shooter.getProjectile(crossbow), shooter, consume);
++        // Paper end - Add EntityLoadCrossbowEvent
+         if (!list.isEmpty()) {
+             crossbow.set(DataComponents.CHARGED_PROJECTILES, ChargedProjectiles.of(list));
+             return true;
+diff --git a/src/main/java/net/minecraft/world/item/ProjectileWeaponItem.java b/src/main/java/net/minecraft/world/item/ProjectileWeaponItem.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/item/ProjectileWeaponItem.java
++++ b/src/main/java/net/minecraft/world/item/ProjectileWeaponItem.java
+@@ -0,0 +0,0 @@ public abstract class ProjectileWeaponItem extends Item {
+     }
+ 
+     protected static List<ItemStack> draw(ItemStack weaponStack, ItemStack projectileStack, LivingEntity shooter) {
++    // Paper start
++        return draw(weaponStack, projectileStack, shooter, false);
++    }
++    protected static List<ItemStack> draw(ItemStack weaponStack, ItemStack projectileStack, LivingEntity shooter, boolean consume) {
++    // Paper end
+         if (projectileStack.isEmpty()) {
+             return List.of();
+         } else {
+@@ -0,0 +0,0 @@ public abstract class ProjectileWeaponItem extends Item {
+             ItemStack itemstack2 = projectileStack.copy();
+ 
+             for (int k = 0; k < j; ++k) {
+-                list.add(ProjectileWeaponItem.useAmmo(weaponStack, k == 0 ? projectileStack : itemstack2, shooter, k > 0));
++                list.add(ProjectileWeaponItem.useAmmo(weaponStack, k == 0 ? projectileStack : itemstack2, shooter, k > 0 || consume)); // Paper
+             }
+ 
+             return list;

patches/server/Add-EntityMoveEvent.patch

@@ -15,7 +15,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            worldserver.hasEntityMoveEvent = io.papermc.paper.event.entity.EntityMoveEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper - Add EntityMoveEvent
  
              this.profiler.push(() -> {
-                 return worldserver + " " + worldserver.dimension().location();
+                 String s = String.valueOf(worldserver);
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java

patches/server/Add-HiddenPotionEffect-API.patch

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class CraftPotionUtil {
  
      public static MobEffectInstance fromBukkit(PotionEffect effect) {
-         MobEffect type = CraftPotionEffectType.bukkitToMinecraft(effect.getType());
+         Holder<MobEffect> type = CraftPotionEffectType.bukkitToMinecraftHolder(effect.getType());
 +        // Paper - Note: do not copy over the hidden effect, as this method is only used for applying to entities which we do not want to convert over.
          return new MobEffectInstance(type, effect.getDuration(), effect.getAmplifier(), effect.isAmbient(), effect.hasParticles(), effect.hasIcon()); // Paper
      }
@@ -26,4 +26,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return new PotionEffect(type, duration, amp, ambient, particles, effect.showIcon(), effect.hiddenEffect == null ? null : toBukkit(effect.hiddenEffect)); // Paper
      }
  
-     public static boolean equals(MobEffect mobEffect, PotionEffectType type) {
+     public static boolean equals(Holder<MobEffect> mobEffect, PotionEffectType type) {

patches/server/Add-PlayerChangeBeaconEffectEvent.patch

@@ -13,23 +13,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 +    // Paper start - Add PlayerChangeBeaconEffectEvent
-+    private static @Nullable org.bukkit.potion.PotionEffectType convert(Optional<MobEffect> optionalEffect) {
++    private static @Nullable org.bukkit.potion.PotionEffectType convert(Optional<Holder<MobEffect>> optionalEffect) {
 +        return optionalEffect.map(org.bukkit.craftbukkit.potion.CraftPotionEffectType::minecraftToBukkit).orElse(null);
 +    }
 +    // Paper end - Add PlayerChangeBeaconEffectEvent
 +
-     public void updateEffects(Optional<MobEffect> primary, Optional<MobEffect> secondary) {
+     public void updateEffects(Optional<Holder<MobEffect>> primary, Optional<Holder<MobEffect>> secondary) {
          if (this.paymentSlot.hasItem()) {
--            this.beaconData.set(1, BeaconMenu.encodeEffect((MobEffect) primary.orElse(null))); // CraftBukkit - decompile error
--            this.beaconData.set(2, BeaconMenu.encodeEffect((MobEffect) secondary.orElse(null))); // CraftBukkit - decompile error
+-            this.beaconData.set(1, BeaconMenu.encodeEffect((Holder) primary.orElse(null)));// CraftBukkit - decompile error
+-            this.beaconData.set(2, BeaconMenu.encodeEffect((Holder) secondary.orElse(null)));// CraftBukkit - decompile error
 +            // Paper start - Add PlayerChangeBeaconEffectEvent
 +            io.papermc.paper.event.player.PlayerChangeBeaconEffectEvent event = new io.papermc.paper.event.player.PlayerChangeBeaconEffectEvent((org.bukkit.entity.Player) this.player.player.getBukkitEntity(), convert(primary), convert(secondary), this.access.getLocation().getBlock());
 +            if (event.callEvent()) {
-+                this.beaconData.set(1, BeaconMenu.encodeEffect(event.getPrimary() == null ? null : org.bukkit.craftbukkit.potion.CraftPotionEffectType.bukkitToMinecraft(event.getPrimary())));
-+                this.beaconData.set(2, BeaconMenu.encodeEffect(event.getSecondary() == null ? null : org.bukkit.craftbukkit.potion.CraftPotionEffectType.bukkitToMinecraft(event.getSecondary())));
-+                if (event.willConsumeItem()) {
++                // Paper end - Add PlayerChangeBeaconEffectEvent
++                this.beaconData.set(1, BeaconMenu.encodeEffect(event.getPrimary() == null ? null : org.bukkit.craftbukkit.potion.CraftPotionEffectType.bukkitToMinecraftHolder(event.getPrimary())));// CraftBukkit - decompile error
++                this.beaconData.set(2, BeaconMenu.encodeEffect(event.getSecondary() == null ? null : org.bukkit.craftbukkit.potion.CraftPotionEffectType.bukkitToMinecraftHolder(event.getSecondary())));// CraftBukkit - decompile error
++            if (event.willConsumeItem()) { // Paper
              this.paymentSlot.remove(1);
-+                }
++            } // Paper
              this.access.execute(Level::blockEntityChanged);
 +            } // Paper end - Add PlayerChangeBeaconEffectEvent
          }

patches/server/Add-PlayerFlowerPotManipulateEvent.patch

@@ -9,17 +9,33 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/FlowerPotBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/FlowerPotBlock.java
 @@ -0,0 +0,0 @@ public class FlowerPotBlock extends Block {
-         boolean bl = blockState.is(Blocks.AIR);
-         boolean bl2 = this.isEmpty();
-         if (bl != bl2) {
+         } else if (!this.isEmpty()) {
+             return ItemInteractionResult.CONSUME;
+         } else {
 +            // Paper start - Add PlayerFlowerPotManipulateEvent
-+            boolean placing = bl2; // OBFHELPER
 +            org.bukkit.block.Block block = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
-+            org.bukkit.inventory.ItemStack placedStack = org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(itemStack);
-+            org.bukkit.inventory.ItemStack pottedStack = new org.bukkit.inventory.ItemStack(org.bukkit.craftbukkit.block.CraftBlockType.minecraftToBukkit(this.potted));
-+            org.bukkit.inventory.ItemStack stack = placing ? placedStack : pottedStack;
++            org.bukkit.inventory.ItemStack placedStack = org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(stack);
 +
-+            io.papermc.paper.event.player.PlayerFlowerPotManipulateEvent event = new io.papermc.paper.event.player.PlayerFlowerPotManipulateEvent((org.bukkit.entity.Player) player.getBukkitEntity(), block, stack, placing);
++            io.papermc.paper.event.player.PlayerFlowerPotManipulateEvent event = new io.papermc.paper.event.player.PlayerFlowerPotManipulateEvent((org.bukkit.entity.Player) player.getBukkitEntity(), block, placedStack, true);
++            if (!event.callEvent()) {
++                // Update client
++                player.containerMenu.sendAllDataToRemote();
++
++                return ItemInteractionResult.CONSUME;
++            }
++            // Paper end - Add PlayerFlowerPotManipulateEvent
+             world.setBlock(pos, blockState, 3);
+             world.gameEvent(player, GameEvent.BLOCK_CHANGE, pos);
+             player.awardStat(Stats.POT_FLOWER);
+@@ -0,0 +0,0 @@ public class FlowerPotBlock extends Block {
+             return InteractionResult.CONSUME;
+         } else {
+             ItemStack itemStack = new ItemStack(this.potted);
++            // Paper start - Add PlayerFlowerPotManipulateEvent
++            org.bukkit.block.Block block = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
++            org.bukkit.inventory.ItemStack pottedStack = new org.bukkit.inventory.ItemStack(org.bukkit.craftbukkit.block.CraftBlockType.minecraftToBukkit(this.potted));
++
++            io.papermc.paper.event.player.PlayerFlowerPotManipulateEvent event = new io.papermc.paper.event.player.PlayerFlowerPotManipulateEvent((org.bukkit.entity.Player) player.getBukkitEntity(), block, pottedStack, false);
 +            if (!event.callEvent()) {
 +                // Update client
 +                player.containerMenu.sendAllDataToRemote();
@@ -27,6 +43,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                return InteractionResult.PASS;
 +            }
 +            // Paper end - Add PlayerFlowerPotManipulateEvent
-             if (bl2) {
-                 world.setBlock(pos, blockState, 3);
-                 player.awardStat(Stats.POT_FLOWER);
+             if (!player.addItem(itemStack)) {
+                 player.drop(itemStack, false);
+             }

patches/server/Add-PlayerNameEntityEvent.patch

@@ -9,20 +9,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/item/NameTagItem.java
 +++ b/src/main/java/net/minecraft/world/item/NameTagItem.java
 @@ -0,0 +0,0 @@ public class NameTagItem extends Item {
-     public InteractionResult interactLivingEntity(ItemStack stack, Player user, LivingEntity entity, InteractionHand hand) {
-         if (stack.hasCustomHoverName() && !(entity instanceof Player)) {
+         Component component = stack.get(DataComponents.CUSTOM_NAME);
+         if (component != null && !(entity instanceof Player)) {
              if (!user.level().isClientSide && entity.isAlive()) {
--                entity.setCustomName(stack.getHoverName());
--                if (entity instanceof Mob) {
--                    ((Mob)entity).setPersistenceRequired();
+-                entity.setCustomName(component);
+-                if (entity instanceof Mob mob) {
 +                // Paper start - Add PlayerNameEntityEvent
 +                io.papermc.paper.event.player.PlayerNameEntityEvent event = new io.papermc.paper.event.player.PlayerNameEntityEvent(((net.minecraft.server.level.ServerPlayer) user).getBukkitEntity(), entity.getBukkitLivingEntity(), io.papermc.paper.adventure.PaperAdventure.asAdventure(stack.getHoverName()), true);
 +                if (!event.callEvent()) return InteractionResult.PASS;
 +                LivingEntity newEntity = ((org.bukkit.craftbukkit.entity.CraftLivingEntity) event.getEntity()).getHandle();
 +                newEntity.setCustomName(event.getName() != null ? io.papermc.paper.adventure.PaperAdventure.asVanilla(event.getName()) : null);
-+                if (event.isPersistent() && newEntity instanceof Mob) {
-+                    ((Mob) newEntity).setPersistenceRequired();
-+                    // Paper end - Add PlayerNameEntityEvent
++                if (event.isPersistent() && newEntity instanceof Mob mob) {
++                // Paper end - Add PlayerNameEntityEvent
+                     mob.setPersistenceRequired();
                  }
  
-                 stack.shrink(1);

patches/server/Add-PlayerShearBlockEvent.patch

@@ -18,9 +18,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
 @@ -0,0 +0,0 @@ public class BeehiveBlock extends BaseEntityBlock {
-             Item item = itemstack.getItem();
+             Item item = stack.getItem();
  
-             if (itemstack.is(Items.SHEARS)) {
+             if (stack.is(Items.SHEARS)) {
 +                // Paper start - Add PlayerShearBlockEvent
 +                io.papermc.paper.event.block.PlayerShearBlockEvent event = new io.papermc.paper.event.block.PlayerShearBlockEvent((org.bukkit.entity.Player) player.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack), org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(hand), new java.util.ArrayList<>());
 +                event.getDrops().add(org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(new ItemStack(Items.HONEYCOMB, 3)));
@@ -35,44 +35,37 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    popResource(world, pos, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(itemDrop));
 +                }
 +                // Paper end - Add PlayerShearBlockEvent
-                 itemstack.hurtAndBreak(1, player, (entityhuman1) -> {
-                     entityhuman1.broadcastBreakEvent(hand);
-                 });
+                 stack.hurtAndBreak(1, player, LivingEntity.getSlotForHand(hand));
+                 flag = true;
+                 world.gameEvent((Entity) player, (Holder) GameEvent.SHEAR, pos);
 diff --git a/src/main/java/net/minecraft/world/level/block/PumpkinBlock.java b/src/main/java/net/minecraft/world/level/block/PumpkinBlock.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/PumpkinBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/PumpkinBlock.java
 @@ -0,0 +0,0 @@ public class PumpkinBlock extends Block {
-         ItemStack itemStack = player.getItemInHand(hand);
-         if (itemStack.is(Items.SHEARS)) {
-             if (!world.isClientSide) {
-+                // Paper start - Add PlayerShearBlockEvent
-+                io.papermc.paper.event.block.PlayerShearBlockEvent event = new io.papermc.paper.event.block.PlayerShearBlockEvent((org.bukkit.entity.Player) player.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemStack), org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(hand), new java.util.ArrayList<>());
-+                event.getDrops().add(org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(new ItemStack(Items.PUMPKIN_SEEDS, 4)));
-+                if (!event.callEvent()) {
-+                    return InteractionResult.PASS;
-+                }
-+                // Paper end - Add PlayerShearBlockEvent
-                 Direction direction = hit.getDirection();
-                 Direction direction2 = direction.getAxis() == Direction.Axis.Y ? player.getDirection().getOpposite() : direction;
-                 world.playSound(null, pos, SoundEvents.PUMPKIN_CARVE, SoundSource.BLOCKS, 1.0F, 1.0F);
-                 world.setBlock(pos, Blocks.CARVED_PUMPKIN.defaultBlockState().setValue(CarvedPumpkinBlock.FACING, direction2), 11);
-+                for (org.bukkit.inventory.ItemStack item : event.getDrops()) { // Paper - Add PlayerShearBlockEvent
-                 ItemEntity itemEntity = new ItemEntity(
-                     world,
-                     (double)pos.getX() + 0.5 + (double)direction2.getStepX() * 0.65,
-                     (double)pos.getY() + 0.1,
-                     (double)pos.getZ() + 0.5 + (double)direction2.getStepZ() * 0.65,
--                    new ItemStack(Items.PUMPKIN_SEEDS, 4)
-+                    org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(item) // Paper - Add PlayerShearBlockEvent
-                 );
-                 itemEntity.setDeltaMovement(
-                     0.05 * (double)direction2.getStepX() + world.random.nextDouble() * 0.02,
+         } else if (world.isClientSide) {
+             return ItemInteractionResult.sidedSuccess(world.isClientSide);
+         } else {
++            // Paper start - Add PlayerShearBlockEvent
++            io.papermc.paper.event.block.PlayerShearBlockEvent event = new io.papermc.paper.event.block.PlayerShearBlockEvent((org.bukkit.entity.Player) player.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemStack), org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(hand), new java.util.ArrayList<>());
++            event.getDrops().add(org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(new ItemStack(Items.PUMPKIN_SEEDS, 4)));
++            if (!event.callEvent()) {
++                return InteractionResult.PASS;
++            }
++            // Paper end - Add PlayerShearBlockEvent
+             Direction direction = hit.getDirection();
+             Direction direction2 = direction.getAxis() == Direction.Axis.Y ? player.getDirection().getOpposite() : direction;
+             world.playSound(null, pos, SoundEvents.PUMPKIN_CARVE, SoundSource.BLOCKS, 1.0F, 1.0F);
+             world.setBlock(pos, Blocks.CARVED_PUMPKIN.defaultBlockState().setValue(CarvedPumpkinBlock.FACING, direction2), 11);
++            for (org.bukkit.inventory.ItemStack item : event.getDrops()) { // Paper - Add PlayerShearBlockEvent
+             ItemEntity itemEntity = new ItemEntity(
+                 world,
+                 (double)pos.getX() + 0.5 + (double)direction2.getStepX() * 0.65,
 @@ -0,0 +0,0 @@ public class PumpkinBlock extends Block {
-                     0.05 * (double)direction2.getStepZ() + world.random.nextDouble() * 0.02
-                 );
-                 world.addFreshEntity(itemEntity);
-+                } // Paper - Add PlayerShearBlockEvent
-                 itemStack.hurtAndBreak(1, player, playerx -> playerx.broadcastBreakEvent(hand));
-                 world.gameEvent(player, GameEvent.SHEAR, pos);
-                 player.awardStat(Stats.ITEM_USED.get(Items.SHEARS));
+                 0.05 * (double)direction2.getStepZ() + world.random.nextDouble() * 0.02
+             );
+             world.addFreshEntity(itemEntity);
++            } // Paper - Add PlayerShearBlockEvent
+             stack.hurtAndBreak(1, player, LivingEntity.getSlotForHand(hand));
+             world.gameEvent(player, GameEvent.SHEAR, pos);
+             player.awardStat(Stats.ITEM_USED.get(Items.SHEARS));

patches/server/Add-ServerResourcesReloadedEvent.patch

@@ -19,9 +19,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    public CompletableFuture<Void> reloadResources(Collection<String> dataPacks, io.papermc.paper.event.server.ServerResourcesReloadedEvent.Cause cause) {
 +        // Paper end - Add ServerResourcesReloadedEvent
-         RegistryAccess.Frozen iregistrycustom_dimension = this.registries.getAccessForLoading(RegistryLayer.RELOADABLE);
          CompletableFuture<Void> completablefuture = CompletableFuture.supplyAsync(() -> {
              Stream<String> stream = dataPacks.stream(); // CraftBukkit - decompile error
+             PackRepository resourcepackrepository = this.packRepository;
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
              this.functionManager.replaceLibrary(this.resources.managers.getFunctionLibrary());
              this.structureTemplateManager.onResourceManagerReload(this.resources.resourceManager);

patches/server/Add-StructuresLocateEvent.patch

@@ -80,7 +80,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/CraftRegistry.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftRegistry.java
 @@ -0,0 +0,0 @@ public class CraftRegistry<B extends Keyed, M> implements Registry<B> {
-             return new CraftRegistry<>(DamageType.class, registryHolder.registryOrThrow(Registries.DAMAGE_TYPE), CraftDamageType::new);
+             return new CraftRegistry<>(Wolf.Variant.class, registryHolder.registryOrThrow(Registries.WOLF_VARIANT), CraftWolf.CraftVariant::new);
          }
          // TODO registry modification API
 +        // Paper start - remove this after a while along with all ConfiguredStructure stuff

patches/server/Add-TargetHitEvent.patch

@@ -10,7 +10,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/world/level/block/TargetBlock.java
 @@ -0,0 +0,0 @@ public class TargetBlock extends Block {
      @Override
-     public void onProjectileHit(Level world, BlockState state, BlockHitResult hit, Projectile projectile) {
+     protected void onProjectileHit(Level world, BlockState state, BlockHitResult hit, Projectile projectile) {
          int i = updateRedstoneOutput(world, state, hit, projectile);
 +        // Paper start - Add TargetHitEvent
 +    }

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

@@ -107,31 +107,31 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
 @@ -0,0 +0,0 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
-                 this.connection.setClientboundProtocolAfterHandshake(ClientIntent.LOGIN);
-                 // CraftBukkit start - Connection throttle
-                 try {
-+                    if (!(this.connection.channel.localAddress() instanceof io.netty.channel.unix.DomainSocketAddress)) { // Paper - Unix domain socket support; the connection throttle is useless when you have a Unix domain socket
-                     long currentTime = System.currentTimeMillis();
-                     long connectionThrottle = this.server.server.getConnectionThrottle();
-                     InetAddress address = ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getAddress();
+         this.connection.setupOutboundProtocol(LoginProtocols.CLIENTBOUND);
+         // CraftBukkit start - Connection throttle
+         try {
++            if (!(this.connection.channel.localAddress() instanceof io.netty.channel.unix.DomainSocketAddress)) { // Paper - Unix domain socket support; the connection throttle is useless when you have a Unix domain socket
+             long currentTime = System.currentTimeMillis();
+             long connectionThrottle = this.server.server.getConnectionThrottle();
+             InetAddress address = ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getAddress();
 @@ -0,0 +0,0 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
-                             }
-                         }
                      }
-+                    } // Paper - Unix domain socket support
-                 } catch (Throwable t) {
-                     org.apache.logging.log4j.LogManager.getLogger().debug("Failed to check connection throttle", t);
                  }
+             }
++            } // Paper - Unix domain socket support
+         } catch (Throwable t) {
+             org.apache.logging.log4j.LogManager.getLogger().debug("Failed to check connection throttle", t);
+         }
 @@ -0,0 +0,0 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
-                         // Paper end - PlayerHandshakeEvent
-                     // if (org.spigotmc.SpigotConfig.bungee) { // Paper - comment out, we check above!
-                         if ( ( split.length == 3 || split.length == 4 ) && ( ServerHandshakePacketListenerImpl.BYPASS_HOSTCHECK || ServerHandshakePacketListenerImpl.HOST_PATTERN.matcher( split[1] ).matches() ) ) { // Paper - Add bypass host check
-+                            // Paper start - Unix domain socket support
-+                            java.net.SocketAddress socketAddress = this.connection.getRemoteAddress();
-                             this.connection.hostname = split[0];
--                            this.connection.address = new java.net.InetSocketAddress(split[1], ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getPort());
-+                            this.connection.address = new java.net.InetSocketAddress(split[1], socketAddress instanceof java.net.InetSocketAddress ? ((java.net.InetSocketAddress) socketAddress).getPort() : 0);
-+                            // Paper end - Unix domain socket support
-                             this.connection.spoofedUUID = com.mojang.util.UndashedUuid.fromStringLenient( split[2] );
-                         } else
-                         {
+             if (!handledByEvent && proxyLogicEnabled) { // Paper
+                 // if (org.spigotmc.SpigotConfig.bungee) { // Paper - comment out, we check above!
+                 if ( ( split.length == 3 || split.length == 4 ) && ( ServerHandshakePacketListenerImpl.BYPASS_HOSTCHECK || ServerHandshakePacketListenerImpl.HOST_PATTERN.matcher( split[1] ).matches() ) ) { // Paper - Add bypass host check
++                    // Paper start - Unix domain socket support
++                    java.net.SocketAddress socketAddress = this.connection.getRemoteAddress();
+                     this.connection.hostname = split[0];
+-                    this.connection.address = new java.net.InetSocketAddress(split[1], ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getPort());
++                    this.connection.address = new java.net.InetSocketAddress(split[1], socketAddress instanceof java.net.InetSocketAddress ? ((java.net.InetSocketAddress) socketAddress).getPort() : 0);
++                    // Paper end - Unix domain socket support
+                     this.connection.spoofedUUID = com.mojang.util.UndashedUuid.fromStringLenient( split[2] );
+                 } else
+                 {

patches/server/Add-a-should-burn-in-sunlight-API-for-Phantoms-and-S.patch

@@ -10,8 +10,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
 @@ -0,0 +0,0 @@ public abstract class AbstractSkeleton extends Monster implements RangedAttackMo
-         return MobType.UNDEAD;
-     }
+ 
+     abstract SoundEvent getStepSound();
  
 +    // Paper start - shouldBurnInDay API
 +    private boolean shouldBurnInDay = true;
@@ -56,8 +56,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void aiStep() {
 -        if (this.isAlive() && this.isSunBurnTick()) {
-+        if (this.isAlive() && shouldBurnInDay && this.isSunBurnTick()) { // Paper - shouldBurnInDay API
-             this.setSecondsOnFire(8);
++        if (this.isAlive() && this.shouldBurnInDay && this.isSunBurnTick()) { // Paper - shouldBurnInDay API
+             this.igniteForSeconds(8);
          }
  
 @@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
@@ -79,15 +79,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 @@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
-         return spawningEntity;
+         return this.spawningEntity;
      }
      public void setSpawningEntity(java.util.UUID entity) { this.spawningEntity = entity; }
 +    private boolean shouldBurnInDay = true;
 +    public boolean shouldBurnInDay() { return shouldBurnInDay; }
 +    public void setShouldBurnInDay(boolean shouldBurnInDay) { this.shouldBurnInDay = shouldBurnInDay; }
      // Paper end
-     private static enum AttackPhase {
  
+     private static enum AttackPhase {
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractSkeleton.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractSkeleton.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractSkeleton.java

patches/server/Add-bypass-host-check.patch

@@ -20,11 +20,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public ServerHandshakePacketListenerImpl(MinecraftServer server, Connection connection) {
          this.server = server;
 @@ -0,0 +0,0 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
-                     if (!handledByEvent && proxyLogicEnabled) {
-                         // Paper end - PlayerHandshakeEvent
-                     // if (org.spigotmc.SpigotConfig.bungee) { // Paper - comment out, we check above!
--                        if ( ( split.length == 3 || split.length == 4 ) && ( ServerHandshakePacketListenerImpl.HOST_PATTERN.matcher( split[1] ).matches() ) ) {
-+                        if ( ( split.length == 3 || split.length == 4 ) && ( ServerHandshakePacketListenerImpl.BYPASS_HOSTCHECK || ServerHandshakePacketListenerImpl.HOST_PATTERN.matcher( split[1] ).matches() ) ) { // Paper - Add bypass host check
-                             this.connection.hostname = split[0];
-                             this.connection.address = new java.net.InetSocketAddress(split[1], ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getPort());
-                             this.connection.spoofedUUID = com.mojang.util.UndashedUuid.fromStringLenient( split[2] );
+             String[] split = packet.hostName().split("\00");
+             if (!handledByEvent && proxyLogicEnabled) { // Paper
+                 // if (org.spigotmc.SpigotConfig.bungee) { // Paper - comment out, we check above!
+-                if ( ( split.length == 3 || split.length == 4 ) && ( ServerHandshakePacketListenerImpl.HOST_PATTERN.matcher( split[1] ).matches() ) ) {
++                if ( ( split.length == 3 || split.length == 4 ) && ( ServerHandshakePacketListenerImpl.BYPASS_HOSTCHECK || ServerHandshakePacketListenerImpl.HOST_PATTERN.matcher( split[1] ).matches() ) ) { // Paper - Add bypass host check
+                     this.connection.hostname = split[0];
+                     this.connection.address = new java.net.InetSocketAddress(split[1], ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getPort());
+                     this.connection.spoofedUUID = com.mojang.util.UndashedUuid.fromStringLenient( split[2] );

patches/server/Add-environment-variable-to-disable-server-gui.patch

@@ -10,9 +10,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/server/Main.java
 @@ -0,0 +0,0 @@ public class Main {
                  */
-                 boolean flag1 = !optionset.has("nogui") && !optionset.nonOptionArguments().contains("nogui");
+                 boolean flag2 = !optionset.has("nogui") && !optionset.nonOptionArguments().contains("nogui");
  
 +                if(!Boolean.parseBoolean(System.getenv().getOrDefault("PAPER_DISABLE_SERVER_GUI", String.valueOf(false)))) // Paper - Add environment variable to disable server gui
-                 if (flag1 && !GraphicsEnvironment.isHeadless()) {
+                 if (flag2 && !GraphicsEnvironment.isHeadless()) {
                      dedicatedserver1.showGui();
                  }

patches/server/Add-ignore-discounts-API.patch

@@ -28,6 +28,17 @@ diff --git a/src/main/java/net/minecraft/world/item/trading/MerchantOffer.java b
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/item/trading/MerchantOffer.java
 +++ b/src/main/java/net/minecraft/world/item/trading/MerchantOffer.java
+@@ -0,0 +0,0 @@ public class MerchantOffer {
+             return merchantrecipe.priceMultiplier;
+         }), Codec.INT.lenientOptionalFieldOf("xp", 1).forGetter((merchantrecipe) -> {
+             return merchantrecipe.xp;
++        // Paper start
++        }), Codec.BOOL.lenientOptionalFieldOf("Paper.IgnoreDiscounts", false).forGetter((merchantrecipe) -> {
++            return merchantrecipe.ignoreDiscounts;
++        // Paper end
+         })).apply(instance, MerchantOffer::new);
+     });
+     public static final StreamCodec<RegistryFriendlyByteBuf, MerchantOffer> STREAM_CODEC = StreamCodec.of(MerchantOffer::writeToStream, MerchantOffer::createFromStream);
 @@ -0,0 +0,0 @@ public class MerchantOffer {
      public int demand;
      public float priceMultiplier;
@@ -38,58 +49,35 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 @@ -0,0 +0,0 @@ public class MerchantOffer {
      }
- 
-     public MerchantOffer(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, int uses, int maxUses, int experience, float priceMultiplier, int demand, CraftMerchantRecipe bukkit) {
--        this(itemstack, itemstack1, itemstack2, uses, maxUses, experience, priceMultiplier, demand);
-+        // Paper start - Add ignore discounts API
-+        this(itemstack, itemstack1, itemstack2, uses, maxUses, experience, priceMultiplier, demand, false, bukkit);
-+    }
-+    public MerchantOffer(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, int uses, int maxUses, int experience, float priceMultiplier, boolean ignoreDiscounts, CraftMerchantRecipe bukkit) {
-+        this(itemstack, itemstack1, itemstack2, uses, maxUses, experience, priceMultiplier, 0, ignoreDiscounts, bukkit);
-+    }
-+    public MerchantOffer(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, int uses, int maxUses, int experience, float priceMultiplier, int demand, boolean ignoreDiscounts, CraftMerchantRecipe bukkit) {
-+        this(itemstack, itemstack1, itemstack2, uses, maxUses, experience, priceMultiplier, demand, ignoreDiscounts);
-+        // Paper end - Add ignore discounts API
-         this.bukkitHandle = bukkit;
-     }
      // CraftBukkit end
-@@ -0,0 +0,0 @@ public class MerchantOffer {
  
-         this.specialPriceDiff = nbt.getInt("specialPrice");
-         this.demand = nbt.getInt("demand");
-+        this.ignoreDiscounts = nbt.getBoolean("Paper.IgnoreDiscounts"); // Paper - Add ignore discounts API
-     }
- 
-     public MerchantOffer(ItemStack buyItem, ItemStack sellItem, int maxUses, int merchantExperience, float priceMultiplier) {
-@@ -0,0 +0,0 @@ public class MerchantOffer {
-     }
- 
-     public MerchantOffer(ItemStack firstBuyItem, ItemStack secondBuyItem, ItemStack sellItem, int uses, int maxUses, int merchantExperience, float priceMultiplier) {
--        this(firstBuyItem, secondBuyItem, sellItem, uses, maxUses, merchantExperience, priceMultiplier, 0);
-+        // Paper start - Add ignore discounts API
-+        this(firstBuyItem, secondBuyItem, sellItem, uses, maxUses, merchantExperience, priceMultiplier, false);
-+    }
-+    public MerchantOffer(ItemStack firstBuyItem, ItemStack secondBuyItem, ItemStack sellItem, int uses, int maxUses, int merchantExperience, float priceMultiplier, boolean ignoreDiscounts) {
-+        this(firstBuyItem, secondBuyItem, sellItem, uses, maxUses, merchantExperience, priceMultiplier, 0, ignoreDiscounts);
-     }
- 
-     public MerchantOffer(ItemStack firstBuyItem, ItemStack secondBuyItem, ItemStack sellItem, int uses, int maxUses, int merchantExperience, float priceMultiplier, int demandBonus) {
-+        this(firstBuyItem, secondBuyItem, sellItem, uses, maxUses, merchantExperience, priceMultiplier, demandBonus, false);
-+    }
-+    public MerchantOffer(ItemStack firstBuyItem, ItemStack secondBuyItem, ItemStack sellItem, int uses, int maxUses, int merchantExperience, float priceMultiplier, int demandBonus, boolean ignoreDiscounts) {
-+        this.ignoreDiscounts = ignoreDiscounts;
-+        // Paper end - Add ignore discounts API
-         this.rewardExp = true;
-         this.xp = 1;
+-    private MerchantOffer(ItemCost firstBuyItem, Optional<ItemCost> secondBuyItem, ItemStack sellItem, int uses, int maxUses, boolean rewardingPlayerExperience, int specialPrice, int demandBonus, float priceMultiplier, int merchantExperience) {
++    private MerchantOffer(ItemCost firstBuyItem, Optional<ItemCost> secondBuyItem, ItemStack sellItem, int uses, int maxUses, boolean rewardingPlayerExperience, int specialPrice, int demandBonus, float priceMultiplier, int merchantExperience, boolean ignoreDiscounts) { // Paper
          this.baseCostA = firstBuyItem;
+         this.costB = secondBuyItem;
+         this.result = sellItem;
 @@ -0,0 +0,0 @@ public class MerchantOffer {
-         nbttagcompound.putFloat("priceMultiplier", this.priceMultiplier);
-         nbttagcompound.putInt("specialPrice", this.specialPriceDiff);
-         nbttagcompound.putInt("demand", this.demand);
-+        nbttagcompound.putBoolean("Paper.IgnoreDiscounts", this.ignoreDiscounts); // Paper - Add ignore discounts API
-         return nbttagcompound;
+         this.demand = demandBonus;
+         this.priceMultiplier = priceMultiplier;
+         this.xp = merchantExperience;
++        this.ignoreDiscounts = ignoreDiscounts;
      }
  
+     public MerchantOffer(ItemCost buyItem, ItemStack sellItem, int maxUses, int merchantExperience, float priceMultiplier) {
+@@ -0,0 +0,0 @@ public class MerchantOffer {
+     }
+ 
+     public MerchantOffer(ItemCost firstBuyItem, Optional<ItemCost> secondBuyItem, ItemStack sellItem, int uses, int maxUses, int merchantExperience, float priceMultiplier, int demandBonus) {
+-        this(firstBuyItem, secondBuyItem, sellItem, uses, maxUses, true, 0, demandBonus, priceMultiplier, merchantExperience);
++        this(firstBuyItem, secondBuyItem, sellItem, uses, maxUses, true, 0, demandBonus, priceMultiplier, merchantExperience, false); // Paper
+     }
+ 
+     private MerchantOffer(MerchantOffer offer) {
+-        this(offer.baseCostA, offer.costB, offer.result.copy(), offer.uses, offer.maxUses, offer.rewardExp, offer.specialPriceDiff, offer.demand, offer.priceMultiplier, offer.xp);
++        this(offer.baseCostA, offer.costB, offer.result.copy(), offer.uses, offer.maxUses, offer.rewardExp, offer.specialPriceDiff, offer.demand, offer.priceMultiplier, offer.xp, offer.ignoreDiscounts); // Paper
+     }
+ 
+     public ItemStack getBaseCostA() {
 diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantRecipe.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantRecipe.java
@@ -114,8 +102,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        super(result, uses, maxUses, experienceReward, experience, priceMultiplier, demand, specialPrice, ignoreDiscounts);
 +        // Paper end
          this.handle = new net.minecraft.world.item.trading.MerchantOffer(
-                 net.minecraft.world.item.ItemStack.EMPTY,
-                 net.minecraft.world.item.ItemStack.EMPTY,
+                 new ItemCost(Items.AIR),
+                 Optional.empty(),
 @@ -0,0 +0,0 @@ public class CraftMerchantRecipe extends MerchantRecipe {
                  experience,
                  priceMultiplier,

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

@@ -22,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
      protected void registerGoals() {
          this.goalSelector.addGoal(0, new FloatGoal(this));
-         this.goalSelector.addGoal(0, new UseItemGoal<>(this, PotionUtils.setPotion(new ItemStack(Items.POTION), Potions.INVISIBILITY), SoundEvents.WANDERING_TRADER_DISAPPEARED, (entityvillagertrader) -> {
+         this.goalSelector.addGoal(0, new UseItemGoal<>(this, PotionContents.createItemStack(Items.POTION, Potions.INVISIBILITY), SoundEvents.WANDERING_TRADER_DISAPPEARED, (entityvillagertrader) -> {
 -            return this.level().isNight() && !entityvillagertrader.isInvisible();
 +            return this.canDrinkPotion && this.level().isNight() && !entityvillagertrader.isInvisible(); // Paper - Add more WanderingTrader API
          }));

patches/server/Add-world-settings-for-mobs-picking-up-loot.patch

@@ -22,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
 @@ -0,0 +0,0 @@ public class Zombie extends Monster {
-         Object object = super.finalizeSpawn(world, difficulty, spawnReason, entityData, entityNbt);
+         Object object = super.finalizeSpawn(world, difficulty, spawnReason, entityData);
          float f = difficulty.getSpecialMultiplier();
  
 -        this.setCanPickUpLoot(randomsource.nextFloat() < 0.55F * f);

patches/server/Allow-disabling-mob-spawner-spawn-egg-transformation.patch

@@ -16,4 +16,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
                  Spawner spawner = (Spawner) tileentity;
  
-                 entitytypes = this.getType(itemstack.getTag());
+                 entitytypes = this.getType(itemstack);

patches/server/Allow-using-signs-inside-spawn-protection.patch

@@ -12,8 +12,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      int i = this.player.level().getMaxBuildHeight();
  
                      if (blockposition.getY() < i) {
--                        if (this.awaitingPositionFromClient == null && this.player.distanceToSqr((double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D) < 64.0D && worldserver.mayInteract(this.player, blockposition)) {
-+                        if (this.awaitingPositionFromClient == null && this.player.distanceToSqr((double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D) < 64.0D && (worldserver.mayInteract(this.player, blockposition)  || (worldserver.paperConfig().spawn.allowUsingSignsInsideSpawnProtection && worldserver.getBlockState(blockposition).getBlock() instanceof net.minecraft.world.level.block.SignBlock))) { // Paper - Allow using signs inside spawn protection
-                             this.player.stopUsingItem(); // CraftBukkit - SPIGOT-4706
+-                        if (this.awaitingPositionFromClient == null && worldserver.mayInteract(this.player, blockposition)) {
+-                            this.player.stopUsingItem(); // CraftBukkit - SPIGOT-4706
++                        if (this.awaitingPositionFromClient == null && (worldserver.mayInteract(this.player, blockposition) || (worldserver.paperConfig().spawn.allowUsingSignsInsideSpawnProtection && worldserver.getBlockState(blockposition).getBlock() instanceof net.minecraft.world.level.block.SignBlock))) { // Paper - Allow using signs inside spawn protection
                              InteractionResult enuminteractionresult = this.player.gameMode.useItemOn(this.player, worldserver, itemstack, enumhand, movingobjectpositionblock);
  
+                             if (enuminteractionresult.consumesAction()) {

patches/server/Beacon-API-custom-effect-ranges.patch

@@ -34,7 +34,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    // Paper end - Custom beacon ranges
  
      @Nullable
-     static MobEffect filterEffect(@Nullable MobEffect effect) {
+     static Holder<MobEffect> filterEffect(@Nullable Holder<MobEffect> effect) {
 @@ -0,0 +0,0 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
              }
  
@@ -62,8 +62,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
      }
  
-     private static void applyEffects(Level world, BlockPos pos, int beaconLevel, @Nullable MobEffect primaryEffect, @Nullable MobEffect secondaryEffect) {
-+        // Paper start - Custom beacon ranges
+     private static void applyEffects(Level world, BlockPos pos, int beaconLevel, @Nullable Holder<MobEffect> primaryEffect, @Nullable Holder<MobEffect> secondaryEffect) {
++    // Paper start - Custom beacon ranges
 +        BeaconBlockEntity.applyEffects(world, pos, beaconLevel, primaryEffect, secondaryEffect, null);
 +    }
 +    private static void applyEffects(Level world, BlockPos pos, int beaconLevel, @Nullable MobEffect primaryEffect, @Nullable MobEffect secondaryEffect, @Nullable BeaconBlockEntity blockEntity) {
@@ -108,8 +108,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              for (Player human : nms) {
 @@ -0,0 +0,0 @@ public class CraftBeacon extends CraftBlockEntityState<BeaconBlockEntity> implem
-     public CraftBeacon copy() {
-         return new CraftBeacon(this);
+     public CraftBeacon copy(Location location) {
+         return new CraftBeacon(this, location);
      }
 +
 +    // Paper start

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

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 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 Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      public boolean isPushable() {

patches/server/Collision-option-for-requiring-a-player-participant.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 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 Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      public void push(Entity entity) {
          if (!this.isPassengerOfSameVehicle(entity)) {
              if (!entity.noPhysics && !this.noPhysics) {

patches/server/Don-t-ignore-result-of-PlayerEditBookEvent.patch

@@ -9,11 +9,11 @@ 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 extends ServerCommonPacketListenerImpl
-         }
+             List<Filterable<String>> list1 = pages.stream().map(this::filterableFromOutgoing).toList();
  
-         itemstack.addTagElement("pages", nbttaglist);
--        CraftEventFactory.handleEditBookEvent(this.player, slot, handItem, itemstack); // CraftBukkit
-+        this.player.getInventory().setItem(slot, CraftEventFactory.handleEditBookEvent(this.player, slot, handItem, itemstack)); // CraftBukkit // Paper - Don't ignore result (see other callsite for handleEditBookEvent)
+             itemstack.set(DataComponents.WRITABLE_BOOK_CONTENT, new WritableBookContent(list1));
+-            CraftEventFactory.handleEditBookEvent(this.player, slotId, handItem, itemstack); // CraftBukkit
++            this.player.getInventory().setItem(slotId, CraftEventFactory.handleEditBookEvent(this.player, slotId, handItem, itemstack)); // CraftBukkit // Paper - Don't ignore result (see other callsite for handleEditBookEvent)
+         }
      }
  
-     @Override

patches/server/Entity-isTicking.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 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 Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      public static int nextEntityId() {
          return ENTITY_COUNTER.incrementAndGet();
      }

patches/server/Expand-EntityUnleashEvent.patch

@@ -8,25 +8,25 @@ 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 implements Targeting {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Targeti
              return InteractionResult.PASS;
          } else if (this.getLeashHolder() == player) {
              // CraftBukkit start - fire PlayerUnleashEntityEvent
 -            if (CraftEventFactory.callPlayerUnleashEntityEvent(this, player, hand).isCancelled()) {
 +            // Paper start - Expand EntityUnleashEvent
-+            org.bukkit.event.player.PlayerUnleashEntityEvent event = CraftEventFactory.callPlayerUnleashEntityEvent(this, player, hand, !player.getAbilities().instabuild);
++            org.bukkit.event.player.PlayerUnleashEntityEvent event = CraftEventFactory.callPlayerUnleashEntityEvent(this, player, hand, !player.hasInfiniteMaterials());
 +            if (event.isCancelled()) {
 +                // Paper end - Expand EntityUnleashEvent
                  ((ServerPlayer) player).connection.send(new ClientboundSetEntityLinkPacket(this, this.getLeashHolder()));
                  return InteractionResult.PASS;
              }
              // CraftBukkit end
--            this.dropLeash(true, !player.getAbilities().instabuild);
+-            this.dropLeash(true, !player.hasInfiniteMaterials());
 +            this.dropLeash(true, event.isDropLeash()); // Paper - Expand EntityUnleashEvent
              this.gameEvent(GameEvent.ENTITY_INTERACT, player);
              return InteractionResult.sidedSuccess(this.level().isClientSide);
          } else {
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements Targeting {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Targeti
  
          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 implements Targeting {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Targeti
          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 implements Targeting {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Targeti
      @Override
      protected void removeAfterChangingDimensions() {
          super.removeAfterChangingDimensions();

patches/server/Expand-PlayerGameModeChangeEvent.patch

@@ -122,9 +122,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
              // CraftBukkit end
              this.setGameModeForPlayer(gameMode, this.previousGameModeForPlayer);
-             this.player.onUpdateAbilities();
-             this.player.server.getPlayerList().broadcastAll(new ClientboundPlayerInfoUpdatePacket(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_GAME_MODE, this.player), this.player); // CraftBukkit
-             this.level.updateSleepingPlayerList();
+@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
+                 this.player.resetCurrentImpulseContext();
+             }
+ 
 -            return true;
 +            return event; // Paper - Expand PlayerGameModeChangeEvent
          }

patches/server/Expand-world-key-API.patch

@@ -49,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            worldKey = ResourceKey.create(Registries.DIMENSION, new net.minecraft.resources.ResourceLocation(creator.key().getNamespace().toLowerCase(java.util.Locale.ENGLISH), creator.key().getKey().toLowerCase(java.util.Locale.ENGLISH))); // Paper
          }
  
-         ServerLevel internal = (ServerLevel) new ServerLevel(this.console, this.console.executor, worldSession, worlddata, worldKey, worlddimension, this.getServer().progressListenerFactory.create(11),
+         // If set to not keep spawn in memory (changed from default) then adjust rule accordingly
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
          return null;
      }

patches/server/Expose-LivingEntity-hurt-direction.patch

@@ -14,9 +14,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public FishingHook fishing;
 -    protected float hurtDir;
 +    public float hurtDir; // Paper - protected -> public
-     public boolean affectsSpawning = true; // Paper - Affects Spawning API
- 
-     // CraftBukkit start
+     @Nullable
+     public Vec3 currentImpulseImpactPos;
+     @Nullable
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java

patches/server/Expose-the-Entity-Counter-to-allow-plugins-to-use-va.patch

@@ -9,7 +9,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 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 Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
  
          void accept(Entity entity, double x, double y, double z);
      }

patches/server/Fix-Entity-Teleportation-and-cancel-velocity-if-tele.patch

@@ -22,9 +22,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.lastGoodY = this.awaitingPositionFromClient.y;
              this.lastGoodZ = this.awaitingPositionFromClient.z;
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-         // CraftBukkit end
  
          this.awaitingTeleportTime = this.tickCount;
+         this.player.resetCurrentImpulseContext();
 -        this.player.absMoveTo(d0, d1, d2, f, f1);
 +        this.player.moveTo(d0, d1, d2, f, f1); // Paper - Fix Entity Teleportation and cancel velocity if teleported
          this.player.connection.send(new ClientboundPlayerPositionPacket(d0 - d3, d1 - d4, d2 - d5, f - f2, f1 - f3, set, this.awaitingTeleport));
@@ -34,7 +34,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 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 Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
  
      // CraftBukkit start
      private static final int CURRENT_LEVEL = 2;
@@ -42,7 +42,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      static boolean isLevelAtLeast(CompoundTag tag, int level) {
          return tag.contains("Bukkit.updateLevel") && tag.getInt("Bukkit.updateLevel") >= level;
      }
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      public void moveTo(double x, double y, double z, float yaw, float pitch) {

patches/server/Fix-Not-a-string-Map-Conversion-spam.patch

@@ -15,19 +15,19 @@ diff --git a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSaved
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
 +++ b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
-@@ -0,0 +0,0 @@ import net.minecraft.core.BlockPos;
+@@ -0,0 +0,0 @@ import net.minecraft.core.component.DataComponents;
  import net.minecraft.nbt.CompoundTag;
  import net.minecraft.nbt.ListTag;
  import net.minecraft.nbt.NbtOps;
 +import net.minecraft.nbt.NumericTag;
 +import net.minecraft.nbt.StringTag;
  import net.minecraft.nbt.Tag;
+ import net.minecraft.network.FriendlyByteBuf;
  import net.minecraft.network.chat.Component;
- import net.minecraft.network.protocol.Packet;
 @@ -0,0 +0,0 @@ public class MapItemSavedData extends SavedData {
      }
  
-     public static MapItemSavedData load(CompoundTag nbt) {
+     public static MapItemSavedData load(CompoundTag nbt, HolderLookup.Provider registryLookup) {
 -        DataResult<ResourceKey<Level>> dataresult = DimensionType.parseLegacy(new Dynamic(NbtOps.INSTANCE, nbt.get("dimension"))); // CraftBukkit - decompile error
 +        // Paper start - fix "Not a string" spam
 +        Tag dimension = nbt.get("dimension");

patches/server/Fix-for-large-move-vectors-crashing-server.patch

@@ -81,6 +81,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            d6 = d0 - this.lastGoodX; // Paper - diff on change, used for checking large move vectors above
 +                            d7 = d1 - this.lastGoodY; // Paper - diff on change, used for checking large move vectors above
 +                            d8 = d2 - this.lastGoodZ; // Paper - diff on change, used for checking large move vectors above
-                             boolean flag = d7 > 0.0D;
+                             boolean flag1 = d7 > 0.0D;
  
-                             if (this.player.onGround() && !packet.isOnGround() && flag) {
+                             if (this.player.onGround() && !packet.isOnGround() && flag1) {

patches/server/Fix-harming-potion-dupe.patch

@@ -15,29 +15,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              CriteriaTriggers.CONSUME_ITEM.trigger((ServerPlayer) entityhuman, stack);
          }
  
-+        List<MobEffectInstance> instantLater = new java.util.ArrayList<>(); // Paper - Fix harming potion dupe
++        List<net.minecraft.world.effect.MobEffectInstance> instantLater = new java.util.ArrayList<>(); // Paper - Fix harming potion dupe
          if (!world.isClientSide) {
-             List<MobEffectInstance> list = PotionUtils.getMobEffects(stack);
-             Iterator iterator = list.iterator();
-@@ -0,0 +0,0 @@ public class PotionItem extends Item {
-                 MobEffectInstance mobeffect = (MobEffectInstance) iterator.next();
+             PotionContents potioncontents = (PotionContents) stack.getOrDefault(DataComponents.POTION_CONTENTS, PotionContents.EMPTY);
  
-                 if (mobeffect.getEffect().isInstantenous()) {
--                    mobeffect.getEffect().applyInstantenousEffect(entityhuman, entityhuman, user, mobeffect.getAmplifier(), 1.0D);
-+                    instantLater.add(mobeffect); // Paper - Fix harming potion dupe
+             potioncontents.forEachEffect((mobeffect) -> {
+                 if (((MobEffect) mobeffect.getEffect().value()).isInstantenous()) {
+-                    ((MobEffect) mobeffect.getEffect().value()).applyInstantenousEffect(entityhuman, entityhuman, user, mobeffect.getAmplifier(), 1.0D);
++                    instantLater.add(mobeffect); // Paper
                  } else {
-                     user.addEffect(new MobEffectInstance(mobeffect), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.POTION_DRINK); // CraftBukkit
+                     user.addEffect(mobeffect, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.POTION_DRINK); // CraftBukkit
                  }
 @@ -0,0 +0,0 @@ public class PotionItem extends Item {
-             }
+             stack.consume(1, entityhuman);
          }
  
 +        // Paper start - Fix harming potion dupe
-+        for (MobEffectInstance mobeffect : instantLater) {
-+            mobeffect.getEffect().applyInstantenousEffect(entityhuman, entityhuman, user, mobeffect.getAmplifier(), 1.0D);
++        for (net.minecraft.world.effect.MobEffectInstance mobeffect : instantLater) {
++            mobeffect.getEffect().value().applyInstantenousEffect(entityhuman, entityhuman, user, mobeffect.getAmplifier(), 1.0D);
 +        }
 +        // Paper end - Fix harming potion dupe
-         if (entityhuman == null || !entityhuman.getAbilities().instabuild) {
+         if (entityhuman == null || !entityhuman.hasInfiniteMaterials()) {
 +            // Paper start - Fix harming potion dupe
 +            if (user.getHealth() <= 0 && !user.level().getGameRules().getBoolean(net.minecraft.world.level.GameRules.RULE_KEEPINVENTORY)) {
 +                user.spawnAtLocation(new ItemStack(Items.GLASS_BOTTLE), 0);

patches/server/Fix-item-locations-dropped-from-campfires.patch

@@ -25,4 +25,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                        // Paper end - Fix item locations dropped from campfires
                          campfire.items.set(i, ItemStack.EMPTY);
                          world.sendBlockUpdated(pos, state, state, 3);
-                         world.gameEvent(GameEvent.BLOCK_CHANGE, pos, GameEvent.Context.of(state));
+                         world.gameEvent((Holder) GameEvent.BLOCK_CHANGE, pos, GameEvent.Context.of(state));

patches/server/Inline-shift-direction-fields.patch

@@ -20,9 +20,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final int adjZ;
 +    // Paper end - Perf: Inline shift direction fields
 +
-     private Direction(int id, int idOpposite, int idHorizontal, String name, Direction.AxisDirection direction, Direction.Axis axis, Vec3i vector) {
-         this.data3d = id;
-         this.data2d = idHorizontal;
+     private Direction(
+         final int id,
+         final int idOpposite,
 @@ -0,0 +0,0 @@ public enum Direction implements StringRepresentable {
          this.axis = axis;
          this.axisDirection = direction;