Patches!!!!!!!

patches/server/API-for-updating-recipes-on-clients.patch

@@ -35,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    public void reloadRecipeData() {
 +        // Paper end - API for updating recipes on clients
-         ClientboundUpdateRecipesPacket packetplayoutrecipeupdate = new ClientboundUpdateRecipesPacket(this.server.getRecipeManager().getRecipes());
+         ClientboundUpdateRecipesPacket packetplayoutrecipeupdate = new ClientboundUpdateRecipesPacket(this.server.getRecipeManager().getOrderedRecipes());
          Iterator iterator1 = this.players.iterator();
  
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java

patches/server/Add-BlockLockCheckEvent.patch

@@ -54,7 +54,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        } // Paper - Add BlockLockCheckEvent
      }
  
-     @Nullable
+     protected abstract NonNullList<ItemStack> getItems();
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java

patches/server/Add-EntityFertilizeEggEvent.patch

@@ -32,7 +32,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java b/sr
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
-@@ -0,0 +0,0 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
+@@ -0,0 +0,0 @@ public class Frog extends Animal implements VariantHolder<Holder<FrogVariant>> {
  
      @Override
      public void spawnChildFromBreeding(ServerLevel world, Animal other) {

patches/server/Add-Listing-API-for-Player.patch

@@ -52,8 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return new ClientboundPlayerInfoUpdatePacket(enumSet, new ClientboundPlayerInfoUpdatePacket.Entry(playerInfoId, listed));
 +    }
 +    // Paper end - Add Listing API for Player
-+
-     public ClientboundPlayerInfoUpdatePacket(FriendlyByteBuf buf) {
+     private ClientboundPlayerInfoUpdatePacket(RegistryFriendlyByteBuf buf) {
          this.actions = buf.readEnumSet(ClientboundPlayerInfoUpdatePacket.Action.class);
          this.entries = buf.readList(buf2 -> {
 @@ -0,0 +0,0 @@ public class ClientboundPlayerInfoUpdatePacket implements Packet<ClientGamePacke

patches/server/Add-Sign-getInteractableSideFor.patch

@@ -19,8 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper end - Add Sign#getInteractableSideFor
          Block block = this.getBlockState().getBlock();
  
-         if (block instanceof SignBlock) {
-             SignBlock blocksign = (SignBlock) block;
+         if (block instanceof SignBlock blocksign) {
              Vec3 vec3d = blocksign.getSignHitboxCenterPosition(this.getBlockState());
 -            double d0 = player.getX() - ((double) this.getBlockPos().getX() + vec3d.x);
 -            double d1 = player.getZ() - ((double) this.getBlockPos().getZ() + vec3d.z);

patches/server/Add-event-for-player-editing-sign.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/ja
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/item/ItemStack.java
 +++ b/src/main/java/net/minecraft/world/item/ItemStack.java
-@@ -0,0 +0,0 @@ public final class ItemStack {
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
                          try {
                              if (world.getBlockEntity(SignItem.openSign) instanceof SignBlockEntity tileentitysign) {
                                  if (world.getBlockState(SignItem.openSign).getBlock() instanceof SignBlock blocksign) {
@@ -22,14 +22,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/SignBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/SignBlock.java
 @@ -0,0 +0,0 @@ public abstract class SignBlock extends BaseEntityBlock implements SimpleWaterlo
-                 } else if (flag2) {
-                     return InteractionResult.SUCCESS;
-                 } else if (!this.otherPlayerIsEditingSign(player, tileentitysign) && player.mayBuild() && this.hasEditableText(player, tileentitysign, flag1)) {
--                    this.openTextEdit(player, tileentitysign, flag1, org.bukkit.event.player.PlayerSignOpenEvent.Cause.INTERACT); // CraftBukkit
-+                    this.openTextEdit(player, tileentitysign, flag1, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause.INTERACT); // Paper - Add PlayerOpenSignEvent
-                     return this.getInteractionResult(flag);
-                 } else {
-                     return InteractionResult.PASS;
+             } else if (flag1) {
+                 return InteractionResult.SUCCESS;
+             } else if (!this.otherPlayerIsEditingSign(player, tileentitysign) && player.mayBuild() && this.hasEditableText(player, tileentitysign, flag)) {
+-                this.openTextEdit(player, tileentitysign, flag, org.bukkit.event.player.PlayerSignOpenEvent.Cause.INTERACT); // CraftBukkit
++                this.openTextEdit(player, tileentitysign, flag, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause.INTERACT); // Paper - Add PlayerOpenSignEvent
+                 return InteractionResult.SUCCESS;
+             } else {
+                 return InteractionResult.PASS;
 @@ -0,0 +0,0 @@ public abstract class SignBlock extends BaseEntityBlock implements SimpleWaterlo
          return blockpropertywood;
      }

patches/server/Add-exploded-block-state-to-BlockExplodeEvent-and-En.patch

@@ -125,7 +125,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockStates.java
 +++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockStates.java
 @@ -0,0 +0,0 @@ public final class CraftBlockStates {
-         BlockEntity tileEntity = (blockEntityTag == null) ? null : BlockEntity.loadStatic(blockPosition, blockData, blockEntityTag);
+         BlockEntity tileEntity = (blockEntityTag == null) ? null : BlockEntity.loadStatic(blockPosition, blockData, blockEntityTag, registry);
          return CraftBlockStates.getBlockState(null, blockPosition, blockData, tileEntity);
      }
 +    // Paper start - add exploded state
@@ -142,7 +142,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
 +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
 @@ -0,0 +0,0 @@ public class CraftEventFactory {
-         Entity damager = source.getCausingEntity();
+         Entity damager = (bukkitDamageSource.isIndirect() && source.getDirectEntity() != null) ? source.getDirectEntity() : source.getCausingEntity();
          if (source.is(DamageTypeTags.IS_EXPLOSION)) {
              if (damager == null) {
 -                return CraftEventFactory.callEntityDamageEvent(source.getDirectBlock(), entity, DamageCause.BLOCK_EXPLOSION, bukkitDamageSource, modifiers, modifierFunctions, cancelled);

patches/server/Add-missing-InventoryHolders-to-inventories.patch

@@ -84,8 +84,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public BeaconMenu(int syncId, Container inventory, ContainerData propertyDelegate, ContainerLevelAccess context) {
          super(MenuType.BEACON, syncId);
          this.player = (Inventory) inventory; // CraftBukkit - TODO: check this
--        this.beacon = new SimpleContainer(1) {
-+        this.beacon = new SimpleContainer(this.createBlockHolder(context), 1) { // Paper - Add missing InventoryHolders
+-        this.beacon = new SimpleContainer(1) { // CraftBukkit - decompile error
++        this.beacon = new SimpleContainer(this.createBlockHolder(context), 1) { // CraftBukkit - decompile error // Paper - Add missing InventoryHolders
              @Override
              public boolean canPlaceItem(int slot, ItemStack stack) {
                  return stack.is(ItemTags.BEACON_PAYMENT_ITEMS);

patches/server/Add-missing-SpigotConfig-logCommands-check.patch

@@ -9,7 +9,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 extends ServerCommonPacketListenerImpl
-     private void performChatCommand(ServerboundChatCommandPacket packet, LastSeenMessages lastSeenMessages) {
+     private void performSignedChatCommand(ServerboundChatCommandSignedPacket packet, LastSeenMessages lastSeenMessages) {
          // CraftBukkit start
          String command = "/" + packet.command();
 +        if (org.spigotmc.SpigotConfig.logCommands) { // Paper - Add missing SpigotConfig logCommands check

patches/server/Add-option-to-disable-block-updates.patch

@@ -19,7 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ChorusPlantBlock extends PipeBlock {
  
      @Override
-     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+     protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableChorusPlantUpdates) return state; // Paper - add option to disable block updates
          if (!state.canSurvive(world, pos)) {
              world.scheduleTick(pos, this, 1);
@@ -27,7 +27,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ChorusPlantBlock extends PipeBlock {
  
      @Override
-     public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
+     protected void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableChorusPlantUpdates) return; // Paper - add option to disable block updates
          if (!state.canSurvive(world, pos)) {
              world.destroyBlock(pos, true);
@@ -35,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ChorusPlantBlock extends PipeBlock {
  
      @Override
-     public boolean canSurvive(BlockState state, LevelReader world, BlockPos pos) {
+     protected boolean canSurvive(BlockState state, LevelReader world, BlockPos pos) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableChorusPlantUpdates) return true; // Paper - add option to disable block updates
          BlockState blockState = world.getBlockState(pos.below());
          boolean bl = !world.getBlockState(pos.above()).isAir() && !blockState.isAir();
@@ -55,7 +55,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class HugeMushroomBlock extends Block {
  
      @Override
-     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+     protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableMushroomBlockUpdates) return state; // Paper - add option to disable block updates
          return neighborState.is(this)
              ? state.setValue(PROPERTY_BY_DIRECTION.get(direction), Boolean.valueOf(false))
@@ -63,7 +63,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class HugeMushroomBlock extends Block {
  
      @Override
-     public BlockState rotate(BlockState state, Rotation rotation) {
+     protected BlockState rotate(BlockState state, Rotation rotation) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableMushroomBlockUpdates) return state; // Paper - add option to disable block updates
          return state.setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.NORTH)), state.getValue(NORTH))
              .setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.SOUTH)), state.getValue(SOUTH))
@@ -71,7 +71,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class HugeMushroomBlock extends Block {
  
      @Override
-     public BlockState mirror(BlockState state, Mirror mirror) {
+     protected BlockState mirror(BlockState state, Mirror mirror) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableMushroomBlockUpdates) return state; // Paper - add option to disable block updates
          return state.setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.NORTH)), state.getValue(NORTH))
              .setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.SOUTH)), state.getValue(SOUTH))
@@ -89,7 +89,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      @Override
-     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+     protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableNoteblockUpdates) return state; // Paper - prevent noteblock instrument from updating
          boolean flag = direction.getAxis() == Direction.Axis.Y;
  
@@ -97,13 +97,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class NoteBlock extends Block {
  
      @Override
-     public void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, BlockPos sourcePos, boolean notify) {
+     protected void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, BlockPos sourcePos, boolean notify) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableNoteblockUpdates) return; // Paper - prevent noteblock powered-state from updating
          boolean flag1 = world.hasNeighborSignal(pos);
  
          if (flag1 != (Boolean) state.getValue(NoteBlock.POWERED)) {
 @@ -0,0 +0,0 @@ public class NoteBlock extends Block {
-         } else if (world.isClientSide) {
+         if (world.isClientSide) {
              return InteractionResult.SUCCESS;
          } else {
 -            state = (BlockState) state.cycle(NoteBlock.NOTE);
@@ -126,13 +126,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class TripWireBlock extends Block {
  
      @Override
-     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+     protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return state; // Paper - prevent tripwire from updating
          return direction.getAxis().isHorizontal() ? (BlockState) state.setValue((Property) TripWireBlock.PROPERTY_BY_DIRECTION.get(direction), this.shouldConnectTo(neighborState, direction)) : super.updateShape(state, direction, neighborState, world, pos, neighborPos);
      }
  
      @Override
-     public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
+     protected void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent adjacent tripwires from updating
          if (!oldState.is(state.getBlock())) {
              this.updateSource(world, pos, state);
@@ -140,7 +140,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class TripWireBlock extends Block {
  
      @Override
-     public void onRemove(BlockState state, Level world, BlockPos pos, BlockState newState, boolean moved) {
+     protected void onRemove(BlockState state, Level world, BlockPos pos, BlockState newState, boolean moved) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent adjacent tripwires from updating
          if (!moved && !state.is(newState.getBlock())) {
              this.updateSource(world, pos, (BlockState) state.setValue(TripWireBlock.POWERED, true));
@@ -152,7 +152,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return state; // Paper - prevent disarming tripwires
          if (!world.isClientSide && !player.getMainHandItem().isEmpty() && player.getMainHandItem().is(Items.SHEARS)) {
              world.setBlock(pos, (BlockState) state.setValue(TripWireBlock.DISARMED, true), 4);
-             world.gameEvent((Entity) player, GameEvent.SHEAR, pos);
+             world.gameEvent((Entity) player, (Holder) GameEvent.SHEAR, pos);
 @@ -0,0 +0,0 @@ public class TripWireBlock extends Block {
      }
  
@@ -164,7 +164,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class TripWireBlock extends Block {
  
      @Override
-     public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
+     protected void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent tripwires from detecting collision
          if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
          if (!world.isClientSide) {
@@ -172,7 +172,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class TripWireBlock extends Block {
  
      @Override
-     public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
+     protected void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
 +        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent tripwire pressed check
          if ((Boolean) world.getBlockState(pos).getValue(TripWireBlock.POWERED)) {
              this.checkPressed(world, pos);

patches/server/Allow-trident-custom-damage.patch

@@ -11,7 +11,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ThrownTrident extends AbstractArrow {
  
      public ThrownTrident(EntityType<? extends ThrownTrident> type, Level world) {
-         super(type, world, ThrownTrident.DEFAULT_ARROW_STACK);
+         super(type, world);
 +        this.setBaseDamage(net.minecraft.world.item.TridentItem.BASE_DAMAGE); // Paper - Allow trident custom damage
      }
  
@@ -28,5 +28,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        float f = 8.0F;
 +        float f = (float) this.getBaseDamage(); // Paper - Allow trident custom damage
  
-         if (entity instanceof LivingEntity) {
-             LivingEntity entityliving = (LivingEntity) entity;
+         if (entity instanceof LivingEntity entityliving) {
+             f += EnchantmentHelper.getDamageBonus(this.getPickupItemStackOrigin(), entityliving.getType());

patches/server/Bandaid-fix-for-Effect.patch

@@ -21,14 +21,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          case VILLAGER_PLANT_GROW:
              datavalue = (Integer) data;
              break;
-         case POTION_BREAK:
-+            if (data instanceof Potion) { // Paper - use Color for POTION_BREAK
-             datavalue = ((Potion) data).toDamageValue() & 0x3F;
-             break;
-+            } // Paper - Color will fall through to cast below
-         case INSTANT_POTION_BREAK:
-             datavalue = ((Color) data).asRGB();
-             break;
 @@ -0,0 +0,0 @@ public class CraftEffect {
              Preconditions.checkArgument(data == Material.AIR || ((Material) data).isRecord(), "Invalid record type for Material %s!", data);
              datavalue = Item.getId(CraftItemType.bukkitToMinecraft((Material) data));

patches/server/Cache-map-ids-on-item-frames.patch

@@ -12,9 +12,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  ItemStack itemstack = entityitemframe.getItem();
  
                  if (this.level.paperConfig().maps.itemFrameCursorUpdateInterval > 0 && this.tickCount % this.level.paperConfig().maps.itemFrameCursorUpdateInterval == 0 && itemstack.getItem() instanceof MapItem) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks // Paper - Make item frame map cursor update interval configurable
--                    Integer integer = MapItem.getMapId(itemstack);
+-                    MapId mapid = (MapId) itemstack.get(DataComponents.MAP_ID);
 +                    Integer integer = entityitemframe.cachedMapId; // Paper - Perf: Cache map ids on item frames
-                     MapItemSavedData worldmap = MapItem.getSavedData(integer, this.level);
+                     MapItemSavedData worldmap = MapItem.getSavedData(mapid, this.level);
  
                      if (worldmap != null) {
 diff --git a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java

patches/server/Configurable-Region-Compression-Format.patch

@@ -11,21 +11,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
      protected final RegionBitmap usedSectors;
  
-     public RegionFile(Path file, Path directory, boolean dsync) throws IOException {
--        this(file, directory, RegionFileVersion.VERSION_DEFLATE, dsync);
+     public RegionFile(RegionStorageInfo storageKey, Path directory, Path path, boolean dsync) throws IOException {
+-        this(storageKey, directory, path, RegionFileVersion.getSelected(), dsync);
 +        this(file, directory, RegionFileVersion.getCompressionFormat(), dsync); // Paper - Configurable region compression format
      }
  
-     public RegionFile(Path file, Path directory, RegionFileVersion outputChunkStreamVersion, boolean dsync) throws IOException {
+     public RegionFile(RegionStorageInfo storageKey, Path path, Path directory, RegionFileVersion compressionFormat, boolean dsync) throws IOException {
 diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java
 +++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java
 @@ -0,0 +0,0 @@ public class RegionFileVersion {
-         )
-     );
-     public static final RegionFileVersion VERSION_NONE = register(new RegionFileVersion(3, stream -> stream, stream -> stream));
-+
+     private final RegionFileVersion.StreamWrapper<InputStream> inputWrapper;
+     private final RegionFileVersion.StreamWrapper<OutputStream> outputWrapper;
+ 
 +    // Paper start - Configurable region compression format
 +    public static RegionFileVersion getCompressionFormat() {
 +        return switch (io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.compressionFormat) {
@@ -35,7 +34,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        };
 +    }
 +    // Paper end - Configurable region compression format
-+
-     private final int id;
-     private final RegionFileVersion.StreamWrapper<InputStream> inputWrapper;
-     private final RegionFileVersion.StreamWrapper<OutputStream> outputWrapper;
+     private RegionFileVersion(
+         int id,
+         @Nullable String name,

patches/server/Do-not-read-tile-entities-in-chunks-that-are-positio.patch

@@ -45,6 +45,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      } else {
 -                        BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound1);
 +                        // Paper - do not read tile entities positioned outside the chunk; move up
-                         BlockEntity tileentity = BlockEntity.loadStatic(blockposition, chunk.getBlockState(blockposition), nbttagcompound1);
+                         BlockEntity tileentity = BlockEntity.loadStatic(blockposition, chunk.getBlockState(blockposition), nbttagcompound1, world.registryAccess());
  
                          if (tileentity != null) {

patches/server/Don-t-load-chunks-for-supporting-block-checks.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
      }
  
      protected BlockPos getOnPos(float offset) {

patches/server/Expand-LingeringPotion-API.patch

@@ -9,11 +9,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/projectile/ThrownPotion.java
 +++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownPotion.java
 @@ -0,0 +0,0 @@ public class ThrownPotion extends ThrowableItemProjectile implements ItemSupplie
- 
+         boolean noEffects = potioncontents.hasEffects(); // Paper - Fix potions splash events
          // CraftBukkit start
          org.bukkit.event.entity.LingeringPotionSplashEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callLingeringPotionSplashEvent(this, position, entityareaeffectcloud);
--        if (!(event.isCancelled() || entityareaeffectcloud.isRemoved() || (noEffects && entityareaeffectcloud.effects.isEmpty() && entityareaeffectcloud.getPotion().getEffects().isEmpty()))) { // Paper - don't spawn area effect cloud if the effects were empty and not changed during the event handling
-+        if (!(event.isCancelled() || entityareaeffectcloud.isRemoved() || (!event.allowsEmptyCreation() && (noEffects && entityareaeffectcloud.effects.isEmpty() && entityareaeffectcloud.getPotion().getEffects().isEmpty())))) { // Paper - don't spawn area effect cloud if the effects were empty and not changed during the event handling
+-        if (!(event.isCancelled() || entityareaeffectcloud.isRemoved() || (noEffects && !entityareaeffectcloud.potionContents.hasEffects()))) { // Paper - don't spawn area effect cloud if the effects were empty and not changed during the event handling
++        if (!(event.isCancelled() || entityareaeffectcloud.isRemoved() || (!event.allowsEmptyCreation() && (noEffects && !entityareaeffectcloud.potionContents.hasEffects())))) { // Paper - don't spawn area effect cloud if the effects were empty and not changed during the event handling
              this.level().addFreshEntity(entityareaeffectcloud);
          } else {
              entityareaeffectcloud.discard(null); // CraftBukkit - add Bukkit remove cause

patches/server/Expand-Pose-API.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
      @javax.annotation.Nullable
      private UUID originWorld;
      public boolean freezeLocked = false; // Paper - Freeze Tick Lock API
@@ -16,7 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public void setOrigin(@javax.annotation.Nonnull Location location) {
          this.origin = location.toVector();
-@@ -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 onClientRemoval() {}
  
      public void setPose(net.minecraft.world.entity.Pose pose) {

patches/server/Expose-pre-collision-moving-velocity-to-VehicleBlock.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
      }
  
      public void move(MoverType movementType, Vec3 movement) {
@@ -17,7 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (this.noPhysics) {
              this.setPos(this.getX() + movement.x, this.getY() + movement.y, this.getZ() + movement.z);
          } else {
-@@ -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
                      }
  
                      if (!bl.getType().isAir()) {

patches/server/Fix-UnsafeValues-loadAdvancement.patch

@@ -10,7 +10,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
 @@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
          JsonElement jsonelement = ServerAdvancementManager.GSON.fromJson(advancement, JsonElement.class);
-         net.minecraft.advancements.Advancement nms = Util.getOrThrow(net.minecraft.advancements.Advancement.CODEC.parse(JsonOps.INSTANCE, jsonelement), JsonParseException::new);
+         net.minecraft.advancements.Advancement nms = net.minecraft.advancements.Advancement.CODEC.parse(JsonOps.INSTANCE, jsonelement).getOrThrow(JsonParseException::new);
          if (nms != null) {
 -            MinecraftServer.getServer().getAdvancements().advancements.put(minecraftkey, new AdvancementHolder(minecraftkey, nms));
 +            // Paper start - Fix throw UnsupportedOperationException

patches/server/Fix-advancement-triggers-for-entity-damage.patch

@@ -14,9 +14,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/Interaction.java
 +++ b/src/main/java/net/minecraft/world/entity/Interaction.java
 @@ -0,0 +0,0 @@ public class Interaction extends Entity implements Attackable, Targeting {
-             if (entityhuman instanceof ServerPlayer) {
-                 ServerPlayer entityplayer = (ServerPlayer) entityhuman;
- 
+             // CraftBukkit end
+             this.attack = new Interaction.PlayerAction(entityhuman.getUUID(), this.level().getGameTime());
+             if (entityhuman instanceof ServerPlayer entityplayer) {
 -                CriteriaTriggers.PLAYER_HURT_ENTITY.trigger(entityplayer, this, source, (float) event.getFinalDamage(), 1.0F, false); // CraftBukkit
 +                CriteriaTriggers.PLAYER_HURT_ENTITY.trigger(entityplayer, this, entityhuman.damageSources().generic(), 1.0F, (float) event.getFinalDamage(), false); // CraftBukkit // Paper - use correct source and fix taken/dealt param order
              }

patches/server/Fix-block-place-logic.patch

@@ -18,14 +18,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -                    // world.playSound(entityhuman, blockposition, this.getPlaceSound(iblockdata1), SoundCategory.BLOCKS, (soundeffecttype.getVolume() + 1.0F) / 2.0F, soundeffecttype.getPitch() * 0.8F);
 +                    if (entityhuman == null) world.playSound(entityhuman, blockposition, this.getPlaceSound(iblockdata1), net.minecraft.sounds.SoundSource.BLOCKS, (soundeffecttype.getVolume() + 1.0F) / 2.0F, soundeffecttype.getPitch() * 0.8F); // Paper - Fix block place logic; reintroduce this for the dispenser (i.e the shulker)
-                     world.gameEvent(GameEvent.BLOCK_PLACE, blockposition, GameEvent.Context.of(entityhuman, iblockdata1));
-                     if ((entityhuman == null || !entityhuman.getAbilities().instabuild) && itemstack != ItemStack.EMPTY) { // CraftBukkit
-                         itemstack.shrink(1);
+                     world.gameEvent((Holder) GameEvent.BLOCK_PLACE, blockposition, GameEvent.Context.of(entityhuman, iblockdata1));
+                     itemstack.consume(1, entityhuman);
+                     return InteractionResult.sidedSuccess(world.isClientSide);
 diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/item/ItemStack.java
 +++ b/src/main/java/net/minecraft/world/item/ItemStack.java
-@@ -0,0 +0,0 @@ public final class ItemStack {
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
                          if (tileentity instanceof JukeboxBlockEntity) {
                              JukeboxBlockEntity tileentityjukebox = (JukeboxBlockEntity) tileentity;
  

patches/server/Fix-demo-flag-not-enabling-demo-mode.patch

@@ -12,11 +12,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class Main {
  
                  /*
-                 dedicatedserver1.setPort((Integer) optionset.valueOf(optionspec10));
+                 dedicatedserver1.setPort((Integer) optionset.valueOf(optionspec11));
 -                dedicatedserver1.setDemo(optionset.has(optionspec2));
 +                */
-+                dedicatedserver1.setDemo(optionset.has("demo")); // Paper - Restore setting the demo mode
++                dedicatedserver1.setDemo(optionset.has("demo")); // Paper
 +                /*
-                 dedicatedserver1.setId((String) optionset.valueOf(optionspec11));
+                 dedicatedserver1.setId((String) optionset.valueOf(optionspec12));
                  */
-                 boolean flag1 = !optionset.has("nogui") && !optionset.nonOptionArguments().contains("nogui");
+                 boolean flag2 = !optionset.has("nogui") && !optionset.nonOptionArguments().contains("nogui");

patches/server/Fix-force-opening-enchantment-tables.patch

@@ -12,9 +12,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          // If there isn't an enchant table we can force create one, won't be very useful though.
          BlockPos pos = CraftLocation.toBlockPosition(location);
--        this.getHandle().openMenu(((EnchantmentTableBlock) Blocks.ENCHANTING_TABLE).getMenuProvider(null, this.getHandle().level(), pos));
+-        this.getHandle().openMenu(Blocks.ENCHANTING_TABLE.defaultBlockState().getMenuProvider(this.getHandle().level(), pos));
 +        // Paper start
-+        MenuProvider menuProvider = ((EnchantmentTableBlock) Blocks.ENCHANTING_TABLE).getMenuProvider(null, this.getHandle().level(), pos);
++        MenuProvider menuProvider = Blocks.ENCHANTING_TABLE.defaultBlockState().getMenuProvider(this.getHandle().level(), pos);
 +        if (menuProvider == null) {
 +            if (!force) {
 +                return null;

patches/server/Fix-inconsistencies-in-dispense-events-regarding-sta.patch

@@ -8,44 +8,6 @@ item which is being dispensed. Before this fix, sometimes it was the whole
 stack before a single item had been taken. This fixes that so the stack size
 is always 1.
 
-diff --git a/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java b/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java
-+++ b/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java
-@@ -0,0 +0,0 @@ public abstract class AbstractProjectileDispenseBehavior extends DefaultDispense
- 
-         // CraftBukkit start
-         // iprojectile.shoot((double) enumdirection.getStepX(), (double) ((float) enumdirection.getStepY() + 0.1F), (double) enumdirection.getStepZ(), this.getPower(), this.getUncertainty());
--        ItemStack itemstack1 = stack.split(1);
-+        ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
-         org.bukkit.block.Block block = CraftBlock.at(worldserver, pointer.pos());
-         CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
- 
-@@ -0,0 +0,0 @@ public abstract class AbstractProjectileDispenseBehavior extends DefaultDispense
-         }
- 
-         if (event.isCancelled()) {
--            stack.grow(1);
-+            // stack.grow(1); // Paper - shrink below
-             return stack;
-         }
- 
-+        boolean shrink = true; // Paper
-         if (!event.getItem().equals(craftItem)) {
--            stack.grow(1);
-+            shrink = false; // Paper - shrink below
-             // Chain to handler for new item
-             ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
-             DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
-@@ -0,0 +0,0 @@ public abstract class AbstractProjectileDispenseBehavior extends DefaultDispense
-         ((Entity) iprojectile).projectileSource = new org.bukkit.craftbukkit.projectiles.CraftBlockProjectileSource(pointer.blockEntity());
-         // CraftBukkit end
-         worldserver.addFreshEntity(iprojectile);
--        // itemstack.shrink(1); // CraftBukkit - Handled during event processing
-+        if (shrink) stack.shrink(1); // Paper - actually handle here
-         return stack;
-     }
- 
 diff --git a/src/main/java/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
@@ -121,7 +83,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -                // itemstack.shrink(1); // Handled during event processing
 +                if (shrink) stack.shrink(1); // Paper - actually handle here
                  // CraftBukkit end
-                 pointer.level().gameEvent((Entity) null, GameEvent.ENTITY_PLACE, pointer.pos());
+                 pointer.level().gameEvent((Entity) null, (Holder) GameEvent.ENTITY_PLACE, pointer.pos());
                  return stack;
 @@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
                  ServerLevel worldserver = pointer.level();
@@ -149,7 +111,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
                      DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
 @@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
-                 ArmorStand entityarmorstand = (ArmorStand) EntityType.ARMOR_STAND.spawn(worldserver, stack.getTag(), consumer, blockposition, MobSpawnType.DISPENSER, false, false);
+                 ArmorStand entityarmorstand = (ArmorStand) EntityType.ARMOR_STAND.spawn(worldserver, consumer, blockposition, MobSpawnType.DISPENSER, false, false);
  
                  if (entityarmorstand != null) {
 -                    // itemstack.shrink(1); // CraftBukkit - Handled during event processing
@@ -163,7 +125,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      // CraftBukkit start
 -                    ItemStack itemstack1 = stack.split(1);
 +                    ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
-                     Level world = pointer.level();
+                     ServerLevel world = pointer.level();
                      org.bukkit.block.Block block = CraftBlock.at(world, pointer.pos());
                      CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
 @@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
@@ -192,12 +154,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      return stack;
                  } else {
 @@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
-                 } while (!entityhorseabstract.isArmor(stack) || entityhorseabstract.isWearingArmor() || !entityhorseabstract.isTamed());
+                 } while (!entityhorseabstract.isBodyArmorItem(stack) || entityhorseabstract.isWearingBodyArmor() || !entityhorseabstract.isTamed());
  
                  // CraftBukkit start
 -                ItemStack itemstack1 = stack.split(1);
 +                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
-                 Level world = pointer.level();
+                 ServerLevel world = pointer.level();
                  org.bukkit.block.Block block = CraftBlock.at(world, pointer.pos());
                  CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
 @@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
@@ -221,7 +183,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
  
 +                if (shrink) stack.shrink(1); // Paper - shrink here
-                 entityhorseabstract.getSlot(401).set(CraftItemStack.asNMSCopy(event.getItem()));
+                 entityhorseabstract.setBodyArmorItem(CraftItemStack.asNMSCopy(event.getItem()));
                  // CraftBukkit end
                  this.setSuccess(true);
 @@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
@@ -230,7 +192,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  } while (!entityhorsechestedabstract.isTamed());
 -                ItemStack itemstack1 = stack.split(1);
 +                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below
-                 Level world = pointer.level();
+                 ServerLevel world = pointer.level();
                  org.bukkit.block.Block block = CraftBlock.at(world, pointer.pos());
                  CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
 @@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
@@ -256,74 +218,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  this.setSuccess(true);
                  return stack;
              }
-@@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
-                 Direction enumdirection = (Direction) pointer.state().getValue(DispenserBlock.FACING);
-                 // CraftBukkit start
-                 ServerLevel worldserver = pointer.level();
--                ItemStack itemstack1 = stack.split(1);
-+                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
-                 org.bukkit.block.Block block = CraftBlock.at(worldserver, pointer.pos());
-                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
- 
-@@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
-                 }
- 
-                 if (event.isCancelled()) {
--                    stack.grow(1);
-+                    // stack.grow(1); // Paper - shrink below
-                     return stack;
-                 }
- 
-+                boolean shrink = true; // Paper
-                 if (!event.getItem().equals(craftItem)) {
--                    stack.grow(1);
-+                    shrink = false; // Paper - shrink below
-                     // Chain to handler for new item
-                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
-                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
-@@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
- 
-                 entityfireworks.shoot((double) enumdirection.getStepX(), (double) enumdirection.getStepY(), (double) enumdirection.getStepZ(), 0.5F, 1.0F);
-                 pointer.level().addFreshEntity(entityfireworks);
--                // itemstack.shrink(1); // Handled during event processing
-+                if (shrink) stack.shrink(1); // Paper - actually handle here
-                 // CraftBukkit end
-                 return stack;
-             }
-@@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
-                 double d5 = randomsource.triangle((double) enumdirection.getStepZ(), 0.11485000000000001D);
- 
-                 // CraftBukkit start
--                ItemStack itemstack1 = stack.split(1);
-+                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
-                 org.bukkit.block.Block block = CraftBlock.at(worldserver, pointer.pos());
-                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
- 
-@@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
-                 }
- 
-                 if (event.isCancelled()) {
--                    stack.grow(1);
-+                    // stack.grow(1); // Paper - shrink at end
-                     return stack;
-                 }
- 
-+                boolean shrink = true; // Paper
-                 if (!event.getItem().equals(craftItem)) {
--                    stack.grow(1);
-+                    shrink = false; // Paper - shrink at end
-                     // Chain to handler for new item
-                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
-                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
-@@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
-                 entitysmallfireball.projectileSource = new org.bukkit.craftbukkit.projectiles.CraftBlockProjectileSource(pointer.blockEntity());
- 
-                 worldserver.addFreshEntity(entitysmallfireball);
--                // itemstack.shrink(1); // Handled during event processing
-+                if (shrink) stack.shrink(1); // Paper - actually handle here
-                 // CraftBukkit end
-                 return stack;
-             }
 @@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
                  if (willEmptyContentsSolidBucketItem || willEmptyBucketItem) {
                  // Paper end - correctly check if the bucket place will succeed
@@ -388,7 +282,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public interface DispenseItemBehavior {
                  worldserver.addFreshEntity(entitytntprimed);
                  worldserver.playSound((Player) null, entitytntprimed.getX(), entitytntprimed.getY(), entitytntprimed.getZ(), SoundEvents.TNT_PRIMED, SoundSource.BLOCKS, 1.0F, 1.0F);
-                 worldserver.gameEvent((Entity) null, GameEvent.ENTITY_PLACE, blockposition);
+                 worldserver.gameEvent((Entity) null, (Holder) GameEvent.ENTITY_PLACE, blockposition);
 -                // itemstack.shrink(1); // CraftBukkit - handled above
 +                if (shrink) stack.shrink(1); // Paper - actually handle here
                  return stack;
@@ -421,6 +315,44 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                  BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
                  if (!DispenserBlock.eventFired) {
+diff --git a/src/main/java/net/minecraft/core/dispenser/ProjectileDispenseBehavior.java b/src/main/java/net/minecraft/core/dispenser/ProjectileDispenseBehavior.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/core/dispenser/ProjectileDispenseBehavior.java
++++ b/src/main/java/net/minecraft/core/dispenser/ProjectileDispenseBehavior.java
+@@ -0,0 +0,0 @@ public class ProjectileDispenseBehavior extends DefaultDispenseItemBehavior {
+ 
+         // CraftBukkit start
+         // this.projectileItem.shoot(iprojectile, (double) enumdirection.getStepX(), (double) enumdirection.getStepY(), (double) enumdirection.getStepZ(), this.dispenseConfig.power(), this.dispenseConfig.uncertainty());
+-        ItemStack itemstack1 = stack.split(1);
++        ItemStack itemstack1 = stack.copyWithCount(1); // Paper
+         org.bukkit.block.Block block = CraftBlock.at(worldserver, pointer.pos());
+         CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -0,0 +0,0 @@ public class ProjectileDispenseBehavior extends DefaultDispenseItemBehavior {
+         }
+ 
+         if (event.isCancelled()) {
+-            stack.grow(1);
++            // stack.grow(1); // Paper - shrink below
+             return stack;
+         }
+ 
++        boolean shrink = true; // Paper
+         if (!event.getItem().equals(craftItem)) {
+-            stack.grow(1);
++            shrink = false; // Paper - shrink below
+             // Chain to handler for new item
+             ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+             DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -0,0 +0,0 @@ public class ProjectileDispenseBehavior extends DefaultDispenseItemBehavior {
+         ((Entity) iprojectile).projectileSource = new org.bukkit.craftbukkit.projectiles.CraftBlockProjectileSource(pointer.blockEntity());
+         // CraftBukkit end
+         worldserver.addFreshEntity(iprojectile);
+-        // itemstack.shrink(1); // CraftBukkit - Handled during event processing
++        if (shrink) stack.shrink(1); // Paper - actually handle here
+         return stack;
+     }
+ 
 diff --git a/src/main/java/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java

patches/server/Fix-incorrect-crafting-result-amount-for-fireworks.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class FireworkRocketRecipe extends CustomRecipe {
  
      @Override
-     public ItemStack getResultItem(RegistryAccess registryManager) {
+     public ItemStack getResultItem(HolderLookup.Provider registriesLookup) {
 -        return new ItemStack(Items.FIREWORK_ROCKET);
 +        return new ItemStack(Items.FIREWORK_ROCKET, 3); // Paper - Fix incorrect crafting result amount
      }

patches/server/Fix-inventory-desync.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 implements Targeting {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Targeti
              // CraftBukkit start - fire PlayerLeashEntityEvent
              if (CraftEventFactory.callPlayerLeashEntityEvent(this, player, player, hand).isCancelled()) {
                  ((ServerPlayer) player).connection.send(new ClientboundSetEntityLinkPacket(this, this.getLeashHolder()));

patches/server/Fix-missing-map-initialize-event-call.patch

@@ -13,9 +13,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
      @Nullable
      @Override
-     public MapItemSavedData getMapData(String id) {
+     public MapItemSavedData getMapData(MapId id) {
 -        // CraftBukkit start
--        MapItemSavedData worldmap = (MapItemSavedData) this.getServer().overworld().getDataStorage().get(MapItemSavedData.factory(), id);
+-        MapItemSavedData worldmap = (MapItemSavedData) this.getServer().overworld().getDataStorage().get(MapItemSavedData.factory(), id.key());
 -        if (worldmap != null) {
 -            worldmap.id = id;
 +        // Paper start - Call missing map initialize event and set id
@@ -23,8 +23,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +        final net.minecraft.world.level.saveddata.SavedData existing = storage.cache.get(id);
 +        if (existing == null && !storage.cache.containsKey(id)) {
-+            final net.minecraft.world.level.saveddata.SavedData.Factory<MapItemSavedData> factory = MapItemSavedData.factory();
-+            final MapItemSavedData map = storage.readSavedData(factory.deserializer(), factory.type(), id);
++            final MapItemSavedData worldmap = (MapItemSavedData) this.getServer().overworld().getDataStorage().get(MapItemSavedData.factory(), id.key());
 +            storage.cache.put(id, map);
 +            if (map != null) {
 +                map.id = id;

patches/server/Fix-rotation-when-spawning-display-entities.patch

@@ -10,7 +10,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
 @@ -0,0 +0,0 @@ public final class CraftEntityTypes {
          Vector direction = spawnData.location().getDirection().multiply(10);
-         entity.setDirection(direction.getX(), direction.getY(), direction.getZ());
+         entity.assignPower(direction.getX(), direction.getY(), direction.getZ());
      };
 +    private static final BiConsumer<SpawnData, net.minecraft.world.entity.Entity> ROT = (spawnData, entity) -> entity.setRot(spawnData.yaw(), spawnData.pitch()); // Paper
      private static final Map<Class<?>, EntityTypeData<?, ?>> CLASS_TYPE_DATA = new HashMap<>();
@@ -29,4 +29,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        register(new EntityTypeData<>(EntityType.TEXT_DISPLAY, TextDisplay.class, CraftTextDisplay::new, combine(createAndSetPos(net.minecraft.world.entity.EntityType.TEXT_DISPLAY), ROT))); // Paper
  
          // MISC
-         register(new EntityTypeData<>(EntityType.DROPPED_ITEM, Item.class, CraftItem::new, spawnData -> {
+         register(new EntityTypeData<>(EntityType.ITEM, Item.class, CraftItem::new, spawnData -> {

patches/server/Fix-silent-equipment-change-for-mobs.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 implements Targeting {
+@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Targeti
  
      @Override
      public void setItemSlot(EquipmentSlot slot, ItemStack stack) {
@@ -28,6 +28,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              case ARMOR:
 -                this.onEquipItem(slot, (ItemStack) this.armorItems.set(slot.getIndex(), stack), stack);
 +                this.onEquipItem(slot, (ItemStack) this.armorItems.set(slot.getIndex(), stack), stack, silent); // Paper - Fix silent equipment change
+                 break;
+             case BODY:
+                 ItemStack itemstack1 = this.bodyArmorItem;
+ 
+                 this.bodyArmorItem = stack;
+-                this.onEquipItem(slot, itemstack1, stack);
++                this.onEquipItem(slot, itemstack1, stack, silent); // Paper - Fix silent equipment change
          }
  
      }

patches/server/Fix-spigot-sound-playing-for-BlockItem-ItemStacks.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/ja
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/item/ItemStack.java
 +++ b/src/main/java/net/minecraft/world/item/ItemStack.java
-@@ -0,0 +0,0 @@ public final class ItemStack {
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
  
                      // SPIGOT-1288 - play sound stripped from ItemBlock
                      if (this.item instanceof BlockItem) {

patches/server/Flying-Fall-Damage.patch

@@ -9,8 +9,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/player/Player.java
 +++ b/src/main/java/net/minecraft/world/entity/player/Player.java
 @@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-     public FishingHook fishing;
-     public float hurtDir; // Paper - protected -> public
+     public Entity currentExplosionCause;
+     public boolean ignoreFallDamageFromCurrentImpulse;
      public boolean affectsSpawning = true; // Paper - Affects Spawning API
 +    public net.kyori.adventure.util.TriState flyingFallDamage = net.kyori.adventure.util.TriState.NOT_SET; // Paper - flying fall damage
  

patches/server/Folia-scheduler-and-owned-region-API.patch

@@ -1188,7 +1188,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 @org.jetbrains.annotations.Nullable net.minecraft.server.level.ChunkMap.TrackedEntity tracker; // Paper
      public CraftEntity getBukkitEntity() {
          if (this.bukkitEntity == null) {
@@ -1213,7 +1213,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public CommandSender getBukkitSender(CommandSourceStack wrapper) {
          return this.getBukkitEntity();
-@@ -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 final void setRemoved(Entity.RemovalReason entity_removalreason, EntityRemoveEvent.Cause cause) {
          CraftEventFactory.callEntityRemoveEvent(this, cause);
          // CraftBukkit end
@@ -1221,7 +1221,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (this.removalReason == null) {
              this.removalReason = entity_removalreason;
          }
-@@ -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
  
          this.getPassengers().forEach(Entity::stopRiding);
          this.levelCallback.onRemove(entity_removalreason);

patches/server/Implement-OfflinePlayer-isConnected.patch

@@ -39,4 +39,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
      @Override
      public InetSocketAddress getAddress() {
-         if (this.getHandle().connection == null) return null;
+         if (this.getHandle().connection.protocol() == null) return null;

patches/server/Implement-PlayerFailMoveEvent.patch

@@ -60,22 +60,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                              d8 = d2 - this.player.getZ();
                              d10 = d6 * d6 + d7 * d7 + d8 * d8;
--                            boolean flag2 = false;
+-                            boolean flag3 = false;
 +                            boolean movedWrongly = false; // Paper - Add fail move event; rename
  
                              if (!this.player.isChangingDimension() && d10 > org.spigotmc.SpigotConfig.movedWronglyThreshold && !this.player.isSleeping() && !this.player.gameMode.isCreative() && this.player.gameMode.getGameModeForPlayer() != GameType.SPECTATOR) { // Spigot
--                                flag2 = true;
+-                                flag3 = true;
 +                                // Paper start - Add fail move event
 +                                io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.MOVED_WRONGLY,
 +                                    toX, toY, toZ, toYaw, toPitch, true);
 +                                if (!event.isAllowed()) {
 +                                    movedWrongly = true;
 +                                    if (event.getLogWarning())
++                                // Paper end
                                  ServerGamePacketListenerImpl.LOGGER.warn("{} moved wrongly!", this.player.getName().getString());
-+                                }
++                                } // Paper
                              }
  
--                            if (!this.player.noPhysics && !this.player.isSleeping() && (flag2 && worldserver.noCollision(this.player, axisalignedbb) || this.isPlayerCollidingWithAnythingNew(worldserver, axisalignedbb, d0, d1, d2))) {
+-                            if (!this.player.noPhysics && !this.player.isSleeping() && (flag3 && worldserver.noCollision(this.player, axisalignedbb) || this.isPlayerCollidingWithAnythingNew(worldserver, axisalignedbb, d0, d1, d2))) {
++                            // Paper start - Add fail move event
 +                            boolean teleportBack = !this.player.noPhysics && !this.player.isSleeping() && (movedWrongly && worldserver.noCollision(this.player, axisalignedbb) || this.isPlayerCollidingWithAnythingNew(worldserver, axisalignedbb, d0, d1, d2));
 +                            if (teleportBack) {
 +                                io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.CLIPPED_INTO_BLOCK,
@@ -85,7 +87,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                                }
 +                            }
 +                            if (teleportBack) {
-+                                // Paper end - Add fail move event
++                            // Paper end - Add fail move event
                                  this.internalTeleport(d3, d4, d5, f, f1, Collections.emptySet()); // CraftBukkit - SPIGOT-1807: Don't call teleport event, when the client thinks the player is falling, because the chunks are not loaded on the client yet.
                                  this.player.doCheckFallDamage(this.player.getX() - d3, this.player.getY() - d4, this.player.getZ() - d5, packet.isOnGround());
                              } else {

patches/server/Improve-PortalEvents.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
          Location enter = bukkitEntity.getLocation();
          Location exit = CraftLocation.toBukkit(exitPosition, exitWorldServer.getWorld());
  

patches/server/Improve-logging-and-errors.patch

@@ -86,10 +86,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java
 +++ b/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java
 @@ -0,0 +0,0 @@ public class RecipeManager extends SimpleJsonResourceReloadListener {
-             return entry1.getValue(); // CraftBukkit // Paper - decompile fix - *shrugs internally* // todo: is this needed anymore?
-         }));
-         this.byName = Maps.newHashMap(builder.build()); // CraftBukkit
--        RecipeManager.LOGGER.info("Loaded {} recipes", map1.size());
+         this.byType = LinkedHashMultimap.create(builder.build());
+         this.byName = Maps.newHashMap(com_google_common_collect_immutablemap_builder.build());
+         // CraftBukkit end
+-        RecipeManager.LOGGER.info("Loaded {} recipes", this.byType.size());
 +        RecipeManager.LOGGER.info("Loaded {} recipes", this.byName.size()); // Paper - Improve logging and errors; log correct number of recipes
      }