400

patches/server/Add-PlayerRecipeBookClickEvent.patch

@@ -0,0 +1,65 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Josh Roy <10731363+JRoy@users.noreply.github.com>
+Date: Fri, 5 Jun 2020 18:24:06 -0400
+Subject: [PATCH] Add PlayerRecipeBookClickEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -0,0 +0,0 @@ import net.minecraft.world.phys.Vec3;
+ import net.minecraft.world.phys.shapes.BooleanOp;
+ import net.minecraft.world.phys.shapes.Shapes;
+ import net.minecraft.world.phys.shapes.VoxelShape;
++import org.bukkit.NamespacedKey;
+ import org.slf4j.Logger;
+ 
+ // CraftBukkit start
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                                 ServerGamePacketListenerImpl.LOGGER.debug("Player {} tried to place impossible recipe {}", this.player, recipeholder.id().location());
+                                 return;
+                             }
++                            // Paper start - Add PlayerRecipeBookClickEvent
++                            NamespacedKey recipeName = org.bukkit.craftbukkit.util.CraftNamespacedKey.fromMinecraft(recipeholder.id().location());
++                            boolean makeAll = packet.useMaxItems();
++                            com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent paperEvent = new com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent(
++                                this.player.getBukkitEntity(), recipeName, makeAll
++                            );
++                            if (!paperEvent.callEvent()) {
++                                return;
++                            }
++                            recipeName = paperEvent.getRecipe();
++                            makeAll = paperEvent.isMakeAll();
++                            if (org.bukkit.event.player.PlayerRecipeBookClickEvent.getHandlerList().getRegisteredListeners().length > 0) {
++                            // Paper end - Add PlayerRecipeBookClickEvent
+ 
+                             // CraftBukkit start - implement PlayerRecipeBookClickEvent
+-                            org.bukkit.inventory.Recipe recipe = recipeholder.toBukkitRecipe();
++                            org.bukkit.inventory.Recipe recipe = this.cserver.getRecipe(recipeName); // Paper - Add PlayerRecipeBookClickEvent - forward to legacy event
+                             if (recipe == null) {
+                                 return;
+                             }
+-                            org.bukkit.event.player.PlayerRecipeBookClickEvent event = CraftEventFactory.callRecipeBookClickEvent(this.player, recipe, packet.useMaxItems());
++                            // Paper start - Add PlayerRecipeBookClickEvent - forward to legacy event
++                            org.bukkit.event.player.PlayerRecipeBookClickEvent event = CraftEventFactory.callRecipeBookClickEvent(this.player, recipe, makeAll);
++                            recipeName = ((org.bukkit.Keyed) event.getRecipe()).getKey();
++                            makeAll = event.isShiftClick();
++                            }
++                            if (!(this.player.containerMenu instanceof RecipeBookMenu)) {
++                                return;
++                            }
++                            // Paper end - Add PlayerRecipeBookClickEvent - forward to legacy event
+ 
+                             // Cast to keyed should be safe as the recipe will never be a MerchantRecipe.
+-                            recipeholder = this.server.getRecipeManager().byKey(CraftRecipe.toMinecraft(((org.bukkit.Keyed) event.getRecipe()).getKey())).orElse(null);
++                            recipeholder = this.server.getRecipeManager().byKey(net.minecraft.resources.ResourceKey.create(net.minecraft.core.registries.Registries.RECIPE, org.bukkit.craftbukkit.util.CraftNamespacedKey.toMinecraft(recipeName))).orElse(null); // Paper - Add PlayerRecipeBookClickEvent - forward to legacy event
+                             if (recipeholder == null) {
+                                 return;
+                             }
+-
+-                            RecipeBookMenu.PostPlaceAction containerrecipebook_a = containerrecipebook.handlePlacement(event.isShiftClick(), this.player.isCreative(), recipeholder, this.player.serverLevel(), this.player.getInventory());
++                            RecipeBookMenu.PostPlaceAction containerrecipebook_a = containerrecipebook.handlePlacement(makeAll, this.player.isCreative(), recipeholder, this.player.serverLevel(), this.player.getInventory());
+                             // CraftBukkit end
+ 
+                             if (containerrecipebook_a == RecipeBookMenu.PostPlaceAction.PLACE_GHOST_RECIPE) {

patches/server/Add-PrepareResultEvent.patch

@@ -74,7 +74,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/inventory/SmithingMenu.java
 +++ b/src/main/java/net/minecraft/world/inventory/SmithingMenu.java
 @@ -0,0 +0,0 @@ public class SmithingMenu extends ItemCombinerMenu {
-             }
+             this.hasRecipeError.set(flag ? 1 : 0);
          }
  
 +        org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareResultEvent(this, RESULT_SLOT); // Paper - Add PrepareResultEvent
