MOOOOOOOORE

2024-10-23 23:35:21 +02:00 · 2024-10-23 23:35:21 +02:00 · d52e2d241d
commit d52e2d241d
parent 1dc142534d
36 changed files with 281 additions and 357 deletions
--- a/patches/server/0729-Fix-plugin-loggers-on-server-shutdown.patch
+++ b/patches/server/0729-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 2101c0a3b000a60733ceada248c202e2c4783af5..027d94dd08e7789b51c8779c65d4ddad4e62f21a 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1279,6 +1279,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                 } catch (Exception ignored) {
+                 }
+                 // CraftBukkit end
+                io.papermc.paper.log.CustomLogManager.forceReset(); // Paper - Reset loggers after shutdown
+                 this.onServerExit();
+             }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
+index 124aeebbbae7dc8cea1260bf3134a339c2e152ed..a7524d3853d5b67b6385d2b74832b9267503dfe6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/Main.java
+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
+@@ -19,6 +19,12 @@ public class Main {
+     public static boolean useJline = true;
+     public static boolean useConsole = true;
+ 
+    // Paper start - Reset loggers after shutdown
+    static {
+        System.setProperty("java.util.logging.manager", "io.papermc.paper.log.CustomLogManager");
+    }
+    // Paper end - Reset loggers after shutdown
+
+     public static void main(String[] args) {
+         // Paper start
+         final String warnWhenLegacyFormattingDetected = String.join(".", "net", "kyori", "adventure", "text", "warnWhenLegacyFormattingDetected");
--- a/patches/server/0730-Stop-large-look-changes-from-crashing-the-server.patch
+++ b/patches/server/0730-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 682d0399b9b3729d16978eca258c55c2150afec7..16f349f8ce621c58f36f445016ea25d8af14910d 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3272,37 +3272,15 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         gameprofilerfiller.pop();
+         gameprofilerfiller.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
+ 
+         gameprofilerfiller.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 846a108af8bacdcaf3a17db9fb808965ce2581bb..4d487090a622d280bdfacc18978929c61f74f147 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+@@ -428,13 +428,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/0731-Fire-EntityChangeBlockEvent-in-more-places.patch
+++ b/patches/server/0731-Fire-EntityChangeBlockEvent-in-more-places.patch
@ -0,0 +1,339 @@
+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>
+Co-authored-by: maxcom1 <46265094+maxcom1@users.noreply.github.com>
+
+diff --git a/src/main/java/net/minecraft/world/effect/WeavingMobEffect.java b/src/main/java/net/minecraft/world/effect/WeavingMobEffect.java
+index e311f94918fb03e9d202cbae71b0909ea3219180..d090126dbe6b69489490e6b1e2d443fa171ddde6 100644
+--- a/src/main/java/net/minecraft/world/effect/WeavingMobEffect.java
+++ b/src/main/java/net/minecraft/world/effect/WeavingMobEffect.java
+@@ -25,7 +25,7 @@ class WeavingMobEffect extends MobEffect {
+     @Override
+     public void onMobRemoved(ServerLevel world, LivingEntity entity, int amplifier, Entity.RemovalReason reason) {
+         if (reason == Entity.RemovalReason.KILLED && (entity instanceof Player || world.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING))) {
+-            this.spawnCobwebsRandomlyAround(world, entity.getRandom(), entity.blockPosition());
+            this.spawnCobwebsRandomlyAround(entity, world, entity.getRandom(), entity.blockPosition()); // Paper - Fire EntityChangeBlockEvent in more places
+         }
+     }
+ 
+@@ -46,6 +46,7 @@ class WeavingMobEffect extends MobEffect {
+         }
+ 
+         for (BlockPos blockPos3 : set) {
+            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, blockPos3, Blocks.COBWEB.defaultBlockState())) continue; // Paper - Fire EntityChangeBlockEvent in more places
+             world.setBlock(blockPos3, Blocks.COBWEB.defaultBlockState(), 3);
+             world.levelEvent(3018, blockPos3, 0);
+         }
+diff --git a/src/main/java/net/minecraft/world/entity/LightningBolt.java b/src/main/java/net/minecraft/world/entity/LightningBolt.java
+index 2b09e9efad198ff596d88f97d703a8a00c108608..152ecd38814089333b8d61538297ce720756d2c3 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 - Call EntityChangeBlockEvent
+                 this.gameEvent(GameEvent.LIGHTNING_STRIKE);
+             }
+         }
+@@ -202,7 +202,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 - Call EntityChangeBlockEvent
+         BlockState iblockdata = world.getBlockState(pos);
+         BlockPos blockposition1;
+         BlockState iblockdata1;
+@@ -216,24 +216,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 - Call EntityChangeBlockEvent
+             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;
+@@ -244,7 +249,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;
+@@ -261,6 +266,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/item/AxeItem.java b/src/main/java/net/minecraft/world/item/AxeItem.java
+index 74c9966093377b67e31b50483c2f24b70734faf6..abff08f2d61014944235ffe2f5494a718a28cc10 100644
+--- a/src/main/java/net/minecraft/world/item/AxeItem.java
+++ b/src/main/java/net/minecraft/world/item/AxeItem.java
+@@ -67,6 +67,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 770467bd319f8e2fdf3d713591368aa825cfa5ae..b00a2fe4cefff26b65789829777b25bbc8e024fa 100644
+--- a/src/main/java/net/minecraft/world/item/EnderEyeItem.java
+++ b/src/main/java/net/minecraft/world/item/EnderEyeItem.java
+@@ -45,6 +45,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 6c0fe41692c9d1fa50a4f421eb4735860a9ae0e9..d7924825823b2bf79ca3a26272de11ff8d2ec74c 100644
+--- a/src/main/java/net/minecraft/world/item/HoneycombItem.java
+++ b/src/main/java/net/minecraft/world/item/HoneycombItem.java
+@@ -74,6 +74,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 serverPlayer) {
+                 CriteriaTriggers.ITEM_USED_ON_BLOCK.trigger(serverPlayer, 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 1c8fd643c32226d72d51abc869a49e256dd2432b..627439c3aa8171e9a54dbcb8842af50cc58f7f23 100644
+--- a/src/main/java/net/minecraft/world/item/PotionItem.java
+++ b/src/main/java/net/minecraft/world/item/PotionItem.java
+@@ -42,6 +42,12 @@ public class PotionItem extends Item {
+         PotionContents potionContents = itemStack.getOrDefault(DataComponents.POTION_CONTENTS, PotionContents.EMPTY);
+         BlockState blockState = level.getBlockState(blockPos);
+         if (context.getClickedFace() != Direction.DOWN && blockState.is(BlockTags.CONVERTABLE_TO_MUD) && potionContents.is(Potions.WATER)) {
+            // Paper start
+            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entityhuman, blockposition, Blocks.MUD.defaultBlockState())) {
+                entityhuman.containerMenu.sendAllDataToRemote();
+                return InteractionResult.PASS;
+            }
+            // Paper end
+             level.playSound(null, blockPos, SoundEvents.GENERIC_SPLASH, SoundSource.BLOCKS, 1.0F, 1.0F);
+             player.setItemInHand(context.getHand(), ItemUtils.createFilledResult(itemStack, player, new ItemStack(Items.GLASS_BOTTLE)));
+             player.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 c0377341227e8f4f1f7b1448580b3c7bc1b65f48..55c18f182166f4905d623d6f5e909eefd5ed2483 100644
+--- a/src/main/java/net/minecraft/world/item/ShovelItem.java
+++ b/src/main/java/net/minecraft/world/item/ShovelItem.java
+@@ -46,20 +46,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(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/CakeBlock.java b/src/main/java/net/minecraft/world/level/block/CakeBlock.java
+index 7629b9212ded7155e94f67ca429f62271e5f5aa0..1104f620a050555f71d058711cc34fadb964222f 100644
+--- a/src/main/java/net/minecraft/world/level/block/CakeBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/CakeBlock.java
+@@ -66,6 +66,12 @@ public class CakeBlock extends Block {
+             if (block instanceof CandleBlock) {
+                 CandleBlock candleblock = (CandleBlock) block;
+ 
+                // Paper start - call change block event
+                if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(player, pos, CandleCakeBlock.byCandle(candleblock))) {
+                    player.containerMenu.sendAllDataToRemote(); // update inv because candle could decrease
+                    return ItemInteractionResult.PASS_TO_DEFAULT_BLOCK_INTERACTION;
+                }
+                // Paper end - call change block event
+                 stack.consume(1, player);
+                 world.playSound((Player) null, pos, SoundEvents.CAKE_ADD_CANDLE, SoundSource.BLOCKS, 1.0F, 1.0F);
+                 world.setBlockAndUpdate(pos, CandleCakeBlock.byCandle(candleblock));
+@@ -97,6 +103,14 @@ public class CakeBlock extends Block {
+         if (!player.canEat(false)) {
+             return InteractionResult.PASS;
+         } else {
+            // Paper start - call change block event
+            int i = state.getValue(CakeBlock.BITES);
+            final BlockState newState = i < MAX_BITES ? state.setValue(CakeBlock.BITES, i + 1) : world.getFluidState(pos).createLegacyBlock();
+            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(player, pos, newState)) {
+                ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().sendHealthUpdate();
+                return InteractionResult.PASS; // return a non-consume result to cake blocks don't drop their candles
+            }
+            // Paper end - call change block event
+             player.awardStat(Stats.EAT_CAKE_SLICE);
+             // CraftBukkit start
+             // entityhuman.getFoodData().eat(2, 0.1F);
+@@ -110,7 +124,7 @@ public class CakeBlock extends Block {
+ 
+             ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity().sendHealthUpdate();
+             // CraftBukkit end
+-            int i = (Integer) state.getValue(CakeBlock.BITES);
+            // Paper - move up
+ 
+             world.gameEvent((Entity) player, (Holder) GameEvent.EAT, pos);
+             if (i < 6) {
+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 2bcd246a26dad560cf69682b29983d320ebf1884..60bf63c2cff3ce8a1892ba5c2303738c35b83d79 100644
+--- a/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
+@@ -243,6 +243,11 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+         if (i < 8 && ComposterBlock.COMPOSTABLES.containsKey(stack.getItem())) {
+             if (i < 7 && !world.isClientSide) {
+                 BlockState iblockdata1 = ComposterBlock.addItem(player, state, world, pos, stack);
+                // Paper start - handle cancelled events
+                if (iblockdata1 == null) {
+                    return ItemInteractionResult.SKIP_DEFAULT_BLOCK_INTERACTION;
+                }
+                // Paper end
+ 
+                 world.levelEvent(1500, pos, state != iblockdata1 ? 1 : 0);
+                 player.awardStat(Stats.ITEM_USED.get(stack.getItem()));
+@@ -273,11 +278,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);
+@@ -318,11 +328,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);
+@@ -333,6 +345,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((Holder) GameEvent.BLOCK_CHANGE, blockposition, GameEvent.Context.of(entity, iblockdata1));
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+index 8224d5bddb7f7893dee09222a673af54791abcfa..f8828dc8334af19d7b2118e8cf34d94be5e09ee8 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+@@ -260,7 +260,13 @@ public class BeehiveBlockEntity extends BlockEntity {
+                                         --j;
+                                     }
+ 
+-                                    world.setBlockAndUpdate(blockposition, (BlockState) iblockdata.setValue(BeehiveBlock.HONEY_LEVEL, i + j));
+                                    // Paper start - Fire EntityChangeBlockEvent in more places
+                                    BlockState newBlockState = iblockdata.setValue(BeehiveBlock.HONEY_LEVEL, i + j);
+
+                                    if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entitybee, blockposition, newBlockState)) {
+                                        world.setBlockAndUpdate(blockposition, newBlockState);
+                                    }
+                                    // Paper end - Fire EntityChangeBlockEvent in more places
+                                 }
+                             }
+                         }
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java b/src/main/java/org/bukkit/craftbukkit/util/DummyGeneratorAccess.java
+index daf3c26fce7569761951bfd5594c6726d854a9ff..e8a73d34dbb372581b03018aade170a31c266099 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(Holder<GameEvent> event, Vec3 emitterPos, GameEvent.Context emitter) {
+-        // Used by BlockComposter
+        // Used by ComposterBlock
+     }
+ 
+     @Override
--- a/patches/server/0732-Missing-eating-regain-reason.patch
+++ b/patches/server/0732-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 bffc7c21727a6e5ff13a498aa51f6797e4d6d596..471d5727b964922d8e898be9e1d5c30f9d3bac97 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
+@@ -407,7 +407,7 @@ public class Cat extends TamableAnimal implements VariantHolder<Holder<CatVarian
+                         this.usePlayerItem(player, hand, itemstack);
+                         FoodProperties foodinfo = (FoodProperties) itemstack.get(DataComponents.FOOD);
+ 
+-                        this.heal(foodinfo != null ? (float) foodinfo.nutrition() : 1.0F);
+                        this.heal(foodinfo != null ? (float) foodinfo.nutrition() : 1.0F, org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason.EATING); // Paper - Add missing regain reason
+                         this.playEatingSound();
+                     }
+ 
+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 dc10449a3bdff694ad872a1ff61c90046aa7954a..b6baa40dac6d6bf40c4ee7ee75b8a8e6f60733a1 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
+@@ -389,7 +389,7 @@ public class Camel extends AbstractHorse {
+             boolean flag = this.getHealth() < this.getMaxHealth();
+ 
+             if (flag) {
+-                this.heal(2.0F);
+                this.heal(2.0F, org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason.EATING); // Paper - Add missing regain reason
+             }
+ 
+             boolean flag1 = 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 d5808d0c190877554a4a8191f68e8b4a36f2ff46..4da66867109394c8966e27551d20b4bcdf4bc9be 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
+@@ -182,7 +182,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 - Add missing regain reason
+             flag = true;
+         }
+ 
--- a/patches/server/0733-Missing-effect-cause.patch
+++ b/patches/server/0733-Missing-effect-cause.patch
@ -0,0 +1,19 @@
+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 068d96cd0bceec79f14fbf3289eeb81533d1ba22..31b10cd404b672d7ce21c2107d8f83e32de26ef4 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
+@@ -424,7 +424,7 @@ public class Axolotl extends Animal implements VariantHolder<Axolotl.Variant>, B
+             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 - Add missing effect cause
+     }
+ 
+     @Override
--- a/patches/server/0734-Added-byte-array-serialization-deserialization-for-P.patch
+++ b/patches/server/0734-Added-byte-array-serialization-deserialization-for-P.patch
@ -0,0 +1,39 @@
+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 984e988a47aa55a3fd92198e379d0f92f511daef..5a4e7e7150b7c137b077e0b393f17ed35b5aec34 100644
+--- a/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
+++ b/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
+@@ -184,4 +184,27 @@ public class CraftPersistentDataContainer implements PersistentDataContainer {
+         this.customDataTags.clear();
+     }
+     // Paper end
+
+    // Paper start - byte array serialization
+    @Override
+    public byte[] serializeToBytes() throws java.io.IOException {
+        final net.minecraft.nbt.CompoundTag root = this.toTagCompound();
+        final java.io.ByteArrayOutputStream byteArrayOutput = new java.io.ByteArrayOutputStream();
+        try (final java.io.DataOutputStream dataOutput = new java.io.DataOutputStream(byteArrayOutput)) {
+            net.minecraft.nbt.NbtIo.write(root, dataOutput);
+            return byteArrayOutput.toByteArray();
+        }
+    }
+
+    @Override
+    public void readFromBytes(final byte[] bytes, final boolean clear) throws java.io.IOException {
+        if (clear) {
+            this.clear();
+        }
+        try (final java.io.DataInputStream dataInput = new java.io.DataInputStream(new java.io.ByteArrayInputStream(bytes))) {
+            final net.minecraft.nbt.CompoundTag compound = net.minecraft.nbt.NbtIo.read(dataInput);
+            this.putAll(compound);
+        }
+    }
+    // Paper end - byte array serialization
+ }
--- a/patches/server/0735-Call-BlockPhysicsEvent-more-often.patch
+++ b/patches/server/0735-Call-BlockPhysicsEvent-more-often.patch
@ -0,0 +1,32 @@
+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 5821c802ec880501df025fcd3fbbd98242ed952c..0587f4e5083a6c890a11642284a9c16fb2eb2fe1 100644
+--- a/src/main/java/net/minecraft/world/level/redstone/CollectingNeighborUpdater.java
+++ b/src/main/java/net/minecraft/world/level/redstone/CollectingNeighborUpdater.java
+@@ -135,7 +135,20 @@ public class CollectingNeighborUpdater implements NeighborUpdater {
+                 orientation = this.orientation.withFront(direction);
+             }
+ 
+-            NeighborUpdater.executeUpdate(world, blockState, blockPos, this.sourceBlock, orientation, false);
+            // Paper start - Call BlockPhysicsEvent
+            try {
+                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, this.sourcePos));
+
+                if (event.callEvent()) { // continue to check for adjacent block (increase idx)
+                    NeighborUpdater.executeUpdate(world, blockState, blockPos, this.sourceBlock, orientation, false);
+                }
+            } catch (StackOverflowError ex) {
+                world.lastPhysicsProblem = blockPos;
+            }
+            // Paper end - Call BlockPhysicsEvent
+             if (this.idx < NeighborUpdater.UPDATE_ORDER.length && NeighborUpdater.UPDATE_ORDER[this.idx] == this.skipDirection) {
+                 this.idx++;
+             }
--- a/patches/server/0736-Configurable-chat-thread-limit.patch
+++ b/patches/server/0736-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 b92bfd89e32becde2e7630c6116c16f8a4f6614a..73e8a524925ed6f2580d3bd01616646fabafda78 100644
+--- a/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
+++ b/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
+@@ -303,7 +303,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/0737-Mitigate-effects-of-WorldCreator-keepSpawnLoaded-ret.patch
+++ b/patches/server/0737-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 63d4ffe93a445abf3c766d4f1f8fbf4a412a2a03..419b899f0e65b9656432513b69f60150c75bd13f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
+@@ -458,6 +458,12 @@ public class Commodore {
+                             super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, runtimeCbPkgPrefix() + "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/0738-fix-Jigsaw-block-kicking-user.patch
+++ b/patches/server/0738-fix-Jigsaw-block-kicking-user.patch
@ -0,0 +1,24 @@
+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 42300114e3baf31fd26090fca3b497c8157d4bb9..8fda7f812ba266cf8051f6796d2c35cba197e904 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
+@@ -131,7 +131,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().lookupOrThrow(Registries.TEMPLATE_POOL);
+-        Holder<StructureTemplatePool> holder = registry.getOrThrow(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 - Replace getHolderOrThrow with a null check
+         JigsawPlacement.generateJigsaw(world, holder, this.target, maxDepth, blockPos, keepJigsaws);
+     }
+ 
--- a/patches/server/0739-use-BlockFormEvent-for-mud-converting-into-clay.patch
+++ b/patches/server/0739-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 bd38a0a73d543a85bb5c6d50219f5438ce194df3..53cea36ec931de89e0060613acf87beb51dc16ec 100644
+--- a/src/main/java/net/minecraft/world/level/block/PointedDripstoneBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/PointedDripstoneBlock.java
+@@ -219,10 +219,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 - Call BlockFormEvent
+                                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((Holder) GameEvent.BLOCK_CHANGE, ((PointedDripstoneBlock.FluidInfo) optional.get()).pos, GameEvent.Context.of(iblockdata1));
+                                 world.levelEvent(1504, blockposition1, 0);
+                                }
+                                // Paper end - Call BlockFormEvent
+                             } else {
+                                 BlockPos blockposition2 = PointedDripstoneBlock.findFillableCauldronBelowStalactiteTip(world, blockposition1, fluidtype);
+ 
--- a/patches/server/0740-Add-getDrops-to-BlockState.patch
+++ b/patches/server/0740-Add-getDrops-to-BlockState.patch
@ -0,0 +1,37 @@
+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 e96023b71845526383288917e8d7c5759a4c0e9b..fa63a6cfcfcc4eee4503a82d85333c139c8c8b2b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java
+@@ -347,5 +347,24 @@ public class CraftBlockState implements BlockState {
+     public boolean isCollidable() {
+         return this.data.getBlock().hasCollision;
+     }
+
+    @Override
+    public java.util.Collection<org.bukkit.inventory.ItemStack> getDrops(org.bukkit.inventory.ItemStack item, org.bukkit.entity.Entity entity) {
+        this.requirePlaced();
+        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/0741-Fix-a-bunch-of-vanilla-bugs.patch
+++ b/patches/server/0741-Fix-a-bunch-of-vanilla-bugs.patch
@ -0,0 +1,394 @@
+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-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-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
+  Fixes sheep eating blocks outside of ticking range
+
+https://bugs.mojang.com/browse/MC-123848
+  Fixes item frames dropping items above when pointing down
+
+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
+
+https://bugs.mojang.com/browse/MC-158900
+  Fix error when joining after tempban expired
+
+https://bugs.mojang.com/browse/MC-99075
+  Fix inventory desync within spawn protected area
+
+https://bugs.mojang.com/browse/MC-273635
+  Fix TrialSpawner forgets assigned mob when placed by player
+
+== AT ==
+public net/minecraft/world/entity/Mob leashInfoTag
+
+Co-authored-by: William Blake Galbreath <blake.galbreath@gmail.com>
+Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
+
+diff --git a/src/main/java/net/minecraft/server/commands/DeOpCommands.java b/src/main/java/net/minecraft/server/commands/DeOpCommands.java
+index 0283f26151488d715dc823a0008c9a37ef6740fb..d98447e58233745665f0833196226077d972cc2a 100644
+--- a/src/main/java/net/minecraft/server/commands/DeOpCommands.java
+++ b/src/main/java/net/minecraft/server/commands/DeOpCommands.java
+@@ -35,7 +35,7 @@ public class DeOpCommands {
+             if (playerList.isOp(gameProfile)) {
+                 playerList.deop(gameProfile);
+                 i++;
+-                source.sendSuccess(() -> Component.translatable("commands.deop.success", targets.iterator().next().getName()), true);
+                source.sendSuccess(() -> Component.translatable("commands.deop.success", gameProfile.getName()), true); // Paper - fixes MC-253721
+             }
+         }
+ 
+diff --git a/src/main/java/net/minecraft/server/commands/OpCommand.java b/src/main/java/net/minecraft/server/commands/OpCommand.java
+index 6854ca4d4fec2b4fa541c3fabf63787665572609..e7b444a10b244828827b3c66c53465206ea8e0ec 100644
+--- a/src/main/java/net/minecraft/server/commands/OpCommand.java
+++ b/src/main/java/net/minecraft/server/commands/OpCommand.java
+@@ -46,7 +46,7 @@ public class OpCommand {
+             if (!playerList.isOp(gameProfile)) {
+                 playerList.op(gameProfile);
+                 i++;
+-                source.sendSuccess(() -> Component.translatable("commands.op.success", targets.iterator().next().getName()), true);
+                source.sendSuccess(() -> Component.translatable("commands.op.success", gameProfile.getName()), true); // Paper - fixes MC-253721
+             }
+         }
+ 
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index 7f18146c0dea654c62b3e01e6848fd1c05f87946..1a724f9bb6ef82a0b5fdd9ade036d7365167f14b 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -1080,7 +1080,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+ 
+     }
+ 
+-    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 100661b77466152a651d22daa7df992c28fbbecb..79fabd52eb3a08ec9c9ab2ec5d6ff4a31a02a292 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -764,7 +764,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         } else {
+             AABB axisalignedbb = AABB.encapsulatingFullBlocks(blockposition1, blockposition1.atY(this.getMaxY() + 1)).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/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index 064a7a3e1c4d192010e072a5e985a54135748d87..a706f0855fdf88cc9aece3ba00ef574b9cd8bd11 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -91,7 +91,7 @@ public class ServerPlayerGameMode {
+                 return event; // Paper - Expand PlayerGameModeChangeEvent
+             }
+             // 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/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 5f567d6a8ac93113c2f57d38736c4891c5f9ae19..6c7c6cd7c071b722faf7ec06e022a6ad8b1ecc42 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1823,7 +1823,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                                     this.player.swing(enumhand, true);
+                                 }
+                             }
+-                        }
+                        } else { this.player.containerMenu.sendAllDataToRemote(); } // Paper - Fix inventory desync; MC-99075
+                     } else {
+                         MutableComponent ichatmutablecomponent1 = Component.translatable("build.tooHigh", i).withStyle(ChatFormatting.RED);
+ 
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index f0ce0041497d038c55019e0f5a8e8b8619cec398..8e71eeb5be2df1352447f3662a6d092a7db9e2d0 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -261,7 +261,7 @@ public abstract class PlayerList {
+         }
+         if (optional.isEmpty() || invalidPlayerWorld[0]) {
+             // Paper end - reset to main world spawn if first spawn or invalid world
+-            player.moveTo(player.adjustSpawnLocation(worldserver1, worldserver1.getSharedSpawnPos()).getBottomCenter(), 0.0F, 0.0F);
+            player.moveTo(player.adjustSpawnLocation(worldserver1, worldserver1.getSharedSpawnPos()).getBottomCenter(), worldserver1.getSharedSpawnAngle(), 0.0F); // Paper - MC-200092 - fix first spawn pos yaw being ignored
+         }
+         // Paper end - Entity#getEntitySpawnReason
+         player.setServerLevel(worldserver1);
+@@ -661,8 +661,10 @@ public abstract class PlayerList {
+         Player player = entity.getBukkitEntity();
+         PlayerLoginEvent event = new PlayerLoginEvent(player, loginlistener.connection.hostname, ((java.net.InetSocketAddress) socketaddress).getAddress(), ((java.net.InetSocketAddress) loginlistener.connection.channel.remoteAddress()).getAddress());
+ 
+-        if (this.bans.isBanned(gameprofile)) {
+-            UserBanListEntry gameprofilebanentry = (UserBanListEntry) this.bans.get(gameprofile);
+        // Paper start - Fix MC-158900
+        UserBanListEntry gameprofilebanentry;
+        if (this.bans.isBanned(gameprofile) && (gameprofilebanentry = this.bans.get(gameprofile)) != null) {
+            // Paper end - Fix MC-158900
+ 
+             ichatmutablecomponent = Component.translatable("multiplayer.disconnect.banned.reason", gameprofilebanentry.getReason());
+             if (gameprofilebanentry.getExpires() != null) {
+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 6827426e6e9706909265f84bf97b5fa7105a7fea..7324da6b7dd2623ce394e3827ff77ef684a3b98b 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
+@@ -78,9 +78,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 9e6f946e6d2878aa3fa8abe0f6fa4770d18676d3..32bb591371fe78ba10a2bc52389ef33978cbc0eb 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/SwellGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/SwellGoal.java
+index ef71b3ef4444c05b4211de87e1c8ec52cbe3e72a..137ec75ee803789deb7b1ca93dd9369c9af362b9 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.0;
+     }
+ 
+    // 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 dbcf14f5af9c9c0655a82529ee99450a8da14525..f745a554b9b84a53d9bd942ca9908153fb0a668c 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
+@@ -247,9 +247,10 @@ public class Goat extends Animal {
+             player.setItemInHand(hand, itemstack1);
+             return InteractionResult.SUCCESS;
+         } 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.playEatingSound();
+             }
+ 
+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 30af4cbb17148c247a46c0346419d6c838dbc9d2..07c143c3eac263848fc5daf6f958d16a1a163e92 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -272,6 +272,14 @@ public class ItemFrame extends HangingEntity {
+         return (ItemStack) this.getEntityData().get(ItemFrame.DATA_ITEM);
+     }
+ 
+    // 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
+
+     @Nullable
+     public MapId getFramedMapId(ItemStack stack) {
+         return (MapId) stack.get(DataComponents.MAP_ID);
+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 15a1ea01917ce57c2457094186dde937c21ffb22..b0236c7bf9441aa84d3795ffed05dd6099f29636 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+++ b/src/main/java/net/minecraft/world/entity/npc/CatSpawner.java
+@@ -82,8 +82,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), EntitySpawnReason.NATURAL, null);
+-            cat.moveTo(pos, 0.0F, 0.0F);
+             world.addFreshEntityWithPassengers(cat);
+             return 1;
+         }
+diff --git a/src/main/java/net/minecraft/world/inventory/BeaconMenu.java b/src/main/java/net/minecraft/world/inventory/BeaconMenu.java
+index cad0b581c992edc5cd312a727695a443e26e96d8..9db647cfbd3f9c884465cf3d3a1b911d46a3da58 100644
+--- a/src/main/java/net/minecraft/world/inventory/BeaconMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/BeaconMenu.java
+@@ -164,6 +164,11 @@ public class BeaconMenu extends AbstractContainerMenu {
+     // Paper end - Add PlayerChangeBeaconEffectEvent
+ 
+     public void updateEffects(Optional<Holder<MobEffect>> primary, Optional<Holder<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 - Add PlayerChangeBeaconEffectEvent
+             io.papermc.paper.event.player.PlayerChangeBeaconEffectEvent event = new io.papermc.paper.event.player.PlayerChangeBeaconEffectEvent((org.bukkit.entity.Player) this.player.player.getBukkitEntity(), convert(primary), convert(secondary), this.access.getLocation().getBlock());
+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 7dd6b7c0ea472cfbc7ece55bc64bc5d85be4a6c0..6dcb571e9f35fbae724be69dc113b0c33eca63b3 100644
+--- a/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/LayeredCauldronBlock.java
+@@ -72,7 +72,7 @@ public class LayeredCauldronBlock extends AbstractCauldronBlock {
+             if (entity.isOnFire() && this.isEntityInsideContent(state, pos, entity)) {
+                 // CraftBukkit start - moved down
+                 // entity.clearFire();
+-                if (entity.mayInteract(worldserver, pos)) {
+                if ((entity instanceof net.minecraft.world.entity.player.Player || worldserver.getGameRules().getBoolean(net.minecraft.world.level.GameRules.RULE_MOBGRIEFING)) && entity.mayInteract(worldserver, pos)) { // Paper - Fixes MC-248588
+                     if (this.handleEntityOnFireInsideWithEvent(state, world, pos, entity)) { // Paper - fix powdered snow cauldron extinguishing entities
+                         entity.clearFire();
+                     }
+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 a23a87da259ab8d28dd8d8513098cd0730e72e0c..18f8b2c469feef659437684ce156a79ec3a3ce83 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
+@@ -531,13 +531,10 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+ 
+     @Override
+     public void fillStackedContents(StackedItemContents 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 8aab6f68f576fb022eb59798585e264f5aafbc69..edd6017937a7f20a1b43fa15204ec130b524b52b 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
+@@ -295,7 +295,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 - beacon activation/deactivation events
+        // 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();
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawnerData.java b/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawnerData.java
+index e64a30577e9000e5c4d22fd3d9cf8a9381c5c459..b9690f31d410e82d833b2ca805df2fa68abcb6d1 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawnerData.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawnerData.java
+@@ -101,17 +101,19 @@ public class TrialSpawnerData {
+         this.ejectingLootTable = rewardLootTable;
+     }
+ 
+-    public void reset() {
+    public void reset(TrialSpawner logic) { // Paper - Fix TrialSpawner forgets assigned mob; MC-273635
+         this.currentMobs.clear();
+         this.nextSpawnData = Optional.empty();
+-        this.resetStatistics();
+        this.resetStatistics(logic);
+     }
+ 
+-    public void resetStatistics() {
+    public void resetStatistics(TrialSpawner logic) { // Paper - Fix TrialSpawner forgets assigned mob; MC-273635
+         this.detectedPlayers.clear();
+         this.totalMobsSpawned = 0;
+         this.nextMobSpawnsAt = 0L;
+         this.cooldownEndsAt = 0L;
+        this.nextSpawnData = Optional.empty();
+        if (!logic.getConfig().spawnPotentialsDefinition().isEmpty()) this.nextSpawnData = Optional.empty(); // Paper - Fix TrialSpawner forgets assigned mob; MC-273635
+     }
+ 
+     public boolean hasMobToSpawn(TrialSpawner logic, RandomSource random) {
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawnerState.java b/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawnerState.java
+index 83cdeee5e2ce115ff696a5afc5465dc4301779b9..027d5c4117feba1e152d0ecf9923aef77ba72207 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawnerState.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawnerState.java
+@@ -68,7 +68,7 @@ public enum TrialSpawnerState implements StringRepresentable {
+             case INACTIVE -> trialSpawnerData.getOrCreateDisplayEntity(logic, world, WAITING_FOR_PLAYERS) == null ? this : WAITING_FOR_PLAYERS;
+             case WAITING_FOR_PLAYERS -> {
+                 if (!logic.canSpawnInLevel(world)) {
+-                    trialSpawnerData.resetStatistics();
+                    trialSpawnerData.resetStatistics(logic); // Paper - Fix TrialSpawner forgets assigned mob; MC-273635
+                     yield this;
+                 } else if (!trialSpawnerData.hasMobToSpawn(logic, world.random)) {
+                     yield INACTIVE;
+@@ -79,7 +79,7 @@ public enum TrialSpawnerState implements StringRepresentable {
+             }
+             case ACTIVE -> {
+                 if (!logic.canSpawnInLevel(world)) {
+-                    trialSpawnerData.resetStatistics();
+                    trialSpawnerData.resetStatistics(logic); // Paper - Fix TrialSpawner forgets assigned mob; MC-273635
+                     yield WAITING_FOR_PLAYERS;
+                 } else if (!trialSpawnerData.hasMobToSpawn(logic, world.random)) {
+                     yield INACTIVE;
+@@ -145,7 +145,7 @@ public enum TrialSpawnerState implements StringRepresentable {
+                     yield ACTIVE;
+                 } else if (trialSpawnerData.isCooldownFinished(world)) {
+                     logic.removeOminous(world, pos);
+-                    trialSpawnerData.reset();
+                    trialSpawnerData.reset(logic); // Paper - Fix TrialSpawner forgets assigned mob; MC-273635
+                     yield WAITING_FOR_PLAYERS;
+                 } else {
+                     yield this;
--- a/patches/server/0742-Remove-unnecessary-onTrackingStart-during-navigation.patch
+++ b/patches/server/0742-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 79fabd52eb3a08ec9c9ab2ec5d6ff4a31a02a292..4b2309d27867eddc50093e895503e02184e1b825 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -2267,7 +2267,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             }
+ 
+             if (entity instanceof Mob entityinsentient) {
+-                if (ServerLevel.this.isUpdatingNavigations) {
+                if (false && ServerLevel.this.isUpdatingNavigations) { // Paper - Remove unnecessary onTrackingStart during navigation warning
+                     String s = "onTrackingStart called during navigation iteration";
+ 
+                     Util.logAndPauseIfInIde("onTrackingStart called during navigation iteration", new IllegalStateException("onTrackingStart called during navigation iteration"));
+@@ -2347,7 +2347,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             }
+ 
+             if (entity instanceof Mob entityinsentient) {
+-                if (ServerLevel.this.isUpdatingNavigations) {
+                if (false && ServerLevel.this.isUpdatingNavigations) { // Paper - Remove unnecessary onTrackingStart during navigation warning
+                     String s = "onTrackingStart called during navigation iteration";
+ 
+                     Util.logAndPauseIfInIde("onTrackingStart called during navigation iteration", new IllegalStateException("onTrackingStart called during navigation iteration"));
--- a/patches/server/0743-Fix-custom-piglin-loved-items.patch
+++ b/patches/server/0743-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 4f3048615a34fc2c067e09aec76af94cde6a74e0..5c26beef2d3f3d4afa51950ddeb7089989218462 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
+@@ -405,7 +405,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/0744-EntityPickupItemEvent-fixes.patch
+++ b/patches/server/0744-EntityPickupItemEvent-fixes.patch
@ -0,0 +1,73 @@
+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 15a49e3541c8b45db5e472a64fa0cb94c5a72f67..e04d2c5e75dc774fe893a552474fdb8045c32693 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
+@@ -429,7 +429,7 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento
+ 
+     @Override
+     protected void pickUpItem(ServerLevel world, ItemEntity itemEntity) {
+-        this.onItemPickup(itemEntity);
+        // this.onItemPickup(itemEntity); // Paper - EntityPickupItemEvent fixes; call in PiglinAi#pickUpItem after EntityPickupItemEvent is fired
+         PiglinAi.pickUpItem(world, this, itemEntity);
+     }
+ 
+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 5c26beef2d3f3d4afa51950ddeb7089989218462..e283b1296c1e831376bfe9491cbf02ed4b3fffe4 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
+@@ -244,11 +244,16 @@ public class PiglinAi {
+         ItemStack itemstack;
+ 
+         // CraftBukkit start
+-        if (itemEntity.getItem().is(Items.GOLD_NUGGET) && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(piglin, itemEntity, 0, false).isCancelled()) {
+        // Paper start - EntityPickupItemEvent fixes; fix event firing twice
+        if (itemEntity.getItem().is(Items.GOLD_NUGGET)/* && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(piglin, itemEntity, 0, false).isCancelled()*/) { // Paper
+            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(piglin, itemEntity, 0, false).isCancelled()) return;
+            piglin.onItemPickup(itemEntity); // Paper - moved from Piglin#pickUpItem - call prior to item entity modification
+            // Paper end
+             piglin.take(itemEntity, itemEntity.getItem().getCount());
+             itemstack = itemEntity.getItem();
+             itemEntity.discard(EntityRemoveEvent.Cause.PICKUP); // CraftBukkit - add Bukkit remove cause
+         } else if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(piglin, itemEntity, itemEntity.getItem().getCount() - 1, false).isCancelled()) {
+            piglin.onItemPickup(itemEntity); // Paper - EntityPickupItemEvent fixes; moved from Piglin#pickUpItem - call prior to item entity modification
+             piglin.take(itemEntity, 1);
+             itemstack = PiglinAi.removeOneItemFromItemEntity(itemEntity);
+         } else {
+@@ -263,7 +268,7 @@ public class PiglinAi {
+         } else if (PiglinAi.isFood(itemstack) && !PiglinAi.hasEatenRecently(piglin)) {
+             PiglinAi.eat(piglin);
+         } else {
+-            boolean flag = !piglin.equipItemIfPossible(world, itemstack, itemEntity).equals(ItemStack.EMPTY); // CraftBukkit
+            boolean flag = !piglin.equipItemIfPossible(world, itemstack, null).equals(ItemStack.EMPTY); // CraftBukkit // Paper - pass null item entity to prevent duplicate pickup item event call - called above.
+ 
+             if (!flag) {
+                 PiglinAi.putInInventory(piglin, itemstack);
+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 69a0a8aa7eec0a68a1460f6d6a4b604963b884c4..02f2107285d1bbe2137afd4f94880ad1f9d82fb9 100644
+--- a/src/main/java/net/minecraft/world/entity/raid/Raider.java
+++ b/src/main/java/net/minecraft/world/entity/raid/Raider.java
+@@ -228,6 +228,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.getOminousBannerInstance(this.registryAccess().lookupOrThrow(Registries.BANNER_PATTERN)))) {
+            // Paper start - EntityPickupItemEvent fixes
+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityPickupItemEvent(this, item, 0, false).isCancelled()) {
+                return;
+            }
+            // Paper end - EntityPickupItemEvent fixes
+             EquipmentSlot enumitemslot = EquipmentSlot.HEAD;
+             ItemStack itemstack1 = this.getItemBySlot(enumitemslot);
+             double d0 = (double) this.getEquipmentDropChance(enumitemslot);
--- a/patches/server/0745-Correctly-handle-interactions-with-items-on-cooldown.patch
+++ b/patches/server/0745-Correctly-handle-interactions-with-items-on-cooldown.patch
@ -0,0 +1,60 @@
+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 a706f0855fdf88cc9aece3ba00ef574b9cd8bd11..2aee9c2fbe38076317a3de7c3fdbd6988b64b389 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -520,6 +520,7 @@ public class ServerPlayerGameMode {
+         BlockPos blockposition = hitResult.getBlockPos();
+         BlockState iblockdata = world.getBlockState(blockposition);
+         boolean cancelledBlock = false;
+        boolean cancelledItem = false; // Paper - correctly handle items on cooldown
+ 
+         if (!iblockdata.getBlock().isEnabled(world.enabledFeatures())) {
+             return InteractionResult.FAIL;
+@@ -529,10 +530,10 @@ public class ServerPlayerGameMode {
+         }
+ 
+         if (player.getCooldowns().isOnCooldown(stack)) {
+-            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 - correctly handle items on cooldown
+         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 f7e26e381c2a2fec70cc2df01a12e7dbeeab48cd..cb05a94f2856a8bfb478bceb7c8712bc5e7ad5c2 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -555,6 +555,12 @@ public class CraftEventFactory {
+     }
+ 
+     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) {
+        // Paper start - cancelledItem param
+        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);
+ 
+@@ -589,6 +595,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/0746-Add-PlayerInventorySlotChangeEvent.patch
+++ b/patches/server/0746-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 f87f12666d4708b7fb7ede3eff03570fed8d1f40..bb0aaa16f0de18b15764ba39a781e8b86d690bb9 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -381,6 +381,25 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
+ 
+                 }
+             }
+            // Paper start - Add PlayerInventorySlotChangeEvent
+            @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 - Add PlayerInventorySlotChangeEvent
+ 
+             @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 3b92fb173f623a05ae99c86d98f2ecdf907f58c4..d830504d08c9de92797c432a868c1ee9dfc46a91 100644
+--- a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+@@ -330,7 +330,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 - Add PlayerInventorySlotChangeEvent
+             }
+         }
+ 
+diff --git a/src/main/java/net/minecraft/world/inventory/ContainerListener.java b/src/main/java/net/minecraft/world/inventory/ContainerListener.java
+index 0e19cc55646625bf32a354d3df2dc2d6bcff96f4..eba024c9aadef8902aacccea1584ffbee6c04e44 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 - Add PlayerInventorySlotChangeEvent
+    default void slotChanged(AbstractContainerMenu handler, int slotId, ItemStack oldStack, ItemStack stack) {
+        slotChanged(handler, slotId, stack);
+    }
+    // Paper end - Add PlayerInventorySlotChangeEvent
+
+     void dataChanged(AbstractContainerMenu handler, int property, int value);
+ }
--- a/patches/server/0747-Elder-Guardian-appearance-API.patch
+++ b/patches/server/0747-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 025c392f2ca89a87f6301d4af64c4d7daec58409..1dc5f21c337bc3fb67e5919308228d75b03989d1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -3311,6 +3311,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/0748-Add-entity-knockback-API.patch
+++ b/patches/server/0748-Add-entity-knockback-API.patch
@ -0,0 +1,23 @@
+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 14b4c3835388d957653ba34444968bb718ce7f68..4fa19ddb1414282020e118eea298d57d2bf42754 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1146,4 +1146,12 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         throw new UnsupportedOperationException("Cannot set the hurt direction on a non player");
+     }
+     // Paper end - hurt direction API
+
+    // Paper start - knockback API
+    @Override
+    public void knockback(final double strength, final double directionX, final double directionZ) {
+        Preconditions.checkArgument(strength > 0, "Knockback strength must be > 0");
+        this.getHandle().knockback(strength, directionX, directionZ);
+    };
+    // Paper end - knockback API
+ }
--- a/patches/server/0749-Detect-headless-JREs.patch
+++ b/patches/server/0749-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 68098dfe716e93aafcca4d8d5b5a81d8648b3654..2b7070e0cefa7cf0777df159693750fea14e800b 100644
+--- a/src/main/java/io/papermc/paper/util/ServerEnvironment.java
+++ b/src/main/java/io/papermc/paper/util/ServerEnvironment.java
+@@ -20,4 +20,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 cf071610ed662c4a309cc26ee73a74fa490d846f..47cd7c66ac37efebf2f63c49d78dd8fe44a70ef8 100644
+--- a/src/main/java/net/minecraft/server/Main.java
+++ b/src/main/java/net/minecraft/server/Main.java
+@@ -167,6 +167,18 @@ public class Main {
+                 return;
+             }
+ 
+            // Paper start - Detect headless JRE
+            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 - Detect headless JRE
+
+             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/0750-fix-entity-vehicle-collision-event-not-called.patch
+++ b/patches/server/0750-fix-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] fix 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 ee7350e19a86ffa115e4bce6b186a2422951e89b..d8fcd6d1edec1f31a861fab4b86cbeb15ddc799d 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+++ b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+@@ -157,7 +157,15 @@ public abstract class AbstractMinecart extends VehicleEntity {
+ 
+     @Override
+     public boolean canCollideWith(Entity other) {
+-        return AbstractBoat.canVehicleCollide(this, other);
+        // Paper start - fix VehicleEntityCollisionEvent not called when colliding with player
+        boolean collides = AbstractBoat.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 - fix VehicleEntityCollisionEvent not called when colliding with player
+     }
+ 
+     @Override
--- a/patches/server/0751-Add-EntityToggleSitEvent.patch
+++ b/patches/server/0751-Add-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] Add EntityToggleSitEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/TamableAnimal.java b/src/main/java/net/minecraft/world/entity/TamableAnimal.java
+index 550c7f3435cc6c3180769e47f05bf693bdc380e3..e9e4d6fd69f9eec25a75b2610e15a19f8326f87b 100644
+--- a/src/main/java/net/minecraft/world/entity/TamableAnimal.java
+++ b/src/main/java/net/minecraft/world/entity/TamableAnimal.java
+@@ -87,7 +87,7 @@ public abstract class TamableAnimal extends Animal implements OwnableEntity {
+         }
+ 
+         this.orderedToSit = nbt.getBoolean("Sitting");
+-        this.setInSittingPose(this.orderedToSit);
+        this.setInSittingPose(this.orderedToSit, false); // Paper - Add EntityToggleSitEvent
+     }
+ 
+     @Override
+@@ -167,6 +167,12 @@ public abstract class TamableAnimal extends Animal implements OwnableEntity {
+     }
+ 
+     public void setInSittingPose(boolean inSittingPose) {
+        // Paper start - Add EntityToggleSitEvent
+        this.setInSittingPose(inSittingPose, true);
+    }
+    public void setInSittingPose(boolean inSittingPose, boolean callEvent) {
+        if (callEvent && !new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), inSittingPose).callEvent()) return;
+        // Paper end - Add EntityToggleSitEvent
+         byte b0 = (Byte) this.entityData.get(TamableAnimal.DATA_FLAGS_ID);
+ 
+         if (inSittingPose) {
+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 ca45a8ccf7f4593d557d157470603e4d233d948d..d98e4882dcba8a903bc86c8d30b290e6e967cc75 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -419,7 +419,7 @@ public class Fox extends Animal implements VariantHolder<Fox.Variant> {
+ 
+         this.setSleeping(nbt.getBoolean("Sleeping"));
+         this.setVariant(Fox.Variant.byName(nbt.getString("Type")));
+-        this.setSitting(nbt.getBoolean("Sitting"));
+        this.setSitting(nbt.getBoolean("Sitting"), false); // Paper - Add EntityToggleSitEvent
+         this.setIsCrouching(nbt.getBoolean("Crouching"));
+         if (this.level() instanceof ServerLevel) {
+             this.setTargetGoals();
+@@ -432,6 +432,12 @@ public class Fox extends Animal implements VariantHolder<Fox.Variant> {
+     }
+ 
+     public void setSitting(boolean sitting) {
+        // Paper start - Add EntityToggleSitEvent
+        this.setSitting(sitting, true);
+    }
+    public void setSitting(boolean sitting, boolean fireEvent) {
+        if (fireEvent && !new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), sitting).callEvent()) return;
+        // Paper end - Add EntityToggleSitEvent
+         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 4f04170b3ec4ff59358e10ccfd0799af3ab590c3..b654bec0fbe903fac24f3bb99399455bf367c68a 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Panda.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Panda.java
+@@ -134,6 +134,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 - Add 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 b6baa40dac6d6bf40c4ee7ee75b8a8e6f60733a1..c99d37a40c63726c11980adccc67d09fd5132885 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
+@@ -572,7 +572,7 @@ public class Camel extends AbstractHorse {
+     }
+ 
+     public void sitDown() {
+-        if (!this.isCamelSitting()) {
+        if (!this.isCamelSitting() && new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), true).callEvent()) { // Paper - Add EntityToggleSitEvent
+             this.makeSound(SoundEvents.CAMEL_SIT);
+             this.setPose(Pose.SITTING);
+             this.gameEvent(GameEvent.ENTITY_ACTION);
+@@ -581,7 +581,7 @@ public class Camel extends AbstractHorse {
+     }
+ 
+     public void standUp() {
+-        if (this.isCamelSitting()) {
+        if (this.isCamelSitting() && new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), false).callEvent()) { // Paper - Add EntityToggleSitEvent
+             this.makeSound(SoundEvents.CAMEL_STAND);
+             this.setPose(Pose.STANDING);
+             this.gameEvent(GameEvent.ENTITY_ACTION);
+@@ -590,6 +590,7 @@ public class Camel extends AbstractHorse {
+     }
+ 
+     public void standUpInstantly() {
+        if (this.isCamelSitting() && !new io.papermc.paper.event.entity.EntityToggleSitEvent(this.getBukkitEntity(), false).callEvent()) return; // Paper - Add EntityToggleSitEvent
+         this.setPose(Pose.STANDING);
+         this.gameEvent(GameEvent.ENTITY_ACTION);
+         this.resetLastPoseChangeTickToFullStand(this.level().getGameTime());
--- a/patches/server/0752-Add-fire-tick-delay-option.patch
+++ b/patches/server/0752-Add-fire-tick-delay-option.patch
@ -0,0 +1,34 @@
+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 065d6164b5c9d65d20e7790c607d77e9ad70dfef..0e5a47ab235d99e6cb1468905f791c2c59ac0082 100644
+--- a/src/main/java/net/minecraft/world/level/block/FireBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/FireBlock.java
+@@ -171,7 +171,7 @@ public class FireBlock extends BaseFireBlock {
+ 
+     @Override
+     protected 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 - Add fire-tick-delay option
+         if (world.getGameRules().getBoolean(GameRules.RULE_DOFIRETICK)) {
+             if (!state.canSurvive(world, pos)) {
+                 this.fireExtinguished(world, pos); // CraftBukkit - invalid place location
+@@ -372,11 +372,11 @@ public class FireBlock extends BaseFireBlock {
+     protected void onPlace(BlockState iblockdata, Level world, BlockPos blockposition, BlockState iblockdata1, boolean flag, UseOnContext context) {
+         super.onPlace(iblockdata, world, blockposition, iblockdata1, flag, context);
+         // CraftBukkit end
+-        world.scheduleTick(blockposition, (Block) this, FireBlock.getFireTickDelay(world.random));
+        world.scheduleTick(blockposition, (Block) this, FireBlock.getFireTickDelay(world)); // Paper - Add fire-tick-delay option
+     }
+ 
+-    private static int getFireTickDelay(RandomSource random) {
+-        return 30 + random.nextInt(10);
+    private static int getFireTickDelay(Level world) { // Paper - Add fire-tick-delay option
+        return world.paperConfig().environment.fireTickDelay + world.random.nextInt(10); // Paper - Add fire-tick-delay option
+     }
+ 
+     @Override
--- a/patches/server/0753-Add-Moving-Piston-API.patch
+++ b/patches/server/0753-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 25b759dee5ae2b311965f26ba311591199894be4..293ac0b658224fc0b3c2acdfc86eff3c8a9fdc04 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftMovingPiston.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftMovingPiston.java
+@@ -4,7 +4,7 @@ import net.minecraft.world.level.block.piston.PistonMovingBlockEntity;
+ import org.bukkit.Location;
+ 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);
+@@ -23,4 +23,26 @@ public class CraftMovingPiston extends CraftBlockEntityState<PistonMovingBlockEn
+     public CraftMovingPiston copy(Location location) {
+         return new CraftMovingPiston(this, location);
+     }
+
+    // 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/0754-Ignore-impossible-spawn-tick.patch
+++ b/patches/server/0754-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 1b6ec72f59504d2f420d6d5dcbed4d3b9115e3d8..7de66aa435dd36899b80f4ecc64480680e474d94 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -84,6 +84,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/0755-Fix-EntityArgument-and-EntitySelectorParser-permissi.patch
+++ b/patches/server/0755-Fix-EntityArgument-and-EntitySelectorParser-permissi.patch
@ -0,0 +1,41 @@
+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 and EntitySelectorParser 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 a327939abe2cce22747366051b6b7aaa2db3a8cc..3281ea4dca20d2bb22b2b1c6b9abb1329bc829c1 100644
+--- a/src/main/java/net/minecraft/commands/arguments/EntityArgument.java
+++ b/src/main/java/net/minecraft/commands/arguments/EntityArgument.java
+@@ -135,7 +135,12 @@ public class EntityArgument implements ArgumentType<EntitySelector> {
+             StringReader stringreader = new StringReader(suggestionsbuilder.getInput());
+ 
+             stringreader.setCursor(suggestionsbuilder.getStart());
+-            EntitySelectorParser argumentparserselector = new EntitySelectorParser(stringreader, EntitySelectorParser.allowSelectors(icompletionprovider));
+            // Paper start - Fix EntityArgument permissions
+            final boolean permission = object instanceof CommandSourceStack stack
+                    ? stack.bypassSelectorPermissions || stack.hasPermission(2, "minecraft.command.selector")
+                    : icompletionprovider.hasPermission(2);
+            EntitySelectorParser argumentparserselector = new EntitySelectorParser(stringreader, permission);
+            // Paper end - Fix EntityArgument permissions
+ 
+             try {
+                 argumentparserselector.parse();
+diff --git a/src/main/java/net/minecraft/commands/arguments/selector/EntitySelectorParser.java b/src/main/java/net/minecraft/commands/arguments/selector/EntitySelectorParser.java
+index dd50a530439576f56f245ff0b7eb090f9f0c9180..9d31e29ec62f437e642ed60da69c4b106bd9e770 100644
+--- a/src/main/java/net/minecraft/commands/arguments/selector/EntitySelectorParser.java
+++ b/src/main/java/net/minecraft/commands/arguments/selector/EntitySelectorParser.java
+@@ -133,7 +133,7 @@ public class EntitySelectorParser {
+         boolean flag;
+ 
+         if (source instanceof SharedSuggestionProvider icompletionprovider) {
+-            if (icompletionprovider.hasPermission(2)) {
+            if (source instanceof net.minecraft.commands.CommandSourceStack stack ? stack.bypassSelectorPermissions || stack.hasPermission(2, "minecraft.command.selector") : icompletionprovider.hasPermission(2)) { // Paper - Fix EntityArgument permissions
+                 flag = true;
+                 return flag;
+             }
--- a/patches/server/0756-Fix-EntityCombustEvent-cancellation-cant-fully-preve.patch
+++ b/patches/server/0756-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 44f585b9dc9e3940193f07a2df1205907b4800ba..24834be9b5596745f9456488076bd89c3c7d2352 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3320,6 +3320,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+             pluginManager.callEvent(entityCombustEvent);
+             if (!entityCombustEvent.isCancelled()) {
+                 this.igniteForSeconds(entityCombustEvent.getDuration(), false);
+            // Paper start - fix EntityCombustEvent cancellation
+            } else {
+                this.setRemainingFireTicks(this.remainingFireTicks - 1);
+            // Paper end - fix EntityCombustEvent cancellation
+             }
+             // 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 c8ca41cd81a72f9bff40f5c1b3bfc1189bf51f98..0cf4133849ed8ff6d4038cc41ede9d3645b31da1 100644
+--- a/src/main/java/net/minecraft/world/level/block/BaseFireBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/BaseFireBlock.java
+@@ -145,6 +145,10 @@ public abstract class BaseFireBlock extends Block {
+ 
+                 if (!event.isCancelled()) {
+                     entity.igniteForSeconds(event.getDuration(), false);
+                    // Paper start - fix EntityCombustEvent cancellation
+                } else {
+                    entity.setRemainingFireTicks(entity.getRemainingFireTicks() - 1);
+                    // Paper end - fix EntityCombustEvent cancellation
+                 }
+                 // CraftBukkit end
+             }
--- a/patches/server/0757-Add-PrePlayerAttackEntityEvent.patch
+++ b/patches/server/0757-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 b8edbd23d547d7189ec64c5d3a8cd1d51859ce23..30e0a5fe3f9bd85d2b702c2c877c5682ed35d461 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -1222,8 +1222,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 - PlayerAttackEntityEvent
+                 float f = this.isAutoSpinAttack() ? this.autoSpinAttackDmg : (float) this.getAttributeValue(Attributes.ATTACK_DAMAGE);
+                 ItemStack itemstack = this.getWeaponItem();
+                 DamageSource damagesource = (DamageSource) Optional.ofNullable(itemstack.getItem().getDamageSource(this)).orElse(this.damageSources().playerAttack(this));
--- a/patches/server/0758-ensure-reset-EnderDragon-boss-event-name.patch
+++ b/patches/server/0758-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 8d0014b0db5ab42321150938fef98458fee84b17..3701cdc9f0e71d19a1090cf179bac9d5b8c4759a 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
+@@ -74,6 +74,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 - ensure reset EnderDragon boss event name
+     public final ServerBossEvent dragonEvent;
+     public final ServerLevel level;
+     private final BlockPos origin;
+@@ -102,7 +103,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 - ensure reset EnderDragon boss event name
+         this.gateways = new ObjectArrayList();
+         this.ticksSinceLastPlayerScan = 21;
+         this.skipArenaLoadedCheck = false;
+@@ -506,6 +507,10 @@ public class EndDragonFight {
+             this.ticksSinceDragonSeen = 0;
+             if (dragon.hasCustomName()) {
+                 this.dragonEvent.setName(dragon.getDisplayName());
+                // Paper start - ensure reset EnderDragon boss event name
+            } else {
+                this.dragonEvent.setName(DEFAULT_BOSS_EVENT_NAME);
+                // Paper end - ensure reset EnderDragon boss event name
+             }
+         }
+ 
--- a/patches/server/0759-Add-Player-Warden-Warning-API.patch
+++ b/patches/server/0759-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 1dc5f21c337bc3fb67e5919308228d75b03989d1..2c38725e6fc0a264df3a0d34c21ab774ad3e2fb5 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -3316,6 +3316,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/0760-More-vanilla-friendly-methods-to-update-trades.patch
+++ b/patches/server/0760-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 f51078e4b9e6267fa43795d009f5d149b86acb5a..a573aa4d387ad3a4e1017890f2b50b83a3c27ff4 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -895,6 +895,12 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+ 
+     @Override
+     protected void updateTrades() {
+        // Paper start - More vanilla friendly methods to update trades
+        updateTrades(TRADES_PER_LEVEL);
+    }
+
+    public boolean updateTrades(int amount) {
+        // Paper end - More vanilla friendly methods to update trades
+         VillagerData villagerdata = this.getVillagerData();
+         Int2ObjectMap int2objectmap;
+ 
+@@ -912,9 +918,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 - More vanilla friendly methods to update trades
+                return true; // Paper - More vanilla friendly methods to update trades
+             }
+         }
+        return false; // Paper - More vanilla friendly methods to update trades
+     }
+ 
+     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 45c44c46edee9f46b8e197f1f54ea2779bf1184c..8e895d6f84f7d84b219f2424909dd42e5f08dec4 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
+@@ -98,6 +98,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/0761-Add-paper-dumplisteners-command.patch
+++ b/patches/server/0761-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 fd4f37711989431f997d77fb0917f8a9232ce53f..46bf42d5ea9e7b046f962531c5962d287cf44a41 100644
+--- a/src/main/java/io/papermc/paper/command/PaperCommand.java
+++ b/src/main/java/io/papermc/paper/command/PaperCommand.java
+@@ -41,6 +41,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);
+    }
+}