Patches!!! MORE

2023-12-06 11:21:56 -05:00 · 2023-12-06 11:21:56 -05:00 · cd61b5d98e
commit cd61b5d98e
parent 6bf2ebf200
147 changed files with 520 additions and 541 deletions
--- a/patches/server/0800-Add-EntityDyeEvent-and-CollarColorable-interface.patch
+++ b/patches/server/0800-Add-EntityDyeEvent-and-CollarColorable-interface.patch
@ -0,0 +1,43 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 18 Mar 2022 21:15:55 -0700
+Subject: [PATCH] Add EntityDyeEvent and CollarColorable interface
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Cat.java b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+index a744cb70ac719eae376fb2ab2271e4f8ac7b12f2..40af8405c6f3ecc5a8168bb62607eb79862cefa6 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+@@ -402,6 +402,13 @@ public class Cat extends TamableAnimal implements VariantHolder<CatVariant> {
+                     DyeColor enumcolor = ((DyeItem) item).getDyeColor();
+ 
+                     if (enumcolor != this.getCollarColor()) {
+                        // Paper start
+                        final io.papermc.paper.event.entity.EntityDyeEvent event = new io.papermc.paper.event.entity.EntityDyeEvent(this.getBukkitEntity(), org.bukkit.DyeColor.getByWoolData((byte) enumcolor.getId()), ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity());
+                        if (!event.callEvent()) {
+                            return InteractionResult.FAIL;
+                        }
+                        enumcolor = DyeColor.byId(event.getColor().getWoolData());
+                        // Paper end
+                         this.setCollarColor(enumcolor);
+                         if (!player.getAbilities().instabuild) {
+                             itemstack.shrink(1);
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Wolf.java b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+index 9ebb994b62b58352525da21385f02803e8414687..eecb7511582e5e316b71fa4a4734881424be5ca7 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+@@ -369,6 +369,14 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+                         DyeColor enumcolor = itemdye.getDyeColor();
+ 
+                         if (enumcolor != this.getCollarColor()) {
+                            // Paper start
+                            final io.papermc.paper.event.entity.EntityDyeEvent event = new io.papermc.paper.event.entity.EntityDyeEvent(this.getBukkitEntity(), org.bukkit.DyeColor.getByWoolData((byte) enumcolor.getId()), ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity());
+                            if (!event.callEvent()) {
+                                return InteractionResult.FAIL;
+                            }
+                            enumcolor = DyeColor.byId(event.getColor().getWoolData());
+                            // Paper end
+
+                             this.setCollarColor(enumcolor);
+                             if (!player.getAbilities().instabuild) {
+                                 itemstack.shrink(1);
--- a/patches/server/0801-Fire-CauldronLevelChange-on-initial-fill.patch
+++ b/patches/server/0801-Fire-CauldronLevelChange-on-initial-fill.patch
@ -0,0 +1,83 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Tue, 29 Mar 2022 13:46:23 -0700
+Subject: [PATCH] Fire CauldronLevelChange on initial fill
+
+Also don't fire level events or game events if stalactite
+drip is cancelled
+
+diff --git a/src/main/java/net/minecraft/world/level/block/CauldronBlock.java b/src/main/java/net/minecraft/world/level/block/CauldronBlock.java
+index 588b3e911d9b22dad2928ea9e32e8a8a3a8e9b96..a821a981adbebdcf22997731b9bbea3d033cd2b1 100644
+--- a/src/main/java/net/minecraft/world/level/block/CauldronBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/CauldronBlock.java
+@@ -43,10 +43,18 @@ public class CauldronBlock extends AbstractCauldronBlock {
+     public void handlePrecipitation(BlockState state, Level world, BlockPos pos, Biome.Precipitation precipitation) {
+         if (CauldronBlock.shouldHandlePrecipitation(world, precipitation)) {
+             if (precipitation == Biome.Precipitation.RAIN) {
+-                world.setBlockAndUpdate(pos, Blocks.WATER_CAULDRON.defaultBlockState());
+                // Paper start - call event for initial fill
+                if (!LayeredCauldronBlock.changeLevel(state, world, pos, Blocks.WATER_CAULDRON.defaultBlockState(), null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL, false)) { // avoid duplicate game event
+                    return;
+                }
+                // Paper end
+                 world.gameEvent((Entity) null, GameEvent.BLOCK_CHANGE, pos);
+             } else if (precipitation == Biome.Precipitation.SNOW) {
+-                world.setBlockAndUpdate(pos, Blocks.POWDER_SNOW_CAULDRON.defaultBlockState());
+                // Paper start - call event for initial fill
+                if (!LayeredCauldronBlock.changeLevel(state, world, pos, Blocks.POWDER_SNOW_CAULDRON.defaultBlockState(), null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL, false)) { // avoid duplicate game event
+                    return;
+                }
+                // Paper end
+                 world.gameEvent((Entity) null, GameEvent.BLOCK_CHANGE, pos);
+             }
+ 
+@@ -64,11 +72,19 @@ public class CauldronBlock extends AbstractCauldronBlock {
+ 
+         if (fluid == Fluids.WATER) {
+             iblockdata1 = Blocks.WATER_CAULDRON.defaultBlockState();
+-            LayeredCauldronBlock.changeLevel(state, world, pos, iblockdata1, null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL); // CraftBukkit
+            // Paper start - don't send level event or game event if cancelled
+            if (!LayeredCauldronBlock.changeLevel(state, world, pos, iblockdata1, null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL)) { // CraftBukkit
+                return;
+            }
+            // Paper end
+             world.levelEvent(1047, pos, 0);
+         } else if (fluid == Fluids.LAVA) {
+             iblockdata1 = Blocks.LAVA_CAULDRON.defaultBlockState();
+-            LayeredCauldronBlock.changeLevel(state, world, pos, iblockdata1, null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL); // CraftBukkit
+            // Paper start - don't send level event or game event if cancelled
+            if (!LayeredCauldronBlock.changeLevel(state, world, pos, iblockdata1, null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL)) { // CraftBukkit
+                return;
+            }
+            // Paper end
+             world.levelEvent(1046, pos, 0);
+         }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java b/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+index a8b2c49ebf531d730d681ca3bceb4dc74b433fdb..7daf2ec30fd31023d326a6149661f38bfc1d646b 100644
+--- a/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+@@ -101,7 +101,13 @@ public class LayeredCauldronBlock extends AbstractCauldronBlock {
+     }
+ 
+     // CraftBukkit start
+-    public static boolean changeLevel(BlockState iblockdata, Level world, BlockPos blockposition, BlockState newBlock, Entity entity, CauldronLevelChangeEvent.ChangeReason reason) {
+    // Paper start
+    public static boolean changeLevel(BlockState iblockdata, Level world, BlockPos blockposition, BlockState newBlock, @javax.annotation.Nullable Entity entity, CauldronLevelChangeEvent.ChangeReason reason) { // Paper - entity is nullable
+        return changeLevel(iblockdata, world, blockposition, newBlock, entity, reason, true);
+    }
+
+    public static boolean changeLevel(BlockState iblockdata, Level world, BlockPos blockposition, BlockState newBlock, @javax.annotation.Nullable Entity entity, CauldronLevelChangeEvent.ChangeReason reason, boolean sendGameEvent) { // Paper - entity is nullable
+    // Paper end
+         CraftBlockState newState = CraftBlockStates.getBlockState(world, blockposition);
+         newState.setData(newBlock);
+ 
+@@ -114,7 +120,7 @@ public class LayeredCauldronBlock extends AbstractCauldronBlock {
+             return false;
+         }
+         newState.update(true);
+-        world.gameEvent(GameEvent.BLOCK_CHANGE, blockposition, GameEvent.Context.of(newBlock));
+        if (sendGameEvent) world.gameEvent(GameEvent.BLOCK_CHANGE, blockposition, GameEvent.Context.of(newBlock)); // Paper
+         return true;
+     }
+     // CraftBukkit end
--- a/patches/server/0802-fix-powder-snow-cauldrons-not-turning-to-water.patch
+++ b/patches/server/0802-fix-powder-snow-cauldrons-not-turning-to-water.patch
@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 30 Dec 2021 14:02:13 -0800
+Subject: [PATCH] fix powder snow cauldrons not turning to water
+
+Powder snow cauldrons should turn to water when
+extinguishing an entity
+
+diff --git a/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java b/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+index 7daf2ec30fd31023d326a6149661f38bfc1d646b..43a72941ab553c154633144d358fb204765257f5 100644
+--- a/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+@@ -69,7 +69,7 @@ public class LayeredCauldronBlock extends AbstractCauldronBlock {
+         if (!world.isClientSide && entity.isOnFire() && this.isEntityInsideContent(state, pos, entity)) {
+             // CraftBukkit start
+             if (entity.mayInteract(world, pos)) {
+-                if (!LayeredCauldronBlock.lowerFillLevel(state, world, pos, entity, CauldronLevelChangeEvent.ChangeReason.EXTINGUISH)) {
+                if (!this.handleEntityOnFireInsideWithEvent(state, world, pos, entity)) { // Paper - fix powdered snow cauldron extinguishing entities
+                     return;
+                 }
+             }
+@@ -79,6 +79,7 @@ public class LayeredCauldronBlock extends AbstractCauldronBlock {
+ 
+     }
+ 
+    @Deprecated // Paper - use #handleEntityOnFireInsideWithEvent
+     private void handleEntityOnFireInside(BlockState state, Level world, BlockPos pos) {
+         if (this.precipitationType == Biome.Precipitation.SNOW) {
+             LayeredCauldronBlock.lowerFillLevel((BlockState) Blocks.WATER_CAULDRON.defaultBlockState().setValue(LayeredCauldronBlock.LEVEL, (Integer) state.getValue(LayeredCauldronBlock.LEVEL)), world, pos);
+@@ -87,6 +88,11 @@ public class LayeredCauldronBlock extends AbstractCauldronBlock {
+         }
+ 
+     }
+    // Paper start
+    protected boolean handleEntityOnFireInsideWithEvent(BlockState state, Level world, BlockPos pos, Entity entity) {
+        return LayeredCauldronBlock.lowerFillLevel(state, world, pos, entity, CauldronLevelChangeEvent.ChangeReason.EXTINGUISH);
+    }
+    // Paper end
+ 
+     public static void lowerFillLevel(BlockState state, Level world, BlockPos pos) {
+         // CraftBukkit start
--- a/patches/server/0803-Add-PlayerStopUsingItemEvent.patch
+++ b/patches/server/0803-Add-PlayerStopUsingItemEvent.patch
@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: u9g <git@u9g.dev>
+Date: Tue, 3 May 2022 20:41:37 -0400
+Subject: [PATCH] Add PlayerStopUsingItemEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index b8c7f0077118825848bddee8279e252914929d35..a21de30eef397308e3f4866a16cc588012e16f50 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -4025,6 +4025,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+     public void releaseUsingItem() {
+         if (!this.useItem.isEmpty()) {
+            if (this instanceof ServerPlayer) new io.papermc.paper.event.player.PlayerStopUsingItemEvent((Player) getBukkitEntity(), useItem.asBukkitMirror(), getTicksUsingItem()).callEvent(); // Paper
+             this.useItem.releaseUsing(this.level(), this, this.getUseItemRemainingTicks());
+             if (this.useItem.useOnRelease()) {
+                 this.updatingUsingItem();
--- a/patches/server/0804-Don-t-tick-markers.patch
+++ b/patches/server/0804-Don-t-tick-markers.patch
@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Noah van der Aa <ndvdaa@gmail.com>
+Date: Fri, 7 Jan 2022 11:58:26 +0100
+Subject: [PATCH] Don't tick markers
+
+Fixes https://github.com/PaperMC/Paper/issues/7276 and https://github.com/PaperMC/Paper/issues/8118
+by using a config option that, when set to false, does not add markers to the entity
+tick list at all and ignores them in Spigot's activation range checks. The entity tick
+list is only used in the tick and tickPassenger methods, so we can safely not add the
+markers to it. When the config option is set to true, markers are ticked as normal.
+
+diff --git a/src/main/java/io/papermc/paper/command/subcommands/EntityCommand.java b/src/main/java/io/papermc/paper/command/subcommands/EntityCommand.java
+index ff99336e0b8131ae161cfa5c4fc83c6905e3dbc8..5f43aedc6596e2b1ac7af9711515714752c262e3 100644
+--- a/src/main/java/io/papermc/paper/command/subcommands/EntityCommand.java
+++ b/src/main/java/io/papermc/paper/command/subcommands/EntityCommand.java
+@@ -109,7 +109,7 @@ public final class EntityCommand implements PaperSubcommand {
+                 ChunkPos chunk = e.chunkPosition();
+                 info.left++;
+                 info.right.put(chunk, info.right.getOrDefault(chunk, 0) + 1);
+-                if (!chunkProviderServer.isPositionTicking(e)) {
+                if (!chunkProviderServer.isPositionTicking(e) || (e instanceof net.minecraft.world.entity.Marker && !world.paperConfig().entities.markers.tick)) { // Configurable marker ticking
+                     nonEntityTicking.merge(key, 1, Integer::sum);
+                 }
+             });
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index b9b7896c2f850f9a02900932ea9255dc0aa07e26..cc91327050998c5e725ee71ac8b91b41a8b01bdf 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -2593,6 +2593,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         }
+ 
+         public void onTickingStart(Entity entity) {
+            if (entity instanceof net.minecraft.world.entity.Marker && !paperConfig().entities.markers.tick) return; // Paper - Configurable marker ticking
+             ServerLevel.this.entityTickList.add(entity);
+         }
+ 
+diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
+index f76b3f410fcc756bb34a5fac21b1d7088ac7a9ce..59103744ac6beeb12719fdefcda54eeff498229e 100644
+--- a/src/main/java/org/spigotmc/ActivationRange.java
+++ b/src/main/java/org/spigotmc/ActivationRange.java
+@@ -213,8 +213,14 @@ public class ActivationRange
+ 
+             // Paper start
+             java.util.List<Entity> entities = world.getEntities((Entity)null, ActivationRange.maxBB, null);
+            boolean tickMarkers = world.paperConfig().entities.markers.tick; // Paper - configurable marker ticking
+             for (int i = 0; i < entities.size(); i++) {
+                 Entity entity = entities.get(i);
+                // Paper start - configurable marker ticking
+                if (!tickMarkers && entity instanceof net.minecraft.world.entity.Marker) {
+                    continue;
+                }
+                // Paper end - configurable marker ticking
+                 ActivationRange.activateEntity(entity);
+             }
+             // Paper end
--- a/patches/server/0805-Expand-FallingBlock-API.patch
+++ b/patches/server/0805-Expand-FallingBlock-API.patch
@ -0,0 +1,107 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sun, 5 Dec 2021 14:58:17 -0500
+Subject: [PATCH] Expand FallingBlock API
+
+- add auto expire setting
+- add setter for block data
+- add accessors for block state
+
+== AT ==
+public net.minecraft.world.entity.item.FallingBlockEntity blockState
+
+Co-authored-by: Lukas Planz <lukas.planz@web.de>
+
+diff --git a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
+index fc33d05cf1a3cceb220dab1ee1da33ffe37834db..45c07733f03b5c11f6d8e820f65dc950c70d9a67 100644
+--- a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
+@@ -66,6 +66,7 @@ public class FallingBlockEntity extends Entity {
+     @Nullable
+     public CompoundTag blockData;
+     protected static final EntityDataAccessor<BlockPos> DATA_START_POS = SynchedEntityData.defineId(FallingBlockEntity.class, EntityDataSerializers.BLOCK_POS);
+    public boolean autoExpire = true; // Paper - Auto expire setting
+ 
+     public FallingBlockEntity(EntityType<? extends FallingBlockEntity> type, Level world) {
+         super(type, world);
+@@ -180,7 +181,7 @@ public class FallingBlockEntity extends Entity {
+                 }
+ 
+                 if (!this.onGround() && !flag1) {
+-                    if (!this.level().isClientSide && (this.time > 100 && (blockposition.getY() <= this.level().getMinBuildHeight() || blockposition.getY() > this.level().getMaxBuildHeight()) || this.time > 600)) {
+                    if (!this.level().isClientSide && ((this.time > 100 && autoExpire) && (blockposition.getY() <= this.level().getMinBuildHeight() || blockposition.getY() > this.level().getMaxBuildHeight()) || (this.time > 600 && autoExpire))) { // Paper - Auto expire setting
+                         if (this.dropItem && this.level().getGameRules().getBoolean(GameRules.RULE_DOENTITYDROPS)) {
+                             this.spawnAtLocation((ItemLike) block);
+                         }
+@@ -328,6 +329,7 @@ public class FallingBlockEntity extends Entity {
+         }
+ 
+         nbt.putBoolean("CancelDrop", this.cancelDrop);
+        if (!autoExpire) {nbt.putBoolean("Paper.AutoExpire", false);} // Paper - AutoExpire setting
+     }
+ 
+     @Override
+@@ -363,6 +365,11 @@ public class FallingBlockEntity extends Entity {
+             this.setOrigin(new org.bukkit.Location(this.level().getWorld(), srcX, srcY, srcZ));
+         }
+         // Paper end
+        // Paper start
+         if (nbt.contains("Paper.AutoExpire")) {
+            this.autoExpire = nbt.getBoolean("Paper.AutoExpire");
+         }
+        // Paper end
+     }
+ 
+     public void setHurtsEntities(float fallHurtAmount, int fallHurtMax) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftFallingBlock.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftFallingBlock.java
+index a7a3f74b846112d752fe04162b30805961457b11..73911b81f4e927026657953a0c68ddda9a8f93c1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftFallingBlock.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftFallingBlock.java
+@@ -33,6 +33,31 @@ public class CraftFallingBlock extends CraftEntity implements FallingBlock {
+     public BlockData getBlockData() {
+         return CraftBlockData.fromData(this.getHandle().getBlockState());
+     }
+    // Paper start
+    @Override
+    public void setBlockData(final BlockData blockData) {
+        Preconditions.checkArgument(blockData != null, "blockData");
+        final net.minecraft.world.level.block.state.BlockState oldState = this.getHandle().blockState, newState = ((CraftBlockData) blockData).getState();
+        this.getHandle().blockState = newState;
+        this.getHandle().blockData = null;
+
+        if (oldState != newState) this.update();
+    }
+
+    @Override
+    public org.bukkit.block.BlockState getBlockState() {
+        return org.bukkit.craftbukkit.block.CraftBlockStates.getBlockState(this.getHandle().blockState, this.getHandle().blockData);
+    }
+
+    @Override
+    public void setBlockState(final org.bukkit.block.BlockState blockState) {
+        Preconditions.checkArgument(blockState != null, "blockState");
+        // Calls #update if needed, the block data compound tag is not synced with the client and hence can be mutated after the sync with clients.
+        // The call also clears any potential old block data.
+        this.setBlockData(blockState.getBlockData());
+        if (blockState instanceof final org.bukkit.craftbukkit.block.CraftBlockEntityState<?> tileEntity) this.getHandle().blockData = tileEntity.getSnapshotNBT();
+    }
+    // Paper end
+ 
+     @Override
+     public boolean getDropItem() {
+@@ -101,4 +126,15 @@ public class CraftFallingBlock extends CraftEntity implements FallingBlock {
+             this.setHurtEntities(true);
+         }
+     }
+    // Paper Start - Auto expire setting
+    @Override
+    public boolean doesAutoExpire() {
+        return this.getHandle().autoExpire;
+    }
+
+    @Override
+    public void shouldAutoExpire(boolean autoExpires) {
+        this.getHandle().autoExpire = autoExpires;
+    }
+    // Paper End - Auto expire setting
+ }
--- a/patches/server/0806-Do-not-accept-invalid-client-settings.patch
+++ b/patches/server/0806-Do-not-accept-invalid-client-settings.patch
@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sat, 7 May 2022 14:58:53 -0700
+Subject: [PATCH] Do not accept invalid client settings
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 600362fdc2d7b1f1f5614018af3339165c24d8a2..1b4fe753a4c4fc38b963720c2a7a9a4538550d32 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -3320,6 +3320,13 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+     @Override
+     public void handleClientInformation(ServerboundClientInformationPacket packet) {
+         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
+        // Paper start - do not accept invalid information
+        if (packet.information().viewDistance() < 0) {
+            LOGGER.warn("Disconnecting " + this.player.getScoreboardName() + " for invalid view distance: " + packet.information().viewDistance());
+            this.disconnect("Invalid client settings", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION);
+            return;
+        }
+        // Paper end - do not accept invalid information
+         this.player.updateOptions(packet.information());
+         this.connection.channel.attr(io.papermc.paper.adventure.PaperAdventure.LOCALE_ATTRIBUTE).set(net.kyori.adventure.translation.Translator.parseLocale(packet.information().language())); // Paper
+     }
--- a/patches/server/0807-Add-support-for-Proxy-Protocol.patch
+++ b/patches/server/0807-Add-support-for-Proxy-Protocol.patch
@ -0,0 +1,65 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: PanSzelescik <panszelescik@gmail.com>
+Date: Thu, 7 Apr 2022 16:13:39 +0200
+Subject: [PATCH] Add support for Proxy Protocol
+
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index 0a98693535b55e03abd158f5c469d2eada80650f..64479f0a892d6847f987d844efe282a6080d607b 100644
+--- a/build.gradle.kts
+++ b/build.gradle.kts
+@@ -30,6 +30,7 @@ dependencies {
+     log4jPlugins.annotationProcessorConfigurationName("org.apache.logging.log4j:log4j-core:2.19.0") // Paper - Needed to generate meta for our Log4j plugins
+     runtimeOnly(log4jPlugins.output)
+     alsoShade(log4jPlugins.output)
+    implementation("io.netty:netty-codec-haproxy:4.1.97.Final") // Paper - Add support for proxy protocol
+     // Paper end
+     implementation("org.apache.logging.log4j:log4j-iostreams:2.19.0") // Paper - remove exclusion
+     implementation("org.ow2.asm:asm:9.5")
+diff --git a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+index 54c7f34ba3dc8466223e589702d0c93af8cf52a0..79326308f6126f84a3cbb3d5a33302de048d8a50 100644
+--- a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+++ b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+@@ -111,6 +111,12 @@ public class ServerConnectionListener {
+             ServerConnectionListener.LOGGER.info("Paper: Using " + com.velocitypowered.natives.util.Natives.cipher.getLoadedVariant() + " cipher from Velocity.");
+             // Paper end
+ 
+            // Paper start - indicate Proxy Protocol usage
+            if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.proxyProtocol) {
+                ServerConnectionListener.LOGGER.info("Paper: Using Proxy Protocol");
+            }
+            // Paper end
+
+             this.channels.add(((ServerBootstrap) ((ServerBootstrap) (new ServerBootstrap()).channel(oclass)).childHandler(new ChannelInitializer<Channel>() {
+                 protected void initChannel(Channel channel) {
+                     Connection.setInitialProtocolAttributes(channel);
+@@ -129,6 +135,29 @@ public class ServerConnectionListener {
+                     Connection object = j > 0 ? new RateKickingConnection(j) : new Connection(PacketFlow.SERVERBOUND); // CraftBukkit - decompile error
+ 
+                     //ServerConnectionListener.this.connections.add(object); // Paper
+                    // Paper start - Add support for Proxy Protocol
+                    if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.proxyProtocol) {
+                        channel.pipeline().addAfter("timeout", "haproxy-decoder", new io.netty.handler.codec.haproxy.HAProxyMessageDecoder());
+                        channel.pipeline().addAfter("haproxy-decoder", "haproxy-handler", new ChannelInboundHandlerAdapter() {
+                            @Override
+                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+                                if (msg instanceof io.netty.handler.codec.haproxy.HAProxyMessage message) {
+                                    if (message.command() == io.netty.handler.codec.haproxy.HAProxyCommand.PROXY) {
+                                        String realaddress = message.sourceAddress();
+                                        int realport = message.sourcePort();
+
+                                        SocketAddress socketaddr = new java.net.InetSocketAddress(realaddress, realport);
+
+                                        Connection connection = (Connection) channel.pipeline().get("packet_handler");
+                                        connection.address = socketaddr;
+                                    }
+                                } else {
+                                    super.channelRead(ctx, msg);
+                                }
+                            }
+                        });
+                    }
+                    // Paper end
+                     pending.add(object); // Paper
+                     ((Connection) object).configurePacketHandler(channelpipeline);
+                     ((Connection) object).setListenerForServerboundHandshake(new ServerHandshakePacketListenerImpl(ServerConnectionListener.this.server, (Connection) object));
--- a/patches/server/0808-Fix-OfflinePlayer-getBedSpawnLocation.patch
+++ b/patches/server/0808-Fix-OfflinePlayer-getBedSpawnLocation.patch
@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Mon, 30 May 2022 16:03:36 -0700
+Subject: [PATCH] Fix OfflinePlayer#getBedSpawnLocation
+
+When calling getBedSpawnLocation on an
+instance of CraftOfflinePlayer the world was incorrect
+due to the logic for reading the NBT not being up-to-date.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+index 5f590575f95eff8bf0cdcafde7dee0e3c7fc30ad..a0fcd11e6b0ca2a7055a4d1910124b20bd9c0b94 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+@@ -36,6 +36,7 @@ import org.bukkit.profile.PlayerProfile;
+ 
+ @SerializableAs("Player")
+ public class CraftOfflinePlayer implements OfflinePlayer, ConfigurationSerializable {
+    private static final org.slf4j.Logger LOGGER = com.mojang.logging.LogUtils.getLogger(); // Paper
+     private final GameProfile profile;
+     private final CraftServer server;
+     private final PlayerDataStorage storage;
+@@ -330,11 +331,20 @@ public class CraftOfflinePlayer implements OfflinePlayer, ConfigurationSerializa
+         if (data == null) return null;
+ 
+         if (data.contains("SpawnX") && data.contains("SpawnY") && data.contains("SpawnZ")) {
+-            String spawnWorld = data.getString("SpawnWorld");
+-            if (spawnWorld.equals("")) {
+-                spawnWorld = this.server.getWorlds().get(0).getName();
+            // Paper start - fix wrong world
+            final float respawnAngle = data.getFloat("SpawnAngle");
+            org.bukkit.World spawnWorld = this.server.getWorld(data.getString("SpawnWorld")); // legacy
+            if (data.contains("SpawnDimension")) {
+                com.mojang.serialization.DataResult<net.minecraft.resources.ResourceKey<net.minecraft.world.level.Level>> result = net.minecraft.world.level.Level.RESOURCE_KEY_CODEC.parse(net.minecraft.nbt.NbtOps.INSTANCE, data.get("SpawnDimension"));
+                net.minecraft.resources.ResourceKey<net.minecraft.world.level.Level> levelKey = result.resultOrPartial(LOGGER::error).orElse(net.minecraft.world.level.Level.OVERWORLD);
+                net.minecraft.server.level.ServerLevel level = this.server.console.getLevel(levelKey);
+                spawnWorld = level != null ? level.getWorld() : spawnWorld;
+             }
+-            return new Location(this.server.getWorld(spawnWorld), data.getInt("SpawnX"), data.getInt("SpawnY"), data.getInt("SpawnZ"));
+            if (spawnWorld == null) {
+                return null;
+            }
+            return new Location(spawnWorld, data.getInt("SpawnX"), data.getInt("SpawnY"), data.getInt("SpawnZ"), respawnAngle, 0);
+            // Paper end
+         }
+         return null;
+     }
--- a/patches/server/0809-Fix-FurnaceInventory-for-smokers-and-blast-furnaces.patch
+++ b/patches/server/0809-Fix-FurnaceInventory-for-smokers-and-blast-furnaces.patch
@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 1 Jan 2022 23:11:26 -0800
+Subject: [PATCH] Fix FurnaceInventory for smokers and blast furnaces
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java
+index e97166d3008cae7897519eaaf56b39c927661098..b835782c9c9b8b47a3ce8727e376f795286299a3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java
+@@ -66,7 +66,7 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+         return new CraftInventory(tileEntity);
+     }
+ 
+-    public static class Furnace extends CraftTileInventoryConverter {
+    public static class Furnace extends AbstractFurnaceInventoryConverter { // Paper - Furnace, BlastFurnace, and Smoker are pretty much identical
+ 
+         @Override
+         public Container getTileEntity() {
+@@ -74,6 +74,11 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+             return furnace;
+         }
+ 
+    // Paper start - abstract furnace converter to apply to all 3 furnaces
+    }
+
+    public static abstract class AbstractFurnaceInventoryConverter extends CraftTileInventoryConverter {
+    // Paper end
+         // Paper start
+         @Override
+         public Inventory createInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) {
+@@ -171,7 +176,7 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+         }
+     }
+ 
+-    public static class BlastFurnace extends CraftTileInventoryConverter {
+    public static class BlastFurnace extends AbstractFurnaceInventoryConverter { // Paper - Furnace, BlastFurnace, and Smoker are pretty much identical
+ 
+         @Override
+         public Container getTileEntity() {
+@@ -187,7 +192,7 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+         }
+     }
+ 
+-    public static class Smoker extends CraftTileInventoryConverter {
+    public static class Smoker extends AbstractFurnaceInventoryConverter { // Paper - Furnace, BlastFurnace, and Smoker are pretty much identical
+ 
+         @Override
+         public Container getTileEntity() {
--- a/patches/server/0810-Sanitize-Sent-BlockEntity-NBT.patch
+++ b/patches/server/0810-Sanitize-Sent-BlockEntity-NBT.patch
@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Fri, 3 Dec 2021 16:55:50 -0500
+Subject: [PATCH] Sanitize Sent BlockEntity NBT
+
+
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java
+index d79284a790569141c2ac8178d6ecc20b17cdd0d3..3944852921335c78a04a9dc301882ab5b152b1ed 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java
+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java
+@@ -17,7 +17,7 @@ public class ClientboundBlockEntityDataPacket implements Packet<ClientGamePacket
+     private final CompoundTag tag;
+ 
+     public static ClientboundBlockEntityDataPacket create(BlockEntity blockEntity, Function<BlockEntity, CompoundTag> nbtGetter) {
+-        return new ClientboundBlockEntityDataPacket(blockEntity.getBlockPos(), blockEntity.getType(), nbtGetter.apply(blockEntity));
+        return new ClientboundBlockEntityDataPacket(blockEntity.getBlockPos(), blockEntity.getType(), blockEntity.sanitizeSentNbt(nbtGetter.apply(blockEntity))); // Paper - Sanitize sent data
+     }
+ 
+     public static ClientboundBlockEntityDataPacket create(BlockEntity blockEntity) {
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+index bf6cdc08367fc26716e7904162a21e63fecab3ed..51e24105facfe71ce9f2757c6c881a21b58dacfd 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+@@ -186,6 +186,7 @@ public class ClientboundLevelChunkPacketData {
+             CompoundTag compoundTag = blockEntity.getUpdateTag();
+             BlockPos blockPos = blockEntity.getBlockPos();
+             int i = SectionPos.sectionRelative(blockPos.getX()) << 4 | SectionPos.sectionRelative(blockPos.getZ());
+            blockEntity.sanitizeSentNbt(compoundTag); // Paper - Sanitize sent data
+             return new ClientboundLevelChunkPacketData.BlockEntityInfo(i, blockPos.getY(), blockEntity.getType(), compoundTag.isEmpty() ? null : compoundTag);
+         }
+     }
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+index e3557f4c8cee7c88b3e352cd246078da7762effc..5bdad1866386908b9fef74d15862eb107fabe68f 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+@@ -253,4 +253,12 @@ public abstract class BlockEntity {
+         return null;
+     }
+     // CraftBukkit end
+    // Paper start
+    public CompoundTag sanitizeSentNbt(CompoundTag tag) {
+        tag.remove("PublicBukkitValues");
+
+        return tag;
+    }
+    // Paper end
+
+ }
--- a/patches/server/0811-Disable-component-selector-resolving-in-books-by-def.patch
+++ b/patches/server/0811-Disable-component-selector-resolving-in-books-by-def.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Nassim Jahnke <nassim@njahnke.dev>
+Date: Thu, 2 Jun 2022 20:35:58 +0200
+Subject: [PATCH] Disable component selector resolving in books by default
+
+
+diff --git a/src/main/java/net/minecraft/world/item/WrittenBookItem.java b/src/main/java/net/minecraft/world/item/WrittenBookItem.java
+index a324df312d9bb87d9e0962f8028d900933e70c07..31911c09fe15753ae32fa39417bdc9e9de552a88 100644
+--- a/src/main/java/net/minecraft/world/item/WrittenBookItem.java
+++ b/src/main/java/net/minecraft/world/item/WrittenBookItem.java
+@@ -111,7 +111,7 @@ public class WrittenBookItem extends Item {
+ 
+     public static boolean resolveBookComponents(ItemStack book, @Nullable CommandSourceStack commandSource, @Nullable Player player) {
+         CompoundTag compoundTag = book.getTag();
+-        if (compoundTag != null && !compoundTag.getBoolean("resolved")) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.resolveSelectorsInBooks && compoundTag != null && !compoundTag.getBoolean("resolved")) { // Paper
+             compoundTag.putBoolean("resolved", true);
+             if (!makeSureTagIsValid(compoundTag)) {
+                 return false;
--- a/patches/server/0812-Prevent-entity-loading-causing-async-lookups.patch
+++ b/patches/server/0812-Prevent-entity-loading-causing-async-lookups.patch
@ -0,0 +1,73 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sun, 6 Mar 2022 11:09:09 -0500
+Subject: [PATCH] Prevent entity loading causing async lookups
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index f5fa686060d40b0e8eddb910464c31085c3ee7c1..3dc4345abb975b555931614642be910785f98a7c 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -801,6 +801,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+ 
+     public void baseTick() {
+         this.level().getProfiler().push("entityBaseTick");
+        if (firstTick && this instanceof net.minecraft.world.entity.NeutralMob neutralMob) neutralMob.tickInitialPersistentAnger(level); // Paper - Update last hurt when ticking
+         this.feetBlockState = null;
+         if (this.isPassenger() && this.getVehicle().isRemoved()) {
+             this.stopRiding();
+diff --git a/src/main/java/net/minecraft/world/entity/NeutralMob.java b/src/main/java/net/minecraft/world/entity/NeutralMob.java
+index fa64c7baa7587f2cfe80b78ed83be011239618cf..55defe4f42bea4600a4e2b93c88e90231e61f6ef 100644
+--- a/src/main/java/net/minecraft/world/entity/NeutralMob.java
+++ b/src/main/java/net/minecraft/world/entity/NeutralMob.java
+@@ -42,18 +42,11 @@ public interface NeutralMob {
+                 UUID uuid = nbt.getUUID("AngryAt");
+ 
+                 this.setPersistentAngerTarget(uuid);
+-                Entity entity = ((ServerLevel) world).getEntity(uuid);
+-
+-                if (entity != null) {
+-                    if (entity instanceof Mob) {
+-                        this.setLastHurtByMob((Mob) entity);
+-                    }
+-
+-                    if (entity.getType() == EntityType.PLAYER) {
+-                        this.setLastHurtByPlayer((Player) entity);
+-                    }
+-
+-                }
+                // Paper - Moved diff to separate method
+                // If this entity already survived its first tick, e.g. is loaded and ticked in sync, actively
+                // tick the initial persistent anger.
+                // If not, let the first tick on the baseTick call the method later down the line.
+                if (this instanceof Entity entity && !entity.firstTick) this.tickInitialPersistentAnger(world);
+             }
+         }
+     }
+@@ -127,4 +120,26 @@ public interface NeutralMob {
+ 
+     @Nullable
+     LivingEntity getTarget();
+
+    // Paper start - Update last hurt when ticking
+    default void tickInitialPersistentAnger(Level level) {
+        UUID target = getPersistentAngerTarget();
+        if (target == null) {
+            return;
+        }
+
+        Entity entity = ((ServerLevel) level).getEntity(target);
+
+        if (entity != null) {
+            if (entity instanceof Mob) {
+                this.setLastHurtByMob((Mob) entity);
+            }
+
+            if (entity.getType() == EntityType.PLAYER) {
+                this.setLastHurtByPlayer((Player) entity);
+            }
+
+        }
+    }
+    // Paper end
+ }
--- a/patches/server/0813-Throw-exception-on-world-create-while-being-ticked.patch
+++ b/patches/server/0813-Throw-exception-on-world-create-while-being-ticked.patch
@ -0,0 +1,78 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Tue, 22 Mar 2022 12:44:30 -0700
+Subject: [PATCH] Throw exception on world create while being ticked
+
+There are no plans to support creating worlds while worlds are
+being ticked themselvess.
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 752e2b122c41e513aee590699c6d4624bbbfc12a..00de78e06b4583880e00f57823a4929eb1484e7a 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -310,6 +310,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+     public volatile Thread shutdownThread; // Paper
+     public volatile boolean abnormalExit = false; // Paper
+    public boolean isIteratingOverLevels = false; // Paper
+ 
+     public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
+         AtomicReference<S> atomicreference = new AtomicReference();
+@@ -1639,7 +1640,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         this.getFunctions().tick();
+         MinecraftTimings.commandFunctionsTimer.stopTiming(); // Spigot // Paper
+         this.profiler.popPush("levels");
+-        Iterator iterator = this.getAllLevels().iterator();
+        //Iterator iterator = this.getAllLevels().iterator(); // Paper - moved down
+ 
+         // CraftBukkit start
+         // Run tasks that are waiting on processing
+@@ -1671,6 +1672,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         // Paper end
+         MinecraftTimings.timeUpdateTimer.stopTiming(); // Spigot // Paper
+ 
+        this.isIteratingOverLevels = true; // Paper
+        Iterator iterator = this.getAllLevels().iterator(); // Paper - move down
+         while (iterator.hasNext()) {
+             ServerLevel worldserver = (ServerLevel) iterator.next();
+             worldserver.hasPhysicsEvent =  org.bukkit.event.block.BlockPhysicsEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper
+@@ -1717,6 +1720,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             this.profiler.pop();
+             worldserver.explosionDensityCache.clear(); // Paper - Optimize explosions
+         }
+        this.isIteratingOverLevels = false; // Paper
+ 
+         this.profiler.popPush("connection");
+         MinecraftTimings.connectionTimer.startTiming(); // Spigot // Paper
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index d005bcd0a64c4a18697aec802732d4f06b7ed85a..0759824929144805d55b4953863eacd5ae1542e0 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -873,6 +873,11 @@ public final class CraftServer implements Server {
+         return new ArrayList<World>(this.worlds.values());
+     }
+ 
+    @Override
+    public boolean isTickingWorlds() {
+        return console.isIteratingOverLevels;
+    }
+
+     public DedicatedPlayerList getHandle() {
+         return this.playerList;
+     }
+@@ -1132,6 +1137,7 @@ public final class CraftServer implements Server {
+     @Override
+     public World createWorld(WorldCreator creator) {
+         Preconditions.checkState(this.console.getAllLevels().iterator().hasNext(), "Cannot create additional worlds on STARTUP");
+        //Preconditions.checkState(!this.console.isIteratingOverLevels, "Cannot create a world while worlds are being ticked"); // Paper - Cat - Temp disable. We'll see how this goes.
+         Preconditions.checkArgument(creator != null, "WorldCreator cannot be null");
+ 
+         String name = creator.name();
+@@ -1309,6 +1315,7 @@ public final class CraftServer implements Server {
+ 
+     @Override
+     public boolean unloadWorld(World world, boolean save) {
+        //Preconditions.checkState(!this.console.isIteratingOverLevels, "Cannot unload a world while worlds are being ticked"); // Paper - Cat - Temp disable. We'll see how this goes.
+         if (world == null) {
+             return false;
+         }
--- a/patches/server/0814-Add-Alternate-Current-redstone-implementation.patch
+++ b/patches/server/0814-Add-Alternate-Current-redstone-implementation.patch
--- a/patches/server/0815-Dont-resent-entity-on-art-update.patch
+++ b/patches/server/0815-Dont-resent-entity-on-art-update.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Wed, 8 Jun 2022 11:04:47 -0400
+Subject: [PATCH] Dont resent entity on art update
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPainting.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPainting.java
+index dd02cec9a82794a6b001c3b64f031f78d5fbb812..bcac1359c667ef1ee46384f9c7a5adf4010d2b08 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPainting.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPainting.java
+@@ -36,7 +36,7 @@ public class CraftPainting extends CraftHanging implements Painting {
+             painting.setDirection(painting.getDirection());
+             return false;
+         }
+-        this.update();
+        //this.update(); Paper - Don't resent entity on art update
+         return true;
+     }
+ 
--- a/patches/server/0816-Add-WardenAngerChangeEvent.patch
+++ b/patches/server/0816-Add-WardenAngerChangeEvent.patch
@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: nopjar <code.nopjar@gmail.com>
+Date: Sun, 12 Jun 2022 02:26:04 +0200
+Subject: [PATCH] Add WardenAngerChangeEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/AngerManagement.java b/src/main/java/net/minecraft/world/entity/monster/warden/AngerManagement.java
+index 02abc5f387d781094bd2f39233444add3a470be1..ece82743df21f0b776382821ad75dee96d0a0748 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/warden/AngerManagement.java
+++ b/src/main/java/net/minecraft/world/entity/monster/warden/AngerManagement.java
+@@ -146,7 +146,7 @@ public class AngerManagement {
+     public int increaseAnger(Entity entity, int amount) {
+         boolean bl = !this.angerBySuspect.containsKey(entity);
+         int i = this.angerBySuspect.computeInt(entity, (suspect, anger) -> {
+-            return Math.min(150, (anger == null ? 0 : anger) + amount);
+            return Math.min(150, (anger == null ? 0 : anger) + amount); // Paper - diff on change
+         });
+         if (bl) {
+             int j = this.angerByUuid.removeInt(entity.getUUID());
+diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
+index b5185fcb635fbf5e5ed9d6cc9cc517cb46ada5aa..9f1b7c629644931074293151ed58a523ca6d488c 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
+++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
+@@ -488,6 +488,15 @@ public class Warden extends Monster implements VibrationSystem {
+     @VisibleForTesting
+     public void increaseAngerAt(@Nullable Entity entity, int amount, boolean listening) {
+         if (!this.isNoAi() && this.canTargetEntity(entity)) {
+            // Paper start
+            int activeAnger = this.angerManagement.getActiveAnger(entity);
+            io.papermc.paper.event.entity.WardenAngerChangeEvent event = new io.papermc.paper.event.entity.WardenAngerChangeEvent((org.bukkit.entity.Warden) this.getBukkitEntity(), entity.getBukkitEntity(), activeAnger, Math.min(150, activeAnger + amount));
+            this.level().getCraftServer().getPluginManager().callEvent(event);
+            if (event.isCancelled()) {
+                return;
+            }
+            amount = event.getNewAnger() - activeAnger;
+            // Paper end
+             WardenAi.setDigCooldown(this);
+             boolean flag1 = !(this.getBrain().getMemory(MemoryModuleType.ATTACK_TARGET).orElse(null) instanceof Player); // CraftBukkit - decompile error
+             int j = this.angerManagement.increaseAnger(entity, amount);
--- a/patches/server/0817-Add-option-for-strict-advancement-dimension-checks.patch
+++ b/patches/server/0817-Add-option-for-strict-advancement-dimension-checks.patch
@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 12 Jun 2022 11:47:24 -0700
+Subject: [PATCH] Add option for strict advancement dimension checks
+
+Craftbukkit attempts to translate worlds that use the
+same generation as the Overworld, The Nether, or The End
+to use those dimensions when checking the `changed_dimension`
+criteria trigger, or whether to trigger the `NETHER_TRAVEL`
+distance trigger. This adds a config option to ignore that
+and use the exact dimension key of the worlds involved.
+
+diff --git a/src/main/java/net/minecraft/advancements/critereon/LocationPredicate.java b/src/main/java/net/minecraft/advancements/critereon/LocationPredicate.java
+index 5f9cb2c7a2874e423087d04d3360af0364692b5c..f81aa5adf9a499cef6dc45bf3f9de2df3dc61460 100644
+--- a/src/main/java/net/minecraft/advancements/critereon/LocationPredicate.java
+++ b/src/main/java/net/minecraft/advancements/critereon/LocationPredicate.java
+@@ -25,7 +25,7 @@ public record LocationPredicate(Optional<LocationPredicate.PositionPredicate> po
+     public boolean matches(ServerLevel world, double x, double y, double z) {
+         if (this.position.isPresent() && !this.position.get().matches(x, y, z)) {
+             return false;
+-        } else if (this.dimension.isPresent() && this.dimension.get() != world.dimension()) {
+        } else if (this.dimension.isPresent() && this.dimension.get() != (io.papermc.paper.configuration.GlobalConfiguration.get().misc.strictAdvancementDimensionCheck ? world.dimension() : org.bukkit.craftbukkit.util.CraftDimensionUtil.getMainDimensionKey(world))) { // Paper
+             return false;
+         } else {
+             BlockPos blockPos = BlockPos.containing(x, y, z);
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index b6142c9f4474749be495ca0638e7b45fad327ce1..4895f0c507aac0c473ecca951f206a5b2182ad97 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1320,6 +1320,12 @@ public class ServerPlayer extends Player {
+         ResourceKey<Level> maindimensionkey = CraftDimensionUtil.getMainDimensionKey(origin);
+         ResourceKey<Level> maindimensionkey1 = CraftDimensionUtil.getMainDimensionKey(this.level());
+ 
+        // Paper start - config for strict advancement checks for dimensions
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().misc.strictAdvancementDimensionCheck) {
+            maindimensionkey = resourcekey;
+            maindimensionkey1 = resourcekey1;
+        }
+        // Paper end
+         CriteriaTriggers.CHANGED_DIMENSION.trigger(this, maindimensionkey, maindimensionkey1);
+         if (maindimensionkey != resourcekey || maindimensionkey1 != resourcekey1) {
+             CriteriaTriggers.CHANGED_DIMENSION.trigger(this, resourcekey, resourcekey1);
--- a/patches/server/0818-Add-missing-important-BlockStateListPopulator-method.patch
+++ b/patches/server/0818-Add-missing-important-BlockStateListPopulator-method.patch
@ -0,0 +1,72 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sun, 12 Jun 2022 13:25:52 -0400
+Subject: [PATCH] Add missing important BlockStateListPopulator methods
+
+Without these methods it causes exceptions due to these being used by certain feature generators.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/BlockStateListPopulator.java b/src/main/java/org/bukkit/craftbukkit/util/BlockStateListPopulator.java
+index ffe6881d93153838cd23f125980b832e6fd1d0eb..f5cbe9ae5802fa48e57092b1e5ca8a5f5f69ee60 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/BlockStateListPopulator.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/BlockStateListPopulator.java
+@@ -129,7 +129,7 @@ public class BlockStateListPopulator extends DummyGeneratorAccess {
+ 
+     @Override
+     public boolean isFluidAtPosition(BlockPos pos, Predicate<FluidState> state) {
+-        return this.world.isFluidAtPosition(pos, state);
+        return state.test(this.getFluidState(pos)); // Paper - fix
+     }
+ 
+     @Override
+@@ -152,4 +152,33 @@ public class BlockStateListPopulator extends DummyGeneratorAccess {
+     public long nextSubTickCount() {
+         return this.world.nextSubTickCount();
+     }
+
+    // Paper start
+    @Override
+    public <T extends BlockEntity> java.util.Optional<T> getBlockEntity(BlockPos pos, net.minecraft.world.level.block.entity.BlockEntityType<T> type) {
+        BlockEntity tileentity = this.getBlockEntity(pos);
+
+        return tileentity != null && tileentity.getType() == type ? (java.util.Optional<T>) java.util.Optional.of(tileentity) : java.util.Optional.empty();
+    }
+
+    @Override
+    public BlockPos getHeightmapPos(net.minecraft.world.level.levelgen.Heightmap.Types heightmap, BlockPos pos) {
+        return world.getHeightmapPos(heightmap, pos);
+    }
+
+    @Override
+    public int getHeight(net.minecraft.world.level.levelgen.Heightmap.Types heightmap, int x, int z) {
+        return world.getHeight(heightmap, x, z);
+    }
+
+    @Override
+    public int getRawBrightness(BlockPos pos, int ambientDarkness) {
+        return world.getRawBrightness(pos, ambientDarkness);
+    }
+
+    @Override
+    public int getBrightness(net.minecraft.world.level.LightLayer type, BlockPos pos) {
+        return world.getBrightness(type, pos);
+    }
+    // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java b/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
+index 187eda2dd40785eb09528c86718d6b4fd3ab252c..32594b4ebe8ab4c820e588573f5e01b08c57984f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
+@@ -274,4 +274,13 @@ public class DummyGeneratorAccess implements WorldGenLevel {
+     @Override
+     public <T> void getEntitiesByClass(Class<? extends T> clazz, Entity except, AABB box, List<? super T> into, Predicate<? super T> predicate) {}
+     // Paper end
+    // Paper start - add more methods
+    public void scheduleTick(BlockPos pos, Fluid fluid, int delay) {}
+
+    @Override
+    public void scheduleTick(BlockPos pos, Block block, int delay, net.minecraft.world.ticks.TickPriority priority) {}
+
+    @Override
+    public void scheduleTick(BlockPos pos, Fluid fluid, int delay, net.minecraft.world.ticks.TickPriority priority) {}
+    // Paper end - add more methods
+ }
--- a/patches/server/0819-Nameable-Banner-API.patch
+++ b/patches/server/0819-Nameable-Banner-API.patch
@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Thu, 7 Apr 2022 17:49:25 -0400
+Subject: [PATCH] Nameable Banner API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBanner.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBanner.java
+index 2b7fcd30b6eb0ab60b44de31ad0e0b20033f45c5..0a80bd370dd41ffbfbbe6b0d88cd6fa8a47a5725 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBanner.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBanner.java
+@@ -108,4 +108,26 @@ public class CraftBanner extends CraftBlockEntityState<BannerBlockEntity> implem
+     public CraftBanner copy() {
+         return new CraftBanner(this);
+     }
+
+    // Paper start
+    @Override
+    public net.kyori.adventure.text.Component customName() {
+        return io.papermc.paper.adventure.PaperAdventure.asAdventure(this.getSnapshot().getCustomName());
+    }
+
+    @Override
+    public void customName(net.kyori.adventure.text.Component customName) {
+        this.getSnapshot().setCustomName(io.papermc.paper.adventure.PaperAdventure.asVanilla(customName));
+    }
+
+    @Override
+    public String getCustomName() {
+        return net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serializeOrNull(this.customName());
+    }
+
+    @Override
+    public void setCustomName(String name) {
+       this.customName(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserializeOrNull(name));
+    }
+    // Paper end
+ }
--- a/patches/server/0820-Don-t-broadcast-messages-to-command-blocks.patch
+++ b/patches/server/0820-Don-t-broadcast-messages-to-command-blocks.patch
@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 16 Jun 2022 14:22:56 -0700
+Subject: [PATCH] Don't broadcast messages to command blocks
+
+Previously the broadcast method would update the last output
+in command blocks, and if called asynchronously, would throw
+an error
+
+diff --git a/src/main/java/net/minecraft/world/level/BaseCommandBlock.java b/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
+index c56f5173fda6b38c2dcaea196217f2f5a7d7c641..d4ff8c6b7801e33be4ff69b8bae13c09f4872c4b 100644
+--- a/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
+++ b/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
+@@ -172,6 +172,7 @@ public abstract class BaseCommandBlock implements CommandSource {
+     @Override
+     public void sendSystemMessage(Component message) {
+         if (this.trackOutput) {
+            org.spigotmc.AsyncCatcher.catchOp("sendSystemMessage to a command block"); // Paper
+             SimpleDateFormat simpledateformat = BaseCommandBlock.TIME_FORMAT;
+             Date date = new Date();
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 0759824929144805d55b4953863eacd5ae1542e0..7c8d21499d49aa88ad771e98a8e5302d1b3a3229 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1872,7 +1872,7 @@ public final class CraftServer implements Server {
+         // Paper end
+         Set<CommandSender> recipients = new HashSet<>();
+         for (Permissible permissible : this.getPluginManager().getPermissionSubscriptions(permission)) {
+-            if (permissible instanceof CommandSender && permissible.hasPermission(permission)) {
+            if (permissible instanceof CommandSender && !(permissible instanceof org.bukkit.command.BlockCommandSender) && permissible.hasPermission(permission)) { // Paper - don't broadcast to BlockCommandSender (specifically Command Blocks)
+                 recipients.add((CommandSender) permissible);
+             }
+         }
--- a/patches/server/0821-Prevent-empty-items-from-being-added-to-world.patch
+++ b/patches/server/0821-Prevent-empty-items-from-being-added-to-world.patch
@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Wed, 15 Jun 2022 21:52:57 -0400
+Subject: [PATCH] Prevent empty items from being added to world
+
+The previous solution caused a bunch of bandaid fixes inorder to resolve edge cases where minecraft/the api might spawn items that are air.
+Just simply prevent them from being added to the world instead.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 9c63f83d2a907afa630b4e05ea486db4d63ff8ec..60eb96c274ac1b899de9b6f79eaab8596aee012c 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -1583,6 +1583,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             // WorldServer.LOGGER.warn("Tried to add entity {} but it was marked as removed already", EntityTypes.getKey(entity.getType())); // CraftBukkit
+             return false;
+         } else {
+            if (entity instanceof net.minecraft.world.entity.item.ItemEntity itemEntity && itemEntity.getItem().isEmpty()) return false; // Paper - Prevent empty items from being added
+             // Paper start - capture all item additions to the world
+             if (captureDrops != null && entity instanceof net.minecraft.world.entity.item.ItemEntity) {
+                 captureDrops.add((net.minecraft.world.entity.item.ItemEntity) entity);
--- a/patches/server/0822-Fix-CCE-for-SplashPotion-and-LingeringPotion-spawnin.patch
+++ b/patches/server/0822-Fix-CCE-for-SplashPotion-and-LingeringPotion-spawnin.patch
@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 21 Apr 2022 18:18:02 -0700
+Subject: [PATCH] Fix CCE for SplashPotion and LingeringPotion spawning
+
+Remove in 1.19 along with the SplashPotion and
+LingeringPotion interfaces
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftThrownPotion.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftThrownPotion.java
+index d5f1681a476c8fe2ae128a84910f4bf04063b75a..d3aeb4b614b2b17d9613aa3ffa34ebfc81666f79 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftThrownPotion.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftThrownPotion.java
+@@ -13,7 +13,7 @@ import org.bukkit.entity.ThrownPotion;
+ import org.bukkit.inventory.ItemStack;
+ import org.bukkit.potion.PotionEffect;
+ 
+-public class CraftThrownPotion extends CraftThrowableProjectile implements ThrownPotion {
+public class CraftThrownPotion extends CraftThrowableProjectile implements ThrownPotion, org.bukkit.entity.SplashPotion, org.bukkit.entity.LingeringPotion { // Paper - implement other classes to avoid violating spawn method generic contracts
+     public CraftThrownPotion(CraftServer server, net.minecraft.world.entity.projectile.ThrownPotion entity) {
+         super(server, entity);
+     }
--- a/patches/server/0823-Add-Player-getFishHook.patch
+++ b/patches/server/0823-Add-Player-getFishHook.patch
@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: u9g <git@u9g.dev>
+Date: Tue, 14 Jun 2022 19:36:10 -0400
+Subject: [PATCH] Add Player#getFishHook
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+index bd2c3425cb17d14ccb6f8390997cc07de354468c..1bfd3f66bf5f269685774b7cd75112ba3429c484 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+@@ -162,6 +162,15 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+         return new Location(worldServer.getWorld(), bed.getX(), bed.getY(), bed.getZ());
+     }
+     // Paper end
+    // Paper start
+    @Override
+    public org.bukkit.entity.FishHook getFishHook() {
+        if (getHandle().fishing == null) {
+            return null;
+        }
+        return (org.bukkit.entity.FishHook) getHandle().fishing.getBukkitEntity();
+    }
+    // Paper end
+     @Override
+     public boolean sleep(Location location, boolean force) {
+         Preconditions.checkArgument(location != null, "Location cannot be null");
--- a/patches/server/0824-Do-not-sync-load-chunk-for-dynamic-game-event-listen.patch
+++ b/patches/server/0824-Do-not-sync-load-chunk-for-dynamic-game-event-listen.patch
@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sun, 3 Jul 2022 22:31:37 -0700
+Subject: [PATCH] Do not sync load chunk for dynamic game event listener
+ registration
+
+These can be called while an entity is being added to the world,
+and if the entity is being added from a chunk load context the
+sync load will block indefinitely (because the chunk load context
+is for completing the chunk to FULL).
+
+This does raise questions about the current system for these
+dynamic registrations, as it looks like there is _zero_ logic
+to account for the case where the chunk is _not_ currently loaded
+and then later loaded.
+
+diff --git a/src/main/java/net/minecraft/world/level/gameevent/DynamicGameEventListener.java b/src/main/java/net/minecraft/world/level/gameevent/DynamicGameEventListener.java
+index e64435c1dfbaf182d2292a1123701033f817ec38..d368ba29fec49a989be1cacd2422599d6d613c29 100644
+--- a/src/main/java/net/minecraft/world/level/gameevent/DynamicGameEventListener.java
+++ b/src/main/java/net/minecraft/world/level/gameevent/DynamicGameEventListener.java
+@@ -48,7 +48,7 @@ public class DynamicGameEventListener<T extends GameEventListener> {
+ 
+     private static void ifChunkExists(LevelReader world, @Nullable SectionPos sectionPos, Consumer<GameEventListenerRegistry> dispatcherConsumer) {
+         if (sectionPos != null) {
+-            ChunkAccess chunkAccess = world.getChunk(sectionPos.x(), sectionPos.z(), ChunkStatus.FULL, false);
+            ChunkAccess chunkAccess = world.getChunkIfLoadedImmediately(sectionPos.getX(), sectionPos.getZ()); // Paper - can cause sync loads while completing a chunk, resulting in deadlock
+             if (chunkAccess != null) {
+                 dispatcherConsumer.accept(chunkAccess.getListenerRegistry(sectionPos.y()));
+             }
--- a/patches/server/0825-Add-various-missing-EntityDropItemEvent-calls.patch
+++ b/patches/server/0825-Add-various-missing-EntityDropItemEvent-calls.patch
@ -0,0 +1,88 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Tue, 20 Jul 2021 21:35:47 -0700
+Subject: [PATCH] Add various missing EntityDropItemEvent calls
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 3dc4345abb975b555931614642be910785f98a7c..97bd7295c1e9af1666cb16c77f54b92947610724 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -2701,6 +2701,14 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+             stack.setCount(0); // Paper - destroy this item - if this ever leaks due to game bugs, ensure it doesn't dupe
+ 
+             entityitem.setDefaultPickUpDelay();
+    // Paper start
+            return this.spawnAtLocation(entityitem);
+        }
+    }
+    @Nullable
+    public ItemEntity spawnAtLocation(ItemEntity entityitem) {
+        {
+            // Paper end
+             // CraftBukkit start
+             EntityDropItemEvent event = new EntityDropItemEvent(this.getBukkitEntity(), (org.bukkit.entity.Item) entityitem.getBukkitEntity());
+             Bukkit.getPluginManager().callEvent(event);
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Dolphin.java b/src/main/java/net/minecraft/world/entity/animal/Dolphin.java
+index fb5e200499a1a73fd40c8b7c81185f48381f49e4..e555fd8ca61e1ce7a52ecd475cc3ea11dedcab08 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Dolphin.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Dolphin.java
+@@ -592,7 +592,7 @@ public class Dolphin extends WaterAnimal {
+                 float f2 = 0.02F * Dolphin.this.random.nextFloat();
+ 
+                 entityitem.setDeltaMovement((double) (0.3F * -Mth.sin(Dolphin.this.getYRot() * 0.017453292F) * Mth.cos(Dolphin.this.getXRot() * 0.017453292F) + Mth.cos(f1) * f2), (double) (0.3F * Mth.sin(Dolphin.this.getXRot() * 0.017453292F) * 1.5F), (double) (0.3F * Mth.cos(Dolphin.this.getYRot() * 0.017453292F) * Mth.cos(Dolphin.this.getXRot() * 0.017453292F) + Mth.sin(f1) * f2));
+-                Dolphin.this.level().addFreshEntity(entityitem);
+                Dolphin.this.spawnAtLocation(entityitem); // Paper - call EntityDropItemEvent
+             }
+         }
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Fox.java b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+index 6124209f50300eeaab45b66c2f1a5b2944119450..96799179b0dd1886f0cdc386f04e152a19b3337d 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -509,14 +509,14 @@ public class Fox extends Animal implements VariantHolder<Fox.Type> {
+             entityitem.setPickUpDelay(40);
+             entityitem.setThrower(this);
+             this.playSound(SoundEvents.FOX_SPIT, 1.0F, 1.0F);
+-            this.level().addFreshEntity(entityitem);
+            this.spawnAtLocation(entityitem); // Paper - call EntityDropItemEvent
+         }
+     }
+ 
+     private void dropItemStack(ItemStack stack) {
+         ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY(), this.getZ(), stack);
+ 
+-        this.level().addFreshEntity(entityitem);
+        this.spawnAtLocation(entityitem); // Paper - call EntityDropItemEvent
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+index 3ec2f590dfe9410f1a9d2afb530eebfcce917798..363892e0c26bab89d2abaa44d8736e2fd84d292f 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+@@ -357,8 +357,7 @@ public class Goat extends Animal {
+             double d2 = (double) Mth.randomBetween(this.random, -0.2F, 0.2F);
+             ItemEntity entityitem = new ItemEntity(this.level(), vec3d.x(), vec3d.y(), vec3d.z(), itemstack, d0, d1, d2);
+ 
+-            this.level().addFreshEntity(entityitem);
+-            return true;
+            return this.spawnAtLocation(entityitem) != null; // Paper - call EntityDropItemEvent by calling spawnAtLocation.
+         }
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/animal/sniffer/Sniffer.java b/src/main/java/net/minecraft/world/entity/animal/sniffer/Sniffer.java
+index 1d9913cbc7fd0c6e29278b02c38703b52af1245b..36b3945832733b5ad66d25aa3a31335234d2acff 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/sniffer/Sniffer.java
+++ b/src/main/java/net/minecraft/world/entity/animal/sniffer/Sniffer.java
+@@ -352,8 +352,9 @@ public class Sniffer extends Animal {
+ 
+         entityitem.setDefaultPickUpDelay();
+         this.finalizeSpawnChildFromBreeding(world, other, (AgeableMob) null);
+        if (this.spawnAtLocation(entityitem) != null) { // Paper - call EntityDropItemEvent
+         this.playSound(SoundEvents.SNIFFER_EGG_PLOP, 1.0F, (this.random.nextFloat() - this.random.nextFloat()) * 0.2F + 0.5F);
+-        world.addFreshEntity(entityitem);
+        } // Paper
+     }
+ 
+     @Override
--- a/patches/server/0826-Fix-Bee-flower-NPE.patch
+++ b/patches/server/0826-Fix-Bee-flower-NPE.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 6 Jul 2022 14:59:38 -0700
+Subject: [PATCH] Fix Bee flower NPE
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Bee.java b/src/main/java/net/minecraft/world/entity/animal/Bee.java
+index c534589762b1361bae7c446dfec8dbbf542485fb..a87a34b0c4c8e5d0cf079025c230b1434c919b54 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Bee.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java
+@@ -810,7 +810,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+             ++this.pollinatingTicks;
+             if (this.pollinatingTicks > 600) {
+                 Bee.this.savedFlowerPos = null;
+-            } else {
+            } else if (Bee.this.savedFlowerPos != null) { // Paper - add null check since API can manipulate this
+                 Vec3 vec3d = Vec3.atBottomCenterOf(Bee.this.savedFlowerPos).add(0.0D, 0.6000000238418579D, 0.0D);
+ 
+                 if (vec3d.distanceTo(Bee.this.position()) > 1.0D) {
--- a/patches/server/0827-Fix-Spigot-Config-not-using-commands.spam-exclusions.patch
+++ b/patches/server/0827-Fix-Spigot-Config-not-using-commands.spam-exclusions.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Doc <nachito94@msn.com>
+Date: Sun, 17 Jul 2022 11:49:43 -0400
+Subject: [PATCH] Fix Spigot Config not using commands.spam-exclusions
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 1b4fe753a4c4fc38b963720c2a7a9a4538550d32..7d35d44f0e95a0ce7bc57e9a306b8a8ab36fce5c 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2377,7 +2377,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+         }
+         // Spigot end
+         // this.chatSpamTickCount += 20;
+-        if (this.chatSpamTickCount.addAndGet(20) > 200 && !this.server.getPlayerList().isOp(this.player.getGameProfile())) {
+        if (counted && this.chatSpamTickCount.addAndGet(20) > 200 && !this.server.getPlayerList().isOp(this.player.getGameProfile())) { // Paper - exclude from SpigotConfig.spamExclusions
+             // CraftBukkit end
+             this.disconnect(Component.translatable("disconnect.spam"), org.bukkit.event.player.PlayerKickEvent.Cause.SPAM); // Paper - kick event cause
+         }
--- a/patches/server/0828-More-Teleport-API.patch
+++ b/patches/server/0828-More-Teleport-API.patch
@ -0,0 +1,214 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sun, 5 Sep 2021 12:15:59 -0400
+Subject: [PATCH] More Teleport API
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 7d35d44f0e95a0ce7bc57e9a306b8a8ab36fce5c..6726fc470843b900ce7b15268cdcbf4881a8fcd0 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1633,11 +1633,17 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+             return false; // CraftBukkit - Return event status
+         }
+ 
+-        PlayerTeleportEvent event = new PlayerTeleportEvent(player, from.clone(), to.clone(), cause);
+        // Paper start - Teleport API
+        Set<io.papermc.paper.entity.TeleportFlag.Relative> relativeFlags = java.util.EnumSet.noneOf(io.papermc.paper.entity.TeleportFlag.Relative.class);
+        for (RelativeMovement relativeArgument : set) {
+            relativeFlags.add(org.bukkit.craftbukkit.entity.CraftPlayer.toApiRelativeFlag(relativeArgument));
+        }
+        PlayerTeleportEvent event = new PlayerTeleportEvent(player, from.clone(), to.clone(), cause, java.util.Set.copyOf(relativeFlags));
+        // Paper end
+         this.cserver.getPluginManager().callEvent(event);
+ 
+         if (event.isCancelled() || !to.equals(event.getTo())) {
+-            set.clear(); // Can't relative teleport
+            //set.clear(); // Can't relative teleport // Paper - Teleport API: Now you can!
+             to = event.isCancelled() ? event.getFrom() : event.getTo();
+             d0 = to.getX();
+             d1 = to.getY();
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index d4fffcc5bb746df8dc177780f15ff4dbca64c018..ed30e079c23f564cbd0a45b38586bd12e17c525e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -573,15 +573,36 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+ 
+     @Override
+     public boolean teleport(Location location, TeleportCause cause) {
+        // Paper start - Teleport passenger API
+        return teleport(location, cause, new io.papermc.paper.entity.TeleportFlag[0]);
+    }
+
+    @Override
+    public boolean teleport(Location location, TeleportCause cause, io.papermc.paper.entity.TeleportFlag... flags) {
+        // Paper end
+         Preconditions.checkArgument(location != null, "location cannot be null");
+         location.checkFinite();
+        // Paper start - Teleport passenger API
+        Set<io.papermc.paper.entity.TeleportFlag> flagSet = Set.of(flags);
+        boolean dismount = !flagSet.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_VEHICLE);
+        boolean ignorePassengers = flagSet.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_PASSENGERS);
+        // Don't allow teleporting between worlds while keeping passengers
+        if (flagSet.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_PASSENGERS) && this.entity.isVehicle() && location.getWorld() != this.getWorld()) {
+            return false;
+        }
+
+        // Don't allow to teleport between worlds if remaining on vehicle
+        if (!dismount && this.entity.isPassenger() && location.getWorld() != this.getWorld()) {
+            return false;
+        }
+        // Paper end
+ 
+-        if (this.entity.isVehicle() || this.entity.isRemoved()) {
+        if ((!ignorePassengers && this.entity.isVehicle()) || this.entity.isRemoved()) { // Paper - Teleport passenger API
+             return false;
+         }
+ 
+         // If this entity is riding another entity, we must dismount before teleporting.
+-        this.entity.stopRiding();
+        if (dismount) this.entity.stopRiding(); // Paper - Teleport passenger API
+ 
+         // Let the server handle cross world teleports
+         if (location.getWorld() != null && !location.getWorld().equals(this.getWorld())) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index d73f94b37472da28a8c3dda9574d95954033785b..ec18039f7a5577d290c2d5da23aa734ddde62332 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1209,13 +1209,101 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+     @Override
+     public void setRotation(float yaw, float pitch) {
+-        throw new UnsupportedOperationException("Cannot set rotation of players. Consider teleporting instead.");
+        // Paper start - Teleport API
+        Location targetLocation = this.getEyeLocation();
+        targetLocation.setYaw(yaw);
+        targetLocation.setPitch(pitch);
+
+        org.bukkit.util.Vector direction = targetLocation.getDirection();
+        direction.multiply(9999999); // We need to move the target block.. FAR out
+        targetLocation.add(direction);
+        this.lookAt(targetLocation, io.papermc.paper.entity.LookAnchor.EYES);
+        // Paper end
+     }
+ 
+     @Override
+     public boolean teleport(Location location, PlayerTeleportEvent.TeleportCause cause) {
+        // Paper start - Teleport API
+        return this.teleport(location, cause, new io.papermc.paper.entity.TeleportFlag[0]);
+    }
+
+    @Override
+    public void lookAt(@NotNull org.bukkit.entity.Entity entity, @NotNull io.papermc.paper.entity.LookAnchor playerAnchor, @NotNull io.papermc.paper.entity.LookAnchor entityAnchor) {
+        this.getHandle().lookAt(toNmsAnchor(playerAnchor), ((CraftEntity) entity).getHandle(), toNmsAnchor(entityAnchor));
+    }
+
+    @Override
+    public void lookAt(double x, double y, double z, @NotNull io.papermc.paper.entity.LookAnchor playerAnchor) {
+        this.getHandle().lookAt(toNmsAnchor(playerAnchor), new Vec3(x, y, z));
+    }
+
+    public static net.minecraft.commands.arguments.EntityAnchorArgument.Anchor toNmsAnchor(io.papermc.paper.entity.LookAnchor nmsAnchor) {
+        return switch (nmsAnchor) {
+            case EYES -> net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.EYES;
+            case FEET -> net.minecraft.commands.arguments.EntityAnchorArgument.Anchor.FEET;
+        };
+    }
+
+    public static io.papermc.paper.entity.LookAnchor toApiAnchor(net.minecraft.commands.arguments.EntityAnchorArgument.Anchor playerAnchor) {
+        return switch (playerAnchor) {
+            case EYES -> io.papermc.paper.entity.LookAnchor.EYES;
+            case FEET -> io.papermc.paper.entity.LookAnchor.FEET;
+        };
+    }
+
+    public static net.minecraft.world.entity.RelativeMovement toNmsRelativeFlag(io.papermc.paper.entity.TeleportFlag.Relative apiFlag) {
+        return switch (apiFlag) {
+            case X -> net.minecraft.world.entity.RelativeMovement.X;
+            case Y -> net.minecraft.world.entity.RelativeMovement.Y;
+            case Z -> net.minecraft.world.entity.RelativeMovement.Z;
+            case PITCH -> net.minecraft.world.entity.RelativeMovement.X_ROT;
+            case YAW -> net.minecraft.world.entity.RelativeMovement.Y_ROT;
+        };
+    }
+
+    public static io.papermc.paper.entity.TeleportFlag.Relative toApiRelativeFlag(net.minecraft.world.entity.RelativeMovement nmsFlag) {
+        return switch (nmsFlag) {
+            case X -> io.papermc.paper.entity.TeleportFlag.Relative.X;
+            case Y -> io.papermc.paper.entity.TeleportFlag.Relative.Y;
+            case Z -> io.papermc.paper.entity.TeleportFlag.Relative.Z;
+            case X_ROT -> io.papermc.paper.entity.TeleportFlag.Relative.PITCH;
+            case Y_ROT -> io.papermc.paper.entity.TeleportFlag.Relative.YAW;
+        };
+    }
+
+    @Override
+    public boolean teleport(Location location, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause cause, io.papermc.paper.entity.TeleportFlag... flags) {
+        java.util.Set<net.minecraft.world.entity.RelativeMovement> relativeArguments;
+        java.util.Set<io.papermc.paper.entity.TeleportFlag> allFlags;
+        if (flags.length == 0) {
+            relativeArguments = Set.of();
+            allFlags = Set.of();
+        } else {
+            relativeArguments = java.util.EnumSet.noneOf(net.minecraft.world.entity.RelativeMovement.class);
+            allFlags = new HashSet<>();
+            for (io.papermc.paper.entity.TeleportFlag flag : flags) {
+                if (flag instanceof io.papermc.paper.entity.TeleportFlag.Relative relativeTeleportFlag) {
+                    relativeArguments.add(toNmsRelativeFlag(relativeTeleportFlag));
+                }
+                allFlags.add(flag);
+            }
+        }
+        boolean dismount = !allFlags.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_VEHICLE);
+        boolean ignorePassengers = allFlags.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_PASSENGERS);
+        // Paper end - Teleport API
+         Preconditions.checkArgument(location != null, "location");
+         Preconditions.checkArgument(location.getWorld() != null, "location.world");
+        // Paper start - Teleport passenger API
+        // Don't allow teleporting between worlds while keeping passengers
+        if (ignorePassengers && entity.isVehicle() && location.getWorld() != this.getWorld()) {
+            return false;
+        }
+
+        // Don't allow to teleport between worlds if remaining on vehicle
+        if (!dismount && entity.isPassenger() && location.getWorld() != this.getWorld()) {
+            return false;
+        }
+        // Paper end
+         location.checkFinite();
+ 
+         ServerPlayer entity = this.getHandle();
+@@ -1228,7 +1316,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+            return false;
+         }
+ 
+-        if (entity.isVehicle()) {
+        if (entity.isVehicle() && !ignorePassengers) { // Paper - Teleport API
+             return false;
+         }
+ 
+@@ -1246,7 +1334,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         }
+ 
+         // If this player is riding another entity, we must dismount before teleporting.
+-        entity.stopRiding();
+        if (dismount) entity.stopRiding(); // Paper - Teleport API
+ 
+         // SPIGOT-5509: Wakeup, similar to riding
+         if (this.isSleeping()) {
+@@ -1262,13 +1350,13 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         ServerLevel toWorld = ((CraftWorld) to.getWorld()).getHandle();
+ 
+         // Close any foreign inventory
+-        if (this.getHandle().containerMenu != this.getHandle().inventoryMenu) {
+        if (this.getHandle().containerMenu != this.getHandle().inventoryMenu && !allFlags.contains(io.papermc.paper.entity.TeleportFlag.EntityState.RETAIN_OPEN_INVENTORY)) { // Paper
+             this.getHandle().closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.TELEPORT); // Paper
+         }
+ 
+         // Check if the fromWorld and toWorld are the same.
+         if (fromWorld == toWorld) {
+-            entity.connection.teleport(to);
+            entity.connection.internalTeleport(to.getX(), to.getY(), to.getZ(), to.getYaw(), to.getPitch(), relativeArguments); // Paper - Teleport API
+         } else {
+             // The respawn reason should never be used if the passed location is non null.
+             this.server.getHandle().respawn(entity, toWorld, true, to, !toWorld.paperConfig().environment.disableTeleportationSuffocationCheck, null); // Paper
--- a/patches/server/0829-Add-EntityPortalReadyEvent.patch
+++ b/patches/server/0829-Add-EntityPortalReadyEvent.patch
@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 12 May 2021 04:30:42 -0700
+Subject: [PATCH] Add EntityPortalReadyEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 97bd7295c1e9af1666cb16c77f54b92947610724..4ef45d704107d03a506627da80ebfeb41a0945f8 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3103,6 +3103,13 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+                 if (true && !this.isPassenger() && this.portalTime++ >= i) { // CraftBukkit
+                     this.level().getProfiler().push("portal");
+                     this.portalTime = i;
+                    // Paper start
+                    io.papermc.paper.event.entity.EntityPortalReadyEvent event = new io.papermc.paper.event.entity.EntityPortalReadyEvent(this.getBukkitEntity(), worldserver1 == null ? null : worldserver1.getWorld(), org.bukkit.PortalType.NETHER);
+                    if (!event.callEvent()) {
+                        this.portalTime = 0;
+                    } else {
+                        worldserver1 = event.getTargetWorld() == null ? null : ((CraftWorld) event.getTargetWorld()).getHandle();
+                    // Paper end
+                     this.setPortalCooldown();
+                     // CraftBukkit start
+                     if (this instanceof ServerPlayer) {
+@@ -3110,6 +3117,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+                     } else {
+                         this.changeDimension(worldserver1);
+                     }
+                    } // Paper
+                     // CraftBukkit end
+                     this.level().getProfiler().pop();
+                 }
--- a/patches/server/0830-Don-t-use-level-random-in-entity-constructors.patch
+++ b/patches/server/0830-Don-t-use-level-random-in-entity-constructors.patch
@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 10 Jul 2022 14:13:22 -0700
+Subject: [PATCH] Don't use level random in entity constructors
+
+Paper makes the entity random thread-safe
+and constructing an entity off the main thread
+should be supported. Some entities (for whatever
+reason) use the level's random in some places.
+
+diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+index fc14a2eb464675f8fb0bff916992687adb4e3d25..6b18f23b57c7000dce9726df98a509ee9477f6d2 100644
+--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+@@ -66,7 +66,12 @@ public class ItemEntity extends Entity implements TraceableEntity {
+     }
+ 
+     public ItemEntity(Level world, double x, double y, double z, ItemStack stack) {
+-        this(world, x, y, z, stack, world.random.nextDouble() * 0.2D - 0.1D, 0.2D, world.random.nextDouble() * 0.2D - 0.1D);
+        // Paper start - don't use world random in entity constructor
+        this(EntityType.ITEM, world);
+        this.setPos(x, y, z);
+        this.setDeltaMovement(this.random.nextDouble() * 0.2D - 0.1D, 0.2D, this.random.nextDouble() * 0.2D - 0.1D);
+        this.setItem(stack);
+        // Paper end
+     }
+ 
+     public ItemEntity(Level world, double x, double y, double z, ItemStack stack, double velocityX, double velocityY, double velocityZ) {
+diff --git a/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java b/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+index d9ed22e9853eebdf6c517b41787a27a1a56a0871..c3e47426382296d650fa00ce0bc1a82bf23c7877 100644
+--- a/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+++ b/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+@@ -43,7 +43,7 @@ public class PrimedTnt extends Entity implements TraceableEntity {
+     public PrimedTnt(Level world, double x, double y, double z, @Nullable LivingEntity igniter) {
+         this(EntityType.TNT, world);
+         this.setPos(x, y, z);
+-        double d3 = world.random.nextDouble() * 6.2831854820251465D;
+        double d3 = this.random.nextDouble() * 6.2831854820251465D; // Paper - don't use world random in entity constructor
+ 
+         this.setDeltaMovement(-Math.sin(d3) * 0.02D, 0.20000000298023224D, -Math.cos(d3) * 0.02D);
+         this.setFuse(80);
--- a/patches/server/0831-Send-block-entities-after-destroy-prediction.patch
+++ b/patches/server/0831-Send-block-entities-after-destroy-prediction.patch
@ -0,0 +1,91 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sat, 25 Jun 2022 19:45:20 -0400
+Subject: [PATCH] Send block entities after destroy prediction
+
+Minecraft's prediction system does not handle block entities, so if we are manually sending block entities during
+block breaking we need to set it after the prediction is finished. This fixes block entities not showing when cancelling the BlockBreakEvent.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index bf9b185e3defb496022c20ec60a84a4f6f99d5be..4e1ed252bf400ec991f95b02984f01a9689f2989 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -62,6 +62,8 @@ public class ServerPlayerGameMode {
+     private BlockPos delayedDestroyPos;
+     private int delayedTickStart;
+     private int lastSentState;
+    public boolean captureSentBlockEntities = false; // Paper
+    public boolean capturedBlockEntity = false; // Paper
+ 
+     public ServerPlayerGameMode(ServerPlayer player) {
+         this.gameModeForPlayer = GameType.DEFAULT_MODE;
+@@ -188,10 +190,7 @@ public class ServerPlayerGameMode {
+                     this.player.connection.send(new ClientboundBlockUpdatePacket(pos, this.level.getBlockState(pos)));
+                     this.debugLogging(pos, false, sequence, "may not interact");
+                     // Update any tile entity data for this block
+-                    BlockEntity tileentity = this.level.getBlockEntity(pos);
+-                    if (tileentity != null) {
+-                        this.player.connection.send(tileentity.getUpdatePacket());
+-                    }
+                    capturedBlockEntity = true; // Paper - send block entity after predicting
+                     // CraftBukkit end
+                     return;
+                 }
+@@ -202,10 +201,7 @@ public class ServerPlayerGameMode {
+                     // Let the client know the block still exists
+                     this.player.connection.send(new ClientboundBlockUpdatePacket(this.level, pos));
+                     // Update any tile entity data for this block
+-                    BlockEntity tileentity = this.level.getBlockEntity(pos);
+-                    if (tileentity != null) {
+-                        this.player.connection.send(tileentity.getUpdatePacket());
+-                    }
+                    capturedBlockEntity = true; // Paper - send block entity after predicting
+                     return;
+                 }
+                 // CraftBukkit end
+@@ -389,10 +385,12 @@ public class ServerPlayerGameMode {
+                 }
+ 
+                 // Update any tile entity data for this block
+                if (!captureSentBlockEntities) { // Paper - Toggle this location for capturing as this is used for api
+                 BlockEntity tileentity = this.level.getBlockEntity(pos);
+                 if (tileentity != null) {
+                     this.player.connection.send(tileentity.getUpdatePacket());
+                 }
+                } else {capturedBlockEntity = true;} // Paper end
+                 return false;
+             }
+         }
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 6726fc470843b900ce7b15268cdcbf4881a8fcd0..d7f551d8cae2055b82782905a14d649e44e8bcec 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1779,8 +1779,28 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                     return;
+                 }
+                 // Paper end - Don't allow digging in unloaded chunks
+                // Paper start - send block entities after prediction
+                this.player.gameMode.capturedBlockEntity = false;
+                this.player.gameMode.captureSentBlockEntities = true;
+                // Paper end - send block entities after prediction
+                 this.player.gameMode.handleBlockBreakAction(blockposition, packetplayinblockdig_enumplayerdigtype, packet.getDirection(), this.player.level().getMaxBuildHeight(), packet.getSequence());
+                 this.player.connection.ackBlockChangesUpTo(packet.getSequence());
+                // Paper start - send block entities after prediction
+                this.player.gameMode.captureSentBlockEntities = false;
+                // If a block entity was modified speedup the block change ack to avoid the block entity
+                // being overriden.
+                if (this.player.gameMode.capturedBlockEntity) {
+                    // manually tick
+                    this.send(new ClientboundBlockChangedAckPacket(this.ackBlockChangesUpTo));
+                    this.player.connection.ackBlockChangesUpTo = -1;
+
+                    this.player.gameMode.capturedBlockEntity = false;
+                    BlockEntity tileentity = this.player.level().getBlockEntity(blockposition);
+                    if (tileentity != null) {
+                        this.player.connection.send(tileentity.getUpdatePacket());
+                    }
+                }
+                // Paper end - send block entities after prediction
+                 return;
+             default:
+                 throw new IllegalArgumentException("Invalid player action");
--- a/patches/server/0832-Warn-on-plugins-accessing-faraway-chunks.patch
+++ b/patches/server/0832-Warn-on-plugins-accessing-faraway-chunks.patch
@ -0,0 +1,96 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Fri, 29 Jul 2022 12:35:19 -0400
+Subject: [PATCH] Warn on plugins accessing faraway chunks
+
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 7886c49b1b224469b8b542023891b2645b69ec71..d26216ad6395f6d74a7fa4d080f5edfd44605ae4 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -813,7 +813,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     }
+ 
+     private static boolean isInWorldBoundsHorizontal(BlockPos pos) {
+-        return pos.getX() >= -30000000 && pos.getZ() >= -30000000 && pos.getX() < 30000000 && pos.getZ() < 30000000;
+        return pos.getX() >= -30000000 && pos.getZ() >= -30000000 && pos.getX() < 30000000 && pos.getZ() < 30000000; // Dif on change
+     }
+ 
+     private static boolean isOutsideSpawnableHeight(int y) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 3f4145bef3ef0d0d54914c1f6ebd216622d9a747..c77fec78636805a496ecea3e56f26290dbcbffff 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -313,9 +313,24 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     public boolean setSpawnLocation(int x, int y, int z) {
+         return this.setSpawnLocation(x, y, z, 0.0F);
+     }
+    // Paper start
+    private static void warnUnsafeChunk(String reason, int x, int z) {
+        // if any chunk coord is outside of 30 million blocks
+        if (x > 1875000 || z > 1875000 || x < -1875000 || z < -1875000) {
+            Plugin plugin = io.papermc.paper.util.StackWalkerUtil.getFirstPluginCaller();
+            if (plugin != null) {
+                plugin.getLogger().warning("Plugin is %s at (%s, %s), this might cause issues.".formatted(reason, x, z));
+            }
+            if (net.minecraft.server.MinecraftServer.getServer().isDebugging()) {
+                io.papermc.paper.util.TraceUtil.dumpTraceForThread("Dangerous chunk retrieval");
+            }
+        }
+    }
+    // Paper end
+ 
+     @Override
+     public Chunk getChunkAt(int x, int z) {
+        warnUnsafeChunk("getting a faraway chunk", x, z); // Paper
+         // Paper start - add ticket to hold chunk for a little while longer if plugin accesses it
+         net.minecraft.world.level.chunk.LevelChunk chunk = this.world.getChunkSource().getChunkAtIfLoadedImmediately(x, z);
+         if (chunk == null) {
+@@ -430,6 +445,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     @Override
+     public boolean regenerateChunk(int x, int z) {
+         org.spigotmc.AsyncCatcher.catchOp("chunk regenerate"); // Spigot
+        warnUnsafeChunk("regenerating a faraway chunk", x, z); // Paper
+         // Paper start - implement regenerateChunk method
+         final ServerLevel serverLevel = this.world;
+         final net.minecraft.server.level.ServerChunkCache serverChunkCache = serverLevel.getChunkSource();
+@@ -525,6 +541,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     @Override
+     public boolean loadChunk(int x, int z, boolean generate) {
+         org.spigotmc.AsyncCatcher.catchOp("chunk load"); // Spigot
+        warnUnsafeChunk("loading a faraway chunk", x, z); // Paper
+         // Paper start - Optimize this method
+         ChunkPos chunkPos = new ChunkPos(x, z);
+         ChunkAccess immediate = world.getChunkSource().getChunkAtIfLoadedImmediately(x, z); // Paper
+@@ -588,6 +605,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+ 
+     @Override
+     public boolean addPluginChunkTicket(int x, int z, Plugin plugin) {
+        warnUnsafeChunk("adding a faraway chunk ticket", x, z); // Paper
+         Preconditions.checkArgument(plugin != null, "null plugin");
+         Preconditions.checkArgument(plugin.isEnabled(), "plugin is not enabled");
+ 
+@@ -656,6 +674,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+ 
+     @Override
+     public void setChunkForceLoaded(int x, int z, boolean forced) {
+        warnUnsafeChunk("forceloading a faraway chunk", x, z); // Paper
+         this.getHandle().setChunkForced(x, z, forced);
+     }
+ 
+@@ -968,6 +987,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+ 
+     @Override
+     public int getHighestBlockYAt(int x, int z, org.bukkit.HeightMap heightMap) {
+        warnUnsafeChunk("getting a faraway chunk", x >> 4, z >> 4); // Paper
+         // Transient load for this tick
+         return this.world.getChunk(x >> 4, z >> 4).getHeight(CraftHeightMap.toNMS(heightMap), x, z);
+     }
+@@ -2420,6 +2440,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     // Spigot end
+     // Paper start
+     public java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(int x, int z, boolean gen, boolean urgent) {
+        warnUnsafeChunk("getting a faraway chunk async", x, z); // Paper
+         if (Bukkit.isPrimaryThread()) {
+             net.minecraft.world.level.chunk.LevelChunk immediate = this.world.getChunkSource().getChunkAtIfLoadedImmediately(x, z);
+             if (immediate != null) {
--- a/patches/server/0833-Custom-Chat-Completion-Suggestions-API.patch
+++ b/patches/server/0833-Custom-Chat-Completion-Suggestions-API.patch
@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sat, 30 Jul 2022 11:23:05 -0400
+Subject: [PATCH] Custom Chat Completion Suggestions API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index ec18039f7a5577d290c2d5da23aa734ddde62332..50d3de2bb715e7de8243174f66d92e45bae10683 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -649,6 +649,24 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+     // Paper end - sendOpLevel API
+ 
+    // Paper start - custom chat completions API
+    @Override
+    public void addAdditionalChatCompletions(@NotNull Collection<String> completions) {
+        this.getHandle().connection.send(new net.minecraft.network.protocol.game.ClientboundCustomChatCompletionsPacket(
+            net.minecraft.network.protocol.game.ClientboundCustomChatCompletionsPacket.Action.ADD,
+            new ArrayList<>(completions)
+        ));
+    }
+
+    @Override
+    public void removeAdditionalChatCompletions(@NotNull Collection<String> completions) {
+        this.getHandle().connection.send(new net.minecraft.network.protocol.game.ClientboundCustomChatCompletionsPacket(
+            net.minecraft.network.protocol.game.ClientboundCustomChatCompletionsPacket.Action.REMOVE,
+            new ArrayList<>(completions)
+        ));
+    }
+    // Paper end - custom chat completions API
+
+     @Override
+     public void setCompassTarget(Location loc) {
+         Preconditions.checkArgument(loc != null, "Location cannot be null");
--- a/patches/server/0834-Add-and-fix-missing-BlockFadeEvents.patch
+++ b/patches/server/0834-Add-and-fix-missing-BlockFadeEvents.patch
@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Thu, 21 Jul 2022 12:07:54 -0400
+Subject: [PATCH] Add and fix missing BlockFadeEvents
+
+Beyond calling the BlockFadeEvent in more places, this patch also aims
+to pass the proper replacement state to the event, specifically for
+potentially waterlogged block states fading.
+
+Co-authored-by: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com
+
+diff --git a/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java b/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
+index a4ca58384ae2a39ec568b153cc1a4f7704136108..0a2de99c22cfcc96a664dc2afe7379987ea815db 100644
+--- a/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
+@@ -92,6 +92,11 @@ public class FrogspawnBlock extends Block {
+     }
+ 
+     private void hatchFrogspawn(ServerLevel world, BlockPos pos, RandomSource random) {
+        // Paper start - Call BlockFadeEvent
+        if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, Blocks.AIR.defaultBlockState()).isCancelled()) {
+            return;
+        }
+        // Paper end
+         this.destroyBlock(world, pos);
+         world.playSound((Player)null, pos, SoundEvents.FROGSPAWN_HATCH, SoundSource.BLOCKS, 1.0F, 1.0F);
+         this.spawnTadpoles(world, pos, random);
+diff --git a/src/main/java/net/minecraft/world/level/block/ScaffoldingBlock.java b/src/main/java/net/minecraft/world/level/block/ScaffoldingBlock.java
+index f660e58badfcc2a90e6dd618428a21bf5ad34969..13ee09f93ec325e416a2b29e3608e870e7f06aed 100644
+--- a/src/main/java/net/minecraft/world/level/block/ScaffoldingBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/ScaffoldingBlock.java
+@@ -103,7 +103,7 @@ public class ScaffoldingBlock extends Block implements SimpleWaterloggedBlock {
+         int i = ScaffoldingBlock.getDistance(world, pos);
+         BlockState iblockdata1 = (BlockState) ((BlockState) state.setValue(ScaffoldingBlock.DISTANCE, i)).setValue(ScaffoldingBlock.BOTTOM, this.isBottom(world, pos, i));
+ 
+-        if ((Integer) iblockdata1.getValue(ScaffoldingBlock.DISTANCE) == 7 && !org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, Blocks.AIR.defaultBlockState()).isCancelled()) { // CraftBukkit - BlockFadeEvent
+        if ((Integer) iblockdata1.getValue(ScaffoldingBlock.DISTANCE) == 7 && !org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, iblockdata1.getFluidState().createLegacyBlock()).isCancelled()) { // CraftBukkit - BlockFadeEvent // Paper - fix wrong block state
+             if ((Integer) state.getValue(ScaffoldingBlock.DISTANCE) == 7) {
+                 FallingBlockEntity.fall(world, pos, iblockdata1);
+             } else {
+diff --git a/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java b/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+index 615ee22b4948d6a4869dc8b2111f48056969dd79..3cedc349e79665d3d471c92b5dca25c9e66ca0bf 100644
+--- a/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+@@ -61,12 +61,26 @@ public class SnifferEggBlock extends Block {
+         return this.getHatchLevel(state) == 2;
+     }
+ 
+    // Paper start
+    private void rescheduleTick(ServerLevel world, BlockPos pos) {
+        int baseDelay = hatchBoost(world, pos) ? BOOSTED_HATCH_TIME_TICKS : REGULAR_HATCH_TIME_TICKS;
+        world.scheduleTick(pos, this, (baseDelay / 3) + world.random.nextInt(RANDOM_HATCH_OFFSET_TICKS));
+        // reschedule to avoid being stuck here and behave like the other calls (see #onPlace)
+    }
+    // Paper end
+
+     @Override
+     public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
+         if (!this.isReadyToHatch(state)) {
+             world.playSound((Player)null, pos, SoundEvents.SNIFFER_EGG_CRACK, SoundSource.BLOCKS, 0.7F, 0.9F + random.nextFloat() * 0.2F);
+             world.setBlock(pos, state.setValue(HATCH, Integer.valueOf(this.getHatchLevel(state) + 1)), 2);
+         } else {
+            // Paper start - Call BlockFadeEvent
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, state.getFluidState().createLegacyBlock()).isCancelled()) {
+                rescheduleTick(world, pos);
+                return;
+            }
+            // Paper end
+             world.playSound((Player)null, pos, SoundEvents.SNIFFER_EGG_HATCH, SoundSource.BLOCKS, 0.7F, 0.9F + random.nextFloat() * 0.2F);
+             world.destroyBlock(pos, false);
+             Sniffer sniffer = EntityType.SNIFFER.create(world);
--- a/patches/server/0835-Collision-API.patch
+++ b/patches/server/0835-Collision-API.patch
@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Wed, 6 Oct 2021 20:10:44 -0400
+Subject: [PATCH] Collision API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+index 681d29902a14b36e4b72e1ca530e131e1aaf273f..0b7faa5b0fce81fd1790341599c632ffc5b171f3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+@@ -1055,5 +1055,12 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+ 
+         return this.getHandle().clip(new net.minecraft.world.level.ClipContext(start, end, net.minecraft.world.level.ClipContext.Block.COLLIDER, net.minecraft.world.level.ClipContext.Fluid.NONE, null)).getType() == net.minecraft.world.phys.HitResult.Type.MISS;
+     }
+
+    @Override
+    public boolean hasCollisionsIn(@org.jetbrains.annotations.NotNull org.bukkit.util.BoundingBox boundingBox) {
+        net.minecraft.world.phys.AABB aabb = new AABB(boundingBox.getMinX(), boundingBox.getMinY(), boundingBox.getMinZ(), boundingBox.getMaxX(), boundingBox.getMaxY(), boundingBox.getMaxZ(), false);
+
+        return !this.getHandle().noCollision(aabb);
+    }
+     // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index ed30e079c23f564cbd0a45b38586bd12e17c525e..1075c90e51cfea5823a74c07847545e227968ad2 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1479,4 +1479,19 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         return getHandle().isInPowderSnow || getHandle().wasInPowderSnow; // depending on the location in the entity "tick" either could be needed.
+     }
+     // Paper end
+    // Paper Start - Collision API
+    @Override
+    public boolean collidesAt(@org.jetbrains.annotations.NotNull Location location) {
+        net.minecraft.world.phys.AABB aabb = this.getHandle().getBoundingBoxAt(location.getX(), location.getY(), location.getZ());
+
+        return !this.getHandle().level().noCollision(this.getHandle(), aabb);
+    }
+
+    @Override
+    public boolean wouldCollideUsing(@org.jetbrains.annotations.NotNull BoundingBox boundingBox) {
+        net.minecraft.world.phys.AABB aabb = new AABB(boundingBox.getMinX(), boundingBox.getMinY(), boundingBox.getMinZ(), boundingBox.getMaxX(), boundingBox.getMaxY(), boundingBox.getMaxZ(), false);
+
+        return !this.getHandle().level().noCollision(this.getHandle(), aabb);
+    }
+    // Paper End - Collision API
+ }
--- a/patches/server/0836-Fix-suggest-command-message-for-brigadier-syntax-exc.patch
+++ b/patches/server/0836-Fix-suggest-command-message-for-brigadier-syntax-exc.patch
@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: chickeneer <emcchickeneer@gmail.com>
+Date: Mon, 1 Aug 2022 20:13:02 -0500
+Subject: [PATCH] Fix suggest command message for brigadier syntax exceptions
+
+This is a bug accidentally introduced in upstream CB
+
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index 0299b79f3643bf8c4f4da176c20fec64f4601228..6bab6dd39ac316f43768f24fef6490073e6c9bb7 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
+++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -392,7 +392,7 @@ public class Commands {
+             if (commandsyntaxexception.getInput() != null && commandsyntaxexception.getCursor() >= 0) {
+                 int i = Math.min(commandsyntaxexception.getInput().length(), commandsyntaxexception.getCursor());
+                 MutableComponent ichatmutablecomponent = Component.empty().withStyle(ChatFormatting.GRAY).withStyle((chatmodifier) -> {
+-                    return chatmodifier.withClickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, label)); // CraftBukkit
+                    return chatmodifier.withClickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, "/" + label)); // CraftBukkit // Paper
+                 });
+ 
+                 if (i > 10) {
--- a/patches/server/0837-Block-Ticking-API.patch
+++ b/patches/server/0837-Block-Ticking-API.patch
@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sun, 26 Dec 2021 13:23:46 -0500
+Subject: [PATCH] Block Ticking API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
+index 6d10396347b69d9243ab902ecc68ede93fa17b7d..0a96b00a98227714ef99005e0a223765feae8fe9 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
+@@ -709,5 +709,21 @@ public class CraftBlock implements Block {
+     public boolean isValidTool(ItemStack itemStack) {
+         return getDrops(itemStack).size() != 0;
+     }
+
+    @Override
+    public void tick() {
+        net.minecraft.world.level.block.state.BlockState blockData = this.getNMS();
+        net.minecraft.server.level.ServerLevel level = this.world.getMinecraftWorld();
+
+        blockData.getBlock().tick(blockData, level, this.position, level.random);
+    }
+
+    @Override
+    public void randomTick() {
+        net.minecraft.world.level.block.state.BlockState blockData = this.getNMS();
+        net.minecraft.server.level.ServerLevel level = this.world.getMinecraftWorld();
+
+        blockData.getBlock().randomTick(blockData, level, this.position, level.random);
+    }
+     // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java b/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java
+index 79c469d461ce9df0994214ebc8b157a095a4c848..28a798e497c2c12794169068e69b56dd954978f3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java
+@@ -711,4 +711,11 @@ public class CraftBlockData implements BlockData {
+         return speed;
+     }
+     // Paper end - destroy speed API
+
+    // Paper start - Block tick API
+    @Override
+    public boolean isRandomlyTicked() {
+        return this.state.isRandomlyTicking();
+    }
+    // Paper end - Block tick API
+ }
--- a/patches/server/0838-Add-Velocity-IP-Forwarding-Support.patch
+++ b/patches/server/0838-Add-Velocity-IP-Forwarding-Support.patch
@ -0,0 +1,229 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Andrew Steinborn <git@steinborn.me>
+Date: Mon, 8 Oct 2018 14:36:14 -0400
+Subject: [PATCH] Add Velocity IP Forwarding Support
+
+While Velocity supports BungeeCord-style IP forwarding, it is not secure. Users
+have a lot of problems setting up firewalls or setting up plugins like IPWhitelist.
+Further, the BungeeCord IP forwarding protocol still retains essentially its original
+form, when there is brand new support for custom login plugin messages in 1.13.
+
+Velocity's modern IP forwarding uses an HMAC-SHA256 code to ensure authenticity
+of messages, is packed into a binary format that is smaller than BungeeCord's
+forwarding, and is integrated into the Minecraft login process by using the 1.13
+login plugin message packet.
+
+diff --git a/src/main/java/com/destroystokyo/paper/proxy/VelocityProxy.java b/src/main/java/com/destroystokyo/paper/proxy/VelocityProxy.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a34381122de53123169927e181df662814df4816
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/proxy/VelocityProxy.java
+@@ -0,0 +1,75 @@
+package com.destroystokyo.paper.proxy;
+
+import io.papermc.paper.configuration.GlobalConfiguration;
+import com.google.common.net.InetAddresses;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import java.net.InetAddress;
+import java.security.InvalidKeyException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.UUID;
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.protocol.login.custom.CustomQueryPayload;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.player.ProfilePublicKey;
+
+public class VelocityProxy {
+    private static final int SUPPORTED_FORWARDING_VERSION = 1;
+    public static final int MODERN_FORWARDING_WITH_KEY = 2;
+    public static final int MODERN_FORWARDING_WITH_KEY_V2 = 3;
+    public static final int MODERN_LAZY_SESSION = 4;
+    public static final byte MAX_SUPPORTED_FORWARDING_VERSION = MODERN_LAZY_SESSION;
+    public static final ResourceLocation PLAYER_INFO_CHANNEL = new ResourceLocation("velocity", "player_info");
+
+    public static boolean checkIntegrity(final FriendlyByteBuf buf) {
+        final byte[] signature = new byte[32];
+        buf.readBytes(signature);
+
+        final byte[] data = new byte[buf.readableBytes()];
+        buf.getBytes(buf.readerIndex(), data);
+
+        try {
+            final Mac mac = Mac.getInstance("HmacSHA256");
+            mac.init(new SecretKeySpec(GlobalConfiguration.get().proxies.velocity.secret.getBytes(java.nio.charset.StandardCharsets.UTF_8), "HmacSHA256"));
+            final byte[] mySignature = mac.doFinal(data);
+            if (!MessageDigest.isEqual(signature, mySignature)) {
+                return false;
+            }
+        } catch (final InvalidKeyException | NoSuchAlgorithmException e) {
+            throw new AssertionError(e);
+        }
+
+        return true;
+    }
+
+    public static InetAddress readAddress(final FriendlyByteBuf buf) {
+        return InetAddresses.forString(buf.readUtf(Short.MAX_VALUE));
+    }
+
+    public static GameProfile createProfile(final FriendlyByteBuf buf) {
+        final GameProfile profile = new GameProfile(buf.readUUID(), buf.readUtf(16));
+        readProperties(buf, profile);
+        return profile;
+    }
+
+    private static void readProperties(final FriendlyByteBuf buf, final GameProfile profile) {
+        final int properties = buf.readVarInt();
+        for (int i1 = 0; i1 < properties; i1++) {
+            final String name = buf.readUtf(Short.MAX_VALUE);
+            final String value = buf.readUtf(Short.MAX_VALUE);
+            final String signature = buf.readBoolean() ? buf.readUtf(Short.MAX_VALUE) : null;
+            profile.getProperties().put(name, new Property(name, value, signature));
+        }
+    }
+
+    public static ProfilePublicKey.Data readForwardedKey(FriendlyByteBuf buf) {
+        return new ProfilePublicKey.Data(buf);
+    }
+
+    public static UUID readSignerUuidOrElse(FriendlyByteBuf buf, UUID orElse) {
+        return buf.readBoolean() ? buf.readUUID() : orElse;
+    }
+}
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index 5264235c1547c78b8123e2efb07dcb77486cc5bf..db363bca264e37c29fda58291246aba0d3759de0 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -274,13 +274,20 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         this.server.enablePlugins(org.bukkit.plugin.PluginLoadOrder.STARTUP);
+         // CraftBukkit end
+ 
+        // Paper start
+        boolean usingProxy = org.spigotmc.SpigotConfig.bungee || io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled;
+        String proxyFlavor = (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) ? "Velocity" : "BungeeCord";
+        String proxyLink = (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) ? "https://docs.papermc.io/velocity/security" : "http://www.spigotmc.org/wiki/firewall-guide/";
+        // Paper end
+         if (!this.usesAuthentication()) {
+             DedicatedServer.LOGGER.warn("**** SERVER IS RUNNING IN OFFLINE/INSECURE MODE!");
+             DedicatedServer.LOGGER.warn("The server will make no attempt to authenticate usernames. Beware.");
+             // Spigot start
+-            if (org.spigotmc.SpigotConfig.bungee) {
+-                DedicatedServer.LOGGER.warn("Whilst this makes it possible to use BungeeCord, unless access to your server is properly restricted, it also opens up the ability for hackers to connect with any username they choose.");
+-                DedicatedServer.LOGGER.warn("Please see http://www.spigotmc.org/wiki/firewall-guide/ for further information.");
+            // Paper start
+            if (usingProxy) {
+                DedicatedServer.LOGGER.warn("Whilst this makes it possible to use " + proxyFlavor + ", unless access to your server is properly restricted, it also opens up the ability for hackers to connect with any username they choose.");
+                DedicatedServer.LOGGER.warn("Please see " + proxyLink + " for further information.");
+            // Paper end
+             } else {
+                 DedicatedServer.LOGGER.warn("While this makes the game possible to play without internet access, it also opens up the ability for hackers to connect with any username they choose.");
+             }
+diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+index 5c767318ff3f589ecebb9608ce173fa578e330a5..83605748ca8cf68c0fc6d99c34f3091183c7a059 100644
+--- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+@@ -64,6 +64,7 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+     private final String serverId;
+     private ServerPlayer player; // CraftBukkit
+     public boolean iKnowThisMayNotBeTheBestIdeaButPleaseDisableUsernameValidation = false; // Paper - username validation overriding
+    private int velocityLoginMessageId = -1; // Paper - Velocity support
+ 
+     public ServerLoginPacketListenerImpl(MinecraftServer server, Connection connection) {
+         this.state = ServerLoginPacketListenerImpl.State.HELLO;
+@@ -177,6 +178,16 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+                 this.state = ServerLoginPacketListenerImpl.State.KEY;
+                 this.connection.send(new ClientboundHelloPacket("", this.server.getKeyPair().getPublic().getEncoded(), this.challenge));
+             } else {
+                // Paper start - Velocity support
+                if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) {
+                    this.velocityLoginMessageId = java.util.concurrent.ThreadLocalRandom.current().nextInt();
+                    net.minecraft.network.FriendlyByteBuf buf = new net.minecraft.network.FriendlyByteBuf(io.netty.buffer.Unpooled.buffer());
+                    buf.writeByte(com.destroystokyo.paper.proxy.VelocityProxy.MAX_SUPPORTED_FORWARDING_VERSION);
+                    net.minecraft.network.protocol.login.ClientboundCustomQueryPacket packet1 = new net.minecraft.network.protocol.login.ClientboundCustomQueryPacket(this.velocityLoginMessageId, new net.minecraft.network.protocol.login.ClientboundCustomQueryPacket.PlayerInfoChannelPayload(com.destroystokyo.paper.proxy.VelocityProxy.PLAYER_INFO_CHANNEL, buf));
+                    this.connection.send(packet1);
+                    return;
+                }
+                // Paper end
+                 // Spigot start
+             // Paper start - Cache authenticator threads
+             authenticatorPool.execute(new Runnable() {
+@@ -314,6 +325,12 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+     public class LoginHandler {
+ 
+         public void fireEvents(GameProfile gameprofile) throws Exception {
+                        // Paper start - Velocity support
+                        if (ServerLoginPacketListenerImpl.this.velocityLoginMessageId == -1 && io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) {
+                            disconnect("This server requires you to connect with Velocity.");
+                            return;
+                        }
+                        // Paper end
+                         String playerName = gameprofile.getName();
+                         java.net.InetAddress address = ((java.net.InetSocketAddress) ServerLoginPacketListenerImpl.this.connection.getRemoteAddress()).getAddress();
+                         java.net.InetAddress rawAddress = ((java.net.InetSocketAddress) ServerLoginPacketListenerImpl.this.connection.channel.remoteAddress()).getAddress(); // Paper
+@@ -363,6 +380,49 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+ 
+     @Override
+     public void handleCustomQueryPacket(ServerboundCustomQueryAnswerPacket packet) {
+        // Paper start - Velocity support
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled && packet.transactionId() == this.velocityLoginMessageId) {
+            ServerboundCustomQueryAnswerPacket.QueryAnswerPayload payload = (ServerboundCustomQueryAnswerPacket.QueryAnswerPayload)packet.payload();
+            if (payload == null) {
+                this.disconnect("This server requires you to connect with Velocity.");
+                return;
+            }
+
+            net.minecraft.network.FriendlyByteBuf buf = payload.buffer;
+
+            if (!com.destroystokyo.paper.proxy.VelocityProxy.checkIntegrity(buf)) {
+                this.disconnect("Unable to verify player details");
+                return;
+            }
+
+            int version = buf.readVarInt();
+            if (version > com.destroystokyo.paper.proxy.VelocityProxy.MAX_SUPPORTED_FORWARDING_VERSION) {
+                throw new IllegalStateException("Unsupported forwarding version " + version + ", wanted upto " + com.destroystokyo.paper.proxy.VelocityProxy.MAX_SUPPORTED_FORWARDING_VERSION);
+            }
+
+            java.net.SocketAddress listening = this.connection.getRemoteAddress();
+            int port = 0;
+            if (listening instanceof java.net.InetSocketAddress) {
+                port = ((java.net.InetSocketAddress) listening).getPort();
+            }
+            this.connection.address = new java.net.InetSocketAddress(com.destroystokyo.paper.proxy.VelocityProxy.readAddress(buf), port);
+
+            this.authenticatedProfile = com.destroystokyo.paper.proxy.VelocityProxy.createProfile(buf);
+
+            //TODO Update handling for lazy sessions, might not even have to do anything?
+
+            // Proceed with login
+            authenticatorPool.execute(() -> {
+                try {
+                    new LoginHandler().fireEvents(this.authenticatedProfile);
+                } catch (Exception ex) {
+                    disconnect("Failed to verify username!");
+                    server.server.getLogger().log(java.util.logging.Level.WARNING, "Exception verifying " + this.authenticatedProfile.getName(), ex);
+                }
+            });
+            return;
+        }
+        // Paper end
+         this.disconnect(ServerLoginPacketListenerImpl.DISCONNECT_UNEXPECTED_QUERY);
+     }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 7c8d21499d49aa88ad771e98a8e5302d1b3a3229..97a32d1d4bc4042c72c488eee92dff69f8336464 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -802,7 +802,7 @@ public final class CraftServer implements Server {
+     @Override
+     public long getConnectionThrottle() {
+         // Spigot Start - Automatically set connection throttle for bungee configurations
+-        if (org.spigotmc.SpigotConfig.bungee) {
+        if (org.spigotmc.SpigotConfig.bungee || io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) { // Paper - Velocity support
+             return -1;
+         } else {
+             return this.configuration.getInt("settings.connection-throttle");
--- a/patches/server/0839-Use-thread-safe-random-in-ServerLoginPacketListenerI.patch
+++ b/patches/server/0839-Use-thread-safe-random-in-ServerLoginPacketListenerI.patch
@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Thu, 11 Aug 2022 14:37:33 +0100
+Subject: [PATCH] Use thread safe random in ServerLoginPacketListenerImpl
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+index 83605748ca8cf68c0fc6d99c34f3091183c7a059..601691db6943ae78530d01468e581760f2331b43 100644
+--- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+@@ -52,6 +52,7 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+     private static final java.util.concurrent.ExecutorService authenticatorPool = java.util.concurrent.Executors.newCachedThreadPool(new com.google.common.util.concurrent.ThreadFactoryBuilder().setNameFormat("User Authenticator #%d").setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(LOGGER)).build()); // Paper - Cache authenticator threads
+     private static final int MAX_TICKS_BEFORE_LOGIN = 600;
+     private static final Component DISCONNECT_UNEXPECTED_QUERY = Component.translatable("multiplayer.disconnect.unexpected_query_response");
+    private static final RandomSource RANDOM = new org.bukkit.craftbukkit.util.RandomSourceWrapper(new java.util.Random()); // Paper - This is called across threads, make safe
+     private final byte[] challenge;
+     final MinecraftServer server;
+     public final Connection connection;
--- a/patches/server/0840-Add-NamespacedKey-biome-methods.patch
+++ b/patches/server/0840-Add-NamespacedKey-biome-methods.patch
@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Josh Roy <10731363+JRoy@users.noreply.github.com>
+Date: Sun, 14 Aug 2022 12:23:11 -0400
+Subject: [PATCH] Add NamespacedKey biome methods
+
+Co-authored-by: Thonk <30448663+ExcessiveAmountsOfZombies@users.noreply.github.com>
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+index ef59fcd13f8835001fcc6fba6165ffd6c35784fa..7cfb8ffd7d107aef20a86d044b453c49e9f59b7f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+@@ -601,6 +601,19 @@ public final class CraftMagicNumbers implements UnsafeValues {
+         Preconditions.checkArgument(material.isBlock(), material + " is not a block");
+         return getBlock(material).hasCollision;
+     }
+
+    @Override
+    public org.bukkit.NamespacedKey getBiomeKey(org.bukkit.RegionAccessor accessor, int x, int y, int z) {
+        org.bukkit.craftbukkit.CraftRegionAccessor cra = (org.bukkit.craftbukkit.CraftRegionAccessor) accessor;
+        return org.bukkit.craftbukkit.util.CraftNamespacedKey.fromMinecraft(cra.getHandle().registryAccess().registryOrThrow(net.minecraft.core.registries.Registries.BIOME).getKey(cra.getHandle().getBiome(new net.minecraft.core.BlockPos(x, y, z)).value()));
+    }
+
+    @Override
+    public void setBiomeKey(org.bukkit.RegionAccessor accessor, int x, int y, int z, org.bukkit.NamespacedKey biomeKey) {
+        org.bukkit.craftbukkit.CraftRegionAccessor cra = (org.bukkit.craftbukkit.CraftRegionAccessor) accessor;
+        net.minecraft.core.Holder<net.minecraft.world.level.biome.Biome> biomeBase = cra.getHandle().registryAccess().registryOrThrow(net.minecraft.core.registries.Registries.BIOME).getHolderOrThrow(net.minecraft.resources.ResourceKey.create(net.minecraft.core.registries.Registries.BIOME, org.bukkit.craftbukkit.util.CraftNamespacedKey.toMinecraft(biomeKey)));
+        cra.setBiome(x, y, z, biomeBase);
+    }
+     // Paper end
+ 
+     /**
--- a/patches/server/0841-Fix-plugin-loggers-on-server-shutdown.patch
+++ b/patches/server/0841-Fix-plugin-loggers-on-server-shutdown.patch
@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Jos=C3=A9=20Miguel=20Moreno?= <josemmo@pm.me>
+Date: Sat, 5 Jun 2021 13:45:15 +0200
+Subject: [PATCH] Fix plugin loggers on server shutdown
+
+
+diff --git a/src/main/java/io/papermc/paper/log/CustomLogManager.java b/src/main/java/io/papermc/paper/log/CustomLogManager.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c1d3bac79bb8b4796c013ff4472f75dcd79602dc
+--- /dev/null
+++ b/src/main/java/io/papermc/paper/log/CustomLogManager.java
+@@ -0,0 +1,26 @@
+package io.papermc.paper.log;
+
+import java.util.logging.LogManager;
+
+public class CustomLogManager extends LogManager {
+    private static CustomLogManager instance;
+
+    public CustomLogManager() {
+        instance = this;
+    }
+
+    @Override
+    public void reset() {
+        // Ignore calls to this method
+    }
+
+    private void superReset() {
+        super.reset();
+    }
+
+    public static void forceReset() {
+        if (instance != null) {
+            instance.superReset();
+        }
+    }
+}
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 00de78e06b4583880e00f57823a4929eb1484e7a..92468b925a742b8e4ab741c39677fb3656f8481b 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1026,6 +1026,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Use TerminalConsoleAppender
+         } catch (Exception e) {
+         }
+        io.papermc.paper.log.CustomLogManager.forceReset(); // Paper - Reset loggers after shutdown
+         this.onServerExit();
+         // Paper end - move final shutdown items here
+     }
+diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
+index f402d0ecc6ed3bfe76a3a2b6780dda5b8ecdd750..f37ac6edc60545600ccd22bfac072585d11b449b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/Main.java
+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
+@@ -18,6 +18,12 @@ public class Main {
+     public static boolean useJline = true;
+     public static boolean useConsole = true;
+ 
+    // Paper start - Hijack log manager to ensure logging on shutdown
+    static {
+        System.setProperty("java.util.logging.manager", "io.papermc.paper.log.CustomLogManager");
+    }
+    // Paper end
+
+     public static void main(String[] args) {
+         // Paper start
+         final String warnWhenLegacyFormattingDetected = String.join(".", "net", "kyori", "adventure", "text", "warnWhenLegacyFormattingDetected");
--- a/patches/server/0842-Stop-large-look-changes-from-crashing-the-server.patch
+++ b/patches/server/0842-Stop-large-look-changes-from-crashing-the-server.patch
@ -0,0 +1,74 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MWHunter <s0521458@student.rockvalleycollege.edu>
+Date: Wed, 24 Aug 2022 09:54:11 -0400
+Subject: [PATCH] Stop large look changes from crashing the server
+
+Co-authored-by: Jaren Knodel <Jaren@Knodel.com>
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index a21de30eef397308e3f4866a16cc588012e16f50..ece2f45427462587e28ba770178e13d7037e6668 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3056,37 +3056,15 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         this.level().getProfiler().pop();
+         this.level().getProfiler().push("rangeChecks");
+ 
+-        while (this.getYRot() - this.yRotO < -180.0F) {
+-            this.yRotO -= 360.0F;
+-        }
+-
+-        while (this.getYRot() - this.yRotO >= 180.0F) {
+-            this.yRotO += 360.0F;
+-        }
+        // Paper start - stop large pitch and yaw changes from crashing the server
+        this.yRotO += Math.round((this.getYRot() - this.yRotO) / 360.0F) * 360.0F;
+ 
+-        while (this.yBodyRot - this.yBodyRotO < -180.0F) {
+-            this.yBodyRotO -= 360.0F;
+-        }
+        this.yBodyRotO += Math.round((this.yBodyRot - this.yBodyRotO) / 360.0F) * 360.0F;
+ 
+-        while (this.yBodyRot - this.yBodyRotO >= 180.0F) {
+-            this.yBodyRotO += 360.0F;
+-        }
+-
+-        while (this.getXRot() - this.xRotO < -180.0F) {
+-            this.xRotO -= 360.0F;
+-        }
+        this.xRotO += Math.round((this.getXRot() - this.xRotO) / 360.0F) * 360.0F;
+ 
+-        while (this.getXRot() - this.xRotO >= 180.0F) {
+-            this.xRotO += 360.0F;
+-        }
+-
+-        while (this.yHeadRot - this.yHeadRotO < -180.0F) {
+-            this.yHeadRotO -= 360.0F;
+-        }
+-
+-        while (this.yHeadRot - this.yHeadRotO >= 180.0F) {
+-            this.yHeadRotO += 360.0F;
+-        }
+        this.yHeadRotO += Math.round((this.yHeadRot - this.yHeadRotO) / 360.0F) * 360.0F;
+        // Paper end
+ 
+         this.level().getProfiler().pop();
+         this.animStep += f2;
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+index 621cb07c02cf318bf1b72c14724a42e0987d5b2f..5d779e75a1516487c53d96744613f292b0ccd1f7 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+@@ -271,13 +271,7 @@ public abstract class Projectile extends Entity implements TraceableEntity {
+     }
+ 
+     protected static float lerpRotation(float prevRot, float newRot) {
+-        while (newRot - prevRot < -180.0F) {
+-            prevRot -= 360.0F;
+-        }
+-
+-        while (newRot - prevRot >= 180.0F) {
+-            prevRot += 360.0F;
+-        }
+        prevRot += Math.round((newRot - prevRot) / 360.0F) * 360.0F; // Paper - stop large look changes from crashing the server
+ 
+         return Mth.lerp(0.2F, prevRot, newRot);
+     }
--- a/patches/server/0843-Fire-EntityChangeBlockEvent-in-more-places.patch
+++ b/patches/server/0843-Fire-EntityChangeBlockEvent-in-more-places.patch
@ -0,0 +1,274 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Mon, 9 Aug 2021 20:45:46 -0700
+Subject: [PATCH] Fire EntityChangeBlockEvent in more places
+
+Co-authored-by: ChristopheG <61288881+chrisgdt@users.noreply.github.com>
+
+diff --git a/src/main/java/net/minecraft/world/entity/LightningBolt.java b/src/main/java/net/minecraft/world/entity/LightningBolt.java
+index 80740ca823915fb2c854f13445d81964e0e971e5..255fb5e922c63130708e4bcab208b4db52a58387 100644
+--- a/src/main/java/net/minecraft/world/entity/LightningBolt.java
+++ b/src/main/java/net/minecraft/world/entity/LightningBolt.java
+@@ -98,7 +98,7 @@ public class LightningBolt extends Entity {
+                 }
+ 
+                 this.powerLightningRod();
+-                LightningBolt.clearCopperOnLightningStrike(this.level(), this.getStrikePosition());
+                LightningBolt.clearCopperOnLightningStrike(this.level(), this.getStrikePosition(), this); // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+                 this.gameEvent(GameEvent.LIGHTNING_STRIKE);
+             }
+         }
+@@ -192,7 +192,7 @@ public class LightningBolt extends Entity {
+         }
+     }
+ 
+-    private static void clearCopperOnLightningStrike(Level world, BlockPos pos) {
+    private static void clearCopperOnLightningStrike(Level world, BlockPos pos, Entity lightning) { // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+         BlockState iblockdata = world.getBlockState(pos);
+         BlockPos blockposition1;
+         BlockState iblockdata1;
+@@ -206,24 +206,29 @@ public class LightningBolt extends Entity {
+         }
+ 
+         if (iblockdata1.getBlock() instanceof WeatheringCopper) {
+-            world.setBlockAndUpdate(blockposition1, WeatheringCopper.getFirst(world.getBlockState(blockposition1)));
+            // Paper start - call EntityChangeBlockEvent
+            BlockState newBlock = WeatheringCopper.getFirst(world.getBlockState(blockposition1));
+            if (CraftEventFactory.callEntityChangeBlockEvent(lightning, blockposition1, newBlock)) {
+                world.setBlockAndUpdate(blockposition1, newBlock);
+            }
+            // Paper end
+             BlockPos.MutableBlockPos blockposition_mutableblockposition = pos.mutable();
+             int i = world.random.nextInt(3) + 3;
+ 
+             for (int j = 0; j < i; ++j) {
+                 int k = world.random.nextInt(8) + 1;
+ 
+-                LightningBolt.randomWalkCleaningCopper(world, blockposition1, blockposition_mutableblockposition, k);
+                LightningBolt.randomWalkCleaningCopper(world, blockposition1, blockposition_mutableblockposition, k, lightning); // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+             }
+ 
+         }
+     }
+ 
+-    private static void randomWalkCleaningCopper(Level world, BlockPos pos, BlockPos.MutableBlockPos mutablePos, int count) {
+    private static void randomWalkCleaningCopper(Level world, BlockPos pos, BlockPos.MutableBlockPos mutablePos, int count, Entity lightning) { // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+         mutablePos.set(pos);
+ 
+         for (int j = 0; j < count; ++j) {
+-            Optional<BlockPos> optional = LightningBolt.randomStepCleaningCopper(world, mutablePos);
+            Optional<BlockPos> optional = LightningBolt.randomStepCleaningCopper(world, mutablePos, lightning); // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+ 
+             if (optional.isEmpty()) {
+                 break;
+@@ -234,7 +239,7 @@ public class LightningBolt extends Entity {
+ 
+     }
+ 
+-    private static Optional<BlockPos> randomStepCleaningCopper(Level world, BlockPos pos) {
+    private static Optional<BlockPos> randomStepCleaningCopper(Level world, BlockPos pos, Entity lightning) { // Paper - transmit LightningBolt instance to call EntityChangeBlockEvent
+         Iterator iterator = BlockPos.randomInCube(world.random, 10, pos, 1).iterator();
+ 
+         BlockPos blockposition1;
+@@ -251,6 +256,7 @@ public class LightningBolt extends Entity {
+ 
+         BlockPos blockposition1Final = blockposition1; // CraftBukkit - decompile error
+         WeatheringCopper.getPrevious(iblockdata).ifPresent((iblockdata1) -> {
+            if (CraftEventFactory.callEntityChangeBlockEvent(lightning, blockposition1Final, iblockdata1)) // Paper - call EntityChangeBlockEvent
+             world.setBlockAndUpdate(blockposition1Final, iblockdata1); // CraftBukkit - decompile error
+         });
+         world.levelEvent(3002, blockposition1, -1);
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/TryLaySpawnOnWaterNearLand.java b/src/main/java/net/minecraft/world/entity/ai/behavior/TryLaySpawnOnWaterNearLand.java
+index 2c443b421e342ebfbdf941a431ba20560521920b..91b68ee3605afdb845405e455c869e48a7fc9aab 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/TryLaySpawnOnWaterNearLand.java
+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/TryLaySpawnOnWaterNearLand.java
+@@ -27,6 +27,12 @@ public class TryLaySpawnOnWaterNearLand {
+                                 BlockPos blockPos3 = blockPos2.above();
+                                 if (world.getBlockState(blockPos3).isAir()) {
+                                     BlockState blockState = frogSpawn.defaultBlockState();
+                                    // Paper start
+                                    if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, blockPos3, blockState)) {
+                                        isPregnant.erase(); // forgot pregnant memory
+                                        return true;
+                                    }
+                                    // Paper end
+                                     world.setBlock(blockPos3, blockState, 3);
+                                     world.gameEvent(GameEvent.BLOCK_PLACE, blockPos3, GameEvent.Context.of(entity, blockState));
+                                     world.playSound((Player)null, entity, SoundEvents.FROG_LAY_SPAWN, SoundSource.BLOCKS, 1.0F, 1.0F);
+diff --git a/src/main/java/net/minecraft/world/item/AxeItem.java b/src/main/java/net/minecraft/world/item/AxeItem.java
+index db507638a97b5a33df712c54daff35b21922c0dd..2e75fd06e9e379eb95ebfe55086ffc327706ab2f 100644
+--- a/src/main/java/net/minecraft/world/item/AxeItem.java
+++ b/src/main/java/net/minecraft/world/item/AxeItem.java
+@@ -38,6 +38,11 @@ public class AxeItem extends DiggerItem {
+             return InteractionResult.PASS;
+         } else {
+             ItemStack itemStack = context.getItemInHand();
+            // Paper start - EntityChangeBlockEvent
+            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(player, blockPos, optional.get())) {
+                return InteractionResult.PASS;
+            }
+            // Paper end
+             if (player instanceof ServerPlayer) {
+                 CriteriaTriggers.ITEM_USED_ON_BLOCK.trigger((ServerPlayer)player, blockPos, itemStack);
+             }
+diff --git a/src/main/java/net/minecraft/world/item/EnderEyeItem.java b/src/main/java/net/minecraft/world/item/EnderEyeItem.java
+index 1fddc9025a9e5079f05dd6c86f6ca43c5d51d9c3..6d45e3ebea6721b9c168fea572e9bd610eb54431 100644
+--- a/src/main/java/net/minecraft/world/item/EnderEyeItem.java
+++ b/src/main/java/net/minecraft/world/item/EnderEyeItem.java
+@@ -43,6 +43,11 @@ public class EnderEyeItem extends Item {
+                 return InteractionResult.SUCCESS;
+             } else {
+                 BlockState iblockdata1 = (BlockState) iblockdata.setValue(EndPortalFrameBlock.HAS_EYE, true);
+                // Paper start
+                if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(context.getPlayer(), blockposition, iblockdata1)) {
+                    return InteractionResult.PASS;
+                }
+                // Paper end
+ 
+                 Block.pushEntitiesUp(iblockdata, iblockdata1, world, blockposition);
+                 world.setBlock(blockposition, iblockdata1, 2);
+diff --git a/src/main/java/net/minecraft/world/item/HoneycombItem.java b/src/main/java/net/minecraft/world/item/HoneycombItem.java
+index 78bdf7c0a058e84cafcd831c6d6f5123c0f168b0..e0cae3b6848af74fefc37a1e3183c501155c4710 100644
+--- a/src/main/java/net/minecraft/world/item/HoneycombItem.java
+++ b/src/main/java/net/minecraft/world/item/HoneycombItem.java
+@@ -39,6 +39,14 @@ public class HoneycombItem extends Item implements SignApplicator {
+         return getWaxed(blockState).map((state) -> {
+             Player player = context.getPlayer();
+             ItemStack itemStack = context.getItemInHand();
+            // Paper start - EntityChangeBlockEvent
+            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(player, blockPos, state)) {
+                if (!player.isCreative()) {
+                    player.containerMenu.sendAllDataToRemote();
+                }
+                return InteractionResult.PASS;
+            }
+            // Paper end
+             if (player instanceof ServerPlayer) {
+                 CriteriaTriggers.ITEM_USED_ON_BLOCK.trigger((ServerPlayer)player, blockPos, itemStack);
+             }
+diff --git a/src/main/java/net/minecraft/world/item/PotionItem.java b/src/main/java/net/minecraft/world/item/PotionItem.java
+index d7ef159cc44787558ba41964f57a79f048371e97..0a61a03c4aa9a66548896126b6f72c7a3474ba5a 100644
+--- a/src/main/java/net/minecraft/world/item/PotionItem.java
+++ b/src/main/java/net/minecraft/world/item/PotionItem.java
+@@ -107,6 +107,12 @@ public class PotionItem extends Item {
+         BlockState iblockdata = world.getBlockState(blockposition);
+ 
+         if (context.getClickedFace() != Direction.DOWN && iblockdata.is(BlockTags.CONVERTABLE_TO_MUD) && PotionUtils.getPotion(itemstack) == Potions.WATER) {
+            // Paper start
+            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entityhuman, blockposition, Blocks.MUD.defaultBlockState())) {
+                entityhuman.containerMenu.sendAllDataToRemote();
+                return InteractionResult.PASS;
+            }
+            // Paper end
+             world.playSound((Player) null, blockposition, SoundEvents.GENERIC_SPLASH, SoundSource.BLOCKS, 1.0F, 1.0F);
+             entityhuman.setItemInHand(context.getHand(), ItemUtils.createFilledResult(itemstack, entityhuman, new ItemStack(Items.GLASS_BOTTLE)));
+             entityhuman.awardStat(Stats.ITEM_USED.get(itemstack.getItem()));
+diff --git a/src/main/java/net/minecraft/world/item/ShovelItem.java b/src/main/java/net/minecraft/world/item/ShovelItem.java
+index 32995cb5efdad0bc34ecacacb78cccd21220ba8d..21212462e6b415e96536a27b2c009d1562f18946 100644
+--- a/src/main/java/net/minecraft/world/item/ShovelItem.java
+++ b/src/main/java/net/minecraft/world/item/ShovelItem.java
+@@ -36,20 +36,29 @@ public class ShovelItem extends DiggerItem {
+             Player player = context.getPlayer();
+             BlockState blockState2 = FLATTENABLES.get(blockState.getBlock());
+             BlockState blockState3 = null;
+            Runnable afterAction = null; // Paper
+             if (blockState2 != null && level.getBlockState(blockPos.above()).isAir()) {
+-                level.playSound(player, blockPos, SoundEvents.SHOVEL_FLATTEN, SoundSource.BLOCKS, 1.0F, 1.0F);
+                afterAction = () -> level.playSound(player, blockPos, SoundEvents.SHOVEL_FLATTEN, SoundSource.BLOCKS, 1.0F, 1.0F); // Paper
+                 blockState3 = blockState2;
+             } else if (blockState.getBlock() instanceof CampfireBlock && blockState.getValue(CampfireBlock.LIT)) {
+                afterAction = () -> { // Paper
+                 if (!level.isClientSide()) {
+                     level.levelEvent((Player)null, 1009, blockPos, 0);
+                 }
+ 
+                 CampfireBlock.dowse(context.getPlayer(), level, blockPos, blockState);
+                }; // Paper
+                 blockState3 = blockState.setValue(CampfireBlock.LIT, Boolean.valueOf(false));
+             }
+ 
+             if (blockState3 != null) {
+                 if (!level.isClientSide) {
+                    // Paper start
+                    if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(context.getPlayer(), blockPos, blockState3)) {
+                        return InteractionResult.PASS;
+                    }
+                    afterAction.run();
+                    // Paper end
+                     level.setBlock(blockPos, blockState3, 11);
+                     level.gameEvent(GameEvent.BLOCK_CHANGE, blockPos, GameEvent.Context.of(player, blockState3));
+                     if (player != null) {
+diff --git a/src/main/java/net/minecraft/world/level/block/ComposterBlock.java b/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
+index 6cccdd1d19488275ff3fe90838cf1c31e844d517..413b307acaad5823b9e06f49fa2faf561f5f7b9a 100644
+--- a/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
+@@ -238,6 +238,11 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+         if (i < 8 && ComposterBlock.COMPOSTABLES.containsKey(itemstack.getItem())) {
+             if (i < 7 && !world.isClientSide) {
+                 BlockState iblockdata1 = ComposterBlock.addItem(player, state, world, pos, itemstack);
+                // Paper start - handle cancelled events
+                if (iblockdata1 == null) {
+                    return InteractionResult.PASS;
+                }
+                // Paper end
+ 
+                 world.levelEvent(1500, pos, state != iblockdata1 ? 1 : 0);
+                 player.awardStat(Stats.ITEM_USED.get(itemstack.getItem()));
+@@ -261,11 +266,16 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+         if (i < 7 && ComposterBlock.COMPOSTABLES.containsKey(stack.getItem())) {
+             // CraftBukkit start
+             double rand = world.getRandom().nextDouble();
+-            BlockState iblockdata1 = ComposterBlock.addItem(user, state, DummyGeneratorAccess.INSTANCE, pos, stack, rand);
+-            if (state == iblockdata1 || !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(user, pos, iblockdata1)) {
+            BlockState iblockdata1 = null; // Paper
+            if (false && (state == iblockdata1 || !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(user, pos, iblockdata1))) { // Paper - move event call into addItem
+                 return state;
+             }
+             iblockdata1 = ComposterBlock.addItem(user, state, world, pos, stack, rand);
+            // Paper start - handle cancelled events
+            if (iblockdata1 == null) {
+                return state;
+            }
+            // Paper end
+             // CraftBukkit end
+ 
+             stack.shrink(1);
+@@ -306,11 +316,13 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+         return iblockdata1;
+     }
+ 
+    @Nullable // Paper
+     static BlockState addItem(@Nullable Entity user, BlockState state, LevelAccessor world, BlockPos pos, ItemStack stack) {
+         // CraftBukkit start
+         return ComposterBlock.addItem(user, state, world, pos, stack, world.getRandom().nextDouble());
+     }
+ 
+    @Nullable // Paper - make it nullable
+     static BlockState addItem(@Nullable Entity entity, BlockState iblockdata, LevelAccessor generatoraccess, BlockPos blockposition, ItemStack itemstack, double rand) {
+         // CraftBukkit end
+         int i = (Integer) iblockdata.getValue(ComposterBlock.LEVEL);
+@@ -321,6 +333,11 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+         } else {
+             int j = i + 1;
+             BlockState iblockdata1 = (BlockState) iblockdata.setValue(ComposterBlock.LEVEL, j);
+            // Paper start - move the EntityChangeBlockEvent here to avoid conflict later for the compost events
+            if (entity != null && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, iblockdata1)) {
+                return null;
+            }
+            // Paper end
+ 
+             generatoraccess.setBlock(blockposition, iblockdata1, 3);
+             generatoraccess.gameEvent(GameEvent.BLOCK_CHANGE, blockposition, GameEvent.Context.of(entity, iblockdata1));
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java b/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
+index 32594b4ebe8ab4c820e588573f5e01b08c57984f..a5e34c25e00e7f770bcb6e15ed0bbfe8f369a68a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
+@@ -120,7 +120,7 @@ public class DummyGeneratorAccess implements WorldGenLevel {
+ 
+     @Override
+     public void gameEvent(GameEvent event, Vec3 emitterPos, GameEvent.Context emitter) {
+-        // Used by BlockComposter
+        // Used by ComposterBlock
+     }
+ 
+     @Override
--- a/patches/server/0844-Missing-eating-regain-reason.patch
+++ b/patches/server/0844-Missing-eating-regain-reason.patch
@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Fri, 5 Aug 2022 12:16:51 +0200
+Subject: [PATCH] Missing eating regain reason
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Cat.java b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+index 40af8405c6f3ecc5a8168bb62607eb79862cefa6..de51ce9875e12961e6e549e87d76f492d2f19787 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+@@ -387,7 +387,7 @@ public class Cat extends TamableAnimal implements VariantHolder<CatVariant> {
+                     if (!(item instanceof DyeItem)) {
+                         if (item.isEdible() && this.isFood(itemstack) && this.getHealth() < this.getMaxHealth()) {
+                             this.usePlayerItem(player, hand, itemstack);
+-                            this.heal((float) item.getFoodProperties().getNutrition());
+                            this.heal((float) item.getFoodProperties().getNutrition(), org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason.EATING); // Paper
+                             return InteractionResult.CONSUME;
+                         }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java b/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java
+index 3aa98f7c282cb4884589cb83b1546b924e66f096..faf3e31f23d71bbc345bf98d4240490ac4677843 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java
+++ b/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java
+@@ -384,7 +384,7 @@ public class Camel extends AbstractHorse implements PlayerRideableJumping, Saddl
+         } else {
+             boolean bl = this.getHealth() < this.getMaxHealth();
+             if (bl) {
+-                this.heal(2.0F);
+                this.heal(2.0F, org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason.EATING); // Paper
+             }
+ 
+             boolean bl2 = this.isTamed() && this.getAge() == 0 && this.canFallInLove();
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java b/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java
+index 91fb62807b3c5600c83d4dc8d3fadf36e94e2133..5f61c97478f005aaaaad1b027118079db7275cf7 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java
+@@ -196,7 +196,7 @@ public class Llama extends AbstractChestedHorse implements VariantHolder<Llama.V
+         }
+ 
+         if (this.getHealth() < this.getMaxHealth() && f > 0.0F) {
+-            this.heal(f);
+            this.heal(f, org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason.EATING); // Paper
+             flag = true;
+         }
+ 
--- a/patches/server/0845-Missing-effect-cause.patch
+++ b/patches/server/0845-Missing-effect-cause.patch
@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Tue, 16 Aug 2022 19:44:55 +0200
+Subject: [PATCH] Missing effect cause
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java
+index af5db5da4e5b2fd90a5cf0ca3c92e87ba82d4779..387006271c246362b0df1bfcadca7b7096660003 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java
+++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java
+@@ -419,7 +419,7 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder<Axolo
+             player.addEffect(new MobEffectInstance(MobEffects.REGENERATION, j, 0), this, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.AXOLOTL); // CraftBukkit
+         }
+ 
+-        player.removeEffect(MobEffects.DIG_SLOWDOWN);
+        player.removeEffect(MobEffects.DIG_SLOWDOWN, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.AXOLOTL); // Paper
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/item/HoneyBottleItem.java b/src/main/java/net/minecraft/world/item/HoneyBottleItem.java
+index c8e783014a6a09d59e85715a7fbf2a5f65201e77..5cba503c7342f66018af568be200999e14aa8d6e 100644
+--- a/src/main/java/net/minecraft/world/item/HoneyBottleItem.java
+++ b/src/main/java/net/minecraft/world/item/HoneyBottleItem.java
+@@ -28,7 +28,7 @@ public class HoneyBottleItem extends Item {
+         }
+ 
+         if (!world.isClientSide) {
+-            user.removeEffect(MobEffects.POISON);
+            user.removeEffect(MobEffects.POISON, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.FOOD); // Paper
+         }
+ 
+         if (stack.isEmpty()) {
+diff --git a/src/main/java/net/minecraft/world/item/SuspiciousStewItem.java b/src/main/java/net/minecraft/world/item/SuspiciousStewItem.java
+index 8a7ab376a260bd70a799ce182a03450b3916f733..ba6dc881343148a17ed02486650e51b1e3bdd73c 100644
+--- a/src/main/java/net/minecraft/world/item/SuspiciousStewItem.java
+++ b/src/main/java/net/minecraft/world/item/SuspiciousStewItem.java
+@@ -66,7 +66,7 @@ public class SuspiciousStewItem extends Item {
+     public ItemStack finishUsingItem(ItemStack stack, Level world, LivingEntity user) {
+         ItemStack itemStack = super.finishUsingItem(stack, world, user);
+         listPotionEffects(itemStack, (effect) -> {
+-            user.addEffect(effect.createEffectInstance());
+            user.addEffect(effect.createEffectInstance(), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.FOOD); // Paper
+         });
+         return user instanceof Player && ((Player)user).getAbilities().instabuild ? itemStack : new ItemStack(Items.BOWL);
+     }
--- a/patches/server/0846-Added-byte-array-serialization-deserialization-for-P.patch
+++ b/patches/server/0846-Added-byte-array-serialization-deserialization-for-P.patch
@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Nex <nex@bits.team>
+Date: Thu, 24 Feb 2022 16:28:07 +0100
+Subject: [PATCH] Added byte array serialization/deserialization for
+ PersistentDataContainers
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java b/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
+index 390d5843233d26b76f90651f49a2a1d68c0aa67f..3351962e85438ed05215ce0d159799ed4707afde 100644
+--- a/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
+++ b/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
+@@ -168,5 +168,26 @@ public class CraftPersistentDataContainer implements PersistentDataContainer {
+ 
+         return this.customDataTags.containsKey(key.toString());
+     }
+
+    @Override
+    public byte[] serializeToBytes() throws java.io.IOException {
+        net.minecraft.nbt.CompoundTag root = this.toTagCompound();
+        java.io.ByteArrayOutputStream byteArrayOutput = new java.io.ByteArrayOutputStream();
+        try (java.io.DataOutputStream dataOutput = new java.io.DataOutputStream(byteArrayOutput)) {
+            net.minecraft.nbt.NbtIo.write(root, dataOutput);
+            return byteArrayOutput.toByteArray();
+        }
+    }
+
+    @Override
+    public void readFromBytes(byte[] bytes, boolean clear) throws java.io.IOException {
+        if (clear) {
+            this.clear();
+        }
+        try (java.io.DataInputStream dataInput = new java.io.DataInputStream(new java.io.ByteArrayInputStream(bytes))) {
+            net.minecraft.nbt.CompoundTag compound = net.minecraft.nbt.NbtIo.read(dataInput);
+            this.putAll(compound);
+        }
+    }
+     // Paper end
+ }
--- a/patches/server/0847-Add-a-consumer-parameter-to-ProjectileSource-launchP.patch
+++ b/patches/server/0847-Add-a-consumer-parameter-to-ProjectileSource-launchP.patch
@ -0,0 +1,69 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Mon, 19 Sep 2022 14:16:10 -0700
+Subject: [PATCH] Add a consumer parameter to ProjectileSource#launchProjectile
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 68d827b95a67f2fb65ed806221bb4e7e906a05f4..bd58fdd7001e41418f4bbc881274814cf9fe79c3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -510,8 +510,15 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+     }
+ 
+     @Override
+-    @SuppressWarnings("unchecked")
+     public <T extends Projectile> T launchProjectile(Class<? extends T> projectile, Vector velocity) {
+        // Paper start - launchProjectile consumer
+        return this.launchProjectile(projectile, velocity, null);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T extends Projectile> T launchProjectile(Class<? extends T> projectile, Vector velocity, java.util.function.Consumer<? super T> function) {
+        // Paper end - launchProjectile consumer
+         Preconditions.checkState(!this.getHandle().generation, "Cannot launch projectile during world generation");
+ 
+         net.minecraft.world.level.Level world = ((CraftWorld) this.getWorld()).getHandle();
+@@ -598,6 +605,11 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         if (velocity != null) {
+             ((T) launch.getBukkitEntity()).setVelocity(velocity);
+         }
+        // Paper start - launchProjectile consumer
+        if (function != null) {
+            function.accept((T) launch.getBukkitEntity());
+        }
+        // Paper end - launchProjectile consumer
+ 
+         world.addFreshEntity(launch);
+         return (T) launch.getBukkitEntity();
+diff --git a/src/main/java/org/bukkit/craftbukkit/projectiles/CraftBlockProjectileSource.java b/src/main/java/org/bukkit/craftbukkit/projectiles/CraftBlockProjectileSource.java
+index d4f6348144f9caa1aa155dfb8484df3524db0770..16f0b3711a6bbff0d4ea1f82bcc8723cbfd932c6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/projectiles/CraftBlockProjectileSource.java
+++ b/src/main/java/org/bukkit/craftbukkit/projectiles/CraftBlockProjectileSource.java
+@@ -56,6 +56,13 @@ public class CraftBlockProjectileSource implements BlockProjectileSource {
+ 
+     @Override
+     public <T extends Projectile> T launchProjectile(Class<? extends T> projectile, Vector velocity) {
+        // Paper start - launchProjectile consumer
+        return this.launchProjectile(projectile, velocity, null);
+    }
+
+    @Override
+    public <T extends Projectile> T launchProjectile(Class<? extends T> projectile, Vector velocity, java.util.function.Consumer<? super T> function) {
+        // Paper end - launchProjectile consumer
+         Preconditions.checkArgument(this.getBlock().getType() == Material.DISPENSER, "Block is no longer dispenser");
+         // Copied from BlockDispenser.dispense()
+         BlockSource sourceblock = new BlockSource((ServerLevel) this.dispenserBlock.getLevel(), this.dispenserBlock.getBlockPos(), this.dispenserBlock.getBlockState(), this.dispenserBlock);
+@@ -146,6 +153,11 @@ public class CraftBlockProjectileSource implements BlockProjectileSource {
+         if (velocity != null) {
+             ((T) launch.getBukkitEntity()).setVelocity(velocity);
+         }
+        // Paper start
+        if (function != null) {
+            function.accept((T) launch.getBukkitEntity());
+        }
+        // Paper end
+ 
+         world.addFreshEntity(launch);
+         return (T) launch.getBukkitEntity();
--- a/patches/server/0848-Call-BlockPhysicsEvent-more-often.patch
+++ b/patches/server/0848-Call-BlockPhysicsEvent-more-often.patch
@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Sun, 7 Aug 2022 22:16:36 +0200
+Subject: [PATCH] Call BlockPhysicsEvent more often
+
+
+diff --git a/src/main/java/net/minecraft/world/level/redstone/CollectingNeighborUpdater.java b/src/main/java/net/minecraft/world/level/redstone/CollectingNeighborUpdater.java
+index 7d54abc2553f4b319df4d533a0b689c1807b6102..598dc0d3a2b9387e76d7e4e19e54c4573a24bc54 100644
+--- a/src/main/java/net/minecraft/world/level/redstone/CollectingNeighborUpdater.java
+++ b/src/main/java/net/minecraft/world/level/redstone/CollectingNeighborUpdater.java
+@@ -119,7 +119,27 @@ public class CollectingNeighborUpdater implements NeighborUpdater {
+         public boolean runNext(Level world) {
+             BlockPos blockPos = this.sourcePos.relative(NeighborUpdater.UPDATE_ORDER[this.idx++]);
+             BlockState blockState = world.getBlockState(blockPos);
+-            NeighborUpdater.executeUpdate(world, blockState, blockPos, this.sourceBlock, this.sourcePos, false);
+            // Paper start
+            try {
+                boolean cancelled = false;
+                org.bukkit.craftbukkit.CraftWorld cworld = world.getWorld();
+                if (cworld != null) {
+                    org.bukkit.event.block.BlockPhysicsEvent event = new org.bukkit.event.block.BlockPhysicsEvent(
+                        org.bukkit.craftbukkit.block.CraftBlock.at(world, blockPos),
+                        org.bukkit.craftbukkit.block.data.CraftBlockData.fromData(blockState),
+                        org.bukkit.craftbukkit.block.CraftBlock.at(world, sourcePos));
+
+                    if (!event.callEvent()) {
+                        cancelled = true;
+                    }
+                }
+                if (!cancelled) { // continue to check for adjacent block (increase idx)
+                    NeighborUpdater.executeUpdate(world, blockState, blockPos, this.sourceBlock, this.sourcePos, false);
+                }
+            } catch (StackOverflowError ex) {
+                world.lastPhysicsProblem = new BlockPos(blockPos);
+            }
+            // Paper end
+             if (this.idx < NeighborUpdater.UPDATE_ORDER.length && NeighborUpdater.UPDATE_ORDER[this.idx] == this.skipDirection) {
+                 ++this.idx;
+             }
--- a/patches/server/0849-Configurable-chat-thread-limit.patch
+++ b/patches/server/0849-Configurable-chat-thread-limit.patch
@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sun, 18 Sep 2022 06:33:17 +0100
+Subject: [PATCH] Configurable chat thread limit
+
+By default, spigot shifts chat over to an unbounded thread pool,
+on a normal server, this really offers no gains, the creation of a thread
+on submitting to the pool on these servers eats more time vs just running it in
+the netty pipeline, however, on servers using plugins which do work in here, there
+could be some overall benefits to moving this stuff outside of the pipeline.
+
+In general, this patch does two things:
+1) Exposes the core size for the pool, this allows for ensuring that a number of threads
+sit around in the pool, mitigating the need for creating new threads; This IS however
+caveated, the ThreadPoolExecutor will ONLY create core threads as they're needed, it
+just won't allow for us to dip back under the # of core threads, this can potentially
+be mitigated by calling prestartCoreThread, however, I'm not sure if there is much justification
+for this
+2) Exposes a max size for the pool, as stated, by default this is unbounded, for most
+servers limiting the size of the pool is going to have 0 effects given how fast chat
+is actually processed, this is honestly really just exposed for the misnomers or people
+who just wanna ensure that this won't grow over a specific size if chat gets stupidly active
+
+diff --git a/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java b/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
+index 276961a11fc2bd747d2dacdc581cecec498d7593..a6f58b3457b7477015c5c6d969e7d83017dd3fa1 100644
+--- a/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
+++ b/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
+@@ -307,7 +307,18 @@ public class GlobalConfiguration extends ConfigurationPart {
+ 
+             @PostProcess
+             private void postProcess() {
+-                // TODO: fill in separate patch
+                //noinspection ConstantConditions
+                if (net.minecraft.server.MinecraftServer.getServer() == null) return; // In testing env, this will be null here
+                int _chatExecutorMaxSize = (this.chatExecutorMaxSize <= 0) ? Integer.MAX_VALUE : this.chatExecutorMaxSize; // This is somewhat dumb, but, this is the default, do we cap this?;
+                int _chatExecutorCoreSize = Math.max(this.chatExecutorCoreSize, 0);
+
+                if (_chatExecutorMaxSize < _chatExecutorCoreSize) {
+                    _chatExecutorMaxSize = _chatExecutorCoreSize;
+                }
+
+                java.util.concurrent.ThreadPoolExecutor executor = (java.util.concurrent.ThreadPoolExecutor) net.minecraft.server.MinecraftServer.getServer().chatExecutor;
+                executor.setCorePoolSize(_chatExecutorCoreSize);
+                executor.setMaximumPoolSize(_chatExecutorMaxSize);
+             }
+         }
+         public int maxJoinsPerTick = 5;
--- a/patches/server/0850-Mitigate-effects-of-WorldCreator-keepSpawnLoaded-ret.patch
+++ b/patches/server/0850-Mitigate-effects-of-WorldCreator-keepSpawnLoaded-ret.patch
@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Mon, 19 Sep 2022 00:13:02 +0100
+Subject: [PATCH] Mitigate effects of WorldCreator#keepSpawnLoaded ret type
+ change
+
+TODO: Remove in 1.21?
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
+index 2a75bd263dce91bc64601f96b622ed6d4fb18fe6..15c5d1c048bf2780e963a1055f0a6dd77b31ff45 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
+@@ -463,6 +463,12 @@ public class Commodore
+                             super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, CB_PACKAGE + "/advancement/CraftAdvancement", "getDisplay0", desc, false);
+                             return;
+                         }
+                        if (owner.equals("org/bukkit/WorldCreator") && name.equals("keepSpawnLoaded") && desc.equals("(Lnet/kyori/adventure/util/TriState;)V")) {
+                            super.visitMethodInsn(opcode, owner, name, "(Lnet/kyori/adventure/util/TriState;)Lorg/bukkit/WorldCreator;", itf);
+                            // new method has a return, so, make sure we pop it
+                            super.visitInsn(Opcodes.POP);
+                            return;
+                        }
+                         // Paper end
+ 
+                         // Paper start - ItemFactory#getSpawnEgg (paper had original method that returned ItemStack, upstream added identical but returned Material)
--- a/patches/server/0851-fix-Jigsaw-block-kicking-user.patch
+++ b/patches/server/0851-fix-Jigsaw-block-kicking-user.patch
@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Legitimoose <legitimoose@gmail.com>
+Date: Wed, 28 Sep 2022 22:45:49 -0700
+Subject: [PATCH] fix Jigsaw block kicking user
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/JigsawBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/JigsawBlockEntity.java
+index 72d89e8999825b43a36ed9ee8f4545bde3927690..3a210e138b6ae065fd32e1b1e0e49999e20c4667 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/JigsawBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/JigsawBlockEntity.java
+@@ -133,7 +133,12 @@ public class JigsawBlockEntity extends BlockEntity {
+     public void generate(ServerLevel world, int maxDepth, boolean keepJigsaws) {
+         BlockPos blockPos = this.getBlockPos().relative(this.getBlockState().getValue(JigsawBlock.ORIENTATION).front());
+         Registry<StructureTemplatePool> registry = world.registryAccess().registryOrThrow(Registries.TEMPLATE_POOL);
+-        Holder<StructureTemplatePool> holder = registry.getHolderOrThrow(this.pool);
+        // Paper start - Replace getHolderOrThrow with a null check
+        Holder<StructureTemplatePool> holder = registry.getHolder(this.pool).orElse(null);
+        if (holder == null) {
+            return;
+        }
+        // Paper end
+         JigsawPlacement.generateJigsaw(world, holder, this.target, maxDepth, blockPos, keepJigsaws);
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/pools/StructureTemplatePool.java b/src/main/java/net/minecraft/world/level/levelgen/structure/pools/StructureTemplatePool.java
+index 2c5165835dede1abc07ff508c820f0fe1a1027d0..194864460a5508b6b60f445d6c7923c2ae14a15b 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/structure/pools/StructureTemplatePool.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/structure/pools/StructureTemplatePool.java
+@@ -85,7 +85,13 @@ public class StructureTemplatePool {
+     }
+ 
+     public StructurePoolElement getRandomTemplate(RandomSource random) {
+        //Paper start - Prevent random.nextInt throwing an IllegalArgumentException
+        if (this.templates.size() == 0) {
+            return EmptyPoolElement.INSTANCE;
+        } else {
+         return this.templates.get(random.nextInt(this.templates.size()));
+        }
+        // Paper end
+     }
+ 
+     public List<StructurePoolElement> getShuffledTemplates(RandomSource random) {
--- a/patches/server/0852-use-BlockFormEvent-for-mud-converting-into-clay.patch
+++ b/patches/server/0852-use-BlockFormEvent-for-mud-converting-into-clay.patch
@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Legitimoose <legitimoose@gmail.com>
+Date: Thu, 29 Sep 2022 16:25:50 -0700
+Subject: [PATCH] use BlockFormEvent for mud converting into clay
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/PointedDripstoneBlock.java b/src/main/java/net/minecraft/world/level/block/PointedDripstoneBlock.java
+index e59f9b83606da83f15924477ea2a2c4b74e7d892..bd22d3fdecbc992b11073a74d854b7d1b43c3f6a 100644
+--- a/src/main/java/net/minecraft/world/level/block/PointedDripstoneBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/PointedDripstoneBlock.java
+@@ -220,10 +220,13 @@ public class PointedDripstoneBlock extends Block implements Fallable, SimpleWate
+                             if (((PointedDripstoneBlock.FluidInfo) optional.get()).sourceState.is(Blocks.MUD) && fluidtype == Fluids.WATER) {
+                                 BlockState iblockdata1 = Blocks.CLAY.defaultBlockState();
+ 
+-                                world.setBlockAndUpdate(((PointedDripstoneBlock.FluidInfo) optional.get()).pos, iblockdata1);
+                                // Paper start
+                                if (org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(world, ((PointedDripstoneBlock.FluidInfo) optional.get()).pos, iblockdata1)) {
+                                 Block.pushEntitiesUp(((PointedDripstoneBlock.FluidInfo) optional.get()).sourceState, iblockdata1, world, ((PointedDripstoneBlock.FluidInfo) optional.get()).pos);
+                                 world.gameEvent(GameEvent.BLOCK_CHANGE, ((PointedDripstoneBlock.FluidInfo) optional.get()).pos, GameEvent.Context.of(iblockdata1));
+                                 world.levelEvent(1504, blockposition1, 0);
+                                }
+                                //Paper end
+                             } else {
+                                 BlockPos blockposition2 = PointedDripstoneBlock.findFillableCauldronBelowStalactiteTip(world, blockposition1, fluidtype);
+ 
--- a/patches/server/0853-Add-getDrops-to-BlockState.patch
+++ b/patches/server/0853-Add-getDrops-to-BlockState.patch
@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Fri, 12 Aug 2022 23:24:37 -0700
+Subject: [PATCH] Add getDrops to BlockState
+
+Originally added isPreferredTool to BlockData but
+upstream added that.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
+index 31bb92c026a4a2de0e8d3500f6ecf35b60d61fb9..390e1b7fd2721b99cb3ce268c6bc1bf0a38e08a3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
+@@ -337,5 +337,33 @@ public class CraftBlockState implements BlockState {
+     public boolean isCollidable() {
+         return this.data.getBlock().hasCollision;
+     }
+
+    @Override
+    public java.util.Collection<org.bukkit.inventory.ItemStack> getDrops() {
+        return this.getDrops(null);
+    }
+
+    @Override
+    public java.util.Collection<org.bukkit.inventory.ItemStack> getDrops(org.bukkit.inventory.ItemStack item) {
+        return this.getDrops(item, null);
+    }
+
+    @Override
+    public java.util.Collection<org.bukkit.inventory.ItemStack> getDrops(org.bukkit.inventory.ItemStack item, org.bukkit.entity.Entity entity) {
+        net.minecraft.world.item.ItemStack nms = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(item);
+
+        // Modelled off EntityHuman#hasBlock
+        if (item == null || !data.requiresCorrectToolForDrops() || nms.isCorrectToolForDrops(data)) {
+            return net.minecraft.world.level.block.Block.getDrops(
+                data,
+                world.getHandle(),
+                position,
+                world.getHandle().getBlockEntity(position), entity == null ? null :
+                    ((org.bukkit.craftbukkit.entity.CraftEntity) entity).getHandle(), nms
+            ).stream().map(org.bukkit.craftbukkit.inventory.CraftItemStack::asBukkitCopy).toList();
+        } else {
+            return java.util.Collections.emptyList();
+        }
+    }
+     // Paper end
+ }
--- a/patches/server/0854-Fix-a-bunch-of-vanilla-bugs.patch
+++ b/patches/server/0854-Fix-a-bunch-of-vanilla-bugs.patch
@ -0,0 +1,488 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Mon, 11 Jul 2022 11:56:41 -0700
+Subject: [PATCH] Fix a bunch of vanilla bugs
+
+https://bugs.mojang.com/browse/MC-253884
+  show raid entity event to all tracking players
+
+https://bugs.mojang.com/browse/MC-253721
+  wrong msg for opping multiple players
+
+https://bugs.mojang.com/browse/MC-248588
+  respect mob griefing gamerule for draining water cauldrons
+
+https://bugs.mojang.com/browse/MC-244739
+  play goat eating sound for last item in stack
+
+https://bugs.mojang.com/browse/MC-243057
+  ignore furnace fuel slot in recipe book click
+
+https://bugs.mojang.com/browse/MC-147659
+  Some witch huts spawn the incorrect cat
+  Note: Marked as Won't Fix, makes 0 sense
+
+https://bugs.mojang.com/browse/MC-179072
+  Creepers do not defuse when switching from Survival to Creative/Spectator
+
+https://bugs.mojang.com/browse/MC-191591
+  Fix items equipped on AbstractHorse losing NBT
+
+https://bugs.mojang.com/browse/MC-259571
+  Fix changeGameModeForPlayer to use gameModeForPlayer
+
+https://bugs.mojang.com/browse/MC-262422
+  Fix lightning being able to hit spectators
+
+https://bugs.mojang.com/browse/MC-224454
+  Fix mobs attempting to pathfind through azalea blocks
+
+https://bugs.mojang.com/browse/MC-263999
+  Fix mobs breaking doors not spawning block break particles
+
+https://bugs.mojang.com/browse/MC-210802
+  by: BillyGalbreath <Blake.Galbreath@Gmail.com>
+  Fixes sheep eating blocks outside of ticking range
+
+https://bugs.mojang.com/browse/MC-123848
+  by: BillyGalbreath <blake.galbreath@gmail.com>
+  Fixes item frames dropping items above when pointing down
+
+https://bugs.mojang.com/browse/MC-264285
+  Fix unbreakable flint and steel being consumed when igniting creepers
+
+https://bugs.mojang.com/browse/MC-84789
+  Fix wild wolves not considering bones interesting
+
+https://bugs.mojang.com/browse/MC-225381
+  Fix overfilled bundles duplicating items / being filled with air
+
+https://bugs.mojang.com/browse/MC-173303
+  Fix leashed pets teleporting to owner when loaded
+
+https://bugs.mojang.com/browse/MC-174630
+  Fix secondary beacon effect remaining after switching effect
+
+https://bugs.mojang.com/browse/MC-153086
+  Fix the beacon deactivation sound always playing when broken
+
+https://bugs.mojang.com/browse/MC-200092
+  Fix yaw being ignored for a player's first spawn pos
+
+== AT ==
+public net/minecraft/world/entity/Mob leashInfoTag
+
+Co-authored-by: William Blake Galbreath <blake.galbreath@gmail.com>
+
+diff --git a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+index 9f220c99d7374ab3d9db222346694342d3e926c1..d9077127757886e5d5e8d63a46fe27f2bfba1420 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -351,7 +351,7 @@ public interface DispenseItemBehavior {
+                         }
+                     }
+                     // CraftBukkit end
+-                    ((Saddleable) list.get(0)).equipSaddle(SoundSource.BLOCKS);
+                    ((Saddleable) list.get(0)).equipSaddle(SoundSource.BLOCKS, CraftItemStack.asNMSCopy(event.getItem())); // Paper - Fix saddles losing nbt data - MC-191591
+                     // itemstack.shrink(1); // CraftBukkit - handled above
+                     this.setSuccess(true);
+                     return stack;
+diff --git a/src/main/java/net/minecraft/server/commands/DeOpCommands.java b/src/main/java/net/minecraft/server/commands/DeOpCommands.java
+index 40490d10649e92cf622849f1bb87538102b130c7..797efca662dcc0fe7f4cf0b4b7baa235ea044f1f 100644
+--- a/src/main/java/net/minecraft/server/commands/DeOpCommands.java
+++ b/src/main/java/net/minecraft/server/commands/DeOpCommands.java
+@@ -34,7 +34,7 @@ public class DeOpCommands {
+                 playerList.deop(gameProfile);
+                 ++i;
+                 source.sendSuccess(() -> {
+-                    return Component.translatable("commands.deop.success", targets.iterator().next().getName());
+                    return Component.translatable("commands.deop.success", gameProfile.getName()); // Paper - fixes MC-253721
+                 }, true);
+             }
+         }
+diff --git a/src/main/java/net/minecraft/server/commands/OpCommand.java b/src/main/java/net/minecraft/server/commands/OpCommand.java
+index 6cd6d69a20e95e344fc18ab67dc300824537a59b..2e2a7c2cf3081187da817479a9da3eb10f662a6d 100644
+--- a/src/main/java/net/minecraft/server/commands/OpCommand.java
+++ b/src/main/java/net/minecraft/server/commands/OpCommand.java
+@@ -39,7 +39,7 @@ public class OpCommand {
+                 playerList.op(gameProfile);
+                 ++i;
+                 source.sendSuccess(() -> {
+-                    return Component.translatable("commands.op.success", targets.iterator().next().getName());
+                    return Component.translatable("commands.op.success", gameProfile.getName()); // Paper - fixes MC-253721
+                 }, true);
+             }
+         }
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index b71be5e7e18f884cf35cc3a940c87e744e00f811..81d3d664d4397e528a02e50469622c4ff3ffb804 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -899,7 +899,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+     }
+     // Paper end
+ 
+-    boolean anyPlayerCloseEnoughForSpawning(ChunkPos pos) {
+    public boolean anyPlayerCloseEnoughForSpawning(ChunkPos pos) { // Paper - public
+         // Spigot start
+         return this.anyPlayerCloseEnoughForSpawning(pos, false);
+     }
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 60eb96c274ac1b899de9b6f79eaab8596aee012c..80283588344ae3ba4a58d4be2c0bfc769cbcd78d 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -1028,7 +1028,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         } else {
+             AABB axisalignedbb = AABB.encapsulatingFullBlocks(blockposition1, new BlockPos(blockposition1.atY(this.getMaxBuildHeight()))).inflate(3.0D);
+             List<LivingEntity> list = this.getEntitiesOfClass(LivingEntity.class, axisalignedbb, (entityliving) -> {
+-                return entityliving != null && entityliving.isAlive() && this.canSeeSky(entityliving.blockPosition());
+                return entityliving != null && entityliving.isAlive() && this.canSeeSky(entityliving.blockPosition()) && !entityliving.isSpectator(); // Paper - Fix lightning being able to hit spectators (MC-262422)
+             });
+ 
+             if (!list.isEmpty()) {
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 4895f0c507aac0c473ecca951f206a5b2182ad97..c0306e2cca4289fae6ebd4a1b232c235f6fe06cb 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -468,14 +468,14 @@ public class ServerPlayer extends Player {
+                 BlockPos blockposition1 = PlayerRespawnLogic.getOverworldRespawnPos(world, blockposition.getX() + j2 - i, blockposition.getZ() + k2 - i);
+ 
+                 if (blockposition1 != null) {
+-                    this.moveTo(blockposition1, 0.0F, 0.0F);
+                    this.moveTo(blockposition1, world.getSharedSpawnAngle(), 0.0F); // Paper - MC-200092 - fix first spawn pos yaw being ignored
+                     if (world.noCollision(this, this.getBoundingBox(), true)) { // Paper - make sure this loads chunks, we default to NOT loading now
+                         break;
+                     }
+                 }
+             }
+         } else {
+-            this.moveTo(blockposition, 0.0F, 0.0F);
+            this.moveTo(blockposition, world.getSharedSpawnAngle(), 0.0F); // Paper - MC-200092 - fix first spawn pos yaw being ignored
+ 
+             while (!world.noCollision(this, this.getBoundingBox(), true) && this.getY() < (double) (world.getMaxBuildHeight() - 1)) { // Paper - make sure this loads chunks, we default to NOT loading now
+                 this.setPos(this.getX(), this.getY() + 1.0D, this.getZ());
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index 4e1ed252bf400ec991f95b02984f01a9689f2989..805c9b9b0e89002b97e1e11e1e6e2435315b8f2c 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -92,7 +92,7 @@ public class ServerPlayerGameMode {
+                 return event; // Paper
+             }
+             // CraftBukkit end
+-            this.setGameModeForPlayer(gameMode, this.previousGameModeForPlayer);
+            this.setGameModeForPlayer(gameMode, this.gameModeForPlayer); // Paper - Fix MC-259571
+             this.player.onUpdateAbilities();
+             this.player.server.getPlayerList().broadcastAll(new ClientboundPlayerInfoUpdatePacket(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_GAME_MODE, this.player), this.player); // CraftBukkit
+             this.level.updateSleepingPlayerList();
+diff --git a/src/main/java/net/minecraft/world/entity/Saddleable.java b/src/main/java/net/minecraft/world/entity/Saddleable.java
+index effe4c4fb37fe13aece70cdef4966047d4719af9..7152674d3f3fb98198585cb5ece2bb88877345f9 100644
+--- a/src/main/java/net/minecraft/world/entity/Saddleable.java
+++ b/src/main/java/net/minecraft/world/entity/Saddleable.java
+@@ -9,6 +9,11 @@ public interface Saddleable {
+     boolean isSaddleable();
+ 
+     void equipSaddle(@Nullable SoundSource sound);
+    // Paper start - Fix saddles losing nbt data - MC-191591
+    default void equipSaddle(final @Nullable SoundSource sound, final @Nullable net.minecraft.world.item.ItemStack stack) {
+        this.equipSaddle(sound);
+    }
+    // Paper end
+ 
+     default SoundEvent getSaddleSoundEvent() {
+         return SoundEvents.HORSE_SADDLE;
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/BegGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/BegGoal.java
+index 9a46007245399481fb6e749d95e9e4791e799250..2afca5652541c9166278f8f2590ddb81003ae579 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/BegGoal.java
+++ b/src/main/java/net/minecraft/world/entity/ai/goal/BegGoal.java
+@@ -65,7 +65,7 @@ public class BegGoal extends Goal {
+     private boolean playerHoldingInteresting(Player player) {
+         for(InteractionHand interactionHand : InteractionHand.values()) {
+             ItemStack itemStack = player.getItemInHand(interactionHand);
+-            if (this.wolf.isTame() && itemStack.is(Items.BONE)) {
+            if (!this.wolf.isTame() && itemStack.is(Items.BONE)) { // Paper - Fix MC-84789
+                 return true;
+             }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/BreakDoorGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/BreakDoorGoal.java
+index 784a894688f98f9d0368a36d456c5c94e1ee3695..a85885ee51df585fa11ae9f8fcd67ff2a71c5a18 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/BreakDoorGoal.java
+++ b/src/main/java/net/minecraft/world/entity/ai/goal/BreakDoorGoal.java
+@@ -77,9 +77,10 @@ public class BreakDoorGoal extends DoorInteractGoal {
+                 return;
+             }
+             // CraftBukkit end
+            final net.minecraft.world.level.block.state.BlockState oldState = this.mob.level().getBlockState(this.doorPos); // Paper - fix MC-263999
+             this.mob.level().removeBlock(this.doorPos, false);
+             this.mob.level().levelEvent(1021, this.doorPos, 0);
+-            this.mob.level().levelEvent(2001, this.doorPos, Block.getId(this.mob.level().getBlockState(this.doorPos)));
+            this.mob.level().levelEvent(2001, this.doorPos, Block.getId(oldState)); // Paper - fix MC-263999
+         }
+ 
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java
+index d802985f1431be4332c07f0dab88feebedea4ce2..4e2c23ccdf4e4a4d65b291dbe20952bae1838bff 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java
+++ b/src/main/java/net/minecraft/world/entity/ai/goal/EatBlockGoal.java
+@@ -31,6 +31,11 @@ public class EatBlockGoal extends Goal {
+ 
+     @Override
+     public boolean canUse() {
+        // Paper start - Fix MC-210802
+        if (!((net.minecraft.server.level.ServerLevel) this.level).chunkSource.chunkMap.anyPlayerCloseEnoughForSpawning(this.mob.chunkPosition())) {
+            return false;
+        }
+        // Paper end
+         if (this.mob.getRandom().nextInt(this.mob.isBaby() ? 50 : 1000) != 0) {
+             return false;
+         } else {
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java
+index 11cc26954b4e97114b59df35a4f9b75a09132e20..0a3f7dcc0e205a85dbaa6dee1fc9ae2c7fa9e02d 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java
+++ b/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java
+@@ -74,7 +74,7 @@ public class FollowOwnerGoal extends Goal {
+     }
+ 
+     private boolean unableToMove() {
+-        return this.tamable.isOrderedToSit() || this.tamable.isPassenger() || this.tamable.isLeashed();
+        return this.tamable.isOrderedToSit() || this.tamable.isPassenger() || this.tamable.isLeashed() || this.tamable.leashInfoTag != null; // Paper - Fix MC-173303
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/SwellGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/SwellGoal.java
+index 19540fd4a7f992888fadb6501d0c8a5a7e71fcf6..e241ae250f4f04a17ef2c583d00b065a4ca56a4c 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/SwellGoal.java
+++ b/src/main/java/net/minecraft/world/entity/ai/goal/SwellGoal.java
+@@ -21,6 +21,13 @@ public class SwellGoal extends Goal {
+         return this.creeper.getSwellDir() > 0 || livingEntity != null && this.creeper.distanceToSqr(livingEntity) < 9.0D;
+     }
+ 
+    // Paper start - Fix MC-179072
+    @Override
+    public boolean canContinueToUse() {
+        return !net.minecraft.world.entity.EntitySelector.NO_CREATIVE_OR_SPECTATOR.test(this.creeper.getTarget()) && canUse();
+    }
+    // Paper end
+
+     @Override
+     public void start() {
+         this.creeper.getNavigation().stop();
+diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+index 363892e0c26bab89d2abaa44d8736e2fd84d292f..111a244087e24f25ba8524a46a228da10cd9498a 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
+@@ -239,9 +239,10 @@ public class Goat extends Animal {
+             player.setItemInHand(hand, itemstack1);
+             return InteractionResult.sidedSuccess(this.level().isClientSide);
+         } else {
+            boolean isFood = this.isFood(itemstack); // Paper - track before stack is possibly decreased to 0 (Fixes MC-244739)
+             InteractionResult enuminteractionresult = super.mobInteract(player, hand);
+ 
+-            if (enuminteractionresult.consumesAction() && this.isFood(itemstack)) {
+            if (enuminteractionresult.consumesAction() && isFood) { // Paper
+                 this.level().playSound((Player) null, (Entity) this, this.getEatingSound(itemstack), SoundSource.NEUTRAL, 1.0F, Mth.randomBetween(this.level().random, 0.8F, 1.2F));
+             }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/AbstractHorse.java b/src/main/java/net/minecraft/world/entity/animal/horse/AbstractHorse.java
+index bd0165d9ca52665a52fbd9678ed895bf4bed2fe7..8fe5a4ccf474c094b8081828c93e8973cdabb6ed 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/AbstractHorse.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/AbstractHorse.java
+@@ -252,7 +252,13 @@ public abstract class AbstractHorse extends Animal implements ContainerListener,
+ 
+     @Override
+     public void equipSaddle(@Nullable SoundSource sound) {
+-        this.inventory.setItem(0, new ItemStack(Items.SADDLE));
+        // Paper start - Fix saddles losing nbt data - MC-191591
+        this.equipSaddle(sound, null);
+    }
+    @Override
+    public void equipSaddle(@Nullable SoundSource sound, @Nullable ItemStack stack) {
+        this.inventory.setItem(0, stack != null ? stack : new ItemStack(Items.SADDLE));
+        // Paper end
+     }
+ 
+     public void equipArmor(Player player, ItemStack stack) {
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+index 63ef00eb6f93a471de1e9c2355099d9dd3a71dd9..6849429c3577f36eb699083375824ae5633f8d06 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -282,6 +282,14 @@ public class ItemFrame extends HangingEntity {
+         }
+     }
+ 
+    // Paper start - Fix MC-123848 (spawn item frame drops above block)
+    @Nullable
+    @Override
+    public net.minecraft.world.entity.item.ItemEntity spawnAtLocation(ItemStack stack) {
+        return this.spawnAtLocation(stack, getDirection().equals(Direction.DOWN) ? -0.6F : 0.0F);
+    }
+    // Paper end
+
+     private void removeFramedMap(ItemStack itemstack) {
+         this.getFramedMapId().ifPresent((i) -> {
+             MapItemSavedData worldmap = MapItem.getSavedData(i, this.level());
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Creeper.java b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+index 7fe90ebc8eced53f72c7f935e40745075f02421b..fd1b5a1beea7594fa65decfdcccfa15781fc005b 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+@@ -248,7 +248,7 @@ public class Creeper extends Monster implements PowerableMob {
+             this.level().playSound(player, this.getX(), this.getY(), this.getZ(), soundeffect, this.getSoundSource(), 1.0F, this.random.nextFloat() * 0.4F + 0.8F);
+             if (!this.level().isClientSide) {
+                 this.ignite();
+-                if (!itemstack.isDamageableItem()) {
+                if (itemstack.getItem().getMaxDamage() == 0) { // Paper - fix MC-264285, only shrink the stack if the item type actually has no durability
+                     itemstack.shrink(1);
+                 } else {
+                     itemstack.hurtAndBreak(1, player, (entityhuman1) -> {
+diff --git a/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java b/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+index f174094febfdfdc309f1b50877be60bae8a98156..5f407535298a31a34cfe114dd863fd6a9b977707 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+++ b/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+@@ -87,8 +87,8 @@ public class CatSpawner implements CustomSpawner {
+         if (cat == null) {
+             return 0;
+         } else {
+            cat.moveTo(pos, 0.0F, 0.0F); // Paper - move up - Fix MC-147659
+             cat.finalizeSpawn(world, world.getCurrentDifficultyAt(pos), MobSpawnType.NATURAL, (SpawnGroupData)null, (CompoundTag)null);
+-            cat.moveTo(pos, 0.0F, 0.0F);
+             world.addFreshEntityWithPassengers(cat);
+             return 1;
+         }
+diff --git a/src/main/java/net/minecraft/world/entity/raid/Raids.java b/src/main/java/net/minecraft/world/entity/raid/Raids.java
+index 4a0f4c83228187a2082ad029680056b1801f77bd..31831811ce16265e9828fa34d9e67d8ac195d723 100644
+--- a/src/main/java/net/minecraft/world/entity/raid/Raids.java
+++ b/src/main/java/net/minecraft/world/entity/raid/Raids.java
+@@ -134,7 +134,7 @@ public class Raids extends SavedData {
+                     // CraftBukkit end
+                 } else {
+                     player.removeEffect(MobEffects.BAD_OMEN);
+-                    player.connection.send(new ClientboundEntityEventPacket(player, (byte) 43));
+                    this.level.broadcastEntityEvent(player, net.minecraft.world.entity.EntityEvent.BAD_OMEN_TRIGGERED /* (byte) 43 */); // Paper - Fix MC-253884
+                 }
+ 
+                 if (flag) {
+@@ -149,7 +149,7 @@ public class Raids extends SavedData {
+                     }
+                     // CraftBukkit end
+                     raid.absorbBadOmen(player);
+-                    player.connection.send(new ClientboundEntityEventPacket(player, (byte) 43));
+                    this.level.broadcastEntityEvent(player, net.minecraft.world.entity.EntityEvent.BAD_OMEN_TRIGGERED /* (byte) 43 */); // Paper - Fix MC-253884
+                     if (!raid.hasFirstWaveSpawned()) {
+                         player.awardStat(Stats.RAID_TRIGGER);
+                         CriteriaTriggers.BAD_OMEN.trigger(player);
+diff --git a/src/main/java/net/minecraft/world/inventory/BeaconMenu.java b/src/main/java/net/minecraft/world/inventory/BeaconMenu.java
+index 685c35419de7e3c4e854a28118a243e65250ef59..0b1a0be964d799f1706c273092dc653fa04e8014 100644
+--- a/src/main/java/net/minecraft/world/inventory/BeaconMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/BeaconMenu.java
+@@ -178,6 +178,11 @@ public class BeaconMenu extends AbstractContainerMenu {
+     // Paper end
+ 
+     public void updateEffects(Optional<MobEffect> primary, Optional<MobEffect> secondary) {
+        // Paper start - fix MC-174630 - validate secondary power
+        if (secondary.isPresent() && secondary.get() != net.minecraft.world.effect.MobEffects.REGENERATION && (primary.isPresent() && secondary.get() != primary.get())) {
+            secondary = Optional.empty();
+        }
+        // Paper end
+         if (this.paymentSlot.hasItem()) {
+             // Paper start
+             io.papermc.paper.event.player.PlayerChangeBeaconEffectEvent event = new io.papermc.paper.event.player.PlayerChangeBeaconEffectEvent((org.bukkit.entity.Player) this.player.player.getBukkitEntity(), convert(primary), convert(secondary), this.access.getLocation().getBlock());
+diff --git a/src/main/java/net/minecraft/world/item/BundleItem.java b/src/main/java/net/minecraft/world/item/BundleItem.java
+index 10b0720ce7eed58fa3cd8c8051efa6225f7d73e1..ac0bc87f60c4e1562d1301522183e449558d42f8 100644
+--- a/src/main/java/net/minecraft/world/item/BundleItem.java
+++ b/src/main/java/net/minecraft/world/item/BundleItem.java
+@@ -52,7 +52,7 @@ public class BundleItem extends Item {
+                 });
+             } else if (itemStack.getItem().canFitInsideContainerItems()) {
+                 int i = (64 - getContentWeight(stack)) / getWeight(itemStack);
+-                int j = add(stack, slot.safeTake(itemStack.getCount(), i, player));
+                int j = add(stack, slot.safeTake(itemStack.getCount(), Math.max(0, i), player)); // Paper - prevent item addition on overfilled bundles - safeTake will yield EMPTY for amount == 0.
+                 if (j > 0) {
+                     this.playInsertSound(player);
+                 }
+@@ -121,7 +121,7 @@ public class BundleItem extends Item {
+             int i = getContentWeight(bundle);
+             int j = getWeight(stack);
+             int k = Math.min(stack.getCount(), (64 - i) / j);
+-            if (k == 0) {
+            if (k <= 0) { // Paper - prevent item addition on overfilled bundles
+                 return 0;
+             } else {
+                 ListTag listTag = compoundTag.getList("Items", 10);
+diff --git a/src/main/java/net/minecraft/world/item/SaddleItem.java b/src/main/java/net/minecraft/world/item/SaddleItem.java
+index ca6a2b9840c9ade87ec8effab01d4f184fe876b7..43129ecefcc8beccbcf2978f262b1ce8cf49ca43 100644
+--- a/src/main/java/net/minecraft/world/item/SaddleItem.java
+++ b/src/main/java/net/minecraft/world/item/SaddleItem.java
+@@ -18,7 +18,7 @@ public class SaddleItem extends Item {
+         if (entity instanceof Saddleable saddleable) {
+             if (entity.isAlive() && !saddleable.isSaddled() && saddleable.isSaddleable()) {
+                 if (!user.level().isClientSide) {
+-                    saddleable.equipSaddle(SoundSource.NEUTRAL);
+                    saddleable.equipSaddle(SoundSource.NEUTRAL, stack.copyWithCount(1)); // Paper - Fix saddles losing nbt data - MC-191591
+                     entity.level().gameEvent(entity, GameEvent.EQUIP, entity.position());
+                     stack.shrink(1);
+                 }
+diff --git a/src/main/java/net/minecraft/world/level/block/AzaleaBlock.java b/src/main/java/net/minecraft/world/level/block/AzaleaBlock.java
+index 6e45582f8ea7dd2a46f58369c5581764538bff0d..3ecc92439fc85d224ff52f41c5e34079e042a5e6 100644
+--- a/src/main/java/net/minecraft/world/level/block/AzaleaBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/AzaleaBlock.java
+@@ -51,4 +51,11 @@ public class AzaleaBlock extends BushBlock implements BonemealableBlock {
+     public void performBonemeal(ServerLevel world, RandomSource random, BlockPos pos, BlockState state) {
+         TreeGrower.AZALEA.growTree(world, world.getChunkSource().getGenerator(), pos, state, random);
+     }
+
+    // Paper start - Fix MC-224454
+    @Override
+    public boolean isPathfindable(BlockState state, BlockGetter world, BlockPos pos, net.minecraft.world.level.pathfinder.PathComputationType type) {
+        return false;
+    }
+    // Paper end
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java b/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+index 43a72941ab553c154633144d358fb204765257f5..b5e4beb21e1669e5af4da4c3b55a56f83ec5db4f 100644
+--- a/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+@@ -68,7 +68,7 @@ public class LayeredCauldronBlock extends AbstractCauldronBlock {
+         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+         if (!world.isClientSide && entity.isOnFire() && this.isEntityInsideContent(state, pos, entity)) {
+             // CraftBukkit start
+-            if (entity.mayInteract(world, pos)) {
+            if ((entity instanceof net.minecraft.world.entity.player.Player || world.getGameRules().getBoolean(net.minecraft.world.level.GameRules.RULE_MOBGRIEFING)) && entity.mayInteract(world, pos)) { // Paper - Fixes MC-248588
+                 if (!this.handleEntityOnFireInsideWithEvent(state, world, pos, entity)) { // Paper - fix powdered snow cauldron extinguishing entities
+                     return;
+                 }
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+index 3530040df9e4999ea4ccc96b5df5767fdb330fe5..1a949a682a8f18ec0e5e5a60e83315441b935416 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+@@ -674,13 +674,10 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+ 
+     @Override
+     public void fillStackedContents(StackedContents finder) {
+-        Iterator iterator = this.items.iterator();
+-
+-        while (iterator.hasNext()) {
+-            ItemStack itemstack = (ItemStack) iterator.next();
+-
+-            finder.accountStack(itemstack);
+-        }
+        // Paper start - don't account fuel stack (fixes MC-243057)
+        finder.accountStack(this.items.get(SLOT_INPUT));
+        finder.accountStack(this.items.get(SLOT_RESULT));
+        // Paper end
+ 
+     }
+ }
+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 ca91b82a21a46b1a62564b5157882a845eae8737..db38c178543e221251ae8c6ad618ad9372af7f40 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+@@ -291,7 +291,11 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+         org.bukkit.block.Block block = org.bukkit.craftbukkit.block.CraftBlock.at(level, worldPosition);
+         new io.papermc.paper.event.block.BeaconDeactivatedEvent(block).callEvent();
+         // Paper end
+        // Paper start - fix MC-153086
+        if (this.levels > 0 && !this.beamSections.isEmpty()) {
+         BeaconBlockEntity.playSound(this.level, this.worldPosition, SoundEvents.BEACON_DEACTIVATE);
+        }
+        // Paper end
+         super.setRemoved();
+     }
+ 
--- a/patches/server/0855-Remove-unnecessary-onTrackingStart-during-navigation.patch
+++ b/patches/server/0855-Remove-unnecessary-onTrackingStart-during-navigation.patch
@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Nassim Jahnke <nassim@njahnke.dev>
+Date: Mon, 3 Oct 2022 20:48:19 +0200
+Subject: [PATCH] Remove unnecessary onTrackingStart during navigation warning
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 80283588344ae3ba4a58d4be2c0bfc769cbcd78d..ba30421e53f935e2860564f8e3748160d64e3665 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -2629,7 +2629,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             if (entity instanceof Mob) {
+                 Mob entityinsentient = (Mob) entity;
+ 
+-                if (ServerLevel.this.isUpdatingNavigations) {
+                if (false && ServerLevel.this.isUpdatingNavigations) { // Paper
+                     String s = "onTrackingStart called during navigation iteration";
+ 
+                     Util.logAndPauseIfInIde("onTrackingStart called during navigation iteration", new IllegalStateException("onTrackingStart called during navigation iteration"));
+@@ -2714,7 +2714,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             if (entity instanceof Mob) {
+                 Mob entityinsentient = (Mob) entity;
+ 
+-                if (ServerLevel.this.isUpdatingNavigations) {
+                if (false && ServerLevel.this.isUpdatingNavigations) { // Paper
+                     String s = "onTrackingStart called during navigation iteration";
+ 
+                     Util.logAndPauseIfInIde("onTrackingStart called during navigation iteration", new IllegalStateException("onTrackingStart called during navigation iteration"));
--- a/patches/server/0856-Fix-custom-piglin-loved-items.patch
+++ b/patches/server/0856-Fix-custom-piglin-loved-items.patch
@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Mon, 4 Jul 2022 21:50:44 -0700
+Subject: [PATCH] Fix custom piglin loved items
+
+Upstream didn't modify the isLovedItem check in wantsToPickup
+so piglins never actually tried to pickup interestItems
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+index b98179602f5b26ecd4df46837b15ca186f65cb38..f0059bd69705ecc7964867b103c93e1df9985803 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+++ b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+@@ -402,7 +402,7 @@ public class PiglinAi {
+         } else {
+             boolean flag = piglin.canAddToInventory(stack);
+ 
+-            return stack.is(Items.GOLD_NUGGET) ? flag : (PiglinAi.isFood(stack) ? !PiglinAi.hasEatenRecently(piglin) && flag : (!PiglinAi.isLovedItem(stack) ? piglin.canReplaceCurrentItem(stack) : PiglinAi.isNotHoldingLovedItemInOffHand(piglin) && flag));
+            return stack.is(Items.GOLD_NUGGET) ? flag : (PiglinAi.isFood(stack) ? !PiglinAi.hasEatenRecently(piglin) && flag : (!PiglinAi.isLovedItem(stack, piglin) ? piglin.canReplaceCurrentItem(stack) : PiglinAi.isNotHoldingLovedItemInOffHand(piglin) && flag)); // Paper - upstream missed isLovedItem check
+         }
+     }
+ 
--- a/patches/server/0857-EntityPickupItemEvent-fixes.patch
+++ b/patches/server/0857-EntityPickupItemEvent-fixes.patch
@ -0,0 +1,64 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Mon, 4 Jul 2022 21:45:36 -0700
+Subject: [PATCH] EntityPickupItemEvent fixes
+
+Fixes double firing of the event in PiglinAi
+
+Fixes cancelling the event for piglins still triggering the
+advancement trigger
+
+Fires the event when a Raider tries to pick up a raid banner
+to become raid leader.
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java
+index 1c42425b9211bea7cb189e967e566ad80fd278c2..6407ddef8442fce4f310ac4babf3e3de0dd5fc9a 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java
+++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java
+@@ -424,7 +424,7 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento
+ 
+     @Override
+     protected void pickUpItem(ItemEntity item) {
+-        this.onItemPickup(item);
+        // this.onItemPickup(item); // Paper - call in PiglinAi#pickUpItem after EntityPickupItemEvent is fired
+         PiglinAi.pickUpItem(this, item);
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+index f0059bd69705ecc7964867b103c93e1df9985803..372d084609216d5437b92ee60810a9efbb0b6f31 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+++ b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinAi.java
+@@ -241,11 +241,16 @@ public class PiglinAi {
+         ItemStack itemstack;
+ 
+         // CraftBukkit start
+-        if (drop.getItem().is(Items.GOLD_NUGGET) && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(piglin, drop, 0, false).isCancelled()) {
+        // Paper start - fix event firing twice
+        if (drop.getItem().is(Items.GOLD_NUGGET) /* && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(piglin, drop, 0, false).isCancelled() */) {
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(piglin, drop, 0, false).isCancelled()) return;
+            piglin.onItemPickup(drop); // Paper - moved from Piglin#pickUpItem - call prior to item entity modification
+            // Paper end
+             piglin.take(drop, drop.getItem().getCount());
+             itemstack = drop.getItem();
+             drop.discard();
+         } else if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(piglin, drop, drop.getItem().getCount() - 1, false).isCancelled()) {
+            piglin.onItemPickup(drop); // Paper - moved from Piglin#pickUpItem - call prior to item entity modification
+             piglin.take(drop, 1);
+             itemstack = PiglinAi.removeOneItemFromItemEntity(drop);
+         } else {
+diff --git a/src/main/java/net/minecraft/world/entity/raid/Raider.java b/src/main/java/net/minecraft/world/entity/raid/Raider.java
+index 5538f7a9024d8708b70de836aa78a4015656a828..cdbc925ef61b8b439415f0a89368227890bcecb2 100644
+--- a/src/main/java/net/minecraft/world/entity/raid/Raider.java
+++ b/src/main/java/net/minecraft/world/entity/raid/Raider.java
+@@ -245,6 +245,11 @@ public abstract class Raider extends PatrollingMonster {
+         boolean flag = this.hasActiveRaid() && this.getCurrentRaid().getLeader(this.getWave()) != null;
+ 
+         if (this.hasActiveRaid() && !flag && ItemStack.matches(itemstack, Raid.getLeaderBannerInstance())) {
+            // Paper start
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(this, item, 0, false).isCancelled()) {
+                return;
+            }
+            // Paper end
+             EquipmentSlot enumitemslot = EquipmentSlot.HEAD;
+             ItemStack itemstack1 = this.getItemBySlot(enumitemslot);
+             double d0 = (double) this.getEquipmentDropChance(enumitemslot);
--- a/patches/server/0858-Correctly-handle-interactions-with-items-on-cooldown.patch
+++ b/patches/server/0858-Correctly-handle-interactions-with-items-on-cooldown.patch
@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 16 Jun 2022 21:57:02 -0700
+Subject: [PATCH] Correctly handle interactions with items on cooldown
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index 805c9b9b0e89002b97e1e11e1e6e2435315b8f2c..f58386e952d29a16d160b628a23efbe102791277 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -516,6 +516,7 @@ public class ServerPlayerGameMode {
+         BlockState iblockdata = world.getBlockState(blockposition);
+         InteractionResult enuminteractionresult = InteractionResult.PASS;
+         boolean cancelledBlock = false;
+        boolean cancelledItem = false; // Paper - correctly handle items on cooldown
+ 
+         if (!iblockdata.getBlock().isEnabled(world.enabledFeatures())) {
+             return InteractionResult.FAIL;
+@@ -525,10 +526,10 @@ public class ServerPlayerGameMode {
+         }
+ 
+         if (player.getCooldowns().isOnCooldown(stack.getItem())) {
+-            cancelledBlock = true;
+            cancelledItem = true; // Paper - correctly handle items on cooldown
+         }
+ 
+-        PlayerInteractEvent event = CraftEventFactory.callPlayerInteractEvent(player, Action.RIGHT_CLICK_BLOCK, blockposition, hitResult.getDirection(), stack, cancelledBlock, hand, hitResult.getLocation());
+        PlayerInteractEvent event = CraftEventFactory.callPlayerInteractEvent(player, Action.RIGHT_CLICK_BLOCK, blockposition, hitResult.getDirection(), stack, cancelledBlock, cancelledItem, hand, hitResult.getLocation()); // Paper
+         this.firedInteract = true;
+         this.interactResult = event.useItemInHand() == Event.Result.DENY;
+         this.interactPosition = blockposition.immutable();
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 2b0a969b185dd959067d8828254f9c48f5b49161..1854933bb3400f44da835364edda51d430da2160 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -546,7 +546,13 @@ public class CraftEventFactory {
+         return CraftEventFactory.callPlayerInteractEvent(who, action, position, direction, itemstack, false, hand, null);
+     }
+ 
+
+    // Paper start - cancelledItem param
+     public static PlayerInteractEvent callPlayerInteractEvent(net.minecraft.world.entity.player.Player who, Action action, BlockPos position, Direction direction, ItemStack itemstack, boolean cancelledBlock, InteractionHand hand, Vec3 targetPos) {
+        return CraftEventFactory.callPlayerInteractEvent(who, action, position, direction, itemstack, cancelledBlock, false, hand, targetPos);
+    }
+    public static PlayerInteractEvent callPlayerInteractEvent(net.minecraft.world.entity.player.Player who, Action action, BlockPos position, Direction direction, ItemStack itemstack, boolean cancelledBlock, boolean cancelledItem, InteractionHand hand, Vec3 targetPos) {
+        // Paper end - cancelledItem param
+         Player player = (who == null) ? null : (Player) who.getBukkitEntity();
+         CraftItemStack itemInHand = CraftItemStack.asCraftMirror(itemstack);
+ 
+@@ -581,6 +587,11 @@ public class CraftEventFactory {
+         if (cancelledBlock) {
+             event.setUseInteractedBlock(Event.Result.DENY);
+         }
+        // Paper start
+        if (cancelledItem) {
+            event.setUseItemInHand(Result.DENY);
+        }
+        // Paper end
+         craftServer.getPluginManager().callEvent(event);
+ 
+         return event;
--- a/patches/server/0859-Add-PlayerInventorySlotChangeEvent.patch
+++ b/patches/server/0859-Add-PlayerInventorySlotChangeEvent.patch
@ -0,0 +1,65 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jakub Zacek <dawon@dawon.eu>
+Date: Sun, 24 Apr 2022 22:56:59 +0200
+Subject: [PATCH] Add PlayerInventorySlotChangeEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index c0306e2cca4289fae6ebd4a1b232c235f6fe06cb..51a7ce409c00f586058d4b7b0e3dba17f3b6900b 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -379,6 +379,25 @@ public class ServerPlayer extends Player {
+ 
+                 }
+             }
+            // Paper start
+            @Override
+            public void slotChanged(AbstractContainerMenu handler, int slotId, ItemStack oldStack, ItemStack stack) {
+                Slot slot = handler.getSlot(slotId);
+                if (!(slot instanceof ResultSlot)) {
+                    if (slot.container == ServerPlayer.this.getInventory()) {
+                        if (io.papermc.paper.event.player.PlayerInventorySlotChangeEvent.getHandlerList().getRegisteredListeners().length == 0) {
+                            CriteriaTriggers.INVENTORY_CHANGED.trigger(ServerPlayer.this, ServerPlayer.this.getInventory(), stack);
+                            return;
+                        }
+                        io.papermc.paper.event.player.PlayerInventorySlotChangeEvent event = new io.papermc.paper.event.player.PlayerInventorySlotChangeEvent(ServerPlayer.this.getBukkitEntity(), slotId, CraftItemStack.asBukkitCopy(oldStack), CraftItemStack.asBukkitCopy(stack));
+                        event.callEvent();
+                        if (event.shouldTriggerAdvancements()) {
+                            CriteriaTriggers.INVENTORY_CHANGED.trigger(ServerPlayer.this, ServerPlayer.this.getInventory(), stack);
+                        }
+                    }
+                }
+            }
+            // Paper end
+ 
+             @Override
+             public void dataChanged(AbstractContainerMenu handler, int property, int value) {}
+diff --git a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+index b22cf4636108794092d8e289368b72a10a16d3cd..c18348f4ea79b15b081cf7ba3bd9d77212aa086e 100644
+--- a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+@@ -302,7 +302,7 @@ public abstract class AbstractContainerMenu {
+             while (iterator.hasNext()) {
+                 ContainerListener icrafting = (ContainerListener) iterator.next();
+ 
+-                icrafting.slotChanged(this, slot, itemstack2);
+                icrafting.slotChanged(this, slot, itemstack1, itemstack2); // Paper
+             }
+         }
+ 
+diff --git a/src/main/java/net/minecraft/world/inventory/ContainerListener.java b/src/main/java/net/minecraft/world/inventory/ContainerListener.java
+index 0e19cc55646625bf32a354d3df2dc2d6bcff96f4..8ca9c14310b1e809662dd4ca6d35668992c2fc8d 100644
+--- a/src/main/java/net/minecraft/world/inventory/ContainerListener.java
+++ b/src/main/java/net/minecraft/world/inventory/ContainerListener.java
+@@ -5,5 +5,11 @@ import net.minecraft.world.item.ItemStack;
+ public interface ContainerListener {
+     void slotChanged(AbstractContainerMenu handler, int slotId, ItemStack stack);
+ 
+    // Paper start
+    default void slotChanged(AbstractContainerMenu handler, int slotId, ItemStack oldStack, ItemStack stack) {
+        slotChanged(handler, slotId, stack);
+    }
+    // Paper end
+
+     void dataChanged(AbstractContainerMenu handler, int property, int value);
+ }
--- a/patches/server/0860-Elder-Guardian-appearance-API.patch
+++ b/patches/server/0860-Elder-Guardian-appearance-API.patch
@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SoSeDiK <mrsosedik@gmail.com>
+Date: Tue, 11 Oct 2022 20:38:47 +0300
+Subject: [PATCH] Elder Guardian appearance API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 50d3de2bb715e7de8243174f66d92e45bae10683..6885b8995906e9fbb94316db5b1ba764f287d942 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -3179,6 +3179,13 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+     // Paper end
+ 
+    // Paper start
+    @Override
+    public void showElderGuardian(boolean silent) {
+        if (getHandle().connection != null) getHandle().connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.GUARDIAN_ELDER_EFFECT, silent ? 0F : 1F));
+    }
+    // Paper end
+
+     public Player.Spigot spigot()
+     {
+         return this.spigot;
--- a/patches/server/0861-Allow-changing-bed-s-occupied-property.patch
+++ b/patches/server/0861-Allow-changing-bed-s-occupied-property.patch
@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SoSeDiK <mrsosedik@gmail.com>
+Date: Wed, 12 Oct 2022 00:36:55 +0300
+Subject: [PATCH] Allow changing bed's 'occupied' property
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/data/type/CraftBed.java b/src/main/java/org/bukkit/craftbukkit/block/data/type/CraftBed.java
+index f636a6b69143e88fc3bebd11620083ab6a419d48..e6ff5225fe8253cbaa79ed15b4c12f3735fc7021 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/data/type/CraftBed.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/data/type/CraftBed.java
+@@ -22,4 +22,11 @@ public abstract class CraftBed extends CraftBlockData implements Bed {
+     public boolean isOccupied() {
+         return this.get(CraftBed.OCCUPIED);
+     }
+
+    // Paper start
+    @Override
+    public void setOccupied(boolean occupied) {
+        set(CraftBed.OCCUPIED, occupied);
+    }
+    // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/impl/CraftBed.java b/src/main/java/org/bukkit/craftbukkit/block/impl/CraftBed.java
+index 2ccf3fbe3f991b7a014cff3bcd424e6a81bc310a..e5450d3511389bf3bd6461fb6ec65ea82e4ae9f0 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/impl/CraftBed.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/impl/CraftBed.java
+@@ -51,4 +51,11 @@ public final class CraftBed extends org.bukkit.craftbukkit.block.data.CraftBlock
+     public java.util.Set<org.bukkit.block.BlockFace> getFaces() {
+         return this.getValues(CraftBed.FACING, org.bukkit.block.BlockFace.class);
+     }
+
+    // Paper start
+    @Override
+    public void setOccupied(boolean occupied) {
+        set(CraftBed.OCCUPIED, occupied);
+    }
+    // Paper end
+ }
--- a/patches/server/0862-Add-entity-knockback-API.patch
+++ b/patches/server/0862-Add-entity-knockback-API.patch
@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MelnCat <melncatuwu@gmail.com>
+Date: Sun, 16 Oct 2022 12:10:17 -0700
+Subject: [PATCH] Add entity knockback API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index bd58fdd7001e41418f4bbc881274814cf9fe79c3..3e99b80bb8d20198e905b18985941e3d32121e5d 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1037,5 +1037,11 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         }
+         throw new IllegalArgumentException(entityCategory + " is an unrecognized entity category");
+     }
+
+    @Override
+    public void knockback(double strength, double directionX, double directionZ) {
+        Preconditions.checkArgument(strength > 0, "Knockback strength must be > 0");
+        getHandle().knockback(strength, directionX, directionZ);
+    };
+     // Paper end
+ }
--- a/patches/server/0863-Detect-headless-JREs.patch
+++ b/patches/server/0863-Detect-headless-JREs.patch
@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Noah van der Aa <ndvdaa@gmail.com>
+Date: Sat, 22 Oct 2022 14:47:45 +0200
+Subject: [PATCH] Detect headless JREs
+
+Crashes caused by the missing AWT dependency come up in the support channels fairly often.
+This patch detects the missing dependency and stops the server with a clear error message,
+containing a link to instructions on how to install a non-headless JRE.
+
+diff --git a/src/main/java/io/papermc/paper/util/ServerEnvironment.java b/src/main/java/io/papermc/paper/util/ServerEnvironment.java
+index 6bd0afddbcc461149dfe9a5c7a86fff6ea13a5f1..148d233f4f5278ff39eacdaa0f4f0e7d73be936a 100644
+--- a/src/main/java/io/papermc/paper/util/ServerEnvironment.java
+++ b/src/main/java/io/papermc/paper/util/ServerEnvironment.java
+@@ -37,4 +37,14 @@ public class ServerEnvironment {
+     public static boolean userIsRootOrAdmin() {
+         return RUNNING_AS_ROOT_OR_ADMIN;
+     }
+
+    public static String awtDependencyCheck() {
+        try {
+            new java.awt.Color(0);
+        } catch (UnsatisfiedLinkError e) {
+            return e.getClass().getName() + ": " + e.getMessage();
+        }
+
+        return null;
+    }
+ }
+diff --git a/src/main/java/net/minecraft/server/Main.java b/src/main/java/net/minecraft/server/Main.java
+index 62f4c2c9485f7700a46f33cf9d158ce3d0552185..4a451d6d5b11f10db9c583823c4d742f4a69970c 100644
+--- a/src/main/java/net/minecraft/server/Main.java
+++ b/src/main/java/net/minecraft/server/Main.java
+@@ -175,6 +175,18 @@ public class Main {
+                 return;
+             }
+ 
+            // Paper start - Warn on headless
+            String awtException = io.papermc.paper.util.ServerEnvironment.awtDependencyCheck();
+            if (awtException != null) {
+                Main.LOGGER.error("You are using a headless JRE distribution.");
+                Main.LOGGER.error("This distribution is missing certain graphic libraries that the Minecraft server needs to function.");
+                Main.LOGGER.error("For instructions on how to install the non-headless JRE, see https://docs.papermc.io/misc/java-install");
+                Main.LOGGER.error("");
+                Main.LOGGER.error(awtException);
+                return;
+            }
+            // Paper end
+
+             org.spigotmc.SpigotConfig.disabledAdvancements = spigotConfiguration.getStringList("advancements.disabled"); // Paper - fix SPIGOT-5885, must be set early in init
+             // Paper start - fix SPIGOT-5824
+             File file;
--- a/patches/server/0864-fixed-entity-vehicle-collision-event-not-called.patch
+++ b/patches/server/0864-fixed-entity-vehicle-collision-event-not-called.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: lukas81298 <lukas81298@gmail.com>
+Date: Tue, 12 Jan 2021 14:41:38 +0100
+Subject: [PATCH] fixed entity vehicle collision event not called
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+index e3745cc43b48ff59a1659a9f88ad118b34f7f22b..48b1cddfca671ac8bcb93a1b60518a4ee9e977e2 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+++ b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+@@ -168,7 +168,15 @@ public abstract class AbstractMinecart extends VehicleEntity {
+ 
+     @Override
+     public boolean canCollideWith(Entity other) {
+-        return Boat.canVehicleCollide(this, other);
+        // Paper start - fixed VehicleEntityCollisionEvent not called when colliding with player
+        boolean collides = Boat.canVehicleCollide(this, other);
+        if (!collides) {
+            return false;
+        }
+        org.bukkit.event.vehicle.VehicleEntityCollisionEvent collisionEvent = new org.bukkit.event.vehicle.VehicleEntityCollisionEvent((org.bukkit.entity.Vehicle) getBukkitEntity(), other.getBukkitEntity());
+
+        return collisionEvent.callEvent();
+        // Paper end
+     }
+ 
+     @Override
--- a/patches/server/0865-optimized-dirt-and-snow-spreading.patch
+++ b/patches/server/0865-optimized-dirt-and-snow-spreading.patch
@ -0,0 +1,78 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: lukas81298 <lukas81298@gommehd.net>
+Date: Fri, 22 Jan 2021 21:50:18 +0100
+Subject: [PATCH] optimized dirt and snow spreading
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java b/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java
+index f38524cbcaa908644d901bf0929331d6dfd99ed9..1acdf9dad2621a20b077c5f88dab5e0f8688a38f 100644
+--- a/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java
+@@ -19,8 +19,13 @@ public abstract class SpreadingSnowyDirtBlock extends SnowyDirtBlock {
+     }
+ 
+     private static boolean canBeGrass(BlockState state, LevelReader world, BlockPos pos) {
+    // Paper start
+        return canBeGrass(world.getChunk(pos), state, world, pos);
+    }
+    private static boolean canBeGrass(net.minecraft.world.level.chunk.ChunkAccess chunk, BlockState state, LevelReader world, BlockPos pos) {
+    // Paper end
+         BlockPos blockposition1 = pos.above();
+-        BlockState iblockdata1 = world.getBlockState(blockposition1);
+        BlockState iblockdata1 = chunk.getBlockState(blockposition1); // Paper
+ 
+         if (iblockdata1.is(Blocks.SNOW) && (Integer) iblockdata1.getValue(SnowLayerBlock.LAYERS) == 1) {
+             return true;
+@@ -37,15 +42,27 @@ public abstract class SpreadingSnowyDirtBlock extends SnowyDirtBlock {
+     protected abstract MapCodec<? extends SpreadingSnowyDirtBlock> codec();
+ 
+     private static boolean canPropagate(BlockState state, LevelReader world, BlockPos pos) {
+    // Paper start
+        return canPropagate(world.getChunk(pos), state, world, pos);
+    }
+
+    private static boolean canPropagate(net.minecraft.world.level.chunk.ChunkAccess chunk, BlockState state, LevelReader world, BlockPos pos) {
+    // Paper end
+         BlockPos blockposition1 = pos.above();
+ 
+-        return SpreadingSnowyDirtBlock.canBeGrass(state, world, pos) && !world.getFluidState(blockposition1).is(FluidTags.WATER);
+        return SpreadingSnowyDirtBlock.canBeGrass(chunk, state, world, pos) && !chunk.getFluidState(blockposition1).is(FluidTags.WATER); // Paper
+     }
+ 
+     @Override
+     public void randomTick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
+         if (this instanceof GrassBlock && world.paperConfig().tickRates.grassSpread != 1 && (world.paperConfig().tickRates.grassSpread < 1 || (MinecraftServer.currentTick + pos.hashCode()) % world.paperConfig().tickRates.grassSpread != 0)) { return; } // Paper
+-        if (!SpreadingSnowyDirtBlock.canBeGrass(state, world, pos)) {
+        // Paper start
+        net.minecraft.world.level.chunk.ChunkAccess cachedBlockChunk = world.getChunkIfLoaded(pos);
+        if (cachedBlockChunk == null) { // Is this needed?
+            return;
+        }
+        if (!SpreadingSnowyDirtBlock.canBeGrass(cachedBlockChunk, state, world, pos)) {
+        // Paper end
+             // CraftBukkit start
+             if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, Blocks.DIRT.defaultBlockState()).isCancelled()) {
+                 return;
+@@ -58,9 +75,19 @@ public abstract class SpreadingSnowyDirtBlock extends SnowyDirtBlock {
+ 
+                 for (int i = 0; i < 4; ++i) {
+                     BlockPos blockposition1 = pos.offset(random.nextInt(3) - 1, random.nextInt(5) - 3, random.nextInt(3) - 1);
+-
+-                    if (world.getBlockState(blockposition1).is(Blocks.DIRT) && SpreadingSnowyDirtBlock.canPropagate(iblockdata1, world, blockposition1)) {
+-                        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, pos, blockposition1, (BlockState) iblockdata1.setValue(SpreadingSnowyDirtBlock.SNOWY, world.getBlockState(blockposition1.above()).is(Blocks.SNOW))); // CraftBukkit
+                    // Paper start
+                    if (pos.getX() == blockposition1.getX() && pos.getY() == blockposition1.getY() && pos.getZ() == blockposition1.getZ()) {
+                        continue;
+                    }
+                    net.minecraft.world.level.chunk.ChunkAccess access;
+                    if (cachedBlockChunk.locX == blockposition1.getX() >> 4 && cachedBlockChunk.locZ == blockposition1.getZ() >> 4) {
+                        access = cachedBlockChunk;
+                    } else {
+                        access = world.getChunkAt(blockposition1);
+                    }
+                    if (access.getBlockState(blockposition1).is(Blocks.DIRT) && SpreadingSnowyDirtBlock.canPropagate(access, iblockdata1, world, blockposition1)) {
+                        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, pos, blockposition1, (BlockState) iblockdata1.setValue(SpreadingSnowyDirtBlock.SNOWY, access.getBlockState(blockposition1.above()).is(Blocks.SNOW))); // CraftBukkit
+                    // Paper end
+                     }
+                 }
+             }
--- a/patches/server/0866-Added-EntityToggleSitEvent.patch
+++ b/patches/server/0866-Added-EntityToggleSitEvent.patch
@ -0,0 +1,100 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: KyGuy2002 <IEatBeans#1165>
+Date: Fri, 11 Mar 2022 15:33:10 +0000
+Subject: [PATCH] Added EntityToggleSitEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/TamableAnimal.java b/src/main/java/net/minecraft/world/entity/TamableAnimal.java
+index 1999cda5876bb12283d8c91a1b3e737c0d27bc38..1611a54bb68af34bfcbfd17028f564b7332aa489 100644
+--- a/src/main/java/net/minecraft/world/entity/TamableAnimal.java
+++ b/src/main/java/net/minecraft/world/entity/TamableAnimal.java
+@@ -67,7 +67,7 @@ public abstract class TamableAnimal extends Animal implements OwnableEntity {
+         }
+ 
+         this.orderedToSit = nbt.getBoolean("Sitting");
+-        this.setInSittingPose(this.orderedToSit);
+        this.setInSittingPose(this.orderedToSit, false); // Paper - Don't fire event
+     }
+ 
+     @Override
+@@ -125,6 +125,12 @@ public abstract class TamableAnimal extends Animal implements OwnableEntity {
+     }
+ 
+     public void setInSittingPose(boolean inSittingPose) {
+    // Paper start
+        this.setInSittingPose(inSittingPose, true);
+    }
+    public void setInSittingPose(boolean inSittingPose, boolean callEvent) {
+    // Paper end
+        if (callEvent && !new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), inSittingPose).callEvent()) return; // Paper start - call EntityToggleSitEvent
+         byte b = this.entityData.get(DATA_FLAGS_ID);
+         if (inSittingPose) {
+             this.entityData.set(DATA_FLAGS_ID, (byte)(b | 1));
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Fox.java b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+index 96799179b0dd1886f0cdc386f04e152a19b3337d..d17c69a857f083350cc9e9ec2b5dbe0a1482c85f 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -433,7 +433,7 @@ public class Fox extends Animal implements VariantHolder<Fox.Type> {
+ 
+         this.setSleeping(nbt.getBoolean("Sleeping"));
+         this.setVariant(Fox.Type.byName(nbt.getString("Type")));
+-        this.setSitting(nbt.getBoolean("Sitting"));
+        this.setSitting(nbt.getBoolean("Sitting"), false); // Paper
+         this.setIsCrouching(nbt.getBoolean("Crouching"));
+         if (this.level() instanceof ServerLevel) {
+             this.setTargetGoals();
+@@ -446,6 +446,12 @@ public class Fox extends Animal implements VariantHolder<Fox.Type> {
+     }
+ 
+     public void setSitting(boolean sitting) {
+        this.setSitting(sitting, true);
+    }
+    // Paper start
+    public void setSitting(boolean sitting, boolean fireEvent) {
+        if (fireEvent && !new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), sitting).callEvent()) return;
+    // Paper end
+         this.setFlag(1, sitting);
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Panda.java b/src/main/java/net/minecraft/world/entity/animal/Panda.java
+index 130761afcaa6723e0a9d9a518f1b526c344484b4..683cc5f9f066d554383fcd30e3654ac06ec76510 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Panda.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Panda.java
+@@ -138,6 +138,7 @@ public class Panda extends Animal {
+     }
+ 
+     public void sit(boolean sitting) {
+        if (!new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), sitting).callEvent()) return; // Paper start - call EntityToggleSitEvent
+         this.setFlag(8, sitting);
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java b/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java
+index faf3e31f23d71bbc345bf98d4240490ac4677843..1d9427da270edb447a2c8e031c4f05fe5d39603b 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java
+++ b/src/main/java/net/minecraft/world/entity/animal/camel/Camel.java
+@@ -556,7 +556,7 @@ public class Camel extends AbstractHorse implements PlayerRideableJumping, Saddl
+     }
+ 
+     public void sitDown() {
+-        if (!this.isCamelSitting()) {
+        if (!this.isCamelSitting() && new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), true).callEvent()) { // Paper
+             this.playSound(SoundEvents.CAMEL_SIT, 1.0F, this.getVoicePitch());
+             this.setPose(Pose.SITTING);
+             this.gameEvent(GameEvent.ENTITY_ACTION);
+@@ -565,7 +565,7 @@ public class Camel extends AbstractHorse implements PlayerRideableJumping, Saddl
+     }
+ 
+     public void standUp() {
+-        if (this.isCamelSitting()) {
+        if (this.isCamelSitting() && new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), false).callEvent()) { // Paper
+             this.playSound(SoundEvents.CAMEL_STAND, 1.0F, this.getVoicePitch());
+             this.setPose(Pose.STANDING);
+             this.gameEvent(GameEvent.ENTITY_ACTION);
+@@ -574,6 +574,7 @@ public class Camel extends AbstractHorse implements PlayerRideableJumping, Saddl
+     }
+ 
+     public void standUpInstantly() {
+        if (this.isCamelSitting() && !new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), false).callEvent()) return; // Paper
+         this.setPose(Pose.STANDING);
+         this.gameEvent(GameEvent.ENTITY_ACTION);
+         this.resetLastPoseChangeTickToFullStand(this.level().getGameTime());
--- a/patches/server/0867-Add-fire-tick-delay-option.patch
+++ b/patches/server/0867-Add-fire-tick-delay-option.patch
@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: VytskaLT <VytskaLT@protonmail.com>
+Date: Wed, 22 Jun 2022 14:34:28 +0300
+Subject: [PATCH] Add fire-tick-delay option
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/FireBlock.java b/src/main/java/net/minecraft/world/level/block/FireBlock.java
+index 3fb197ee3bfd3f36881b7d67f7a37f035bb27daf..8c0db5219ff30bdfae61b4b9f6033c8e28d21ee1 100644
+--- a/src/main/java/net/minecraft/world/level/block/FireBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/FireBlock.java
+@@ -172,7 +172,7 @@ public class FireBlock extends BaseFireBlock {
+ 
+     @Override
+     public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
+-        world.scheduleTick(pos, (Block) this, FireBlock.getFireTickDelay(world.random));
+        world.scheduleTick(pos, (Block) this, FireBlock.getFireTickDelay(world)); // Paper
+         if (world.getGameRules().getBoolean(GameRules.RULE_DOFIRETICK)) {
+             if (!state.canSurvive(world, pos)) {
+                 this.fireExtinguished(world, pos); // CraftBukkit - invalid place location
+@@ -373,11 +373,13 @@ public class FireBlock extends BaseFireBlock {
+     public void onPlace(BlockState iblockdata, Level world, BlockPos blockposition, BlockState iblockdata1, boolean flag, UseOnContext itemActionContext) {
+         super.onPlace(iblockdata, world, blockposition, iblockdata1, flag, itemActionContext);
+         // Paper end
+-        world.scheduleTick(blockposition, this, getFireTickDelay(world.random));
+        world.scheduleTick(blockposition, this, getFireTickDelay(world)); // Paper
+     }
+ 
+-    private static int getFireTickDelay(RandomSource random) {
+-        return 30 + random.nextInt(10);
+    // Paper start - customisable fire tick delay
+    private static int getFireTickDelay(Level world) {
+        return world.paperConfig().environment.fireTickDelay + world.random.nextInt(10);
+    // Paper end
+     }
+ 
+     @Override
--- a/patches/server/0868-Add-Moving-Piston-API.patch
+++ b/patches/server/0868-Add-Moving-Piston-API.patch
@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sat, 4 Dec 2021 13:29:36 -0500
+Subject: [PATCH] Add Moving Piston API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftMovingPiston.java b/src/main/java/org/bukkit/craftbukkit/block/CraftMovingPiston.java
+index c685846a539756ca7f0857e27f2b60d25cc13959..93ad5fed9a4d92169af0546c7e1cd8a62d19d1d7 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftMovingPiston.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftMovingPiston.java
+@@ -3,7 +3,7 @@ package org.bukkit.craftbukkit.block;
+ import net.minecraft.world.level.block.piston.PistonMovingBlockEntity;
+ import org.bukkit.World;
+ 
+-public class CraftMovingPiston extends CraftBlockEntityState<PistonMovingBlockEntity> {
+public class CraftMovingPiston extends CraftBlockEntityState<PistonMovingBlockEntity> implements io.papermc.paper.block.MovingPiston { // Paper - Add Moving Piston API
+ 
+     public CraftMovingPiston(World world, PistonMovingBlockEntity tileEntity) {
+         super(world, tileEntity);
+@@ -17,4 +17,26 @@ public class CraftMovingPiston extends CraftBlockEntityState<PistonMovingBlockEn
+     public CraftMovingPiston copy() {
+         return new CraftMovingPiston(this);
+     }
+
+    // Paper start - Add Moving Piston API
+    @Override
+    public org.bukkit.block.data.BlockData getMovingBlock() {
+        return org.bukkit.craftbukkit.block.data.CraftBlockData.fromData(this.getTileEntity().getMovedState());
+    }
+
+    @Override
+    public org.bukkit.block.BlockFace getDirection() {
+        return org.bukkit.craftbukkit.block.CraftBlock.notchToBlockFace(this.getTileEntity().getDirection());
+    }
+
+    @Override
+    public boolean isExtending() {
+        return this.getTileEntity().isExtending();
+    }
+
+    @Override
+    public boolean isPistonHead() {
+        return this.getTileEntity().isSourcePiston();
+    }
+    // Paper end - Add Moving Piston API
+ }
--- a/patches/server/0869-Ignore-impossible-spawn-tick.patch
+++ b/patches/server/0869-Ignore-impossible-spawn-tick.patch
@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: dannyball710 <dannyball710@gmail.com>
+Date: Sat, 12 Feb 2022 23:42:48 +0800
+Subject: [PATCH] Ignore impossible spawn tick
+
+
+diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+index 9ec83d6eeff22c2ce25374a83f581a675d4fd067..d88a23984dcea9c2119bdc245013af8b25448da3 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -82,6 +82,7 @@ public abstract class BaseSpawner {
+     }
+ 
+     public void serverTick(ServerLevel world, BlockPos pos) {
+        if (spawnCount <= 0 || maxNearbyEntities <= 0) return; // Paper - Ignore impossible spawn tick
+         // Paper start - Configurable mob spawner tick rate
+         if (spawnDelay > 0 && --tickDelay > 0) return;
+         tickDelay = world.paperConfig().tickRates.mobSpawner;
--- a/patches/server/0870-Track-projectile-source-for-fireworks-from-dispenser.patch
+++ b/patches/server/0870-Track-projectile-source-for-fireworks-from-dispenser.patch
@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 23 Jun 2022 19:25:51 -0700
+Subject: [PATCH] Track projectile source for fireworks from dispensers
+
+
+diff --git a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+index d9077127757886e5d5e8d63a46fe27f2bfba1420..b65d0c2ac5b4f7eb3da85b693c354463c6f49694 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -517,6 +517,7 @@ public interface DispenseItemBehavior {
+                 itemstack1 = CraftItemStack.asNMSCopy(event.getItem());
+                 Vec3 vec3d = DispenseItemBehavior.getEntityPokingOutOfBlockPos(pointer, EntityType.FIREWORK_ROCKET, enumdirection);
+                 FireworkRocketEntity entityfireworks = new FireworkRocketEntity(pointer.level(), itemstack1, vec3d.x(), vec3d.y(), vec3d.z(), true); // Paper - GH-2871 - fix last firework in stack having no effects when dispensed
+                entityfireworks.projectileSource = new org.bukkit.craftbukkit.projectiles.CraftBlockProjectileSource(pointer.blockEntity()); // Paper - track projectile source for fireworks
+ 
+                 entityfireworks.shoot((double) enumdirection.getStepX(), (double) enumdirection.getStepY(), (double) enumdirection.getStepZ(), 0.5F, 1.0F);
+                 pointer.level().addFreshEntity(entityfireworks);
--- a/patches/server/0871-Fix-EntityArgument-suggestion-permissions-to-align-w.patch
+++ b/patches/server/0871-Fix-EntityArgument-suggestion-permissions-to-align-w.patch
@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Wed, 26 Oct 2022 13:13:12 -0700
+Subject: [PATCH] Fix EntityArgument suggestion permissions to align with
+ EntitySelector#checkPermissions
+
+Fixes where the user has permission for selectors but not their
+suggestions, which especially matters when we force suggestions to
+the server for this type
+
+diff --git a/src/main/java/net/minecraft/commands/arguments/EntityArgument.java b/src/main/java/net/minecraft/commands/arguments/EntityArgument.java
+index a71726cee91fb406875a4540c9fb7c0ecf757294..150daf6bf4b27a6ff984d872a28002f19beef51c 100644
+--- a/src/main/java/net/minecraft/commands/arguments/EntityArgument.java
+++ b/src/main/java/net/minecraft/commands/arguments/EntityArgument.java
+@@ -128,7 +128,12 @@ public class EntityArgument implements ArgumentType<EntitySelector> {
+             StringReader stringreader = new StringReader(suggestionsbuilder.getInput());
+ 
+             stringreader.setCursor(suggestionsbuilder.getStart());
+-            EntitySelectorParser argumentparserselector = new EntitySelectorParser(stringreader, icompletionprovider.hasPermission(2), true); // Paper
+            // Paper start
+            final boolean permission = object instanceof CommandSourceStack stack
+                    ? stack.bypassSelectorPermissions || stack.hasPermission(2, "minecraft.command.selector")
+                    : icompletionprovider.hasPermission(2);
+            EntitySelectorParser argumentparserselector = new EntitySelectorParser(stringreader, permission, true); // Paper
+            // Paper end
+ 
+             try {
+                 argumentparserselector.parse();
--- a/patches/server/0872-Fix-EntityCombustEvent-cancellation-cant-fully-preve.patch
+++ b/patches/server/0872-Fix-EntityCombustEvent-cancellation-cant-fully-preve.patch
@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Denery <dorofeevij@gmail.com>
+Date: Mon, 31 Oct 2022 14:20:52 +0300
+Subject: [PATCH] Fix EntityCombustEvent cancellation cant fully prevent
+ entities from being set on fire
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 4ef45d704107d03a506627da80ebfeb41a0945f8..a59d738a8697ed06c445b0837b887aabcd92e366 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3382,6 +3382,10 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+             pluginManager.callEvent(entityCombustEvent);
+             if (!entityCombustEvent.isCancelled()) {
+                 this.setSecondsOnFire(entityCombustEvent.getDuration(), false);
+            // Paper start - fix EntityCombustEvent cancellation.
+            } else {
+                this.setRemainingFireTicks(this.remainingFireTicks - 1);
+            // Paper end
+             }
+             // CraftBukkit end
+         }
+diff --git a/src/main/java/net/minecraft/world/level/block/BaseFireBlock.java b/src/main/java/net/minecraft/world/level/block/BaseFireBlock.java
+index 02cbb25b8b1fdaf6e2b771067ca132245eab13dc..116dc2ac4c0176244eb8fc22a471d2b9ede72822 100644
+--- a/src/main/java/net/minecraft/world/level/block/BaseFireBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/BaseFireBlock.java
+@@ -134,6 +134,10 @@ public abstract class BaseFireBlock extends Block {
+ 
+                 if (!event.isCancelled()) {
+                     entity.setSecondsOnFire(event.getDuration(), false);
+                    // Paper start - fix EntityCombustEvent cancellation.
+                } else {
+                    entity.setRemainingFireTicks(entity.getRemainingFireTicks() - 1);
+                    // Paper end
+                 }
+                 // CraftBukkit end
+             }
--- a/patches/server/0873-Prevent-compass-from-loading-chunks.patch
+++ b/patches/server/0873-Prevent-compass-from-loading-chunks.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sun, 6 Nov 2022 22:35:51 +0000
+Subject: [PATCH] Prevent compass from loading chunks
+
+
+diff --git a/src/main/java/net/minecraft/world/item/CompassItem.java b/src/main/java/net/minecraft/world/item/CompassItem.java
+index 5d3047a420efe59063e90bfc7b42392127e0ad7d..7c4a2f8bb3efd11db2f8711952cc26a067c6d56b 100644
+--- a/src/main/java/net/minecraft/world/item/CompassItem.java
+++ b/src/main/java/net/minecraft/world/item/CompassItem.java
+@@ -77,7 +77,7 @@ public class CompassItem extends Item implements Vanishable {
+                 Optional<ResourceKey<Level>> optional = getLodestoneDimension(compoundTag);
+                 if (optional.isPresent() && optional.get() == world.dimension() && compoundTag.contains("LodestonePos")) {
+                     BlockPos blockPos = NbtUtils.readBlockPos(compoundTag.getCompound("LodestonePos"));
+-                    if (!world.isInWorldBounds(blockPos) || !((ServerLevel)world).getPoiManager().existsAtPosition(PoiTypes.LODESTONE, blockPos)) {
+                    if (!world.isInWorldBounds(blockPos) || (world.hasChunkAt(blockPos) && !((ServerLevel)world).getPoiManager().existsAtPosition(PoiTypes.LODESTONE, blockPos))) { // Paper
+                         compoundTag.remove("LodestonePos");
+                     }
+                 }
--- a/patches/server/0874-Add-PrePlayerAttackEntityEvent.patch
+++ b/patches/server/0874-Add-PrePlayerAttackEntityEvent.patch
@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sun, 18 Sep 2022 13:10:18 -0400
+Subject: [PATCH] Add PrePlayerAttackEntityEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java
+index bce494bb7bc1ce20809ac7d355f04aa7aad78308..078dd3ccf046d3ee5ef41108e9db4736182778f1 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -1240,8 +1240,17 @@ public abstract class Player extends LivingEntity {
+     }
+ 
+     public void attack(Entity target) {
+-        if (target.isAttackable()) {
+-            if (!target.skipAttackInteraction(this)) {
+        // Paper start - PlayerAttackEntityEvent
+        boolean willAttack = target.isAttackable() && !target.skipAttackInteraction(this); // Vanilla logic
+        io.papermc.paper.event.player.PrePlayerAttackEntityEvent playerAttackEntityEvent = new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(
+            (org.bukkit.entity.Player) this.getBukkitEntity(),
+            target.getBukkitEntity(),
+            willAttack
+        );
+
+        if (playerAttackEntityEvent.callEvent() && willAttack) { // Logic moved to willAttack local variable.
+            {
+        // Paper end
+                 float f = (float) this.getAttributeValue(Attributes.ATTACK_DAMAGE);
+                 float f1;
+ 
--- a/patches/server/0875-ensure-reset-EnderDragon-boss-event-name.patch
+++ b/patches/server/0875-ensure-reset-EnderDragon-boss-event-name.patch
@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 12 Nov 2022 10:08:58 -0800
+Subject: [PATCH] ensure reset EnderDragon boss event name
+
+Fix MC-257487
+
+diff --git a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+index 44f799d595d7150f00dfdfa2f85c87386f896607..390542c42fe957e8e2d21c879c1c8908c8970b44 100644
+--- a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+++ b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+@@ -73,6 +73,7 @@ public class EndDragonFight {
+     private static final int GATEWAY_DISTANCE = 96;
+     public static final int DRAGON_SPAWN_Y = 128;
+     private final Predicate<Entity> validPlayer;
+    private static final Component DEFAULT_BOSS_EVENT_NAME = Component.translatable("entity.minecraft.ender_dragon"); // Paper
+     public final ServerBossEvent dragonEvent;
+     public final ServerLevel level;
+     private final BlockPos origin;
+@@ -101,7 +102,7 @@ public class EndDragonFight {
+     }
+ 
+     public EndDragonFight(ServerLevel world, long gatewaysSeed, EndDragonFight.Data data, BlockPos origin) {
+-        this.dragonEvent = (ServerBossEvent) (new ServerBossEvent(Component.translatable("entity.minecraft.ender_dragon"), BossEvent.BossBarColor.PINK, BossEvent.BossBarOverlay.PROGRESS)).setPlayBossMusic(true).setCreateWorldFog(true);
+        this.dragonEvent = (ServerBossEvent) (new ServerBossEvent(DEFAULT_BOSS_EVENT_NAME, BossEvent.BossBarColor.PINK, BossEvent.BossBarOverlay.PROGRESS)).setPlayBossMusic(true).setCreateWorldFog(true); // Paper
+         this.gateways = new ObjectArrayList();
+         this.ticksSinceLastPlayerScan = 21;
+         this.skipArenaLoadedCheck = false;
+@@ -503,6 +504,10 @@ public class EndDragonFight {
+             this.ticksSinceDragonSeen = 0;
+             if (dragon.hasCustomName()) {
+                 this.dragonEvent.setName(dragon.getDisplayName());
+                // Paper start - reset to default name
+            } else {
+                this.dragonEvent.setName(DEFAULT_BOSS_EVENT_NAME);
+                // Paper end
+             }
+         }
+ 
--- a/patches/server/0876-fix-MC-252817-green-map-markers-do-not-disappear.patch
+++ b/patches/server/0876-fix-MC-252817-green-map-markers-do-not-disappear.patch
@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: braindead <totsuka.sama@gmail.com>
+Date: Sat, 5 Nov 2022 17:47:26 -0400
+Subject: [PATCH] fix MC-252817 (green map markers do not disappear).
+
+this bug is caused by the fact that the itemframe's item is set to empty before the green marker is requested to be removed. this is fixed by getting the mapid from this method's parameter, rather than the air block now stored by the item frame.
+
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+index 6849429c3577f36eb699083375824ae5633f8d06..9c11d0af958ec47408d238d34d30750d29ecdd88 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -291,7 +291,9 @@ public class ItemFrame extends HangingEntity {
+     // Paper end
+ 
+     private void removeFramedMap(ItemStack itemstack) {
+-        this.getFramedMapId().ifPresent((i) -> {
+        // Paper start - fix MC-252817 (green map markers do not disappear)
+        this.getFramedMapIdFromItem(itemstack).ifPresent((i) -> {
+            // Paper end
+             MapItemSavedData worldmap = MapItem.getSavedData(i, this.level());
+ 
+             if (worldmap != null) {
+@@ -309,7 +311,12 @@ public class ItemFrame extends HangingEntity {
+ 
+     public OptionalInt getFramedMapId() {
+         ItemStack itemstack = this.getItem();
+        // Paper start - fix MC-252817 (green map markers do not disappear)
+        return this.getFramedMapIdFromItem(itemstack);
+    }
+ 
+    public OptionalInt getFramedMapIdFromItem(ItemStack itemstack) {
+        // Paper end
+         if (itemstack.is(Items.FILLED_MAP)) {
+             Integer integer = MapItem.getMapId(itemstack);
+ 
--- a/patches/server/0877-Add-Player-Warden-Warning-API.patch
+++ b/patches/server/0877-Add-Player-Warden-Warning-API.patch
@ -0,0 +1,57 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: dawon <dawon@dawon.eu>
+Date: Sat, 15 Oct 2022 00:46:57 +0200
+Subject: [PATCH] Add Player Warden Warning API
+
+== AT ==
+public net.minecraft.server.level.ServerPlayer wardenSpawnTracker
+public net.minecraft.world.entity.monster.warden.WardenSpawnTracker ticksSinceLastWarning
+public net.minecraft.world.entity.monster.warden.WardenSpawnTracker cooldownTicks
+public net.minecraft.world.entity.monster.warden.WardenSpawnTracker increaseWarningLevel()V
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 6885b8995906e9fbb94316db5b1ba764f287d942..003ff30116a6b91e244af12e51aa5dd0925c778e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -3184,6 +3184,41 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     public void showElderGuardian(boolean silent) {
+         if (getHandle().connection != null) getHandle().connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.GUARDIAN_ELDER_EFFECT, silent ? 0F : 1F));
+     }
+
+    @Override
+    public int getWardenWarningCooldown() {
+        return this.getHandle().wardenSpawnTracker.cooldownTicks;
+    }
+
+    @Override
+    public void setWardenWarningCooldown(int cooldown) {
+        this.getHandle().wardenSpawnTracker.cooldownTicks = Math.max(cooldown, 0);
+    }
+
+    @Override
+    public int getWardenTimeSinceLastWarning() {
+        return this.getHandle().wardenSpawnTracker.ticksSinceLastWarning;
+    }
+
+    @Override
+    public void setWardenTimeSinceLastWarning(int time) {
+        this.getHandle().wardenSpawnTracker.ticksSinceLastWarning = time;
+    }
+
+    @Override
+    public int getWardenWarningLevel() {
+        return this.getHandle().wardenSpawnTracker.getWarningLevel();
+    }
+
+    @Override
+    public void setWardenWarningLevel(int warningLevel) {
+        this.getHandle().wardenSpawnTracker.setWarningLevel(warningLevel);
+    }
+
+    @Override
+    public void increaseWardenWarningLevel() {
+        this.getHandle().wardenSpawnTracker.increaseWarningLevel();
+    }
+     // Paper end
+ 
+     public Player.Spigot spigot()
--- a/patches/server/0878-More-vanilla-friendly-methods-to-update-trades.patch
+++ b/patches/server/0878-More-vanilla-friendly-methods-to-update-trades.patch
@ -0,0 +1,75 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Sun, 16 Oct 2022 16:12:49 +0200
+Subject: [PATCH] More vanilla friendly methods to update trades
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+index 363d1f469862c2e980624ff69f74be015c19412d..11935e5b16324af572b07c5b173708f5a91f8289 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -944,6 +944,12 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+ 
+     @Override
+     protected void updateTrades() {
+        // Paper start
+        updateTrades(TRADES_PER_LEVEL);
+    }
+
+    public boolean updateTrades(int amount) {
+        // Paper end
+         VillagerData villagerdata = this.getVillagerData();
+         Int2ObjectMap int2objectmap;
+ 
+@@ -961,9 +967,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+             if (avillagertrades_imerchantrecipeoption != null) {
+                 MerchantOffers merchantrecipelist = this.getOffers();
+ 
+-                this.addOffersFromItemListings(merchantrecipelist, avillagertrades_imerchantrecipeoption, 2);
+                this.addOffersFromItemListings(merchantrecipelist, avillagertrades_imerchantrecipeoption, amount); // Paper
+                return true; // Paper
+             }
+         }
+        return false; // Paper
+     }
+ 
+     public void gossip(ServerLevel world, Villager villager, long time) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
+index 00fb708bce2c79817cd9fccadec72f07f0d26317..6c15d40979fd3e3d246a447c432b321fbf29ada3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
+@@ -95,6 +95,34 @@ public class CraftVillager extends CraftAbstractVillager implements Villager {
+     }
+ 
+     // Paper start
+    @Override
+    public boolean increaseLevel(int amount) {
+        Preconditions.checkArgument(amount > 0, "Level earned must be positive");
+        int supposedFinalLevel = this.getVillagerLevel() + amount;
+        Preconditions.checkArgument(net.minecraft.world.entity.npc.VillagerData.MIN_VILLAGER_LEVEL <= supposedFinalLevel && supposedFinalLevel <= net.minecraft.world.entity.npc.VillagerData.MAX_VILLAGER_LEVEL,
+            "Final level reached after the donation (%d) must be between [%d, %d]".formatted(supposedFinalLevel, net.minecraft.world.entity.npc.VillagerData.MIN_VILLAGER_LEVEL, net.minecraft.world.entity.npc.VillagerData.MAX_VILLAGER_LEVEL));
+
+        it.unimi.dsi.fastutil.ints.Int2ObjectMap<net.minecraft.world.entity.npc.VillagerTrades.ItemListing[]> trades =
+            net.minecraft.world.entity.npc.VillagerTrades.TRADES.get(this.getHandle().getVillagerData().getProfession());
+
+        if (trades == null || trades.isEmpty()) {
+            this.getHandle().setVillagerData(this.getHandle().getVillagerData().setLevel(supposedFinalLevel));
+            return false;
+        }
+
+        while (amount > 0) {
+            this.getHandle().increaseMerchantCareer();
+            amount--;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean addTrades(int amount) {
+        Preconditions.checkArgument(amount > 0, "Number of trades unlocked must be positive");
+        return this.getHandle().updateTrades(amount);
+    }
+
+     @Override
+     public int getRestocksToday() {
+         return getHandle().numberOfRestocksToday;
--- a/patches/server/0879-Add-paper-dumplisteners-command.patch
+++ b/patches/server/0879-Add-paper-dumplisteners-command.patch
@ -0,0 +1,197 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Warrior <50800980+Warriorrrr@users.noreply.github.com>
+Date: Tue, 25 Oct 2022 21:15:37 +0200
+Subject: [PATCH] Add /paper dumplisteners command
+
+Co-authored-by: TwoLeggedCat <80929284+TwoLeggedCat@users.noreply.github.com>
+
+diff --git a/src/main/java/io/papermc/paper/command/PaperCommand.java b/src/main/java/io/papermc/paper/command/PaperCommand.java
+index b7fc337ab2bbe3c6d80ed70834e294ab3a7f9dc2..05b29305f5e3018a662884c2ef1af5ae4f6867ee 100644
+--- a/src/main/java/io/papermc/paper/command/PaperCommand.java
+++ b/src/main/java/io/papermc/paper/command/PaperCommand.java
+@@ -43,6 +43,7 @@ public final class PaperCommand extends Command {
+         commands.put(Set.of("syncloadinfo"), new SyncLoadInfoCommand());
+         commands.put(Set.of("dumpitem"), new DumpItemCommand());
+         commands.put(Set.of("mobcaps", "playermobcaps"), new MobcapsCommand());
+        commands.put(Set.of("dumplisteners"), new DumpListenersCommand());
+ 
+         return commands.entrySet().stream()
+             .flatMap(entry -> entry.getKey().stream().map(s -> Map.entry(s, entry.getValue())))
+diff --git a/src/main/java/io/papermc/paper/command/subcommands/DumpListenersCommand.java b/src/main/java/io/papermc/paper/command/subcommands/DumpListenersCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..aa44d4685de3caee4131449bead7a084868ff976
+--- /dev/null
+++ b/src/main/java/io/papermc/paper/command/subcommands/DumpListenersCommand.java
+@@ -0,0 +1,172 @@
+package io.papermc.paper.command.subcommands;
+
+import com.destroystokyo.paper.util.SneakyThrow;
+import io.papermc.paper.command.PaperSubcommand;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Field;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import net.kyori.adventure.text.Component;
+import net.minecraft.server.MinecraftServer;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.HandlerList;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.RegisteredListener;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.framework.qual.DefaultQualifier;
+
+import static net.kyori.adventure.text.Component.newline;
+import static net.kyori.adventure.text.Component.space;
+import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.format.NamedTextColor.GRAY;
+import static net.kyori.adventure.text.format.NamedTextColor.GREEN;
+import static net.kyori.adventure.text.format.NamedTextColor.RED;
+import static net.kyori.adventure.text.format.NamedTextColor.WHITE;
+
+@DefaultQualifier(NonNull.class)
+public final class DumpListenersCommand implements PaperSubcommand {
+    private static final MethodHandle EVENT_TYPES_HANDLE;
+
+    static {
+        try {
+            final Field eventTypesField = HandlerList.class.getDeclaredField("EVENT_TYPES");
+            eventTypesField.setAccessible(true);
+            EVENT_TYPES_HANDLE = MethodHandles.lookup().unreflectGetter(eventTypesField);
+        } catch (final ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public boolean execute(final CommandSender sender, final String subCommand, final String[] args) {
+        if (args.length >= 1 && args[0].equals("tofile")) {
+            this.dumpToFile(sender);
+            return true;
+        }
+        this.doDumpListeners(sender, args);
+        return true;
+    }
+
+    private void dumpToFile(final CommandSender sender) {
+        final File file = new File("debug/listeners-"
+            + DateTimeFormatter.ofPattern("yyyy-MM-dd_HH.mm.ss").format(LocalDateTime.now()) + ".txt");
+        file.getParentFile().mkdirs();
+        try (final PrintWriter writer = new PrintWriter(file)) {
+            for (final String eventClass : eventClassNames()) {
+                final HandlerList handlers;
+                try {
+                    handlers = (HandlerList) findClass(eventClass).getMethod("getHandlerList").invoke(null);
+                } catch (final ReflectiveOperationException e) {
+                    continue;
+                }
+                if (handlers.getRegisteredListeners().length != 0) {
+                    writer.println(eventClass);
+                }
+                for (final RegisteredListener registeredListener : handlers.getRegisteredListeners()) {
+                    writer.println(" - " + registeredListener);
+                }
+            }
+        } catch (final IOException ex) {
+            throw new RuntimeException(ex);
+        }
+        sender.sendMessage(text("Dumped listeners to " + file, GREEN));
+    }
+
+    private void doDumpListeners(final CommandSender sender, final String[] args) {
+        if (args.length == 0) {
+            sender.sendMessage(text("Usage: /paper dumplisteners tofile|<className>", RED));
+            return;
+        }
+
+        try {
+            final HandlerList handlers = (HandlerList) findClass(args[0]).getMethod("getHandlerList").invoke(null);
+
+            if (handlers.getRegisteredListeners().length == 0) {
+                sender.sendMessage(text(args[0] + " does not have any registered listeners."));
+                return;
+            }
+
+            sender.sendMessage(text("Listeners for " + args[0] + ":"));
+
+            for (final RegisteredListener listener : handlers.getRegisteredListeners()) {
+                final Component hoverText = text("Priority: " + listener.getPriority().name() + " (" + listener.getPriority().getSlot() + ")", WHITE)
+                    .append(newline())
+                    .append(text("Listener: " + listener.getListener()))
+                    .append(newline())
+                    .append(text("Executor: " + listener.getExecutor()))
+                    .append(newline())
+                    .append(text("Ignoring cancelled: " + listener.isIgnoringCancelled()));
+
+                sender.sendMessage(text(listener.getPlugin().getName(), GREEN)
+                    .append(space())
+                    .append(text("(" + listener.getListener().getClass().getName() + ")", GRAY).hoverEvent(hoverText)));
+            }
+
+            sender.sendMessage(text("Total listeners: " + handlers.getRegisteredListeners().length));
+
+        } catch (final ClassNotFoundException e) {
+            sender.sendMessage(text("Unable to find a class named '" + args[0] + "'. Make sure to use the fully qualified name.", RED));
+        } catch (final NoSuchMethodException e) {
+            sender.sendMessage(text("Class '" + args[0] + "' does not have a valid getHandlerList method.", RED));
+        } catch (final ReflectiveOperationException e) {
+            sender.sendMessage(text("Something went wrong, see the console for more details.", RED));
+            MinecraftServer.LOGGER.warn("Error occurred while dumping listeners for class " + args[0], e);
+        }
+    }
+
+    @Override
+    public List<String> tabComplete(final CommandSender sender, final String subCommand, final String[] args) {
+        return switch (args.length) {
+            case 0 -> suggestions();
+            case 1 -> suggestions().stream()
+                .filter(clazz -> clazz.toLowerCase(Locale.ROOT).contains(args[0].toLowerCase(Locale.ROOT)))
+                .toList();
+            default -> Collections.emptyList();
+        };
+    }
+
+    private static List<String> suggestions() {
+        final List<String> ret = new ArrayList<>();
+        ret.add("tofile");
+        ret.addAll(eventClassNames());
+        return ret;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Set<String> eventClassNames() {
+        try {
+            return (Set<String>) EVENT_TYPES_HANDLE.invokeExact();
+        } catch (final Throwable e) {
+            SneakyThrow.sneaky(e);
+            return Collections.emptySet(); // Unreachable
+        }
+    }
+
+    private static Class<?> findClass(final String className) throws ClassNotFoundException {
+        try {
+            return Class.forName(className);
+        } catch (final ClassNotFoundException ignore) {
+            for (final Plugin plugin : Bukkit.getServer().getPluginManager().getPlugins()) {
+                if (!plugin.isEnabled()) {
+                    continue;
+                }
+
+                try {
+                    return Class.forName(className, false, plugin.getClass().getClassLoader());
+                } catch (final ClassNotFoundException ignore0) {
+                }
+            }
+        }
+        throw new ClassNotFoundException(className);
+    }
+}
--- a/patches/server/0880-check-global-player-list-where-appropriate.patch
+++ b/patches/server/0880-check-global-player-list-where-appropriate.patch
@ -0,0 +1,85 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Tue, 22 Nov 2022 13:16:01 -0800
+Subject: [PATCH] check global player list where appropriate
+
+Makes certain entities check all players when searching for a player
+instead of just checking players in their world.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index ba30421e53f935e2860564f8e3748160d64e3665..56f1bbeaab24975b76026ebb5a4c73b62635c730 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -2751,4 +2751,12 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             entity.updateDynamicGameEventListener(DynamicGameEventListener::move);
+         }
+     }
+
+    // Paper start
+    @Override
+    @Nullable
+    public Player getGlobalPlayerByUUID(UUID uuid) {
+        return this.server.getPlayerList().getPlayer(uuid);
+    }
+    // Paper end
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index ece2f45427462587e28ba770178e13d7037e6668..9ea6c0b250c361949a7f2d2c6b5fb2eeac7c650a 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3678,7 +3678,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     }
+ 
+     public void onItemPickup(ItemEntity item) {
+-        Entity entity = item.getOwner();
+        Entity entity = item.thrower != null ? this.level().getGlobalPlayerByUUID(item.thrower) : null; // Paper - check all players
+ 
+         if (entity instanceof ServerPlayer) {
+             CriteriaTriggers.THROWN_ITEM_PICKED_UP_BY_ENTITY.trigger((ServerPlayer) entity, item.getItem(), this);
+diff --git a/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java b/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java
+index d4ac3e566b47cfc8688bcc2ab08385b6de4693f8..94396ad1a3c280787d36c6c18256d10340ace488 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java
+++ b/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java
+@@ -272,7 +272,7 @@ public class ZombieVillager extends Zombie implements VillagerDataHolder {
+         entityvillager.finalizeSpawn(world, world.getCurrentDifficultyAt(entityvillager.blockPosition()), MobSpawnType.CONVERSION, (SpawnGroupData) null, (CompoundTag) null);
+         entityvillager.refreshBrain(world);
+         if (this.conversionStarter != null) {
+-            Player entityhuman = world.getPlayerByUUID(this.conversionStarter);
+            Player entityhuman = world.getGlobalPlayerByUUID(this.conversionStarter); // Paper - check all players
+ 
+             if (entityhuman instanceof ServerPlayer) {
+                 CriteriaTriggers.CURED_ZOMBIE_VILLAGER.trigger((ServerPlayer) entityhuman, this, entityvillager);
+diff --git a/src/main/java/net/minecraft/world/level/EntityGetter.java b/src/main/java/net/minecraft/world/level/EntityGetter.java
+index 9f892de55ab03367daed4c30cc44c9dd8adc29ed..b3293a722fb5c5262a777402140c764c03367800 100644
+--- a/src/main/java/net/minecraft/world/level/EntityGetter.java
+++ b/src/main/java/net/minecraft/world/level/EntityGetter.java
+@@ -280,4 +280,11 @@ public interface EntityGetter {
+ 
+         return null;
+     }
+
+    // Paper start
+    @Nullable
+    default Player getGlobalPlayerByUUID(UUID uuid) {
+        return this.getPlayerByUUID(uuid);
+    }
+    // Paper end
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/SculkShriekerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SculkShriekerBlockEntity.java
+index ee11a52e82091911aa3a196bcc1f7ab829626cef..bcb9556314ccfcf54ec49860f46b309c72be0714 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/SculkShriekerBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/SculkShriekerBlockEntity.java
+@@ -100,6 +100,13 @@ public class SculkShriekerBlockEntity extends BlockEntity implements GameEventLi
+ 
+     @Nullable
+     public static ServerPlayer tryGetPlayer(@Nullable Entity entity) {
+        // Paper start - ensure level is the same for sculk events
+        final ServerPlayer player = tryGetPlayer0(entity);
+        return player != null && player.level() == entity.level() ? player : null;
+    }
+    @Nullable
+    private static ServerPlayer tryGetPlayer0(@Nullable Entity entity) {
+        // Paper end
+         if (entity instanceof ServerPlayer serverPlayer) {
+             return serverPlayer;
+         } else {
--- a/patches/server/0881-Fix-async-entity-add-due-to-fungus-trees.patch
+++ b/patches/server/0881-Fix-async-entity-add-due-to-fungus-trees.patch
@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 18 Mar 2022 21:30:00 -0700
+Subject: [PATCH] Fix async entity add due to fungus trees
+
+
+diff --git a/src/main/java/net/minecraft/server/level/WorldGenRegion.java b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+index 49c7825156afd053df1b7721a63070b51427aff2..14a5492428eac823a295ef3746d0aca6fbdab4ec 100644
+--- a/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+++ b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+@@ -249,6 +249,7 @@ public class WorldGenRegion implements WorldGenLevel {
+         if (iblockdata.isAir()) {
+             return false;
+         } else {
+            if (drop) LOGGER.warn("Potential async entity add during worldgen", new Throwable()); // Paper - log when this happens
+             if (false) { // CraftBukkit - SPIGOT-6833: Do not drop during world generation
+                 BlockEntity tileentity = iblockdata.hasBlockEntity() ? this.getBlockEntity(pos) : null;
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+index 0b7faa5b0fce81fd1790341599c632ffc5b171f3..096e1cc920f5f48fe59b9419827c3cbb7adefe14 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+@@ -405,10 +405,10 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+                 ((ChorusFlowerBlock) Blocks.CHORUS_FLOWER).generatePlant(access, pos, random, 8);
+                 return true;
+             case CRIMSON_FUNGUS:
+-                gen = TreeFeatures.CRIMSON_FUNGUS_PLANTED;
+                gen = this.isNormalWorld() ? TreeFeatures.CRIMSON_FUNGUS_PLANTED : TreeFeatures.CRIMSON_FUNGUS; // Paper - if world gen, don't use planted version
+                 break;
+             case WARPED_FUNGUS:
+-                gen = TreeFeatures.WARPED_FUNGUS_PLANTED;
+                gen = this.isNormalWorld() ? TreeFeatures.WARPED_FUNGUS_PLANTED : TreeFeatures.WARPED_FUNGUS; // Paper - if world gen, don't use planted version
+                 break;
+             case AZALEA:
+                 gen = TreeFeatures.AZALEA_TREE;
--- a/patches/server/0882-ItemStack-damage-API.patch
+++ b/patches/server/0882-ItemStack-damage-API.patch
@ -0,0 +1,70 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 8 May 2022 13:35:45 -0700
+Subject: [PATCH] ItemStack damage API
+
+Adds methods notify clients about item breaks and
+to simulate damage done to an itemstack and all
+the logic associated with damaging them
+
+== AT ==
+public net.minecraft.world.entity.LivingEntity entityEventForEquipmentBreak(Lnet/minecraft/world/entity/EquipmentSlot;)B
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 3e99b80bb8d20198e905b18985941e3d32121e5d..14ff9f9951bbb567ad76198477d61d22d522dac9 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1038,6 +1038,53 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         throw new IllegalArgumentException(entityCategory + " is an unrecognized entity category");
+     }
+ 
+    @Override
+    public void broadcastSlotBreak(org.bukkit.inventory.EquipmentSlot slot) {
+        this.getHandle().broadcastBreakEvent(org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot));
+    }
+
+    @Override
+    public void broadcastSlotBreak(org.bukkit.inventory.EquipmentSlot slot, Collection<org.bukkit.entity.Player> players) {
+        if (players.isEmpty()) {
+            return;
+        }
+        final net.minecraft.network.protocol.game.ClientboundEntityEventPacket packet = new net.minecraft.network.protocol.game.ClientboundEntityEventPacket(
+            this.getHandle(),
+            net.minecraft.world.entity.LivingEntity.entityEventForEquipmentBreak(org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot))
+        );
+        players.forEach(player -> ((CraftPlayer) player).getHandle().connection.send(packet));
+    }
+
+    @Override
+    public ItemStack damageItemStack(ItemStack stack, int amount) {
+        final net.minecraft.world.item.ItemStack nmsStack;
+        if (stack instanceof CraftItemStack craftItemStack) {
+            if (craftItemStack.handle == null || craftItemStack.handle.isEmpty()) {
+                return stack;
+            }
+            nmsStack = craftItemStack.handle;
+        } else {
+            nmsStack = CraftItemStack.asNMSCopy(stack);
+            stack = CraftItemStack.asCraftMirror(nmsStack); // mirror to capture changes in hurt logic & events
+        }
+        this.damageItemStack0(nmsStack, amount, null);
+        return stack;
+    }
+
+    @Override
+    public void damageItemStack(org.bukkit.inventory.EquipmentSlot slot, int amount) {
+        final net.minecraft.world.entity.EquipmentSlot nmsSlot = org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot);
+        this.damageItemStack0(this.getHandle().getItemBySlot(nmsSlot), amount, nmsSlot);
+    }
+
+    private void damageItemStack0(net.minecraft.world.item.ItemStack nmsStack, int amount, net.minecraft.world.entity.EquipmentSlot slot) {
+        nmsStack.hurtAndBreak(amount, this.getHandle(), livingEntity -> {
+            if (slot != null) {
+                livingEntity.broadcastBreakEvent(slot);
+            }
+        });
+    }
+
+     @Override
+     public void knockback(double strength, double directionX, double directionZ) {
+         Preconditions.checkArgument(strength > 0, "Knockback strength must be > 0");
--- a/patches/server/0883-Friction-API.patch
+++ b/patches/server/0883-Friction-API.patch
@ -0,0 +1,156 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Noah van der Aa <ndvdaa@gmail.com>
+Date: Wed, 15 Sep 2021 20:44:22 +0200
+Subject: [PATCH] Friction API
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 9ea6c0b250c361949a7f2d2c6b5fb2eeac7c650a..58fdbdcc5de9f93230669d93778c4c1392e0a4cf 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -261,6 +261,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     public boolean bukkitPickUpLoot;
+     public org.bukkit.craftbukkit.entity.CraftLivingEntity getBukkitLivingEntity() { return (org.bukkit.craftbukkit.entity.CraftLivingEntity) super.getBukkitEntity(); } // Paper
+     public boolean silentDeath = false; // Paper - mark entity as dying silently for cancellable death event
+    public net.kyori.adventure.util.TriState frictionState = net.kyori.adventure.util.TriState.NOT_SET; // Paper
+ 
+     @Override
+     public float getBukkitYaw() {
+@@ -716,7 +717,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     }
+ 
+     public boolean shouldDiscardFriction() {
+-        return this.discardFriction;
+        return !this.frictionState.toBooleanOrElse(!this.discardFriction); // Paper
+     }
+ 
+     public void setDiscardFriction(boolean noDrag) {
+@@ -760,6 +761,11 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+     @Override
+     public void addAdditionalSaveData(CompoundTag nbt) {
+        // Paper start
+        if (this.frictionState != net.kyori.adventure.util.TriState.NOT_SET) {
+            nbt.putString("Paper.FrictionState", this.frictionState.toString());
+        }
+        // Paper end
+         nbt.putFloat("Health", this.getHealth());
+         nbt.putShort("HurtTime", (short) this.hurtTime);
+         nbt.putInt("HurtByTimestamp", this.lastHurtByMobTimestamp);
+@@ -802,6 +808,15 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             absorptionAmount = 0;
+         }
+         this.internalSetAbsorptionAmount(absorptionAmount);
+
+        if (nbt.contains("Paper.FrictionState")) {
+            String fs = nbt.getString("Paper.FrictionState");
+            try {
+                frictionState = net.kyori.adventure.util.TriState.valueOf(fs);
+            } catch (Exception ignored) {
+                LOGGER.error("Unknown friction state " + fs + " for " + this);
+            }
+        }
+         // Paper end
+         if (nbt.contains("Attributes", 9) && this.level() != null && !this.level().isClientSide) {
+             this.getAttributes().load(nbt.getList("Attributes", 10));
+diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+index 6b18f23b57c7000dce9726df98a509ee9477f6d2..a39db702063887cf530f272deaf4f334047cc7d4 100644
+--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+@@ -57,6 +57,7 @@ public class ItemEntity extends Entity implements TraceableEntity {
+     private int lastTick = MinecraftServer.currentTick - 1; // CraftBukkit
+     public boolean canMobPickup = true; // Paper
+     private int despawnRate = -1; // Paper
+    public net.kyori.adventure.util.TriState frictionState = net.kyori.adventure.util.TriState.NOT_SET; // Paper
+ 
+     public ItemEntity(EntityType<? extends ItemEntity> type, Level world) {
+         super(type, world);
+@@ -178,7 +179,11 @@ public class ItemEntity extends Entity implements TraceableEntity {
+                 this.move(MoverType.SELF, this.getDeltaMovement());
+                 float f1 = 0.98F;
+ 
+-                if (this.onGround()) {
+                // Paper start
+                if (frictionState == net.kyori.adventure.util.TriState.FALSE) {
+                    f1 = 1F;
+                } else if (this.onGround()) {
+                    // Paper end
+                     f1 = this.level().getBlockState(this.getBlockPosBelowThatAffectsMyMovement()).getBlock().getFriction() * 0.98F;
+                 }
+ 
+@@ -387,6 +392,11 @@ public class ItemEntity extends Entity implements TraceableEntity {
+ 
+     @Override
+     public void addAdditionalSaveData(CompoundTag nbt) {
+        // Paper start
+        if (this.frictionState != net.kyori.adventure.util.TriState.NOT_SET) {
+            nbt.putString("Paper.FrictionState", this.frictionState.toString());
+        }
+        // Paper end
+         nbt.putShort("Health", (short) this.health);
+         nbt.putShort("Age", (short) this.age);
+         nbt.putShort("PickupDelay", (short) this.pickupDelay);
+@@ -421,6 +431,17 @@ public class ItemEntity extends Entity implements TraceableEntity {
+             this.cachedThrower = null;
+         }
+ 
+        // Paper start
+        if (nbt.contains("Paper.FrictionState")) {
+            String fs = nbt.getString("Paper.FrictionState");
+            try {
+                frictionState = net.kyori.adventure.util.TriState.valueOf(fs);
+            } catch (Exception ignored) {
+                com.mojang.logging.LogUtils.getLogger().error("Unknown friction state " + fs + " for " + this);
+            }
+        }
+        // Paper end
+
+         CompoundTag nbttagcompound1 = nbt.getCompound("Item");
+ 
+         this.setItem(ItemStack.of(nbttagcompound1));
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+index b1bbab951ef9a3d2bd98cc54665ba824263542eb..81498941748d646ebe6495f4a7ce6953532144c6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+@@ -99,6 +99,18 @@ public class CraftItem extends CraftEntity implements Item {
+         this.getHandle().age = willAge ? 0 : NO_AGE_TIME;
+      }
+ 
+     @org.jetbrains.annotations.NotNull
+     @Override
+     public net.kyori.adventure.util.TriState getFrictionState() {
+        return this.getHandle().frictionState;
+     }
+
+     @Override
+     public void setFrictionState(@org.jetbrains.annotations.NotNull net.kyori.adventure.util.TriState state) {
+         java.util.Objects.requireNonNull(state, "state may not be null");
+         this.getHandle().frictionState = state;
+     }
+
+     @Override
+     public int getHealth() {
+         return this.getHandle().health;
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 14ff9f9951bbb567ad76198477d61d22d522dac9..edb086d479f2485b3ec7a6fffe2c7e4a15f0c319 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1085,6 +1085,18 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         });
+     }
+ 
+    @org.jetbrains.annotations.NotNull
+    @Override
+    public net.kyori.adventure.util.TriState getFrictionState() {
+        return this.getHandle().frictionState;
+    }
+
+    @Override
+    public void setFrictionState(@org.jetbrains.annotations.NotNull net.kyori.adventure.util.TriState state) {
+        java.util.Objects.requireNonNull(state, "state may not be null");
+        this.getHandle().frictionState = state;
+    }
+
+     @Override
+     public void knockback(double strength, double directionX, double directionZ) {
+         Preconditions.checkArgument(strength > 0, "Knockback strength must be > 0");
--- a/patches/server/0884-Ability-to-control-player-s-insomnia-and-phantoms.patch
+++ b/patches/server/0884-Ability-to-control-player-s-insomnia-and-phantoms.patch
@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jan Villim <jan.villim@student.tuke.sk>
+Date: Sat, 22 Jan 2022 17:56:19 +0100
+Subject: [PATCH] Ability to control player's insomnia and phantoms
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/EntitySelector.java b/src/main/java/net/minecraft/world/entity/EntitySelector.java
+index 93a41156a01a1638f3ef469b1518a07e7961f378..2986c3b1c9dd7f3a00ed7f25b25bfc2b513b35eb 100644
+--- a/src/main/java/net/minecraft/world/entity/EntitySelector.java
+++ b/src/main/java/net/minecraft/world/entity/EntitySelector.java
+@@ -28,7 +28,18 @@ public final class EntitySelector {
+         return !entity.isSpectator();
+     };
+     public static final Predicate<Entity> CAN_BE_COLLIDED_WITH = EntitySelector.NO_SPECTATORS.and(Entity::canBeCollidedWith);
+-    public static Predicate<Player> IS_INSOMNIAC = (player) -> net.minecraft.util.Mth.clamp(((net.minecraft.server.level.ServerPlayer) player).getStats().getValue(net.minecraft.stats.Stats.CUSTOM.get(net.minecraft.stats.Stats.TIME_SINCE_REST)), 1, Integer.MAX_VALUE) >= 72000; // Paper
+    // Paper start
+    public static Predicate<Player> IS_INSOMNIAC = (player) -> {
+        net.minecraft.server.level.ServerPlayer serverPlayer = (net.minecraft.server.level.ServerPlayer) player;
+        int playerInsomniaTicks = serverPlayer.level().paperConfig().entities.behavior.playerInsomniaStartTicks;
+
+        if (playerInsomniaTicks <= 0) {
+            return false;
+        }
+
+        return net.minecraft.util.Mth.clamp(serverPlayer.getStats().getValue(net.minecraft.stats.Stats.CUSTOM.get(net.minecraft.stats.Stats.TIME_SINCE_REST)), 1, Integer.MAX_VALUE) >= playerInsomniaTicks;
+    };
+    // Paper end
+ 
+     private EntitySelector() {}
+     // Paper start
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+index b1fc786970b5288a02cc3a46e3fe7784ac566c07..dfeb3e336e06ef01f5401a362755030db942bb07 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+@@ -33,13 +33,22 @@ public class PhantomSpawner implements CustomSpawner {
+         } else if (!world.getGameRules().getBoolean(GameRules.RULE_DOINSOMNIA)) {
+             return 0;
+         } else {
+            // Paper start
+            if (world.paperConfig().entities.behavior.phantomsSpawnAttemptMaxSeconds <= 0) {
+                return 0;
+            }
+            // Paper end
+             RandomSource randomsource = world.random;
+ 
+             --this.nextTick;
+             if (this.nextTick > 0) {
+                 return 0;
+             } else {
+-                this.nextTick += (60 + randomsource.nextInt(60)) * 20;
+                // Paper start
+                int spawnAttemptMinSeconds = world.paperConfig().entities.behavior.phantomsSpawnAttemptMinSeconds;
+                int spawnAttemptMaxSeconds = world.paperConfig().entities.behavior.phantomsSpawnAttemptMaxSeconds;
+                this.nextTick += (spawnAttemptMinSeconds + randomsource.nextInt(spawnAttemptMaxSeconds - spawnAttemptMinSeconds + 1)) * 20;
+                // Paper end
+                 if (world.getSkyDarken() < 5 && world.dimensionType().hasSkyLight()) {
+                     return 0;
+                 } else {
+@@ -60,7 +69,7 @@ public class PhantomSpawner implements CustomSpawner {
+                                     int j = Mth.clamp(serverstatisticmanager.getValue(Stats.CUSTOM.get(Stats.TIME_SINCE_REST)), 1, Integer.MAX_VALUE);
+                                     boolean flag2 = true;
+ 
+-                                    if (randomsource.nextInt(j) >= 72000) {
+                                    if (randomsource.nextInt(j) >= world.paperConfig().entities.behavior.playerInsomniaStartTicks) { // Paper
+                                         BlockPos blockposition1 = blockposition.above(20 + randomsource.nextInt(15)).east(-10 + randomsource.nextInt(21)).south(-10 + randomsource.nextInt(21));
+                                         BlockState iblockdata = world.getBlockState(blockposition1);
+                                         FluidState fluid = world.getFluidState(blockposition1);
--- a/patches/server/0885-Fix-player-kick-on-shutdown.patch
+++ b/patches/server/0885-Fix-player-kick-on-shutdown.patch
@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Denery <dorofeevij@gmail.com>
+Date: Sun, 6 Nov 2022 02:02:46 +0300
+Subject: [PATCH] Fix player kick on shutdown
+
+Fix preemptive player kick on a server shutdown.
+If you update minecraft version / upstream and something is changed in this method make sure that a server doesn't disconnect a player preemptively,
+also check if all packets are ignored during the shutdown process.
+See net.minecraft.network.Connection#channelRead0(ChannelHandlerContext, Packet) and net.minecraft.util.thread.BlockableEventLoop#executeIfPossible(Runnable)
+
+diff --git a/src/main/java/net/minecraft/network/protocol/PacketUtils.java b/src/main/java/net/minecraft/network/protocol/PacketUtils.java
+index 7297bca9224c12d7ace0e1967340d99436afafc1..c5c734b9eb80d1cdf0e9fd8a043f2b6d1f4cbffe 100644
+--- a/src/main/java/net/minecraft/network/protocol/PacketUtils.java
+++ b/src/main/java/net/minecraft/network/protocol/PacketUtils.java
+@@ -44,7 +44,7 @@ public class PacketUtils {
+ 
+     public static <T extends PacketListener> void ensureRunningOnSameThread(Packet<T> packet, T listener, BlockableEventLoop<?> engine) throws RunningOnDifferentThreadException {
+         if (!engine.isSameThread()) {
+-            engine.executeIfPossible(() -> {
+            engine.execute(() -> { // Paper - Fix preemptive player kick on a server shutdown.
+                 packetProcessing.push(listener); // Paper - detailed watchdog information
+                 try { // Paper - detailed watchdog information
+                 if (MinecraftServer.getServer().hasStopped() || (listener instanceof ServerCommonPacketListenerImpl && ((ServerCommonPacketListenerImpl) listener).processedDisconnect)) return; // CraftBukkit, MC-142590
--- a/patches/server/0886-Sync-offhand-slot-in-menus.patch
+++ b/patches/server/0886-Sync-offhand-slot-in-menus.patch
@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 14 Jan 2022 10:20:40 -0800
+Subject: [PATCH] Sync offhand slot in menus
+
+Menus don't add slots for the offhand, so on sendAllDataToRemote calls the
+offhand slot isn't sent. This is not correct because you *can* put stuff into the offhand
+by pressing the offhand swap item
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 51a7ce409c00f586058d4b7b0e3dba17f3b6900b..cca1f44ba8cefcc0ee3e6dadd175bd67b311b2de 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -348,6 +348,13 @@ public class ServerPlayer extends Player {
+ 
+             }
+ 
+            // Paper start
+            @Override
+            public void sendOffHandSlotChange() {
+                ServerPlayer.this.connection.send(new ClientboundContainerSetSlotPacket(ServerPlayer.this.inventoryMenu.containerId, ServerPlayer.this.inventoryMenu.incrementStateId(), net.minecraft.world.inventory.InventoryMenu.SHIELD_SLOT, ServerPlayer.this.inventoryMenu.getSlot(net.minecraft.world.inventory.InventoryMenu.SHIELD_SLOT).getItem().copy()));
+            }
+            // Paper end
+
+             @Override
+             public void sendSlotChange(AbstractContainerMenu handler, int slot, ItemStack stack) {
+                 ServerPlayer.this.connection.send(new ClientboundContainerSetSlotPacket(handler.containerId, handler.incrementStateId(), slot, stack));
+diff --git a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+index c18348f4ea79b15b081cf7ba3bd9d77212aa086e..9ee3c2e0dcfaa4280be4973479c6490ded33809c 100644
+--- a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+@@ -200,6 +200,7 @@ public abstract class AbstractContainerMenu {
+ 
+         if (this.synchronizer != null) {
+             this.synchronizer.sendInitialData(this, this.remoteSlots, this.remoteCarried, this.remoteDataSlots.toIntArray());
+            this.synchronizer.sendOffHandSlotChange(); // Paper - update player's offhand since the offhand slot is not added to the slots for menus but can be changed by swapping from a menu slot
+         }
+ 
+     }
+diff --git a/src/main/java/net/minecraft/world/inventory/ContainerSynchronizer.java b/src/main/java/net/minecraft/world/inventory/ContainerSynchronizer.java
+index ff4fa86f9408e83e505f7e27692d3423f8570c48..db6c290dcbb8f5cb502f85e154b42ac89350a460 100644
+--- a/src/main/java/net/minecraft/world/inventory/ContainerSynchronizer.java
+++ b/src/main/java/net/minecraft/world/inventory/ContainerSynchronizer.java
+@@ -6,6 +6,7 @@ import net.minecraft.world.item.ItemStack;
+ public interface ContainerSynchronizer {
+     void sendInitialData(AbstractContainerMenu handler, NonNullList<ItemStack> stacks, ItemStack cursorStack, int[] properties);
+ 
+    default void sendOffHandSlotChange() {} // Paper
+     void sendSlotChange(AbstractContainerMenu handler, int slot, ItemStack stack);
+ 
+     void sendCarriedChange(AbstractContainerMenu handler, ItemStack stack);
--- a/patches/server/0887-Player-Entity-Tracking-Events.patch
+++ b/patches/server/0887-Player-Entity-Tracking-Events.patch
@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Yannick Lamprecht <yannicklamprecht@live.de>
+Date: Wed, 30 Mar 2022 18:16:52 +0200
+Subject: [PATCH] Player Entity Tracking Events
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index 81d3d664d4397e528a02e50469622c4ff3ffb804..c081842b4416d15342cbfc583ef367901dab2b7e 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -1410,9 +1410,18 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 // CraftBukkit end
+                 if (flag) {
+                     if (this.seenBy.add(player.connection)) {
+                        // Paper start - entity tracking events
+                        if (io.papermc.paper.event.player.PlayerTrackEntityEvent.getHandlerList().getRegisteredListeners().length == 0 || new io.papermc.paper.event.player.PlayerTrackEntityEvent(player.getBukkitEntity(), this.entity.getBukkitEntity()).callEvent()) {
+                         this.serverEntity.addPairing(player);
+                        }
+                        // Paper end
+                     }
+                 } else if (this.seenBy.remove(player.connection)) {
+                    // Paper start - entity tracking events
+                    if (io.papermc.paper.event.player.PlayerUntrackEntityEvent.getHandlerList().getRegisteredListeners().length > 0) {
+                        new io.papermc.paper.event.player.PlayerUntrackEntityEvent(player.getBukkitEntity(), this.entity.getBukkitEntity()).callEvent();
+                    }
+                    // Paper end
+                     this.serverEntity.removePairing(player);
+                 }
+ 
--- a/patches/server/0888-Limit-pet-look-distance.patch
+++ b/patches/server/0888-Limit-pet-look-distance.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Noah van der Aa <ndvdaa@gmail.com>
+Date: Tue, 6 Dec 2022 18:45:54 +0100
+Subject: [PATCH] Limit pet look distance
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java
+index 0a3f7dcc0e205a85dbaa6dee1fc9ae2c7fa9e02d..689bbc0feb700cfd6b10601d2c5a237ec40ed756 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java
+++ b/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java
+@@ -93,7 +93,7 @@ public class FollowOwnerGoal extends Goal {
+ 
+     @Override
+     public void tick() {
+-        this.tamable.getLookControl().setLookAt(this.owner, 10.0F, (float) this.tamable.getMaxHeadXRot());
+        if (this.tamable.distanceToSqr(this.owner) <= 16 * 16) this.tamable.getLookControl().setLookAt(this.owner, 10.0F, (float) this.tamable.getMaxHeadXRot()); // Paper
+         if (--this.timeToRecalcPath <= 0) {
+             this.timeToRecalcPath = this.adjustedTickDelay(10);
+             if (this.tamable.distanceToSqr((Entity) this.owner) >= 144.0D) {
--- a/patches/server/0889-Properly-resend-entities.patch
+++ b/patches/server/0889-Properly-resend-entities.patch
@ -0,0 +1,161 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Wed, 7 Dec 2022 17:25:19 -0500
+Subject: [PATCH] Properly resend entities
+
+This resolves some issues which caused entities to not be resent correctly.
+Entities that are interacted with need to be resent to the client, so we resend all the entity
+data to the player whilst making sure not to clear dirty entries from the tracker. This makes
+sure that values will be correctly updated to other players.
+
+This also adds utilities to aid in further preventing entity desyncs.
+
+See: https://github.com/PaperMC/Paper/pull/1896
+
+== AT ==
+public net.minecraft.server.level.ChunkMap$TrackedEntity serverEntity
+
+diff --git a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+index d088479d160dbd2fc90b48a30553be141db8eef2..ccb7d92b6c36b6225a2e640f8cea6c0da37464c8 100644
+--- a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+++ b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+@@ -253,14 +253,63 @@ public class SynchedEntityData {
+     // CraftBukkit start
+     public void refresh(ServerPlayer to) {
+         if (!this.isEmpty()) {
+-            List<SynchedEntityData.DataValue<?>> list = this.getNonDefaultValues();
+            List<SynchedEntityData.DataValue<?>> list = this.packAll(); // Paper - Update EVERYTHING not just not default
+ 
+             if (list != null) {
+                if (to.getBukkitEntity().canSee(this.entity.getBukkitEntity())) { // Paper
+                 to.connection.send(new ClientboundSetEntityDataPacket(this.entity.getId(), list));
+                } // Paper
+             }
+         }
+     }
+     // CraftBukkit end
+    // Paper start
+    // We need to pack all as we cannot rely on "non default values" or "dirty" ones.
+    // Because these values can possibly be desynced on the client.
+    @Nullable
+    private List<SynchedEntityData.DataValue<?>> packAll() {
+        if (this.isEmpty()) {
+            return null;
+        }
+
+        List<SynchedEntityData.DataValue<?>> list = new ArrayList<>();
+        for (DataItem<?> dataItem : this.itemsById.values()) {
+            list.add(dataItem.value());
+        }
+
+        return list;
+    }
+
+    // This method should only be used if the data of an entity could have became desynced
+    // due to interactions on the client.
+    public void resendPossiblyDesyncedEntity(ServerPlayer player) {
+        if (this.entity.tracker == null) {
+            return;
+        }
+
+        if (player.getBukkitEntity().canSee(entity.getBukkitEntity())) {
+            net.minecraft.server.level.ServerEntity serverEntity = this.entity.tracker.serverEntity;
+
+            List<net.minecraft.network.protocol.Packet<net.minecraft.network.protocol.game.ClientGamePacketListener>> list = new ArrayList<>();
+            serverEntity.sendPairingData(player, list::add);
+            player.connection.send(new net.minecraft.network.protocol.game.ClientboundBundlePacket(list));
+        }
+    }
+
+    // This method allows you to specifically resend certain data accessor keys to the client
+    public void resendPossiblyDesyncedDataValues(List<EntityDataAccessor<?>> keys, ServerPlayer to) {
+        if (!to.getBukkitEntity().canSee(this.entity.getBukkitEntity())) {
+            return;
+        }
+        List<SynchedEntityData.DataValue<?>> values = new ArrayList<>(keys.size());
+        for (EntityDataAccessor<?> key : keys) {
+            SynchedEntityData.DataItem<?> synchedValue = this.getItem(key);
+            values.add(synchedValue.value());
+        }
+
+        to.connection.send(new ClientboundSetEntityDataPacket(this.entity.getId(), values));
+    }
+    // Paper end
+ 
+     public static class DataItem<T> {
+ 
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index d7f551d8cae2055b82782905a14d649e44e8bcec..199a9e1d082ab937e2be9fd5abdd0891b7b78024 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2657,7 +2657,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+                             // Entity in bucket - SPIGOT-4048 and SPIGOT-6859a
+                             if ((entity instanceof Bucketable && entity instanceof LivingEntity && origItem != null && origItem.asItem() == Items.WATER_BUCKET) && (event.isCancelled() || ServerGamePacketListenerImpl.this.player.getInventory().getSelected() == null || ServerGamePacketListenerImpl.this.player.getInventory().getSelected().getItem() != origItem)) {
+-                                ServerGamePacketListenerImpl.this.send(new ClientboundAddEntityPacket(entity));
+                                entity.getEntityData().resendPossiblyDesyncedEntity(player); // Paper - The entire mob gets deleted, so resend it.
+                                 ServerGamePacketListenerImpl.this.player.containerMenu.sendAllDataToRemote();
+                             }
+ 
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 5afafee10b32b7f09757b5d60ad58e35cd467c17..53f9286d37215af55ab17c447327b13464c7a79d 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -376,7 +376,7 @@ public abstract class PlayerList {
+         ((ServerLevel)player.level()).getChunkSource().chunkMap.addEntity(player); // Paper - track entity now
+         // CraftBukkit end
+ 
+-        player.getEntityData().refresh(player); // CraftBukkit - BungeeCord#2321, send complete data to self on spawn
+        //player.getEntityData().refresh(player); // CraftBukkit - BungeeCord#2321, send complete data to self on spawn Paper - THIS IS NOT NEEDED ANYMORE
+ 
+         this.sendLevelInfo(player, worldserver1);
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Bucketable.java b/src/main/java/net/minecraft/world/entity/animal/Bucketable.java
+index 37596c7b65f280be00e8e59ae18bd1aceae21080..eca18540aeb0b0d4098477d73b14c78a7bf9f455 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Bucketable.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Bucketable.java
+@@ -109,8 +109,7 @@ public interface Bucketable {
+             itemstack1 = CraftItemStack.asNMSCopy(playerBucketFishEvent.getEntityBucket());
+             if (playerBucketFishEvent.isCancelled()) {
+                 ((ServerPlayer) player).containerMenu.sendAllDataToRemote(); // We need to update inventory to resync client's bucket
+-                ((ServerPlayer) player).connection.send(new ClientboundAddEntityPacket(entity)); // We need to play out these packets as the client assumes the fish is gone
+-                entity.getEntityData().refresh((ServerPlayer) player); // Need to send data such as the display name to client
+                entity.getEntityData().resendPossiblyDesyncedEntity((ServerPlayer) player); // Paper
+                 return Optional.of(InteractionResult.FAIL);
+             }
+             entity.playSound(((Bucketable) entity).getPickupSound(), 1.0F, 1.0F);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 1075c90e51cfea5823a74c07847545e227968ad2..c0f11fb8de8c15f8b07023fc05a7856413bc8036 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1302,7 +1302,11 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+             return;
+         }
+ 
+-        entityTracker.broadcast(this.getHandle().getAddEntityPacket());
+        // Paper start, resend possibly desynced entity instead of add entity packet
+        for (ServerPlayerConnection playerConnection : entityTracker.seenBy) {
+            this.getHandle().getEntityData().resendPossiblyDesyncedEntity(playerConnection.getPlayer());
+        }
+        // Paper end
+     }
+ 
+     private static PermissibleBase getPermissibleBase() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftItemFrame.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftItemFrame.java
+index 0801bcdee8fcff0d388d302387e4f1d587e0a283..2fcd9b836d42e3549a3b6b921c57a4c103146dff 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftItemFrame.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftItemFrame.java
+@@ -39,9 +39,11 @@ public class CraftItemFrame extends CraftHanging implements ItemFrame {
+     protected void update() {
+         super.update();
+ 
+        // Paper start, don't mark as dirty as this is handled in super.update()
+         // mark dirty, so that the client gets updated with item and rotation
+-        this.getHandle().getEntityData().markDirty(net.minecraft.world.entity.decoration.ItemFrame.DATA_ITEM);
+-        this.getHandle().getEntityData().markDirty(net.minecraft.world.entity.decoration.ItemFrame.DATA_ROTATION);
+        //this.getHandle().getEntityData().markDirty(net.minecraft.world.entity.decoration.ItemFrame.DATA_ITEM);
+        //this.getHandle().getEntityData().markDirty(net.minecraft.world.entity.decoration.ItemFrame.DATA_ROTATION);
+        // Paper end
+ 
+         // update redstone
+         if (!this.getHandle().generation) {
--- a/patches/server/0890-Fixes-and-additions-to-the-SpawnReason-API.patch
+++ b/patches/server/0890-Fixes-and-additions-to-the-SpawnReason-API.patch
@ -0,0 +1,84 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 25 Sep 2022 11:21:01 -0700
+Subject: [PATCH] Fixes and additions to the SpawnReason API
+
+Fixes some wrong reasons, and adds missing spawn reasons for entities.
+
+Co-authored-by: Doc <nachito94@msn.com>
+
+diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
+index 823f3b3093cffb49ccdcbcfbe6d348009a553ad7..e754a294645e1af9e39bde32dd1387cd54335e7e 100644
+--- a/src/main/java/net/minecraft/world/entity/EntityType.java
+++ b/src/main/java/net/minecraft/world/entity/EntityType.java
+@@ -353,7 +353,7 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+     @Nullable
+     public T spawn(ServerLevel world, @Nullable ItemStack stack, @Nullable Player player, BlockPos pos, MobSpawnType spawnReason, boolean alignPosition, boolean invertY) {
+         // CraftBukkit start
+-        return this.spawn(world, stack, player, pos, spawnReason, alignPosition, invertY, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER_EGG);
+        return this.spawn(world, stack, player, pos, spawnReason, alignPosition, invertY, spawnReason == MobSpawnType.DISPENSER ? org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DISPENSE_EGG : org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER_EGG); // Paper - use correct spawn reason for dispenser spawn eggs
+     }
+ 
+     @Nullable
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java b/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
+index 9652e3385ad10e5d825dd141f6be3522c596916d..6256ce68d6ecada66745fb09360cba2bf991360c 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
+@@ -54,7 +54,7 @@ public class DragonFireball extends AbstractHurtingProjectile {
+ 
+                 if (new com.destroystokyo.paper.event.entity.EnderDragonFireballHitEvent((org.bukkit.entity.DragonFireball) this.getBukkitEntity(), list.stream().map(LivingEntity::getBukkitLivingEntity).collect(java.util.stream.Collectors.toList()), (org.bukkit.entity.AreaEffectCloud) areaEffectCloud.getBukkitEntity()).callEvent()) { // Paper
+                 this.level().levelEvent(2006, this.blockPosition(), this.isSilent() ? -1 : 1);
+-                this.level().addFreshEntity(areaEffectCloud);
+                this.level().addFreshEntity(areaEffectCloud, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.EXPLOSION); // Paper
+                 } else areaEffectCloud.discard(); // Paper
+                 this.discard();
+             }
+diff --git a/src/main/java/net/minecraft/world/level/block/CarvedPumpkinBlock.java b/src/main/java/net/minecraft/world/level/block/CarvedPumpkinBlock.java
+index 8f38965b42a20ac39cb1170278562070ebf2f958..a63733fa01dc58b3c0abb28c1cd88c8b0a456083 100644
+--- a/src/main/java/net/minecraft/world/level/block/CarvedPumpkinBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/CarvedPumpkinBlock.java
+@@ -92,7 +92,17 @@ public class CarvedPumpkinBlock extends HorizontalDirectionalBlock {
+         // clearPatternBlocks(world, shapedetector_shapedetectorcollection); // CraftBukkit - moved down
+         entity.moveTo((double) pos.getX() + 0.5D, (double) pos.getY() + 0.05D, (double) pos.getZ() + 0.5D, 0.0F, 0.0F);
+         // CraftBukkit start
+-        if (!world.addFreshEntity(entity, SpawnReason.BUILD_IRONGOLEM)) {
+        // Paper start - correct spawn reason
+        final SpawnReason spawnReason;
+        if (entity.getType() == EntityType.SNOW_GOLEM) {
+            spawnReason = SpawnReason.BUILD_SNOWMAN;
+        } else if (entity.getType() == EntityType.IRON_GOLEM) {
+            spawnReason = SpawnReason.BUILD_IRONGOLEM;
+        } else {
+            spawnReason = SpawnReason.DEFAULT;
+        }
+        if (!world.addFreshEntity(entity, spawnReason)) {
+        // Paper end
+             return;
+         }
+         CarvedPumpkinBlock.clearPatternBlocks(world, patternResult); // CraftBukkit - from above
+diff --git a/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java b/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
+index 0a2de99c22cfcc96a664dc2afe7379987ea815db..6fc8d7f93141d85d8aecc97314e747624beb5e6c 100644
+--- a/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
+@@ -117,7 +117,7 @@ public class FrogspawnBlock extends Block {
+                 int k = random.nextInt(1, 361);
+                 tadpole.moveTo(d, (double)pos.getY() - 0.5D, e, (float)k, 0.0F);
+                 tadpole.setPersistenceRequired();
+-                world.addFreshEntity(tadpole);
+                world.addFreshEntity(tadpole, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.EGG); // Paper
+             }
+         }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java b/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+index 3cedc349e79665d3d471c92b5dca25c9e66ca0bf..6c025c0fac9bd6373b99e374b773ca626d47ee6d 100644
+--- a/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+@@ -88,7 +88,7 @@ public class SnifferEggBlock extends Block {
+                 Vec3 vec3 = pos.getCenter();
+                 sniffer.setBaby(true);
+                 sniffer.moveTo(vec3.x(), vec3.y(), vec3.z(), Mth.wrapDegrees(world.random.nextFloat() * 360.0F), 0.0F);
+-                world.addFreshEntity(sniffer);
+                world.addFreshEntity(sniffer, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.EGG); // Paper
+             }
+ 
+         }
--- a/patches/server/0891-fix-Instruments.patch
+++ b/patches/server/0891-fix-Instruments.patch
@ -0,0 +1,56 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 9 Dec 2022 01:47:23 -0800
+Subject: [PATCH] fix Instruments
+
+properly handle Player#playNote
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 003ff30116a6b91e244af12e51aa5dd0925c778e..a25cdcb4468d16a064ea290c0a397ea8cf0864ad 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -726,7 +726,10 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         Sound instrumentSound = instrument.getSound();
+         if (instrumentSound == null) return;
+ 
+-        float pitch = note.getPitch();
+        // Paper start - use correct pitch (modeled off of NoteBlock)
+        final net.minecraft.world.level.block.state.properties.NoteBlockInstrument noteBlockInstrument = CraftBlockData.toNMS(instrument, net.minecraft.world.level.block.state.properties.NoteBlockInstrument.class);
+        final float pitch = noteBlockInstrument.isTunable() ? note.getPitch() : 1.0f;
+        // Paper end
+         this.getHandle().connection.send(new ClientboundSoundPacket(CraftSound.bukkitToMinecraftHolder(instrumentSound), net.minecraft.sounds.SoundSource.RECORDS, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ(), 3.0f, pitch, this.getHandle().getRandom().nextLong()));
+     }
+ 
+diff --git a/src/test/java/io/papermc/paper/block/InstrumentSoundTest.java b/src/test/java/io/papermc/paper/block/InstrumentSoundTest.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..28fc01045675247e75438bdc039fb8a90493419f
+--- /dev/null
+++ b/src/test/java/io/papermc/paper/block/InstrumentSoundTest.java
+@@ -0,0 +1,27 @@
+package io.papermc.paper.block;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+import net.minecraft.world.level.block.state.properties.NoteBlockInstrument;
+import org.bukkit.Instrument;
+import org.bukkit.craftbukkit.CraftSound;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class InstrumentSoundTest extends AbstractTestingBase {
+
+    static Stream<Instrument> bukkitInstruments() {
+        return Arrays.stream(Instrument.values()).filter(i -> i.getSound() != null);
+    }
+
+    @ParameterizedTest
+    @MethodSource("bukkitInstruments")
+    void checkInstrumentSound(final Instrument bukkit) {
+        final NoteBlockInstrument nms = CraftBlockData.toNMS(bukkit, NoteBlockInstrument.class);
+        assertEquals(nms.getSoundEvent(), CraftSound.bukkitToMinecraftHolder(bukkit.getSound()));
+    }
+}
--- a/patches/server/0892-Improve-inlining-for-some-hot-BlockBehavior-and-Flui.patch
+++ b/patches/server/0892-Improve-inlining-for-some-hot-BlockBehavior-and-Flui.patch
@ -0,0 +1,79 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Mon, 6 Jul 2020 20:46:50 -0700
+Subject: [PATCH] Improve inlining for some hot BlockBehavior and FluidState
+ methods
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+index 84d7aeafafe1497d96dca2238b579007cbe27146..3ab8b99837b1d1faea722c598b0228b2780be8b1 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+@@ -1078,15 +1078,15 @@ public abstract class BlockBehaviour implements FeatureElement {
+             return this.shapeExceedsCube; // Paper - moved into shape cache init
+         }
+ 
+-        public boolean useShapeForLightOcclusion() {
+        public final boolean useShapeForLightOcclusion() { // Paper
+             return this.useShapeForLightOcclusion;
+         }
+ 
+-        public int getLightEmission() {
+        public final int getLightEmission() { // Paper
+             return this.lightEmission;
+         }
+ 
+-        public boolean isAir() {
+        public final boolean isAir() { // Paper
+             return this.isAir;
+         }
+ 
+@@ -1170,7 +1170,7 @@ public abstract class BlockBehaviour implements FeatureElement {
+             }
+         }
+ 
+-        public boolean canOcclude() {
+        public final boolean canOcclude() { // Paper
+             return this.canOcclude;
+         }
+ 
+@@ -1378,11 +1378,11 @@ public abstract class BlockBehaviour implements FeatureElement {
+             return this.getBlock().builtInRegistryHolder().is(key);
+         }
+ 
+-        public FluidState getFluidState() {
+        public final FluidState getFluidState() { // Paper
+             return this.fluidState;
+         }
+ 
+-        public boolean isRandomlyTicking() {
+        public final boolean isRandomlyTicking() { // Paper
+             return this.isRandomlyTicking;
+         }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/material/FluidState.java b/src/main/java/net/minecraft/world/level/material/FluidState.java
+index ea2a04e5298832177fac93568656ac45784d5eb6..27f136815afc360387704fa1f2773e3816cccff6 100644
+--- a/src/main/java/net/minecraft/world/level/material/FluidState.java
+++ b/src/main/java/net/minecraft/world/level/material/FluidState.java
+@@ -26,8 +26,12 @@ public final class FluidState extends StateHolder<Fluid, FluidState> {
+     public static final int AMOUNT_MAX = 9;
+     public static final int AMOUNT_FULL = 8;
+ 
+    // Paper start
+    protected final boolean isEmpty;
+    // Paper end
+     public FluidState(Fluid fluid, ImmutableMap<Property<?>, Comparable<?>> propertiesMap, MapCodec<FluidState> codec) {
+         super(fluid, propertiesMap, codec);
+        this.isEmpty = fluid.isEmpty(); // Paper - moved from isEmpty()
+     }
+ 
+     public Fluid getType() {
+@@ -43,7 +47,7 @@ public final class FluidState extends StateHolder<Fluid, FluidState> {
+     }
+ 
+     public boolean isEmpty() {
+-        return this.getType().isEmpty();
+        return this.isEmpty; // Paper - moved into constructor
+     }
+ 
+     public float getHeight(BlockGetter world, BlockPos pos) {
--- a/patches/server/0893-Fix-inconsistencies-in-dispense-events-regarding-sta.patch
+++ b/patches/server/0893-Fix-inconsistencies-in-dispense-events-regarding-sta.patch
@ -0,0 +1,557 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 11 Dec 2022 23:47:22 -0800
+Subject: [PATCH] Fix inconsistencies in dispense events regarding stack size
+
+The javadocs for BlockDispenseEvent suggest the ItemStack is a single
+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 e22d71c371952e91b838d10206d3dcdf9dc8716d..155bd3d6d9c7d3cac7fd04de8210301251d1e17a 100644
+--- a/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java
+++ b/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java
+@@ -27,7 +27,7 @@ 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);
+ 
+@@ -37,12 +37,13 @@ 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());
+@@ -56,7 +57,7 @@ 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 90e1914599b43c8bf813596b3b428d8be3bac1b5..6df0db8b4cdab23494ea34236949ece4989110a3 100644
+--- a/src/main/java/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
+++ b/src/main/java/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
+@@ -58,7 +58,7 @@ public class BoatDispenseItemBehavior extends DefaultDispenseItemBehavior {
+ 
+         // Object object = this.isChestBoat ? new ChestBoat(worldserver, d1, d2 + d4, d3) : new EntityBoat(worldserver, d1, d2 + d4, d3);
+         // CraftBukkit start
+-        ItemStack itemstack1 = stack.split(1);
+        ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink at end and single item in event
+         org.bukkit.block.Block block = CraftBlock.at(worldserver, pointer.pos());
+         CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -68,12 +68,13 @@ public class BoatDispenseItemBehavior 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());
+@@ -89,8 +90,7 @@ public class BoatDispenseItemBehavior extends DefaultDispenseItemBehavior {
+         EntityType.createDefaultStackConfig(worldserver, stack, (Player) null).accept(object);
+         ((Boat) object).setVariant(this.type);
+         ((Boat) object).setYRot(enumdirection.toYRot());
+-        if (!worldserver.addFreshEntity((Entity) object)) stack.grow(1); // CraftBukkit
+-        // itemstack.shrink(1); // CraftBukkit - handled during event processing
+        if (worldserver.addFreshEntity((Entity) object) && shrink) stack.shrink(1); // Paper - if entity add was successful and supposed to shrink
+         return stack;
+     }
+ 
+diff --git a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+index b65d0c2ac5b4f7eb3da85b693c354463c6f49694..dd017c33ff89a516022378160410bc41cce9222e 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -217,7 +217,7 @@ public interface DispenseItemBehavior {
+ 
+                 // 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);
+ 
+@@ -227,12 +227,13 @@ 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());
+@@ -249,7 +250,7 @@ public interface DispenseItemBehavior {
+                     return ItemStack.EMPTY;
+                 }
+ 
+-                // 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());
+                 return stack;
+@@ -271,7 +272,7 @@ public interface DispenseItemBehavior {
+                 ServerLevel worldserver = pointer.level();
+ 
+                 // 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);
+ 
+@@ -281,12 +282,13 @@ 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());
+@@ -303,7 +305,7 @@ public interface DispenseItemBehavior {
+                 ArmorStand entityarmorstand = (ArmorStand) EntityType.ARMOR_STAND.spawn(worldserver, stack.getTag(), consumer, blockposition, MobSpawnType.DISPENSER, false, false);
+ 
+                 if (entityarmorstand != null) {
+-                    // itemstack.shrink(1); // CraftBukkit - Handled during event processing
+                    if (shrink) stack.shrink(1); // Paper - actually handle here
+                 }
+ 
+                 return stack;
+@@ -325,7 +327,7 @@ public interface DispenseItemBehavior {
+ 
+                 if (!list.isEmpty()) {
+                     // CraftBukkit start
+-                    ItemStack itemstack1 = stack.split(1);
+                    ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+                     Level world = pointer.level();
+                     org.bukkit.block.Block block = CraftBlock.at(world, pointer.pos());
+                     CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+@@ -336,12 +338,13 @@ 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());
+@@ -352,7 +355,7 @@ public interface DispenseItemBehavior {
+                     }
+                     // CraftBukkit end
+                     ((Saddleable) list.get(0)).equipSaddle(SoundSource.BLOCKS, CraftItemStack.asNMSCopy(event.getItem())); // Paper - Fix saddles losing nbt data - MC-191591
+-                    // itemstack.shrink(1); // CraftBukkit - handled above
+                    if (shrink) stack.shrink(1); // Paper - actually handle here
+                     this.setSuccess(true);
+                     return stack;
+                 } else {
+@@ -380,7 +383,7 @@ public interface DispenseItemBehavior {
+                 } while (!entityhorseabstract.isArmor(stack) || entityhorseabstract.isWearingArmor() || !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();
+                 org.bukkit.block.Block block = CraftBlock.at(world, pointer.pos());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+@@ -391,12 +394,13 @@ 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());
+@@ -406,6 +410,7 @@ public interface DispenseItemBehavior {
+                     }
+                 }
+ 
+                if (shrink) stack.shrink(1); // Paper - shrink here
+                 entityhorseabstract.getSlot(401).set(CraftItemStack.asNMSCopy(event.getItem()));
+                 // CraftBukkit end
+                 this.setSuccess(true);
+@@ -452,7 +457,7 @@ public interface DispenseItemBehavior {
+                     entityhorsechestedabstract = (AbstractChestedHorse) iterator1.next();
+                     // CraftBukkit start
+                 } while (!entityhorsechestedabstract.isTamed());
+-                ItemStack itemstack1 = stack.split(1);
+                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below
+                 Level world = pointer.level();
+                 org.bukkit.block.Block block = CraftBlock.at(world, pointer.pos());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+@@ -463,10 +468,13 @@ public interface DispenseItemBehavior {
+                 }
+ 
+                 if (event.isCancelled()) {
+                    // stack.grow(1); // Paper - shrink below (this was actually missing and should be here, added it commented out just for less confusion)
+                     return stack;
+                 }
+ 
+                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+                    shrink = false; // Paper - shrink below (this was actually missing and should be here, added it commented out just for less confusion)
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -478,7 +486,7 @@ public interface DispenseItemBehavior {
+                 entityhorsechestedabstract.getSlot(499).set(CraftItemStack.asNMSCopy(event.getItem()));
+                 // CraftBukkit end
+ 
+-                // itemstack.shrink(1); // CraftBukkit - handled above
+                if (shrink) stack.shrink(1); // Paper - actually handle here
+                 this.setSuccess(true);
+                 return stack;
+             }
+@@ -489,7 +497,7 @@ 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);
+ 
+@@ -499,12 +507,13 @@ 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());
+@@ -521,7 +530,7 @@ 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;
+             }
+@@ -546,7 +555,7 @@ 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);
+ 
+@@ -556,12 +565,13 @@ 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());
+@@ -576,7 +586,7 @@ 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;
+             }
+@@ -620,7 +630,7 @@ public interface DispenseItemBehavior {
+                 BlockState iblockdata = worldserver.getBlockState(blockposition);
+                 if (iblockdata.isAir() || iblockdata.canBeReplaced() || (dispensiblecontaineritem instanceof BucketItem && iblockdata.getBlock() instanceof LiquidBlockContainer && ((LiquidBlockContainer) iblockdata.getBlock()).canPlaceLiquid((Player) null, worldserver, blockposition, iblockdata, ((BucketItem) dispensiblecontaineritem).content))) {
+                     org.bukkit.block.Block block = CraftBlock.at(worldserver, pointer.pos());
+-                    CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
+                    CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                     BlockDispenseEvent event = new BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector(x, y, z));
+                     if (!DispenserBlock.eventFired) {
+@@ -631,6 +641,7 @@ public interface DispenseItemBehavior {
+                         return stack;
+                     }
+ 
+                    boolean shrink = true; // Paper
+                     if (!event.getItem().equals(craftItem)) {
+                         // Chain to handler for new item
+                         ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+@@ -694,7 +705,7 @@ public interface DispenseItemBehavior {
+ 
+                         // CraftBukkit start
+                         org.bukkit.block.Block bukkitBlock = CraftBlock.at(worldserver, pointer.pos());
+-                        CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
+                        CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                         BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                         if (!DispenserBlock.eventFired) {
+@@ -752,7 +763,9 @@ public interface DispenseItemBehavior {
+                     return stack;
+                 }
+ 
+                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+                    shrink = false; // Paper - shrink below (this was actually missing and should be here, added it commented out just for less confusion)
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -802,7 +815,7 @@ public interface DispenseItemBehavior {
+                 BlockPos blockposition = pointer.pos().relative((Direction) pointer.state().getValue(DispenserBlock.FACING));
+                 // CraftBukkit start
+                 org.bukkit.block.Block block = CraftBlock.at(worldserver, pointer.pos());
+-                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
+                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                 BlockDispenseEvent event = new BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector(0, 0, 0));
+                 if (!DispenserBlock.eventFired) {
+@@ -813,6 +826,7 @@ public interface DispenseItemBehavior {
+                     return stack;
+                 }
+ 
+                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+@@ -868,7 +882,7 @@ public interface DispenseItemBehavior {
+                 // CraftBukkit start
+                 // EntityTNTPrimed entitytntprimed = new EntityTNTPrimed(worldserver, (double) blockposition.getX() + 0.5D, (double) blockposition.getY(), (double) blockposition.getZ() + 0.5D, (EntityLiving) null);
+ 
+-                ItemStack itemstack1 = stack.split(1);
+                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink at end and single item in event
+                 org.bukkit.block.Block block = CraftBlock.at(worldserver, pointer.pos());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -878,12 +892,13 @@ 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());
+@@ -899,7 +914,7 @@ 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);
+-                // itemstack.shrink(1); // CraftBukkit - handled above
+                if (shrink) stack.shrink(1); // Paper - actually handle here
+                 return stack;
+             }
+         });
+@@ -926,7 +941,7 @@ public interface DispenseItemBehavior {
+ 
+                 // CraftBukkit start
+                 org.bukkit.block.Block bukkitBlock = CraftBlock.at(worldserver, pointer.pos());
+-                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
+                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                 BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                 if (!DispenserBlock.eventFired) {
+@@ -934,9 +949,11 @@ public interface DispenseItemBehavior {
+                 }
+ 
+                 if (event.isCancelled()) {
+                    // stack.grow(1); // Paper - shrink below (this was actually missing and should be here, added it commented out just for less confusion)
+                     return stack;
+                 }
+ 
+                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+@@ -975,7 +992,7 @@ public interface DispenseItemBehavior {
+ 
+                 // CraftBukkit start
+                 org.bukkit.block.Block bukkitBlock = CraftBlock.at(worldserver, pointer.pos());
+-                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
+                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                 BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                 if (!DispenserBlock.eventFired) {
+@@ -986,6 +1003,7 @@ public interface DispenseItemBehavior {
+                     return stack;
+                 }
+ 
+                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+@@ -1048,7 +1066,7 @@ public interface DispenseItemBehavior {
+ 
+                 // CraftBukkit start
+                 org.bukkit.block.Block bukkitBlock = CraftBlock.at(worldserver, pointer.pos());
+-                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
+                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - only single item in event
+ 
+                 BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                 if (!DispenserBlock.eventFired) {
+@@ -1059,6 +1077,7 @@ public interface DispenseItemBehavior {
+                     return stack;
+                 }
+ 
+                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+diff --git a/src/main/java/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java b/src/main/java/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java
+index f84987c36a16df19286d6f1badfb1ffb9cc7e770..6f2adf2334e35e8a617a4ced0c1af2abf32bbd8d 100644
+--- a/src/main/java/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java
+++ b/src/main/java/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java
+@@ -34,7 +34,7 @@ public class ShulkerBoxDispenseBehavior extends OptionalDispenseItemBehavior {
+ 
+             // CraftBukkit start
+             org.bukkit.block.Block bukkitBlock = CraftBlock.at(pointer.level(), pointer.pos());
+-            CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
+            CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+             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/world/item/ArmorItem.java b/src/main/java/net/minecraft/world/item/ArmorItem.java
+index a745dc02ae25bcf10cee954b6e53f8b106fd045d..42d87800a328f71c5127ce5599ca4c71cc9bb1cd 100644
+--- a/src/main/java/net/minecraft/world/item/ArmorItem.java
+++ b/src/main/java/net/minecraft/world/item/ArmorItem.java
+@@ -62,7 +62,7 @@ public class ArmorItem extends Item implements Equipable {
+         } else {
+             LivingEntity entityliving = (LivingEntity) list.get(0);
+             EquipmentSlot enumitemslot = Mob.getEquipmentSlotForItem(armor);
+-            ItemStack itemstack1 = armor.split(1);
+            ItemStack itemstack1 = armor.copyWithCount(1); // Paper - shrink below and single item in event
+             // CraftBukkit start
+             Level world = pointer.level();
+             org.bukkit.block.Block block = CraftBlock.at(world, pointer.pos());
+@@ -74,12 +74,13 @@ public class ArmorItem extends Item implements Equipable {
+             }
+ 
+             if (event.isCancelled()) {
+-                armor.grow(1);
+                // armor.grow(1); // Paper - shrink below
+                 return false;
+             }
+ 
+            boolean shrink = true; // Paper
+             if (!event.getItem().equals(craftItem)) {
+-                armor.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());
+@@ -96,6 +97,7 @@ public class ArmorItem extends Item implements Equipable {
+                 ((Mob) entityliving).setPersistenceRequired();
+             }
+ 
+            if (shrink) armor.shrink(1); // Paper
+             return true;
+         }
+     }
+diff --git a/src/main/java/net/minecraft/world/item/MinecartItem.java b/src/main/java/net/minecraft/world/item/MinecartItem.java
+index 9bcca21ba03dc838f3e857018adee9506d8bb6a3..3aa73cd44aa8c86b78c35bc1788e4f83018c49ed 100644
+--- a/src/main/java/net/minecraft/world/item/MinecartItem.java
+++ b/src/main/java/net/minecraft/world/item/MinecartItem.java
+@@ -65,7 +65,7 @@ public class MinecartItem extends Item {
+ 
+             // CraftBukkit start
+             // EntityMinecartAbstract entityminecartabstract = EntityMinecartAbstract.createMinecart(worldserver, d0, d1 + d3, d2, ((ItemMinecart) itemstack.getItem()).type);
+-            ItemStack itemstack1 = stack.split(1);
+            ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+             org.bukkit.block.Block block2 = CraftBlock.at(worldserver, pointer.pos());
+             CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -75,12 +75,13 @@ public class MinecartItem extends Item {
+             }
+ 
+             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());
+@@ -93,8 +94,7 @@ public class MinecartItem extends Item {
+             itemstack1 = CraftItemStack.asNMSCopy(event.getItem());
+             AbstractMinecart entityminecartabstract = AbstractMinecart.createMinecart(worldserver, event.getVelocity().getX(), event.getVelocity().getY(), event.getVelocity().getZ(), ((MinecartItem) itemstack1.getItem()).type, itemstack1, (Player) null);
+ 
+-            if (!worldserver.addFreshEntity(entityminecartabstract)) stack.grow(1);
+-            // itemstack.shrink(1); // CraftBukkit - handled during event processing
+            if (worldserver.addFreshEntity(entityminecartabstract) && shrink) stack.shrink(1); // Paper - actually handle here
+             // CraftBukkit end
+             return stack;
+         }
--- a/patches/server/0894-Add-BlockLockCheckEvent.patch
+++ b/patches/server/0894-Add-BlockLockCheckEvent.patch
@ -0,0 +1,70 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 21 May 2022 20:59:45 -0700
+Subject: [PATCH] Add BlockLockCheckEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
+index fce3a45d09a93ca68a3d49f2e666afa4c860d042..c134d089e55ea2ffb180f92aea020bd7647259c9 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
+@@ -69,17 +69,44 @@ public abstract class BaseContainerBlockEntity extends BlockEntity implements Co
+     protected abstract Component getDefaultName();
+ 
+     public boolean canOpen(Player player) {
+-        return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName());
+        return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName(), this); // Paper
+     }
+ 
+    @Deprecated @io.papermc.paper.annotation.DoNotUse // Paper
+     public static boolean canUnlock(Player player, LockCode lock, Component containerName) {
+        // Paper start
+        return canUnlock(player, lock, containerName, null);
+    }
+    public static boolean canUnlock(Player player, LockCode lock, Component containerName, @Nullable BlockEntity blockEntity) {
+        if (player instanceof net.minecraft.server.level.ServerPlayer serverPlayer && blockEntity != null && blockEntity.getLevel() != null && blockEntity.getLevel().getBlockEntity(blockEntity.getBlockPos()) == blockEntity) {
+            final org.bukkit.block.Block block = org.bukkit.craftbukkit.block.CraftBlock.at(blockEntity.getLevel(), blockEntity.getBlockPos());
+            net.kyori.adventure.text.Component lockedMessage = net.kyori.adventure.text.Component.translatable("container.isLocked", io.papermc.paper.adventure.PaperAdventure.asAdventure(containerName));
+            net.kyori.adventure.sound.Sound lockedSound = net.kyori.adventure.sound.Sound.sound(org.bukkit.Sound.BLOCK_CHEST_LOCKED, net.kyori.adventure.sound.Sound.Source.BLOCK, 1.0F, 1.0F);
+            final io.papermc.paper.event.block.BlockLockCheckEvent event = new io.papermc.paper.event.block.BlockLockCheckEvent(block, (io.papermc.paper.block.LockableTileState) block.getState(), serverPlayer.getBukkitEntity(), lockedMessage, lockedSound);
+            event.callEvent();
+            if (event.getResult() == org.bukkit.event.Event.Result.ALLOW) {
+                return true;
+            } else if (event.getResult() == org.bukkit.event.Event.Result.DENY || (!player.isSpectator() && !lock.unlocksWith(event.isUsingCustomKeyItemStack() ? org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getKeyItem()) : player.getMainHandItem()))) {
+                if (event.getLockedMessage() != null) {
+                    event.getPlayer().sendActionBar(event.getLockedMessage());
+                }
+                if (event.getLockedSound() != null) {
+                    event.getPlayer().playSound(event.getLockedSound());
+                }
+                return false;
+            } else {
+                return true;
+            }
+        } else { // logic below is replaced by logic above
+        // Paper end
+         if (!player.isSpectator() && !lock.unlocksWith(player.getMainHandItem())) {
+-            player.displayClientMessage(Component.translatable("container.isLocked", containerName), true);
+            player.displayClientMessage(Component.translatable("container.isLocked", containerName), true); // Paper - diff on change
+             player.playNotifySound(SoundEvents.CHEST_LOCKED, SoundSource.BLOCKS, 1.0F, 1.0F);
+             return false;
+         } else {
+             return true;
+         }
+        } // Paper
+     }
+ 
+     @Nullable
+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 db38c178543e221251ae8c6ad618ad9372af7f40..2f12a1054c9c9e311e02dc5c3244ad3688db15ba 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+@@ -470,7 +470,7 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+     @Nullable
+     @Override
+     public AbstractContainerMenu createMenu(int syncId, Inventory playerInventory, Player player) {
+-        return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName()) ? new BeaconMenu(syncId, playerInventory, this.dataAccess, ContainerLevelAccess.create(this.level, this.getBlockPos())) : null;
+        return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName(), this) ? new BeaconMenu(syncId, playerInventory, this.dataAccess, ContainerLevelAccess.create(this.level, this.getBlockPos())) : null;
+     }
+ 
+     @Override
--- a/patches/server/0895-Add-Sneaking-API-for-Entities.patch
+++ b/patches/server/0895-Add-Sneaking-API-for-Entities.patch
@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: dawon <dawon@dawon.eu>
+Date: Wed, 19 Oct 2022 23:31:53 +0200
+Subject: [PATCH] Add Sneaking API for Entities
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index c0f11fb8de8c15f8b07023fc05a7856413bc8036..908da9217c6553301c22ca0415924d2aebe993ef 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1226,6 +1226,18 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         return Pose.values()[this.getHandle().getPose().ordinal()];
+     }
+ 
+    // Paper start
+    @Override
+    public void setSneaking(boolean sneak) {
+        this.getHandle().setShiftKeyDown(sneak);
+    }
+
+    @Override
+    public boolean isSneaking() {
+        return this.getHandle().isShiftKeyDown();
+    }
+    // Paper end
+
+     @Override
+     public SpawnCategory getSpawnCategory() {
+         return CraftSpawnCategory.toBukkit(this.getHandle().getType().getCategory());
--- a/patches/server/0896-Improve-logging-and-errors.patch
+++ b/patches/server/0896-Improve-logging-and-errors.patch
@ -0,0 +1,105 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 14 Dec 2022 15:52:11 -0800
+Subject: [PATCH] Improve logging and errors
+
+Co-authored-by: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+
+diff --git a/src/main/java/net/minecraft/advancements/AdvancementTree.java b/src/main/java/net/minecraft/advancements/AdvancementTree.java
+index 938fe76677139e7e99698b61691bfcadf70dbd87..5cf3732d2197b381ae9256d8bed03a755d8539f4 100644
+--- a/src/main/java/net/minecraft/advancements/AdvancementTree.java
+++ b/src/main/java/net/minecraft/advancements/AdvancementTree.java
+@@ -35,7 +35,7 @@ public class AdvancementTree {
+             this.remove(advancementnode1);
+         }
+ 
+-        AdvancementTree.LOGGER.info("Forgot about advancement {}", advancement.holder());
+        AdvancementTree.LOGGER.debug("Forgot about advancement {}", advancement.holder()); // Paper
+         this.nodes.remove(advancement.holder().id());
+         if (advancement.parent() == null) {
+             this.roots.remove(advancement);
+@@ -77,7 +77,7 @@ public class AdvancementTree {
+             }
+         }
+ 
+-        // AdvancementTree.LOGGER.info("Loaded {} advancements", this.nodes.size()); // CraftBukkit - moved to AdvancementDataWorld#reload
+        // AdvancementTree.LOGGER.info("Loaded {} advancements", this.nodes.size()); // CraftBukkit - moved to AdvancementDataWorld#reload // Paper - you say it was moved... but it wasn't :) it should be moved however, since this is called when the API creates an advancement
+     }
+ 
+     private boolean tryInsert(AdvancementHolder advancement) {
+diff --git a/src/main/java/net/minecraft/server/ServerAdvancementManager.java b/src/main/java/net/minecraft/server/ServerAdvancementManager.java
+index 536f0c496ce36ca3248fc6eeac9bbd77214a36f9..5e24c1e712eb16d0d5343760a65310bd79d1020c 100644
+--- a/src/main/java/net/minecraft/server/ServerAdvancementManager.java
+++ b/src/main/java/net/minecraft/server/ServerAdvancementManager.java
+@@ -66,6 +66,7 @@ public class ServerAdvancementManager extends SimpleJsonResourceReloadListener {
+         AdvancementTree advancementtree = new AdvancementTree();
+ 
+         advancementtree.addAll(this.advancements.values());
+        LOGGER.info("Loaded {} advancements", advancementtree.nodes().size()); // Paper - moved from AdvancementTree#addAll
+         Iterator iterator = advancementtree.roots().iterator();
+ 
+         while (iterator.hasNext()) {
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 199a9e1d082ab937e2be9fd5abdd0891b7b78024..57526743fd14cef2510e3b446d4421bad28fe437 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -3394,7 +3394,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+                     this.resetPlayerChatState(remotechatsession_a.validate(this.player.getGameProfile(), signaturevalidator));
+                 } catch (ProfilePublicKey.ValidationException profilepublickey_b) {
+-                    ServerGamePacketListenerImpl.LOGGER.error("Failed to validate profile key: {}", profilepublickey_b.getMessage());
+                    // ServerGamePacketListenerImpl.LOGGER.error("Failed to validate profile key: {}", profilepublickey_b.getMessage()); // Paper - unnecessary log
+                     this.disconnect(profilepublickey_b.getComponent(), profilepublickey_b.kickCause); // Paper - kick event causes
+                 }
+ 
+diff --git a/src/main/java/net/minecraft/server/packs/PathPackResources.java b/src/main/java/net/minecraft/server/packs/PathPackResources.java
+index 89aa86a49eda563c82ccedc99641e699f8e578b0..4822f94ce183a99ad9e0d1bdc6c5708d958f6104 100644
+--- a/src/main/java/net/minecraft/server/packs/PathPackResources.java
+++ b/src/main/java/net/minecraft/server/packs/PathPackResources.java
+@@ -108,6 +108,12 @@ public class PathPackResources extends AbstractPackResources {
+         try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path)) {
+             for(Path path2 : directoryStream) {
+                 String string = path2.getFileName().toString();
+                // Paper start
+                if (!Files.isDirectory(path2)) {
+                    LOGGER.error("Invalid directory entry: {} in {}.", string, this.root, new java.nio.file.NotDirectoryException(string));
+                    continue;
+                }
+                // Paper end
+                 if (ResourceLocation.isValidNamespace(string)) {
+                     set.add(string);
+                 } else {
+diff --git a/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java b/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java
+index 4259181bab2dc4f2d0409b56fdf81d966003376d..93e7d350a4176250d9ae3f0e1e7e6a4197d613b0 100644
+--- a/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java
+++ b/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java
+@@ -84,7 +84,7 @@ 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());
+        RecipeManager.LOGGER.info("Loaded {} recipes", this.byName.size()); // Paper - log correct number of recipes
+     }
+ 
+     // CraftBukkit start
+diff --git a/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java b/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java
+index 080cca90f15d90249b7a38f33286ae2f735ba7d9..2677e21d8239bf0361a3bc5c9a50c328e54d70f6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java
+++ b/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java
+@@ -44,6 +44,7 @@ import org.bukkit.material.MaterialData;
+  */
+ @Deprecated
+ public final class CraftLegacy {
+    private static final org.slf4j.Logger LOGGER = com.mojang.logging.LogUtils.getLogger(); // Paper
+ 
+     private static final Map<Byte, Material> SPAWN_EGGS = new HashMap<>();
+     private static final Set<String> whitelistedStates = new HashSet<>(Arrays.asList("explode", "check_decay", "decayable", "facing"));
+@@ -255,7 +256,7 @@ public final class CraftLegacy {
+     }
+ 
+     static {
+-        System.err.println("Initializing Legacy Material Support. Unless you have legacy plugins and/or data this is a bug!");
+        LOGGER.warn("Initializing Legacy Material Support. Unless you have legacy plugins and/or data this is a bug!"); // Paper - doesn't need to be an error
+         if (MinecraftServer.getServer() != null && MinecraftServer.getServer().isDebugging()) {
+             new Exception().printStackTrace();
+         }
--- a/patches/server/0897-Improve-PortalEvents.patch
+++ b/patches/server/0897-Improve-PortalEvents.patch
@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 15 Dec 2022 10:33:39 -0800
+Subject: [PATCH] Improve PortalEvents
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index a59d738a8697ed06c445b0837b887aabcd92e366..fab6f1a470334e0a2a552ff12da70f463888d7f1 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3769,7 +3769,14 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+         Location enter = bukkitEntity.getLocation();
+         Location exit = CraftLocation.toBukkit(exitPosition, exitWorldServer.getWorld());
+ 
+-        EntityPortalEvent event = new EntityPortalEvent(bukkitEntity, enter, exit, searchRadius);
+        // Paper start
+        final org.bukkit.PortalType portalType = switch (cause) {
+            case END_PORTAL -> org.bukkit.PortalType.ENDER;
+            case NETHER_PORTAL -> org.bukkit.PortalType.NETHER;
+            default -> org.bukkit.PortalType.CUSTOM;
+        };
+        EntityPortalEvent event = new EntityPortalEvent(bukkitEntity, enter, exit, searchRadius, portalType);
+        // Paper end
+         event.getEntity().getServer().getPluginManager().callEvent(event);
+         if (event.isCancelled() || event.getTo() == null || event.getTo().getWorld() == null || !entity.isAlive()) {
+             return null;
--- a/patches/server/0898-Add-config-option-for-spider-worldborder-climbing.patch
+++ b/patches/server/0898-Add-config-option-for-spider-worldborder-climbing.patch
@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Thu, 27 Oct 2022 15:35:47 +0200
+Subject: [PATCH] Add config option for spider worldborder climbing
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index fab6f1a470334e0a2a552ff12da70f463888d7f1..a84811f050378840206f7c2c4591bcd0b948c8fa 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -408,6 +408,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+     @javax.annotation.Nullable
+     private UUID originWorld;
+     public boolean freezeLocked = false; // Paper - Freeze Tick Lock API
+    public boolean collidingWithWorldBorder; // Paper
+ 
+     public void setOrigin(@javax.annotation.Nonnull Location location) {
+         this.origin = location.toVector();
+@@ -1481,7 +1482,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+                 null, null
+         );
+ 
+-        if (io.papermc.paper.util.CollisionUtil.isCollidingWithBorderEdge(world.getWorldBorder(), collisionBox)) {
+        if (collidingWithWorldBorder = io.papermc.paper.util.CollisionUtil.isCollidingWithBorderEdge(world.getWorldBorder(), collisionBox)) { // Paper - this line *is* correct, ignore the IDE warning about assignments being used as a condition
+             potentialCollisionsVoxel.add(world.getWorldBorder().getCollisionShape());
+         }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Spider.java b/src/main/java/net/minecraft/world/entity/monster/Spider.java
+index 9e5d68fe86d17118df3d6a1c36b296f32b4d7fc1..71b5a9c97a13f703073c0122742ff9e8a0e49df2 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Spider.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Spider.java
+@@ -86,7 +86,7 @@ public class Spider extends Monster {
+     public void tick() {
+         super.tick();
+         if (!this.level().isClientSide) {
+-            this.setClimbing(this.horizontalCollision);
+            this.setClimbing(this.horizontalCollision && (this.level().paperConfig().entities.behavior.allowSpiderWorldBorderClimbing || !collidingWithWorldBorder)); // Paper
+         }
+ 
+     }
--- a/patches/server/0899-Add-missing-SpigotConfig-logCommands-check.patch
+++ b/patches/server/0899-Add-missing-SpigotConfig-logCommands-check.patch
@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: NonSwag <mrminecraft00@gmail.com>
+Date: Thu, 8 Dec 2022 20:25:05 +0100
+Subject: [PATCH] Add missing SpigotConfig logCommands check
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 57526743fd14cef2510e3b446d4421bad28fe437..40e69eaf83b7e18718fc347ea10766c27c345d1e 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2139,7 +2139,9 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+     private void performChatCommand(ServerboundChatCommandPacket packet, LastSeenMessages lastSeenMessages) {
+         // CraftBukkit start
+         String command = "/" + packet.command();
+        if (org.spigotmc.SpigotConfig.logCommands) { // Paper
+         ServerGamePacketListenerImpl.LOGGER.info(this.player.getScoreboardName() + " issued server command: " + command);
+        } // Paper
+ 
+         PlayerCommandPreprocessEvent event = new PlayerCommandPreprocessEvent(this.getCraftPlayer(), command, new LazyPlayerSet(this.server));
+         this.cserver.getPluginManager().callEvent(event);
--- a/Show more
+++ b/Show more