@@ -86,18 +86,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/inventory/StonecutterMenu.java
 +++ b/src/main/java/net/minecraft/world/inventory/StonecutterMenu.java
 @@ -0,0 +0,0 @@ public class StonecutterMenu extends AbstractContainerMenu {
-             this.setupRecipeList(inventory, itemstack);
+             this.setupRecipeList(itemstack);
          }
  
 +        org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareResultEvent(this, RESULT_SLOT); // Paper - Add PrepareResultEvent
      }
  
-     private static SingleRecipeInput createRecipeInput(Container inventory) {
+     private void setupRecipeList(ItemStack stack) {
 diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- 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 {
+@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable
      }
  
      public static PrepareAnvilEvent callPrepareAnvilEvent(AnvilView view, ItemStack item) {
@@ -110,7 +110,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          PrepareAnvilEvent event = new PrepareAnvilEvent(view, CraftItemStack.asCraftMirror(item).clone());
          event.getView().getPlayer().getServer().getPluginManager().callEvent(event);
          event.getInventory().setItem(2, event.getResult());
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
+@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable
      }
  
      public static PrepareGrindstoneEvent callPrepareGrindstoneEvent(InventoryView view, ItemStack item) {
@@ -123,7 +123,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          PrepareGrindstoneEvent event = new PrepareGrindstoneEvent(view, CraftItemStack.asCraftMirror(item).clone());
          event.getView().getPlayer().getServer().getPluginManager().callEvent(event);
          event.getInventory().setItem(2, event.getResult());
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
+@@ -0,0 +0,0 @@ populateFields(victim, event); // Paper - make cancellable
      }
  
      public static PrepareSmithingEvent callPrepareSmithingEvent(InventoryView view, ItemStack item) {

patches/server/Add-permission-for-command-blocks.patch

@@ -63,7 +63,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        if (tileentity instanceof CommandBlockEntity && player.canUseGameMasterBlocks()) {
 +        if (tileentity instanceof CommandBlockEntity && (player.canUseGameMasterBlocks() || (player.isCreative() && player.getBukkitEntity().hasPermission("minecraft.commandblock")))) { // Paper - command block permission
              player.openCommandBlock((CommandBlockEntity) tileentity);
-             return InteractionResult.sidedSuccess(world.isClientSide);
+             return InteractionResult.SUCCESS;
          } else {
 diff --git a/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java b/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/server/Cache-block-data-strings.patch

@@ -9,9 +9,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.getPlayerList().reloadResources();
              this.functionManager.replaceLibrary(this.resources.managers.getFunctionLibrary());
              this.structureTemplateManager.onResourceManagerReload(this.resources.resourceManager);
+             this.fuelValues = FuelValues.vanillaBurnTimes(this.registries.compositeAccess(), this.worldData.enabledFeatures());
 +            org.bukkit.craftbukkit.block.data.CraftBlockData.reloadCache(); // Paper - cache block data strings; they can be defined by datapacks so refresh it here
          }, this);
  

patches/server/Do-not-let-the-server-load-chunks-from-newer-version.patch

@@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <1254957+zachbr@users.noreply.github.com>
+Date: Tue, 23 Jul 2019 20:44:47 -0500
+Subject: [PATCH] Do not let the server load chunks from newer versions
+
+If the server attempts to load a chunk generated by a newer version of
+the game, immediately stop the server to prevent data corruption.
+
+You can override this functionality at your own peril.
+
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java b/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java
++++ b/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java
+@@ -0,0 +0,0 @@ public record SerializableChunkData(Registry<Biome> biomeRegistry, ChunkPos chun
+     }
+     // Paper end - guard against serializing mismatching coordinates
+ 
++    // Paper start - Do not let the server load chunks from newer versions
++    private static final int CURRENT_DATA_VERSION = net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion();
++    private static final boolean JUST_CORRUPT_IT = Boolean.getBoolean("Paper.ignoreWorldDataVersion");
++    // Paper end - Do not let the server load chunks from newer versions
++
+     @Nullable
+     public static SerializableChunkData parse(LevelHeightAccessor world, RegistryAccess registryManager, CompoundTag nbt) {
+         if (!nbt.contains("Status", 8)) {
+             return null;
+         } else {
++            // Paper start - Do not let the server load chunks from newer versions
++            if (nbt.contains("DataVersion", net.minecraft.nbt.Tag.TAG_ANY_NUMERIC)) {
++                final int dataVersion = nbt.getInt("DataVersion");
++                if (!JUST_CORRUPT_IT && dataVersion > CURRENT_DATA_VERSION) {
++                    new RuntimeException("Server attempted to load chunk saved with newer version of minecraft! " + dataVersion + " > " + CURRENT_DATA_VERSION).printStackTrace();
++                    System.exit(1);
++                }
++            }
++            // Paper end - Do not let the server load chunks from newer versions
+             ChunkPos chunkcoordintpair = new ChunkPos(nbt.getInt("xPos"), nbt.getInt("zPos")); // Paper - guard against serializing mismatching coordinates; diff on change, see ChunkSerializer#getChunkCoordinate
+             long i = nbt.getLong("LastUpdate");
+             long j = nbt.getLong("InhabitedTime");

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

@@ -21,15 +21,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.lastGoodX = this.awaitingPositionFromClient.x;
              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.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));
-     }
- 
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
@@ -63,11 +54,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class DragonStrafePlayerPhase extends AbstractDragonPhaseInstance {
                          }
  
-                         DragonFireball dragonFireball = new DragonFireball(this.dragon.level(), this.dragon, vec34.normalize());
+                         DragonFireball dragonFireball = new DragonFireball(world, this.dragon, vec34.normalize());
 +                        dragonFireball.preserveMotion = true; // Paper - Fix Entity Teleportation and cancel velocity if teleported
                          dragonFireball.moveTo(o, p, q, 0.0F, 0.0F);
                          if (new com.destroystokyo.paper.event.entity.EnderDragonShootFireballEvent((org.bukkit.entity.EnderDragon) dragon.getBukkitEntity(), (org.bukkit.entity.DragonFireball) dragonFireball.getBukkitEntity()).callEvent()) // Paper - EnderDragon Events
-                         this.dragon.level().addFreshEntity(dragonFireball);
+                         world.addFreshEntity(dragonFireball);
 diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/BaseSpawner.java

patches/server/Fix-Per-World-Difficulty-Remembering-Difficulty.patch

@@ -15,8 +15,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          worldloadlistener.stop();
          // CraftBukkit start
          // this.updateMobSpawningFlags();
--        worldserver.setSpawnSettings(this.isSpawningMonsters(), this.isSpawningAnimals());
-+        worldserver.setSpawnSettings(worldserver.serverLevelData.getDifficulty() != Difficulty.PEACEFUL && ((DedicatedServer) this).settings.getProperties().spawnMonsters, this.isSpawningAnimals()); // Paper - per level difficulty (from setDifficulty(ServerLevel, Difficulty, boolean))
+-        worldserver.setSpawnSettings(this.isSpawningMonsters());
++        worldserver.setSpawnSettings(worldserver.serverLevelData.getDifficulty() != Difficulty.PEACEFUL && ((DedicatedServer) this).settings.getProperties().spawnMonsters); // Paper - per level difficulty (from setDifficulty(ServerLevel, Difficulty, boolean))
  
          this.forceTicks = false;
          // CraftBukkit end
@@ -44,8 +44,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          while (iterator.hasNext()) {
              ServerLevel worldserver = (ServerLevel) iterator.next();
  
--            worldserver.setSpawnSettings(this.isSpawningMonsters(), this.isSpawningAnimals());
-+            worldserver.setSpawnSettings(worldserver.serverLevelData.getDifficulty() != Difficulty.PEACEFUL && ((DedicatedServer) this).settings.getProperties().spawnMonsters, this.isSpawningAnimals()); // Paper - per level difficulty (from setDifficulty(ServerLevel, Difficulty, boolean))
+-            worldserver.setSpawnSettings(this.isSpawningMonsters());
++            worldserver.setSpawnSettings(worldserver.serverLevelData.getDifficulty() != Difficulty.PEACEFUL && ((DedicatedServer) this).settings.getProperties().spawnMonsters); // Paper - per level difficulty (from setDifficulty(ServerLevel, Difficulty, boolean))
          }
  
      }
@@ -97,9 +97,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.console.paperConfigurations.reloadConfigs(this.console);
          for (ServerLevel world : this.console.getAllLevels()) {
 -            world.serverLevelData.setDifficulty(config.difficulty);
--            world.setSpawnSettings(config.spawnMonsters, config.spawnAnimals);
+-            world.setSpawnSettings(config.spawnMonsters);
 +            // world.serverLevelData.setDifficulty(config.difficulty); // Paper - per level difficulty
-+            world.setSpawnSettings(world.serverLevelData.getDifficulty() != Difficulty.PEACEFUL && config.spawnMonsters, config.spawnAnimals); // Paper - per level difficulty (from MinecraftServer#setDifficulty(ServerLevel, Difficulty, boolean))
++            world.setSpawnSettings(world.serverLevelData.getDifficulty() != Difficulty.PEACEFUL && config.spawnMonsters); // Paper - per level difficulty (from MinecraftServer#setDifficulty(ServerLevel, Difficulty, boolean))
  
              for (SpawnCategory spawnCategory : SpawnCategory.values()) {
                  if (CraftSpawnCategory.isValidForLimits(spawnCategory)) {

patches/server/Fix-SpawnChangeEvent-not-firing-for-all-use-cases.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/mai
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
+@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
          float f1 = this.levelData.getSpawnAngle();
  
          if (!blockposition1.equals(pos) || f1 != angle) {

patches/server/Fix-arrows-never-despawning-MC-125757.patch

@@ -13,8 +13,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
 +++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
 @@ -0,0 +0,0 @@ public abstract class AbstractArrow extends Projectile {
+             }
  
-             ++this.inGroundTime;
          } else {
 +            if (tickCount > 200) this.tickDespawn(); // Paper - tick despawnCounter regardless after 10 seconds
              this.inGroundTime = 0;

patches/server/Fix-some-rails-connecting-improperly.patch

@@ -11,7 +11,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public abstract class BaseRailBlock extends Block implements SimpleWaterloggedBl
          state = this.updateDir(world, pos, state, true);
          if (this.isStraight) {
-             world.neighborChanged(state, pos, this, pos, notify);
+             world.neighborChanged(state, pos, this, null, notify);
 +            state = world.getBlockState(pos); // Paper - Fix some rails connecting improperly
          }
  

patches/server/Improve-fix-EntityTargetLivingEntityEvent.patch

@@ -9,7 +9,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/ai/behavior/StopAttackingIfTargetInvalid.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/behavior/StopAttackingIfTargetInvalid.java
 @@ -0,0 +0,0 @@ public class StopAttackingIfTargetInvalid {
-                     if (entityinsentient.canAttack(entityliving) && (!shouldForgetIfTargetUnreachable || !StopAttackingIfTargetInvalid.isTiredOfTryingToReachTarget(entityinsentient, behaviorbuilder_b.tryGet(memoryaccessor1))) && entityliving.isAlive() && entityliving.level() == entityinsentient.level() && !alternativeCondition.test(entityliving)) {
+                     if (entityinsentient.canAttack(entityliving) && (!shouldForgetIfTargetUnreachable || !StopAttackingIfTargetInvalid.isTiredOfTryingToReachTarget(entityinsentient, behaviorbuilder_b.tryGet(memoryaccessor1))) && entityliving.isAlive() && entityliving.level() == entityinsentient.level() && !condition.test(worldserver, entityliving)) {
                          return true;
                      } else {
 +                        // Paper start - better track target change reason

patches/server/Prevent-headless-pistons-from-being-created.patch

@@ -5,11 +5,11 @@ Subject: [PATCH] Prevent headless pistons from being created
 
 Prevent headless pistons from being created by explosions or tree/mushroom growth.
 
-diff --git a/src/main/java/net/minecraft/world/level/Explosion.java b/src/main/java/net/minecraft/world/level/Explosion.java
+diff --git a/src/main/java/net/minecraft/world/level/ServerExplosion.java b/src/main/java/net/minecraft/world/level/ServerExplosion.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/Explosion.java
-+++ b/src/main/java/net/minecraft/world/level/Explosion.java
-@@ -0,0 +0,0 @@ public class Explosion {
+--- a/src/main/java/net/minecraft/world/level/ServerExplosion.java
++++ b/src/main/java/net/minecraft/world/level/ServerExplosion.java
+@@ -0,0 +0,0 @@ public class ServerExplosion implements Explosion {
  
                              if (f > 0.0F && this.damageCalculator.shouldBlockExplode(this, this.level, blockposition, iblockdata, f)) {
                                  set.add(blockposition);

patches/unapplied/server/Add-PlayerRecipeBookClickEvent.patch

@@ -1,55 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Fri, 5 Jun 2020 18:24:06 -0400
-Subject: [PATCH] Add PlayerRecipeBookClickEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-             if (!this.player.containerMenu.stillValid(this.player)) {
-                 ServerGamePacketListenerImpl.LOGGER.debug("Player {} interacted with invalid menu {}", this.player, this.player.containerMenu);
-             } else {
-+                // Paper start - Add PlayerRecipeBookClickEvent
-+                ResourceLocation recipeName = packet.getRecipe();
-+                boolean makeAll = packet.isShiftDown();
-+                com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent paperEvent = new com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent(
-+                    this.player.getBukkitEntity(), org.bukkit.craftbukkit.util.CraftNamespacedKey.fromMinecraft(recipeName), makeAll
-+                );
-+                if (!paperEvent.callEvent()) {
-+                    return;
-+                }
-+                recipeName = CraftNamespacedKey.toMinecraft(paperEvent.getRecipe());
-+                makeAll = paperEvent.isMakeAll();
-+                if (org.bukkit.event.player.PlayerRecipeBookClickEvent.getHandlerList().getRegisteredListeners().length > 0) {
-+                // Paper end - Add PlayerRecipeBookClickEvent
-                 // CraftBukkit start - implement PlayerRecipeBookClickEvent
--                org.bukkit.inventory.Recipe recipe = this.cserver.getRecipe(CraftNamespacedKey.fromMinecraft(packet.getRecipe()));
-+                org.bukkit.inventory.Recipe recipe = this.cserver.getRecipe(CraftNamespacedKey.fromMinecraft(recipeName)); // Paper
-                 if (recipe == null) {
-                     return;
-                 }
--                org.bukkit.event.player.PlayerRecipeBookClickEvent event = CraftEventFactory.callRecipeBookClickEvent(this.player, recipe, packet.isShiftDown());
-+                // Paper start - Add PlayerRecipeBookClickEvent
-+                org.bukkit.event.player.PlayerRecipeBookClickEvent event = CraftEventFactory.callRecipeBookClickEvent(this.player, recipe, makeAll);
-+                recipeName = CraftNamespacedKey.toMinecraft(((org.bukkit.Keyed) event.getRecipe()).getKey());
-+                makeAll = event.isShiftClick();
-+                }
-+                if (!(this.player.containerMenu instanceof RecipeBookMenu<?, ?> recipeBookMenu)) {
-+                    return;
-+                }
-+                // Paper end - Add PlayerRecipeBookClickEvent
- 
-                 // Cast to keyed should be safe as the recipe will never be a MerchantRecipe.
--                this.server.getRecipeManager().byKey(CraftNamespacedKey.toMinecraft(((org.bukkit.Keyed) event.getRecipe()).getKey())).ifPresent((recipeholder) -> {
--                    ((RecipeBookMenu) this.player.containerMenu).handlePlacement(event.isShiftClick(), recipeholder, this.player);
-+                // Paper start - Add PlayerRecipeBookClickEvent
-+                final boolean finalMakeAll = makeAll;
-+                this.server.getRecipeManager().byKey(recipeName).ifPresent((recipeholder) -> {
-+                    recipeBookMenu.handlePlacement(finalMakeAll, recipeholder, this.player);
-+                    // Paper end - Add PlayerRecipeBookClickEvent
-                 });
-                 // CraftBukkit end
-             }

patches/unapplied/server/Do-not-let-the-server-load-chunks-from-newer-version.patch

@@ -1,41 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Tue, 23 Jul 2019 20:44:47 -0500
-Subject: [PATCH] Do not let the server load chunks from newer versions
-
-If the server attempts to load a chunk generated by a newer version of
-the game, immediately stop the server to prevent data corruption.
-
-You can override this functionality at your own peril.
-
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
-@@ -0,0 +0,0 @@ public class ChunkSerializer {
-     public static final String BLOCK_LIGHT_TAG = "BlockLight";
-     public static final String SKY_LIGHT_TAG = "SkyLight";
- 
-+    // Paper start - Do not let the server load chunks from newer versions
-+    private static final int CURRENT_DATA_VERSION = net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion();
-+    private static final boolean JUST_CORRUPT_IT = Boolean.getBoolean("Paper.ignoreWorldDataVersion");
-+    // Paper end - Do not let the server load chunks from newer versions
-     public ChunkSerializer() {}
- 
-     // Paper start - guard against serializing mismatching coordinates
-@@ -0,0 +0,0 @@ public class ChunkSerializer {
-     // Paper end - guard against serializing mismatching coordinates
- 
-     public static ProtoChunk read(ServerLevel world, PoiManager poiStorage, RegionStorageInfo key, ChunkPos chunkPos, CompoundTag nbt) {
-+        // Paper start - Do not let the server load chunks from newer versions
-+        if (nbt.contains("DataVersion", net.minecraft.nbt.Tag.TAG_ANY_NUMERIC)) {
-+            final int dataVersion = nbt.getInt("DataVersion");
-+            if (!JUST_CORRUPT_IT && dataVersion > CURRENT_DATA_VERSION) {
-+                new RuntimeException("Server attempted to load chunk saved with newer version of minecraft! " + dataVersion + " > " + CURRENT_DATA_VERSION).printStackTrace();
-+                System.exit(1);
-+            }
-+        }
-+        // Paper end - Do not let the server load chunks from newer versions
-         ChunkPos chunkcoordintpair1 = new ChunkPos(nbt.getInt("xPos"), nbt.getInt("zPos")); // Paper - guard against serializing mismatching coordinates; diff on change, see ChunkSerializer#getChunkCoordinate
- 
-         if (!Objects.equals(chunkPos, chunkcoordintpair1)) {