385

2024-06-13 13:14:13 -07:00
parent e07671b7df
commit 7bcc1a4674
108 changed files with 127 additions and 173 deletions
--- a/patches/unapplied/server/Add-BlockStateMeta-clearBlockState.patch
+++ b/patches/unapplied/server/Add-BlockStateMeta-clearBlockState.patch
@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Thu, 11 Jan 2024 12:41:50 -0800
-Subject: [PATCH] Add BlockStateMeta#clearBlockState
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBlockState.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBlockState.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBlockState.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaBlockState.java
-@@ -0,0 +0,0 @@ public class CraftMetaBlockState extends CraftMetaItem implements BlockStateMeta
-         return this.blockEntityTag != null;
-     }
- 
-+    // Paper start - add method to clear block state
-+    @Override
-+    public void clearBlockState() {
-+        this.blockEntityTag = null;
-+    }
-+    // Paper end - add method to clear block state
-+
-     @Override
-     public BlockState getBlockState() {
-         return (this.blockEntityTag != null) ? this.blockEntityTag.copy() : CraftMetaBlockState.getBlockState(this.material, null);
--- a/patches/unapplied/server/Add-Heightmap-API.patch
+++ b/patches/unapplied/server/Add-Heightmap-API.patch
@ -1,40 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Tue, 1 Jan 2019 02:22:01 -0800
-Subject: [PATCH] Add Heightmap API
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         return CraftBlock.at(this.world, new BlockPos(x, y, z));
-     }
- 
-+    // Paper start - Implement heightmap api
-+    @Override
-+    public int getHighestBlockYAt(final int x, final int z, final com.destroystokyo.paper.HeightmapType heightmap) throws UnsupportedOperationException {
-+        this.getChunkAt(x >> 4, z >> 4); // heightmap will ret 0 on unloaded areas
-+
-+        switch (heightmap) {
-+            case LIGHT_BLOCKING:
-+                throw new UnsupportedOperationException(); // TODO
-+                //return this.world.getHighestBlockY(HeightMap.Type.LIGHT_BLOCKING, x, z);
-+            case ANY:
-+                return this.world.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.WORLD_SURFACE, x, z);
-+            case SOLID:
-+                return this.world.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.OCEAN_FLOOR, x, z);
-+            case SOLID_OR_LIQUID:
-+                return this.world.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.MOTION_BLOCKING, x, z);
-+            case SOLID_OR_LIQUID_NO_LEAVES:
-+                return this.world.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, x, z);
-+            default:
-+                throw new UnsupportedOperationException();
-+        }
-+    }
-+    // Paper end
-+
-     @Override
-     public Location getSpawnLocation() {
-         BlockPos spawn = this.world.getSharedSpawnPos();
--- a/patches/unapplied/server/Add-PlayerAttackEntityCooldownResetEvent.patch
+++ b/patches/unapplied/server/Add-PlayerAttackEntityCooldownResetEvent.patch
@ -1,28 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: nossr50 <nossr50@gmail.com>
-Date: Thu, 26 Mar 2020 19:44:50 -0700
-Subject: [PATCH] Add PlayerAttackEntityCooldownResetEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
- 
-             EntityDamageEvent event = CraftEventFactory.handleLivingEntityDamageEvent(this, damagesource, originalDamage, hardHatModifier, blockingModifier, armorModifier, resistanceModifier, magicModifier, absorptionModifier, hardHat, blocking, armor, resistance, magic, absorption);
-             if (damagesource.getEntity() instanceof net.minecraft.world.entity.player.Player) {
-                ((net.minecraft.world.entity.player.Player) damagesource.getEntity()).resetAttackStrengthTicker(); // Moved from EntityHuman in order to make the cooldown reset get called after the damage event is fired
-+                // Paper start - PlayerAttackEntityCooldownResetEvent
-+                if (damagesource.getEntity() instanceof ServerPlayer) {
-+                    ServerPlayer player = (ServerPlayer) damagesource.getEntity();
-+                    if (new com.destroystokyo.paper.event.player.PlayerAttackEntityCooldownResetEvent(player.getBukkitEntity(), this.getBukkitEntity(), player.getAttackStrengthScale(0F)).callEvent()) {
-+                        player.resetAttackStrengthTicker();
-+                    }
-+                } else {
-+                    ((net.minecraft.world.entity.player.Player) damagesource.getEntity()).resetAttackStrengthTicker();
-+                }
-+                // Paper end - PlayerAttackEntityCooldownResetEvent
-             }
-             if (event.isCancelled()) {
-                 return false;
--- a/patches/unapplied/server/Add-PlayerPostRespawnEvent.patch
+++ b/patches/unapplied/server/Add-PlayerPostRespawnEvent.patch
@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MisterVector <whizkid3000@hotmail.com>
-Date: Fri, 26 Oct 2018 21:31:00 -0700
-Subject: [PATCH] Add PlayerPostRespawnEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
- 
-         boolean flag2 = false;
- 
-+        // Paper start - Add PlayerPostRespawnEvent
-+        boolean isBedSpawn = false;
-+        boolean isRespawn = false;
-+        // Paper end - Add PlayerPostRespawnEvent
-+
-         // CraftBukkit start - fire PlayerRespawnEvent
-         if (location == null) {
-            boolean isBedSpawn = false;
-+            // boolean isBedSpawn = false; // Paper - Add PlayerPostRespawnEvent; moved up
-             ServerLevel worldserver1 = this.server.getLevel(entityplayer.getRespawnDimension());
-             if (worldserver1 != null) {
-                 Optional optional;
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
- 
-             location = respawnEvent.getRespawnLocation();
-             if (!flag) entityplayer.reset(); // SPIGOT-4785
-+            isRespawn = true; // Paper - Add PlayerPostRespawnEvent
-         } else {
-             location.setWorld(worldserver.getWorld());
-         }
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-         if (entityplayer.connection.isDisconnected()) {
-             this.save(entityplayer);
-         }
-+
-+        // Paper start - Add PlayerPostRespawnEvent
-+        if (isRespawn) {
-+            cserver.getPluginManager().callEvent(new com.destroystokyo.paper.event.player.PlayerPostRespawnEvent(entityplayer.getBukkitEntity(), location, isBedSpawn));
-+        }
-+        // Paper end - Add PlayerPostRespawnEvent
-+
-         // CraftBukkit end
-         return entityplayer1;
-     }
--- a/patches/unapplied/server/Add-PlayerRecipeBookClickEvent.patch
+++ b/patches/unapplied/server/Add-PlayerRecipeBookClickEvent.patch
@ -1,55 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Fri, 5 Jun 2020 18:24:06 -0400
-Subject: [PATCH] Add PlayerRecipeBookClickEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-             if (!this.player.containerMenu.stillValid(this.player)) {
-                 ServerGamePacketListenerImpl.LOGGER.debug("Player {} interacted with invalid menu {}", this.player, this.player.containerMenu);
-             } else {
-+                // Paper start - Add PlayerRecipeBookClickEvent
-+                ResourceLocation recipeName = packet.getRecipe();
-+                boolean makeAll = packet.isShiftDown();
-+                com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent paperEvent = new com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent(
-+                    this.player.getBukkitEntity(), org.bukkit.craftbukkit.util.CraftNamespacedKey.fromMinecraft(recipeName), makeAll
-+                );
-+                if (!paperEvent.callEvent()) {
-+                    return;
-+                }
-+                recipeName = CraftNamespacedKey.toMinecraft(paperEvent.getRecipe());
-+                makeAll = paperEvent.isMakeAll();
-+                if (org.bukkit.event.player.PlayerRecipeBookClickEvent.getHandlerList().getRegisteredListeners().length > 0) {
-+                // Paper end - Add PlayerRecipeBookClickEvent
-                 // CraftBukkit start - implement PlayerRecipeBookClickEvent
-                org.bukkit.inventory.Recipe recipe = this.cserver.getRecipe(CraftNamespacedKey.fromMinecraft(packet.getRecipe()));
-+                org.bukkit.inventory.Recipe recipe = this.cserver.getRecipe(CraftNamespacedKey.fromMinecraft(recipeName)); // Paper
-                 if (recipe == null) {
-                     return;
-                 }
-                org.bukkit.event.player.PlayerRecipeBookClickEvent event = CraftEventFactory.callRecipeBookClickEvent(this.player, recipe, packet.isShiftDown());
-+                // Paper start - Add PlayerRecipeBookClickEvent
-+                org.bukkit.event.player.PlayerRecipeBookClickEvent event = CraftEventFactory.callRecipeBookClickEvent(this.player, recipe, makeAll);
-+                recipeName = CraftNamespacedKey.toMinecraft(((org.bukkit.Keyed) event.getRecipe()).getKey());
-+                makeAll = event.isShiftClick();
-+                }
-+                if (!(this.player.containerMenu instanceof RecipeBookMenu<?> recipeBookMenu)) {
-+                    return;
-+                }
-+                // Paper end - Add PlayerRecipeBookClickEvent
- 
-                 // Cast to keyed should be safe as the recipe will never be a MerchantRecipe.
-                this.server.getRecipeManager().byKey(CraftNamespacedKey.toMinecraft(((org.bukkit.Keyed) event.getRecipe()).getKey())).ifPresent((recipeholder) -> {
-                    ((RecipeBookMenu) this.player.containerMenu).handlePlacement(event.isShiftClick(), recipeholder, this.player);
-+                // Paper start - Add PlayerRecipeBookClickEvent
-+                final boolean finalMakeAll = makeAll;
-+                this.server.getRecipeManager().byKey(recipeName).ifPresent((recipeholder) -> {
-+                    recipeBookMenu.handlePlacement(finalMakeAll, recipeholder, this.player);
-+                    // Paper end - Add PlayerRecipeBookClickEvent
-                 });
-                 // CraftBukkit end
-             }
--- a/patches/unapplied/server/Add-Plugin-Tickets-to-API-Chunk-Methods.patch
+++ b/patches/unapplied/server/Add-Plugin-Tickets-to-API-Chunk-Methods.patch
@ -1,103 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 9 Jun 2020 03:33:03 -0400
-Subject: [PATCH] Add Plugin Tickets to API Chunk Methods
-
-Like previous versions, plugins loading chunks kept them loaded until
-they garbage collected to avoid constant spamming of chunk loads
-
-This adds tickets to a few more places so that they can be unloaded.
-
-Additionally, this drops their ticket level to BORDER so they wont be ticking
-so they will just sit inactive instead.
-
-Using .loadChunk to keep a chunk ticking was a horrible idea for upstream
-when we have TWO methods that are able to do that already in the API.
-
-Also reduce their collection count down to a maximum of 1 second. Barely
-anyone knows what chunk-gc is in bukkit.yml as its less relevant now, and
-since this wasn't spigot behavior, this is safe to mostly ignore (unless someone
-wants it to collect even faster, they can restore that setting back to 1 instead of 20+)
-
-Not adding it to .getType() though to keep behavior consistent with vanilla for performance reasons.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         this.overrideSpawnLimits();
-         console.autosavePeriod = this.configuration.getInt("ticks-per.autosave");
-         this.warningState = WarningState.value(this.configuration.getString("settings.deprecated-verbose"));
-        TicketType.PLUGIN.timeout = this.configuration.getInt("chunk-gc.period-in-ticks");
-+        TicketType.PLUGIN.timeout = Math.min(20, this.configuration.getInt("chunk-gc.period-in-ticks")); // Paper - cap plugin loads to 1 second
-         this.minimumAPI = ApiVersion.getOrCreateVersion(this.configuration.getString("settings.minimum-api"));
-         this.loadIcon();
-         this.loadCompatibilities();
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         this.console.setMotd(config.motd);
-         this.overrideSpawnLimits();
-         this.warningState = WarningState.value(this.configuration.getString("settings.deprecated-verbose"));
-        TicketType.PLUGIN.timeout = this.configuration.getInt("chunk-gc.period-in-ticks");
-+        TicketType.PLUGIN.timeout = Math.min(20, configuration.getInt("chunk-gc.period-in-ticks")); // Paper - cap plugin loads to 1 second
-         this.minimumAPI = ApiVersion.getOrCreateVersion(this.configuration.getString("settings.minimum-api"));
-         this.printSaveWarning = false;
-         this.console.autosavePeriod = this.configuration.getInt("ticks-per.autosave");
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
- 
-     @Override
-     public Chunk getChunkAt(int x, int z) {
-        net.minecraft.world.level.chunk.LevelChunk chunk = (net.minecraft.world.level.chunk.LevelChunk) this.world.getChunk(x, z, ChunkStatus.FULL, true);
-+        // Paper start - add ticket to hold chunk for a little while longer if plugin accesses it
-+        net.minecraft.world.level.chunk.LevelChunk chunk = this.world.getChunkSource().getChunkAtIfLoadedImmediately(x, z);
-+        if (chunk == null) {
-+            this.addTicket(x, z);
-+            chunk = this.world.getChunkSource().getChunk(x, z, true);
-+        }
-+        // Paper end
-         return new CraftChunk(chunk);
-     }
- 
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         return new CraftChunk(this.getHandle(), x, z);
-     }
- 
-+    // Paper start
-+    private void addTicket(int x, int z) {
-+        io.papermc.paper.util.MCUtil.MAIN_EXECUTOR.execute(() -> this.world.getChunkSource().addRegionTicket(TicketType.PLUGIN, new ChunkPos(x, z), 0, Unit.INSTANCE)); // Paper
-+    }
-+    // Paper end
-+
-     @Override
-     public Chunk getChunkAt(Block block) {
-         Preconditions.checkArgument(block != null, "null block");
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-     public boolean unloadChunkRequest(int x, int z) {
-         org.spigotmc.AsyncCatcher.catchOp("chunk unload"); // Spigot
-         if (this.isChunkLoaded(x, z)) {
-            this.world.getChunkSource().removeRegionTicket(TicketType.PLUGIN, new ChunkPos(x, z), 1, Unit.INSTANCE);
-+            this.world.getChunkSource().removeRegionTicket(TicketType.PLUGIN, new ChunkPos(x, z), 0, Unit.INSTANCE); // Paper
-         }
- 
-         return true;
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         }
- 
-         if (chunk instanceof net.minecraft.world.level.chunk.LevelChunk) {
-            this.world.getChunkSource().addRegionTicket(TicketType.PLUGIN, new ChunkPos(x, z), 1, Unit.INSTANCE);
-+            this.world.getChunkSource().addRegionTicket(TicketType.PLUGIN, new ChunkPos(x, z), 0, Unit.INSTANCE); // Paper
-             return true;
-         }
- 
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         io.papermc.paper.chunk.system.ChunkSystem.scheduleChunkLoad(this.getHandle(), x, z, gen, ChunkStatus.FULL, true, priority, (c) -> {
-             net.minecraft.server.MinecraftServer.getServer().scheduleOnMain(() -> {
-                 net.minecraft.world.level.chunk.LevelChunk chunk = (net.minecraft.world.level.chunk.LevelChunk)c;
-+                if (chunk != null) this.addTicket(x, z); // Paper
-                 ret.complete(chunk == null ? null : new CraftChunk(chunk));
-             });
-         });
--- a/patches/unapplied/server/Add-Raw-Byte-ItemStack-Serialization.patch
+++ b/patches/unapplied/server/Add-Raw-Byte-ItemStack-Serialization.patch
@ -1,65 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Thu, 30 Apr 2020 16:56:54 +0200
-Subject: [PATCH] Add Raw Byte ItemStack Serialization
-
-Serializes using NBT which is safer for server data migrations than bukkits format.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-@@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
-     public com.destroystokyo.paper.util.VersionFetcher getVersionFetcher() {
-         return new com.destroystokyo.paper.PaperVersionFetcher();
-     }
-+
-+    @Override
-+    public byte[] serializeItem(ItemStack item) {
-+        Preconditions.checkNotNull(item, "null cannot be serialized");
-+        Preconditions.checkArgument(item.getType() != Material.AIR, "air cannot be serialized");
-+
-+        return serializeNbtToBytes((net.minecraft.nbt.CompoundTag) (item instanceof CraftItemStack ? ((CraftItemStack) item).handle : CraftItemStack.asNMSCopy(item)).save(MinecraftServer.getServer().registryAccess()));
-+    }
-+
-+    @Override
-+    public ItemStack deserializeItem(byte[] data) {
-+        Preconditions.checkNotNull(data, "null cannot be deserialized");
-+        Preconditions.checkArgument(data.length > 0, "cannot deserialize nothing");
-+
-+        net.minecraft.nbt.CompoundTag compound = deserializeNbtFromBytes(data);
-+        final int dataVersion = compound.getInt("DataVersion");
-+        compound = (net.minecraft.nbt.CompoundTag) MinecraftServer.getServer().fixerUpper.update(References.ITEM_STACK, new Dynamic<>(NbtOps.INSTANCE, compound), dataVersion, this.getDataVersion()).getValue();
-+        return CraftItemStack.asCraftMirror(net.minecraft.world.item.ItemStack.parse(MinecraftServer.getServer().registryAccess(), compound).orElseThrow());
-+    }
-+
-+    private byte[] serializeNbtToBytes(CompoundTag compound) {
-+        compound.putInt("DataVersion", getDataVersion());
-+        java.io.ByteArrayOutputStream outputStream = new java.io.ByteArrayOutputStream();
-+        try {
-+            net.minecraft.nbt.NbtIo.writeCompressed(
-+                compound,
-+                outputStream
-+            );
-+        } catch (IOException ex) {
-+            throw new RuntimeException(ex);
-+        }
-+        return outputStream.toByteArray();
-+    }
-+
-+    private net.minecraft.nbt.CompoundTag deserializeNbtFromBytes(byte[] data) {
-+        net.minecraft.nbt.CompoundTag compound;
-+        try {
-+            compound = net.minecraft.nbt.NbtIo.readCompressed(
-+                new java.io.ByteArrayInputStream(data), net.minecraft.nbt.NbtAccounter.unlimitedHeap()
-+            );
-+        } catch (IOException ex) {
-+            throw new RuntimeException(ex);
-+        }
-+        int dataVersion = compound.getInt("DataVersion");
-+        Preconditions.checkArgument(dataVersion <= getDataVersion(), "Newer version! Server downgrades are not supported!");
-+        return compound;
-+    }
-     // Paper end
- 
-     @Override
--- a/patches/unapplied/server/Add-ThrownEggHatchEvent.patch
+++ b/patches/unapplied/server/Add-ThrownEggHatchEvent.patch
@ -1,26 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <blake.galbreath@gmail.com>
-Date: Sun, 9 Feb 2020 00:19:05 -0600
-Subject: [PATCH] Add ThrownEggHatchEvent
-
-Adds a new event similar to PlayerEggThrowEvent, but without the Player requirement
-(dispensers can throw eggs to hatch them, too).
-
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownEgg.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownEgg.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownEgg.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownEgg.java
-@@ -0,0 +0,0 @@ public class ThrownEgg extends ThrowableItemProjectile {
-                     }
-                 }
-                 // CraftBukkit end
-+                // Paper start - Add ThrownEggHatchEvent
-+                com.destroystokyo.paper.event.entity.ThrownEggHatchEvent event = new com.destroystokyo.paper.event.entity.ThrownEggHatchEvent((org.bukkit.entity.Egg) getBukkitEntity(), hatching, b0, hatchingType);
-+                event.callEvent();
-+                hatching = event.isHatching();
-+                b0 = hatching ? event.getNumHatches() : 0; // If hatching is set to false, ensure child count is 0
-+                hatchingType = event.getHatchingType();
-+                // Paper end - Add ThrownEggHatchEvent
- 
-                 for (int i = 0; i < b0; ++i) {
-                     Entity entitychicken = this.level().getWorld().makeEntity(new org.bukkit.Location(this.level().getWorld(), this.getX(), this.getY(), this.getZ(), this.getYRot(), 0.0F), hatchingType.getEntityClass()); // CraftBukkit
--- a/patches/unapplied/server/Add-debug-for-sync-chunk-loads.patch
+++ b/patches/unapplied/server/Add-debug-for-sync-chunk-loads.patch
@ -1,331 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Fri, 19 Jul 2019 03:29:14 -0700
-Subject: [PATCH] Add debug for sync chunk loads
-
-This patch adds a tool to find calls to getChunkAt which would load
-chunks, however it must be enabled by setting the startup flag
-Dpaper.debug-sync-loads=true
-
- To get a debug log for sync loads, the command is
-  /paper syncloadinfo
- To clear clear the currently stored sync load info, use
-  /paper syncloadinfo clear
-
-diff --git a/src/main/java/com/destroystokyo/paper/io/SyncLoadFinder.java b/src/main/java/com/destroystokyo/paper/io/SyncLoadFinder.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/io/SyncLoadFinder.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.io;
-+
-+import com.google.gson.JsonArray;
-+import com.google.gson.JsonObject;
-+import com.mojang.datafixers.util.Pair;
-+import it.unimi.dsi.fastutil.longs.Long2IntMap;
-+import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap;
-+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
-+
-+import java.util.ArrayList;
-+import java.util.List;
-+import java.util.Map;
-+import java.util.WeakHashMap;
-+import net.minecraft.world.level.Level;
-+
-+public class SyncLoadFinder {
-+
-+    public static final boolean ENABLED = Boolean.getBoolean("paper.debug-sync-loads");
-+
-+    private static final WeakHashMap<Level, Object2ObjectOpenHashMap<ThrowableWithEquals, SyncLoadInformation>> SYNC_LOADS = new WeakHashMap<>();
-+
-+    private static final class SyncLoadInformation {
-+
-+        public int times;
-+
-+        public final Long2IntOpenHashMap coordinateTimes = new Long2IntOpenHashMap();
-+    }
-+
-+    public static void clear() {
-+        SYNC_LOADS.clear();
-+    }
-+
-+    public static void logSyncLoad(final Level world, final int chunkX, final int chunkZ) {
-+        if (!ENABLED) {
-+            return;
-+        }
-+
-+        final ThrowableWithEquals stacktrace = new ThrowableWithEquals(Thread.currentThread().getStackTrace());
-+
-+        SYNC_LOADS.compute(world, (final Level keyInMap, Object2ObjectOpenHashMap<ThrowableWithEquals, SyncLoadInformation> map) -> {
-+            if (map == null) {
-+                map = new Object2ObjectOpenHashMap<>();
-+            }
-+
-+            map.compute(stacktrace, (ThrowableWithEquals keyInMap0, SyncLoadInformation valueInMap) -> {
-+                if (valueInMap == null) {
-+                    valueInMap = new SyncLoadInformation();
-+                }
-+
-+                ++valueInMap.times;
-+
-+                valueInMap.coordinateTimes.compute(io.papermc.paper.util.MCUtil.getCoordinateKey(chunkX, chunkZ), (Long keyInMap1, Integer valueInMap1) -> {
-+                    return valueInMap1 == null ? Integer.valueOf(1) : Integer.valueOf(valueInMap1.intValue() + 1);
-+                });
-+
-+                return valueInMap;
-+            });
-+
-+            return map;
-+        });
-+    }
-+
-+    public static JsonObject serialize() {
-+        final JsonObject ret = new JsonObject();
-+
-+        final JsonArray worldsData = new JsonArray();
-+
-+        for (final Map.Entry<Level, Object2ObjectOpenHashMap<ThrowableWithEquals, SyncLoadInformation>> entry : SYNC_LOADS.entrySet()) {
-+            final Level world = entry.getKey();
-+
-+            final JsonObject worldData = new JsonObject();
-+
-+            worldData.addProperty("name", world.getWorld().getName());
-+
-+            final List<Pair<ThrowableWithEquals, SyncLoadInformation>> data = new ArrayList<>();
-+
-+            entry.getValue().forEach((ThrowableWithEquals stacktrace, SyncLoadInformation times) -> {
-+                data.add(new Pair<>(stacktrace, times));
-+            });
-+
-+            data.sort((Pair<ThrowableWithEquals, SyncLoadInformation> pair1, Pair<ThrowableWithEquals, SyncLoadInformation> pair2) -> {
-+                return Integer.compare(pair2.getSecond().times, pair1.getSecond().times); // reverse order
-+            });
-+
-+            final JsonArray stacktraces = new JsonArray();
-+
-+            for (Pair<ThrowableWithEquals, SyncLoadInformation> pair : data) {
-+                final JsonObject stacktrace = new JsonObject();
-+
-+                stacktrace.addProperty("times", pair.getSecond().times);
-+
-+                final JsonArray traces = new JsonArray();
-+
-+                for (StackTraceElement element : pair.getFirst().stacktrace) {
-+                    traces.add(String.valueOf(element));
-+                }
-+
-+                stacktrace.add("stacktrace", traces);
-+
-+                final JsonArray coordinates = new JsonArray();
-+
-+                for (Long2IntMap.Entry coordinate : pair.getSecond().coordinateTimes.long2IntEntrySet()) {
-+                    final long key = coordinate.getLongKey();
-+                    final int times = coordinate.getIntValue();
-+                    coordinates.add("(" + io.papermc.paper.util.MCUtil.getCoordinateX(key) + "," + io.papermc.paper.util.MCUtil.getCoordinateZ(key) + "): " + times);
-+                }
-+
-+                stacktrace.add("coordinates", coordinates);
-+
-+                stacktraces.add(stacktrace);
-+            }
-+
-+
-+            worldData.add("stacktraces", stacktraces);
-+            worldsData.add(worldData);
-+        }
-+
-+        ret.add("worlds", worldsData);
-+
-+        return ret;
-+    }
-+
-+    static final class ThrowableWithEquals {
-+
-+        private final StackTraceElement[] stacktrace;
-+        private final int hash;
-+
-+        public ThrowableWithEquals(final StackTraceElement[] stacktrace) {
-+            this.stacktrace = stacktrace;
-+            this.hash = ThrowableWithEquals.hash(stacktrace);
-+        }
-+
-+        public static int hash(final StackTraceElement[] stacktrace) {
-+            int hash = 0;
-+
-+            for (int i = 0; i < stacktrace.length; ++i) {
-+                hash *= 31;
-+                hash += stacktrace[i].hashCode();
-+            }
-+
-+            return hash;
-+        }
-+
-+        @Override
-+        public int hashCode() {
-+            return this.hash;
-+        }
-+
-+        @Override
-+        public boolean equals(final Object obj) {
-+            if (obj == null || obj.getClass() != this.getClass()) {
-+                return false;
-+            }
-+
-+            final ThrowableWithEquals other = (ThrowableWithEquals)obj;
-+            final StackTraceElement[] otherStackTrace = other.stacktrace;
-+
-+            if (this.stacktrace.length != otherStackTrace.length || this.hash != other.hash) {
-+                return false;
-+            }
-+
-+            if (this == obj) {
-+                return true;
-+            }
-+
-+            for (int i = 0; i < this.stacktrace.length; ++i) {
-+                if (!this.stacktrace[i].equals(otherStackTrace[i])) {
-+                    return false;
-+                }
-+            }
-+
-+            return true;
-+        }
-+    }
-+}
-diff --git a/src/main/java/io/papermc/paper/command/PaperCommand.java b/src/main/java/io/papermc/paper/command/PaperCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/io/papermc/paper/command/PaperCommand.java
-+++ b/src/main/java/io/papermc/paper/command/PaperCommand.java
-@@ -0,0 +0,0 @@ public final class PaperCommand extends Command {
-         commands.put(Set.of("reload"), new ReloadCommand());
-         commands.put(Set.of("version"), new VersionCommand());
-         commands.put(Set.of("dumpplugins"), new DumpPluginsCommand());
-+        commands.put(Set.of("syncloadinfo"), new SyncLoadInfoCommand());
- 
-         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/SyncLoadInfoCommand.java b/src/main/java/io/papermc/paper/command/subcommands/SyncLoadInfoCommand.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/io/papermc/paper/command/subcommands/SyncLoadInfoCommand.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.command.subcommands;
-+
-+import com.destroystokyo.paper.io.SyncLoadFinder;
-+import com.google.gson.JsonObject;
-+import com.google.gson.internal.Streams;
-+import com.google.gson.stream.JsonWriter;
-+import io.papermc.paper.command.CommandUtil;
-+import io.papermc.paper.command.PaperSubcommand;
-+import java.io.File;
-+import java.io.FileOutputStream;
-+import java.io.PrintStream;
-+import java.io.StringWriter;
-+import java.nio.charset.StandardCharsets;
-+import java.time.LocalDateTime;
-+import java.time.format.DateTimeFormatter;
-+import java.util.List;
-+
-+import net.kyori.adventure.text.event.ClickEvent;
-+import net.kyori.adventure.text.event.HoverEvent;
-+import net.minecraft.server.MinecraftServer;
-+import org.bukkit.command.CommandSender;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+import org.checkerframework.framework.qual.DefaultQualifier;
-+
-+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 SyncLoadInfoCommand implements PaperSubcommand {
-+    @Override
-+    public boolean execute(final CommandSender sender, final String subCommand, final String[] args) {
-+        this.doSyncLoadInfo(sender, args);
-+        return true;
-+    }
-+
-+    @Override
-+    public List<String> tabComplete(final CommandSender sender, final String subCommand, final String[] args) {
-+        return CommandUtil.getListMatchingLast(sender, args, "clear");
-+    }
-+
-+    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH.mm.ss");
-+
-+    private void doSyncLoadInfo(final CommandSender sender, final String[] args) {
-+        if (!SyncLoadFinder.ENABLED) {
-+            String systemFlag = "-Dpaper.debug-sync-loads=true";
-+            sender.sendMessage(text().color(RED).append(text("This command requires the server startup flag '")).append(
-+                text(systemFlag, WHITE).clickEvent(ClickEvent.copyToClipboard(systemFlag))
-+                                       .hoverEvent(HoverEvent.showText(text("Click to copy the system flag")))).append(
-+                text("' to be set.")));
-+            return;
-+        }
-+
-+        if (args.length > 0 && args[0].equals("clear")) {
-+            SyncLoadFinder.clear();
-+            sender.sendMessage(text("Sync load data cleared.", GRAY));
-+            return;
-+        }
-+
-+        File file = new File(new File(new File("."), "debug"),
-+            "sync-load-info-" + FORMATTER.format(LocalDateTime.now()) + ".txt");
-+        file.getParentFile().mkdirs();
-+        sender.sendMessage(text("Writing sync load info to " + file, GREEN));
-+
-+
-+        try {
-+            final JsonObject data = SyncLoadFinder.serialize();
-+
-+            StringWriter stringWriter = new StringWriter();
-+            JsonWriter jsonWriter = new JsonWriter(stringWriter);
-+            jsonWriter.setIndent(" ");
-+            jsonWriter.setLenient(false);
-+            Streams.write(data, jsonWriter);
-+
-+            try (
-+                PrintStream out = new PrintStream(new FileOutputStream(file), false, StandardCharsets.UTF_8)
-+            ) {
-+                out.print(stringWriter);
-+            }
-+            sender.sendMessage(text("Successfully written sync load information!", GREEN));
-+        } catch (Throwable thr) {
-+            sender.sendMessage(text("Failed to write sync load information! See the console for more info.", RED));
-+            MinecraftServer.LOGGER.warn("Error occurred while dumping sync chunk load info", thr);
-+        }
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
- 
-             Objects.requireNonNull(completablefuture);
-             if (!completablefuture.isDone()) { // Paper
-+                com.destroystokyo.paper.io.SyncLoadFinder.logSyncLoad(this.level, x, z); // Paper - Add debug for sync chunk loads
-                 this.level.timings.syncChunkLoad.startTiming(); // Paper
-             chunkproviderserver_b.managedBlock(completablefuture::isDone);
-                 this.level.timings.syncChunkLoad.stopTiming(); // Paper
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-         this.getCraftServer().addWorld(this.getWorld()); // CraftBukkit
-     }
- 
-+    // Paper start
-+    @Override
-+    public boolean hasChunk(int chunkX, int chunkZ) {
-+        return this.getChunkSource().getChunkAtIfLoadedImmediately(chunkX, chunkZ) != null;
-+    }
-+    // Paper end
-+
-     /** @deprecated */
-     @Deprecated
-     @VisibleForTesting
--- a/patches/unapplied/server/Add-entity-liquid-API.patch
+++ b/patches/unapplied/server/Add-entity-liquid-API.patch
@ -1,55 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Thu, 2 Jul 2020 18:11:43 -0500
-Subject: [PATCH] Add entity liquid API
-
-== AT ==
-public net.minecraft.world.entity.Entity isInRain()Z
-public net.minecraft.world.entity.Entity isInBubbleColumn()Z
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-@@ -0,0 +0,0 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
-         return getHandle().spawnReason;
-     }
-     // Paper end - entity spawn reason API
-+
-+    // Paper start - entity liquid API
-+    @Override
-+    public boolean isUnderWater() {
-+        return getHandle().isUnderWater();
-+    }
-+
-+    @Override
-+    public boolean isInRain() {
-+        return getHandle().isInRain();
-+    }
-+
-+    @Override
-+    public boolean isInBubbleColumn() {
-+        return getHandle().isInBubbleColumn();
-+    }
-+
-+    @Override
-+    public boolean isInWaterOrRain() {
-+        return getHandle().isInWaterOrRain();
-+    }
-+
-+    @Override
-+    public boolean isInWaterOrBubbleColumn() {
-+        return getHandle().isInWaterOrBubble();
-+    }
-+
-+    @Override
-+    public boolean isInWaterOrRainOrBubbleColumn() {
-+        return getHandle().isInWaterRainOrBubble();
-+    }
-+
-+    @Override
-+    public boolean isInLava() {
-+        return getHandle().isInLava();
-+    }
-+    // Paper end - entity liquid API
- }
--- a/patches/unapplied/server/Add-option-for-console-having-all-permissions.patch
+++ b/patches/unapplied/server/Add-option-for-console-having-all-permissions.patch
@ -1,47 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Sat, 16 May 2020 10:12:15 +0200
-Subject: [PATCH] Add option for console having all permissions
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java
-+++ b/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java
-@@ -0,0 +0,0 @@ public class CraftConsoleCommandSender extends ServerCommandSender implements Co
-     public void sendMessage(final net.kyori.adventure.identity.Identity identity, final net.kyori.adventure.text.Component message, final net.kyori.adventure.audience.MessageType type) {
-         this.sendRawMessage(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().serialize(message));
-     }
-+
-+    @Override
-+    public boolean hasPermission(String name) {
-+        return io.papermc.paper.configuration.GlobalConfiguration.get().console.hasAllPermissions || super.hasPermission(name);
-+    }
-+
-+    @Override
-+    public boolean hasPermission(org.bukkit.permissions.Permission perm) {
-+        return io.papermc.paper.configuration.GlobalConfiguration.get().console.hasAllPermissions || super.hasPermission(perm);
-+    }
-     // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java
-+++ b/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java
-@@ -0,0 +0,0 @@ public class CraftRemoteConsoleCommandSender extends ServerCommandSender impleme
-     public void setOp(boolean value) {
-         throw new UnsupportedOperationException("Cannot change operator status of remote controller.");
-     }
-+
-+    // Paper start
-+    @Override
-+    public boolean hasPermission(String name) {
-+        return io.papermc.paper.configuration.GlobalConfiguration.get().console.hasAllPermissions || super.hasPermission(name);
-+    }
-+
-+    @Override
-+    public boolean hasPermission(org.bukkit.permissions.Permission perm) {
-+        return io.papermc.paper.configuration.GlobalConfiguration.get().console.hasAllPermissions || super.hasPermission(perm);
-+    }
-+    // Paper end
- }
--- a/patches/unapplied/server/Add-option-to-allow-iron-golems-to-spawn-in-air.patch
+++ b/patches/unapplied/server/Add-option-to-allow-iron-golems-to-spawn-in-air.patch
@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <blake.galbreath@gmail.com>
-Date: Sat, 13 Apr 2019 16:50:58 -0500
-Subject: [PATCH] Add option to allow iron golems to spawn in air
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/animal/IronGolem.java b/src/main/java/net/minecraft/world/entity/animal/IronGolem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/animal/IronGolem.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/IronGolem.java
-@@ -0,0 +0,0 @@ public class IronGolem extends AbstractGolem implements NeutralMob {
-         BlockPos blockposition1 = blockposition.below();
-         BlockState iblockdata = world.getBlockState(blockposition1);
- 
-        if (!iblockdata.entityCanStandOn(world, blockposition1, this)) {
-+        if (!iblockdata.entityCanStandOn(world, blockposition1, this) && !this.level().paperConfig().entities.spawning.ironGolemsCanSpawnInAir) { // Paper - Add option to allow iron golems to spawn in air
-             return false;
-         } else {
-             for (int i = 1; i < 3; ++i) {
--- a/patches/unapplied/server/Add-option-to-disable-pillager-patrols.patch
+++ b/patches/unapplied/server/Add-option-to-disable-pillager-patrols.patch
@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <blake.galbreath@gmail.com>
-Date: Wed, 9 Oct 2019 21:46:15 -0500
-Subject: [PATCH] Add option to disable pillager patrols
-
-
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
-@@ -0,0 +0,0 @@ public class PatrolSpawner implements CustomSpawner {
- 
-     @Override
-     public int tick(ServerLevel world, boolean spawnMonsters, boolean spawnAnimals) {
-+        if (world.paperConfig().entities.behavior.pillagerPatrols.disable) return 0; // Paper - Add option to disable pillager patrols
-         if (!spawnMonsters) {
-             return 0;
-         } else if (!world.getGameRules().getBoolean(GameRules.RULE_DO_PATROL_SPAWNING)) {
--- a/patches/unapplied/server/Add-option-to-nerf-pigmen-from-nether-portals.patch
+++ b/patches/unapplied/server/Add-option-to-nerf-pigmen-from-nether-portals.patch
@ -1,49 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 7 Feb 2020 14:36:56 -0600
-Subject: [PATCH] Add option to nerf pigmen from nether portals
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     public void inactiveTick() { }
-     // Spigot end
-     protected int numCollisions = 0; // Paper - Cap entity collisions
-+    public boolean fromNetherPortal; // Paper - Add option to nerf pigmen from nether portals
-     public boolean spawnedViaMobSpawner; // Paper - Yes this name is similar to above, upstream took the better one
-     // Paper start - Entity origin API
-     @javax.annotation.Nullable
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-             if (spawnedViaMobSpawner) {
-                 nbttagcompound.putBoolean("Paper.FromMobSpawner", true);
-             }
-+            if (fromNetherPortal) {
-+                nbttagcompound.putBoolean("Paper.FromNetherPortal", true);
-+            }
-             // Paper end
-             return nbttagcompound;
-         } catch (Throwable throwable) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-             }
- 
-             spawnedViaMobSpawner = nbt.getBoolean("Paper.FromMobSpawner"); // Restore entity's from mob spawner status
-+            fromNetherPortal = nbt.getBoolean("Paper.FromNetherPortal");
-             if (nbt.contains("Paper.SpawnReason")) {
-                 String spawnReasonName = nbt.getString("Paper.SpawnReason");
-                 try {
-diff --git a/src/main/java/net/minecraft/world/level/block/NetherPortalBlock.java b/src/main/java/net/minecraft/world/level/block/NetherPortalBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/NetherPortalBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/NetherPortalBlock.java
-@@ -0,0 +0,0 @@ public class NetherPortalBlock extends Block {
- 
-                 if (entity != null) {
-                     entity.setPortalCooldown();
-+                    entity.fromNetherPortal = true; // Paper - Add option to nerf pigmen from nether portals
-+                    if (world.paperConfig().entities.behavior.nerfPigmenFromNetherPortals) ((net.minecraft.world.entity.Mob) entity).aware = false; // Paper - Add option to nerf pigmen from nether portals
-                 }
-             }
-         }
--- a/patches/unapplied/server/Add-permission-for-command-blocks.patch
+++ b/patches/unapplied/server/Add-permission-for-command-blocks.patch
@ -1,79 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Sat, 16 May 2020 10:05:30 +0200
-Subject: [PATCH] Add permission for command blocks
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-             BlockEntity tileentity = this.level.getBlockEntity(pos);
-             Block block = iblockdata.getBlock();
- 
-            if (block instanceof GameMasterBlock && !this.player.canUseGameMasterBlocks()) {
-+            if (block instanceof GameMasterBlock && !this.player.canUseGameMasterBlocks() && !(block instanceof net.minecraft.world.level.block.CommandBlock && (this.player.isCreative() && this.player.getBukkitEntity().hasPermission("minecraft.commandblock")))) { // Paper - command block permission
-                 this.level.sendBlockUpdated(pos, iblockdata, iblockdata, 3);
-                 return false;
-             } else if (this.player.blockActionRestricted(this.level, pos, this.gameModeForPlayer)) {
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
-         if (!this.server.isCommandBlockEnabled()) {
-             this.player.sendSystemMessage(Component.translatable("advMode.notEnabled"));
-        } else if (!this.player.canUseGameMasterBlocks()) {
-+        } else if (!this.player.canUseGameMasterBlocks() && (!this.player.isCreative() || !this.player.getBukkitEntity().hasPermission("minecraft.commandblock"))) { // Paper - command block permission
-             this.player.sendSystemMessage(Component.translatable("advMode.notAllowed"));
-         } else {
-             BaseCommandBlock commandblocklistenerabstract = null;
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
-         if (!this.server.isCommandBlockEnabled()) {
-             this.player.sendSystemMessage(Component.translatable("advMode.notEnabled"));
-        } else if (!this.player.canUseGameMasterBlocks()) {
-+        } else if (!this.player.canUseGameMasterBlocks() && (!this.player.isCreative() || !this.player.getBukkitEntity().hasPermission("minecraft.commandblock"))) { // Paper - command block permission
-             this.player.sendSystemMessage(Component.translatable("advMode.notAllowed"));
-         } else {
-             BaseCommandBlock commandblocklistenerabstract = packet.getCommandBlock(this.player.level());
-diff --git a/src/main/java/net/minecraft/world/level/BaseCommandBlock.java b/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
-+++ b/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
-@@ -0,0 +0,0 @@ public abstract class BaseCommandBlock implements CommandSource {
-     }
- 
-     public InteractionResult usedBy(Player player) {
-        if (!player.canUseGameMasterBlocks()) {
-+        if (!player.canUseGameMasterBlocks() && (!player.isCreative() || !player.getBukkitEntity().hasPermission("minecraft.commandblock"))) { // Paper - command block permission
-             return InteractionResult.PASS;
-         } else {
-             if (player.getCommandSenderWorld().isClientSide) {
-diff --git a/src/main/java/net/minecraft/world/level/block/CommandBlock.java b/src/main/java/net/minecraft/world/level/block/CommandBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/CommandBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/CommandBlock.java
-@@ -0,0 +0,0 @@ public class CommandBlock extends BaseEntityBlock implements GameMasterBlock {
-     protected InteractionResult useWithoutItem(BlockState state, Level world, BlockPos pos, Player player, BlockHitResult hit) {
-         BlockEntity tileentity = world.getBlockEntity(pos);
- 
-        if (tileentity instanceof CommandBlockEntity && player.canUseGameMasterBlocks()) {
-+        if (tileentity instanceof CommandBlockEntity && (player.canUseGameMasterBlocks() || (player.isCreative() && player.getBukkitEntity().hasPermission("minecraft.commandblock")))) { // Paper - command block permission
-             player.openCommandBlock((CommandBlockEntity) tileentity);
-             return InteractionResult.sidedSuccess(world.isClientSide);
-         } else {
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java b/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java
-@@ -0,0 +0,0 @@ public final class CraftDefaultPermissions {
-         DefaultPermissions.registerPermission(CraftDefaultPermissions.ROOT + ".nbt.copy", "Gives the user the ability to copy NBT in creative", org.bukkit.permissions.PermissionDefault.TRUE, parent);
-         DefaultPermissions.registerPermission(CraftDefaultPermissions.ROOT + ".debugstick", "Gives the user the ability to use the debug stick in creative", org.bukkit.permissions.PermissionDefault.OP, parent);
-         DefaultPermissions.registerPermission(CraftDefaultPermissions.ROOT + ".debugstick.always", "Gives the user the ability to use the debug stick in all game modes", org.bukkit.permissions.PermissionDefault.FALSE/* , parent */); // Paper - should not have this parent, as it's not a "vanilla" utility
-+        DefaultPermissions.registerPermission(CraftDefaultPermissions.ROOT + ".commandblock", "Gives the user the ability to use command blocks.", org.bukkit.permissions.PermissionDefault.OP, parent); // Paper
-         // Spigot end
-         parent.recalculatePermissibles();
-     }
--- a/patches/unapplied/server/Add-phantom-creative-and-insomniac-controls.patch
+++ b/patches/unapplied/server/Add-phantom-creative-and-insomniac-controls.patch
@ -1,43 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Sat, 25 Apr 2020 15:13:41 -0500
-Subject: [PATCH] Add phantom creative and insomniac controls
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntitySelector.java b/src/main/java/net/minecraft/world/entity/EntitySelector.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/EntitySelector.java
-+++ b/src/main/java/net/minecraft/world/entity/EntitySelector.java
-@@ -0,0 +0,0 @@ public final class EntitySelector {
-         return !entity.isSpectator();
-     };
-     public static final Predicate<Entity> CAN_BE_COLLIDED_WITH = EntitySelector.NO_SPECTATORS.and(Entity::canBeCollidedWith);
-+    public static Predicate<Player> IS_INSOMNIAC = (player) -> net.minecraft.util.Mth.clamp(((net.minecraft.server.level.ServerPlayer) player).getStats().getValue(net.minecraft.stats.Stats.CUSTOM.get(net.minecraft.stats.Stats.TIME_SINCE_REST)), 1, Integer.MAX_VALUE) >= 72000; // Paper - Add phantom creative and insomniac controls
- 
-     private EntitySelector() {}
-     // Paper start - Affects Spawning API
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Phantom.java b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/monster/Phantom.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
-@@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
-                         Player entityhuman = (Player) iterator.next();
- 
-                         if (Phantom.this.canAttack(entityhuman, TargetingConditions.DEFAULT)) {
-+                            if (!level().paperConfig().entities.behavior.phantomsOnlyAttackInsomniacs || EntitySelector.IS_INSOMNIAC.test(entityhuman)) // Paper - Add phantom creative and insomniac controls
-                             Phantom.this.setTarget(entityhuman, org.bukkit.event.entity.EntityTargetEvent.TargetReason.CLOSEST_PLAYER, true); // CraftBukkit - reason
-                             return true;
-                         }
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
-@@ -0,0 +0,0 @@ public class PhantomSpawner implements CustomSpawner {
-                     while (iterator.hasNext()) {
-                         ServerPlayer entityplayer = (ServerPlayer) iterator.next();
- 
-                        if (!entityplayer.isSpectator()) {
-+                        if (!entityplayer.isSpectator() && (!world.paperConfig().entities.behavior.phantomsDoNotSpawnOnCreativePlayers || !entityplayer.isCreative())) { // Paper - Add phantom creative and insomniac controls
-                             BlockPos blockposition = entityplayer.blockPosition();
- 
-                             if (!world.dimensionType().hasSkyLight() || blockposition.getY() >= world.getSeaLevel() && world.canSeeSky(blockposition)) {
--- a/patches/unapplied/server/Add-tick-times-API-and-mspt-command.patch
+++ b/patches/unapplied/server/Add-tick-times-API-and-mspt-command.patch
@ -1,206 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 5 Apr 2020 22:23:14 -0500
-Subject: [PATCH] Add tick times API and /mspt command
-
-
-diff --git a/src/main/java/io/papermc/paper/command/MSPTCommand.java b/src/main/java/io/papermc/paper/command/MSPTCommand.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/io/papermc/paper/command/MSPTCommand.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.command;
-+
-+import net.kyori.adventure.text.Component;
-+import net.minecraft.server.MinecraftServer;
-+import org.bukkit.Location;
-+import org.bukkit.command.Command;
-+import org.bukkit.command.CommandSender;
-+
-+import java.text.DecimalFormat;
-+import java.util.ArrayList;
-+import java.util.Arrays;
-+import java.util.Collections;
-+import java.util.List;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+import org.checkerframework.framework.qual.DefaultQualifier;
-+
-+import static net.kyori.adventure.text.Component.text;
-+import static net.kyori.adventure.text.format.NamedTextColor.GOLD;
-+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.YELLOW;
-+
-+@DefaultQualifier(NonNull.class)
-+public final class MSPTCommand extends Command {
-+    private static final DecimalFormat DF = new DecimalFormat("########0.0");
-+    private static final Component SLASH = text("/");
-+
-+    public MSPTCommand(final String name) {
-+        super(name);
-+        this.description = "View server tick times";
-+        this.usageMessage = "/mspt";
-+        this.setPermission("bukkit.command.mspt");
-+    }
-+
-+    @Override
-+    public List<String> tabComplete(CommandSender sender, String alias, String[] args, Location location) throws IllegalArgumentException {
-+        return Collections.emptyList();
-+    }
-+
-+    @Override
-+    public boolean execute(CommandSender sender, String commandLabel, String[] args) {
-+        if (!testPermission(sender)) return true;
-+
-+        MinecraftServer server = MinecraftServer.getServer();
-+
-+        List<Component> times = new ArrayList<>();
-+        times.addAll(eval(server.tickTimes5s.getTimes()));
-+        times.addAll(eval(server.tickTimes10s.getTimes()));
-+        times.addAll(eval(server.tickTimes60s.getTimes()));
-+
-+        sender.sendMessage(text().content("Server tick times ").color(GOLD)
-+            .append(text().color(YELLOW)
-+                .append(
-+                    text("("),
-+                    text("avg", GRAY),
-+                    text("/"),
-+                    text("min", GRAY),
-+                    text("/"),
-+                    text("max", GRAY),
-+                    text(")")
-+                )
-+            ).append(
-+                text(" from last 5s"),
-+                text(",", GRAY),
-+                text(" 10s"),
-+                text(",", GRAY),
-+                text(" 1m"),
-+                text(":", YELLOW)
-+            )
-+        );
-+        sender.sendMessage(text().content("◴ ").color(GOLD)
-+            .append(text().color(GRAY)
-+                .append(
-+                    times.get(0), SLASH, times.get(1), SLASH, times.get(2), text(", ", YELLOW),
-+                    times.get(3), SLASH, times.get(4), SLASH, times.get(5), text(", ", YELLOW),
-+                    times.get(6), SLASH, times.get(7), SLASH, times.get(8)
-+                )
-+            )
-+        );
-+        return true;
-+    }
-+
-+    private static List<Component> eval(long[] times) {
-+        long min = Integer.MAX_VALUE;
-+        long max = 0L;
-+        long total = 0L;
-+        for (long value : times) {
-+            if (value > 0L && value < min) min = value;
-+            if (value > max) max = value;
-+            total += value;
-+        }
-+        double avgD = ((double) total / (double) times.length) * 1.0E-6D;
-+        double minD = ((double) min) * 1.0E-6D;
-+        double maxD = ((double) max) * 1.0E-6D;
-+        return Arrays.asList(getColor(avgD), getColor(minD), getColor(maxD));
-+    }
-+
-+    private static Component getColor(double avg) {
-+        return text(DF.format(avg), avg >= 50 ? RED : avg >= 40 ? YELLOW : GREEN);
-+    }
-+}
-diff --git a/src/main/java/io/papermc/paper/command/PaperCommands.java b/src/main/java/io/papermc/paper/command/PaperCommands.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/io/papermc/paper/command/PaperCommands.java
-+++ b/src/main/java/io/papermc/paper/command/PaperCommands.java
-@@ -0,0 +0,0 @@ public final class PaperCommands {
-     static {
-         COMMANDS.put("paper", new PaperCommand("paper"));
-         COMMANDS.put("callback", new CallbackCommand("callback"));
-+        COMMANDS.put("mspt", new MSPTCommand("mspt"));
-     }
- 
-     public static void registerCommands(final MinecraftServer server) {
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-     private int playerIdleTimeout;
-     private final long[] tickTimesNanos;
-     private long aggregatedTickTimesNanos;
-+    // Paper start - Add tick times API and /mspt command
-+    public final TickTimes tickTimes5s = new TickTimes(100);
-+    public final TickTimes tickTimes10s = new TickTimes(200);
-+    public final TickTimes tickTimes60s = new TickTimes(1200);
-+    // Paper end - Add tick times API and /mspt command
-     @Nullable
-     private KeyPair keyPair;
-     @Nullable
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         this.aggregatedTickTimesNanos += j;
-         this.tickTimesNanos[k] = j;
-         this.smoothedTickTimeMillis = this.smoothedTickTimeMillis * 0.8F + (float) j / (float) TimeUtil.NANOSECONDS_PER_MILLISECOND * 0.19999999F;
-+        // Paper start - Add tick times API and /mspt command
-+        this.tickTimes5s.add(this.tickCount, j);
-+        this.tickTimes10s.add(this.tickCount, j);
-+        this.tickTimes60s.add(this.tickCount, j);
-+        // Paper end - Add tick times API and /mspt command
-         this.logTickMethodTime(i);
-         this.profiler.pop();
-         org.spigotmc.WatchdogThread.tick(); // Spigot
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-     public static record ServerResourcePackInfo(UUID id, String url, String hash, boolean isRequired, @Nullable Component prompt) {
- 
-     }
-+
-+    // Paper start - Add tick times API and /mspt command
-+    public static class TickTimes {
-+        private final long[] times;
-+
-+        public TickTimes(int length) {
-+            times = new long[length];
-+        }
-+
-+        void add(int index, long time) {
-+            times[index % times.length] = time;
-+        }
-+
-+        public long[] getTimes() {
-+            return times.clone();
-+        }
-+
-+        public double getAverage() {
-+            long total = 0L;
-+            for (long value : times) {
-+                total += value;
-+            }
-+            return ((double) total / (double) times.length) * 1.0E-6D;
-+        }
-+    }
-+    // Paper end - Add tick times API and /mspt command
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         return CraftMagicNumbers.INSTANCE;
-     }
- 
-+    @Override
-+    public long[] getTickTimes() {
-+        return this.getServer().tickTimes5s.getTimes();
-+    }
-+
-+    @Override
-+    public double getAverageTickTime() {
-+        return this.getServer().tickTimes5s.getAverage();
-+    }
-+
-     // Spigot start
-     private final org.bukkit.Server.Spigot spigot = new org.bukkit.Server.Spigot()
-     {
--- a/patches/unapplied/server/Add-villager-reputation-API.patch
+++ b/patches/unapplied/server/Add-villager-reputation-API.patch
@ -1,122 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Wed, 22 Apr 2020 23:29:20 +0200
-Subject: [PATCH] Add villager reputation API
-
-== AT ==
-public net.minecraft.world.entity.ai.gossip.GossipContainer$EntityGossips
-public net.minecraft.world.entity.ai.gossip.GossipContainer$EntityGossips <init>()V
-public net.minecraft.world.entity.ai.gossip.GossipContainer gossips
-
-diff --git a/src/main/java/net/minecraft/world/entity/ai/gossip/GossipContainer.java b/src/main/java/net/minecraft/world/entity/ai/gossip/GossipContainer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/ai/gossip/GossipContainer.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/gossip/GossipContainer.java
-@@ -0,0 +0,0 @@ public class GossipContainer {
-         public void remove(GossipType gossipType) {
-             this.entries.removeInt(gossipType);
-         }
-+
-+        // Paper start - Add villager reputation API
-+        private static final GossipType[] TYPES = GossipType.values();
-+        public com.destroystokyo.paper.entity.villager.Reputation getPaperReputation() {
-+            Map<com.destroystokyo.paper.entity.villager.ReputationType, Integer> map = new java.util.EnumMap<>(com.destroystokyo.paper.entity.villager.ReputationType.class);
-+            for (Object2IntMap.Entry<GossipType> type : this.entries.object2IntEntrySet()) {
-+                map.put(toApi(type.getKey()), type.getIntValue());
-+            }
-+
-+            return new com.destroystokyo.paper.entity.villager.Reputation(map);
-+        }
-+
-+        public void assignFromPaperReputation(com.destroystokyo.paper.entity.villager.Reputation rep) {
-+            for (GossipType type : TYPES) {
-+                com.destroystokyo.paper.entity.villager.ReputationType api = toApi(type);
-+
-+                if (rep.hasReputationSet(api)) {
-+                    int reputation = rep.getReputation(api);
-+                    if (reputation == 0) {
-+                        this.entries.removeInt(type);
-+                    } else {
-+                        this.entries.put(type, reputation);
-+                    }
-+                }
-+            }
-+        }
-+
-+        private static com.destroystokyo.paper.entity.villager.ReputationType toApi(GossipType type) {
-+            return switch (type) {
-+                case MAJOR_NEGATIVE -> com.destroystokyo.paper.entity.villager.ReputationType.MAJOR_NEGATIVE;
-+                case MINOR_NEGATIVE -> com.destroystokyo.paper.entity.villager.ReputationType.MINOR_NEGATIVE;
-+                case MINOR_POSITIVE -> com.destroystokyo.paper.entity.villager.ReputationType.MINOR_POSITIVE;
-+                case MAJOR_POSITIVE -> com.destroystokyo.paper.entity.villager.ReputationType.MAJOR_POSITIVE;
-+                case TRADING -> com.destroystokyo.paper.entity.villager.ReputationType.TRADING;
-+            };
-+        }
-+        // Paper end - Add villager reputation API
-     }
- 
-     static record GossipEntry(UUID target, GossipType type, int value) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
-@@ -0,0 +0,0 @@ import org.bukkit.entity.Villager;
- import org.bukkit.entity.ZombieVillager;
- import org.bukkit.event.entity.CreatureSpawnEvent;
- 
-+// Paper start
-+import com.destroystokyo.paper.entity.villager.Reputation;
-+import com.google.common.collect.Maps;
-+import java.util.Map;
-+import java.util.UUID;
-+// Paper end
-+
- public class CraftVillager extends CraftAbstractVillager implements Villager {
- 
-     public CraftVillager(CraftServer server, net.minecraft.world.entity.npc.Villager entity) {
-@@ -0,0 +0,0 @@ public class CraftVillager extends CraftAbstractVillager implements Villager {
-                     .getOptional(CraftNamespacedKey.toMinecraft(bukkit.getKey())).orElseThrow();
-         }
-     }
-+
-+    // Paper start - Add villager reputation API
-+    @Override
-+    public Reputation getReputation(UUID uniqueId) {
-+        net.minecraft.world.entity.ai.gossip.GossipContainer.EntityGossips rep = getHandle().getGossips().gossips.get(uniqueId);
-+        if (rep == null) {
-+            return new Reputation(new java.util.EnumMap<>(com.destroystokyo.paper.entity.villager.ReputationType.class));
-+        }
-+
-+        return rep.getPaperReputation();
-+    }
-+
-+    @Override
-+    public Map<UUID, Reputation> getReputations() {
-+        return getHandle().getGossips().gossips.entrySet()
-+            .stream()
-+            .collect(java.util.stream.Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().getPaperReputation()));
-+    }
-+
-+    @Override
-+    public void setReputation(UUID uniqueId, Reputation reputation) {
-+        net.minecraft.world.entity.ai.gossip.GossipContainer.EntityGossips nmsReputation =
-+            getHandle().getGossips().gossips.computeIfAbsent(
-+                uniqueId,
-+                key -> new net.minecraft.world.entity.ai.gossip.GossipContainer.EntityGossips()
-+            );
-+        nmsReputation.assignFromPaperReputation(reputation);
-+    }
-+
-+    @Override
-+    public void setReputations(Map<UUID, Reputation> reputations) {
-+        for (Map.Entry<UUID, Reputation> entry : reputations.entrySet()) {
-+            setReputation(entry.getKey(), entry.getValue());
-+        }
-+    }
-+
-+    @Override
-+    public void clearReputations() {
-+        getHandle().getGossips().gossips.clear();
-+    }
-+    // Paper end
- }
--- a/patches/unapplied/server/Alternative-item-despawn-rate.patch
+++ b/patches/unapplied/server/Alternative-item-despawn-rate.patch
@ -1,63 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: kickash32 <kickash32@gmail.com>
-Date: Mon, 3 Jun 2019 02:02:39 -0400
-Subject: [PATCH] Alternative item-despawn-rate
-
-Co-authored-by: Noah van der Aa <ndvdaa@gmail.com>
-
-diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-@@ -0,0 +0,0 @@ public class ItemEntity extends Entity implements TraceableEntity {
-     public final float bobOffs;
-     private int lastTick = MinecraftServer.currentTick - 1; // CraftBukkit
-     public boolean canMobPickup = true; // Paper - Item#canEntityPickup
-+    private int despawnRate = -1; // Paper - Alternative item-despawn-rate
- 
-     public ItemEntity(EntityType<? extends ItemEntity> type, Level world) {
-         super(type, world);
-@@ -0,0 +0,0 @@ public class ItemEntity extends Entity implements TraceableEntity {
-                 }
-             }
- 
-            if (!this.level().isClientSide && this.age >= this.level().spigotConfig.itemDespawnRate) { // Spigot
-+            if (!this.level().isClientSide && this.age >= this.despawnRate) { // Spigot // Paper - Alternative item-despawn-rate
-                 // CraftBukkit start - fire ItemDespawnEvent
-                 if (CraftEventFactory.callItemDespawnEvent(this).isCancelled()) {
-                     this.age = 0;
-@@ -0,0 +0,0 @@ public class ItemEntity extends Entity implements TraceableEntity {
-         this.lastTick = MinecraftServer.currentTick;
-         // CraftBukkit end
- 
-        if (!this.level().isClientSide && this.age >= this.level().spigotConfig.itemDespawnRate) { // Spigot
-+        if (!this.level().isClientSide && this.age >= this.despawnRate) { // Spigot // Paper - Alternative item-despawn-rate
-             // CraftBukkit start - fire ItemDespawnEvent
-             if (org.bukkit.craftbukkit.event.CraftEventFactory.callItemDespawnEvent(this).isCancelled()) {
-                 this.age = 0;
-@@ -0,0 +0,0 @@ public class ItemEntity extends Entity implements TraceableEntity {
-     private boolean isMergable() {
-         ItemStack itemstack = this.getItem();
- 
-        return this.isAlive() && this.pickupDelay != 32767 && this.age != -32768 && this.age < 6000 && itemstack.getCount() < itemstack.getMaxStackSize();
-+        return this.isAlive() && this.pickupDelay != 32767 && this.age != -32768 && this.age < this.despawnRate && itemstack.getCount() < itemstack.getMaxStackSize(); // Paper - Alternative item-despawn-rate
-     }
- 
-     private void tryToMerge(ItemEntity other) {
-@@ -0,0 +0,0 @@ public class ItemEntity extends Entity implements TraceableEntity {
- 
-     public void setItem(ItemStack stack) {
-         this.getEntityData().set(ItemEntity.DATA_ITEM, stack);
-+        this.despawnRate = this.level().paperConfig().entities.spawning.altItemDespawnRate.enabled ? this.level().paperConfig().entities.spawning.altItemDespawnRate.items.getOrDefault(stack.getItem(), this.level().spigotConfig.itemDespawnRate) : this.level().spigotConfig.itemDespawnRate; // Paper - Alternative item-despawn-rate
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class ItemEntity extends Entity implements TraceableEntity {
- 
-     public void makeFakeItem() {
-         this.setNeverPickUp();
-        this.age = this.level().spigotConfig.itemDespawnRate - 1; // Spigot
-+        this.age = this.despawnRate - 1; // Spigot // Paper - Alternative item-despawn-rate
-     }
- 
-     public float getSpin(float tickDelta) {
--- a/patches/unapplied/server/Bees-get-gravity-in-void.-Fixes-MC-167279.patch
+++ b/patches/unapplied/server/Bees-get-gravity-in-void.-Fixes-MC-167279.patch
@ -1,34 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 26 Jan 2020 16:30:19 -0600
-Subject: [PATCH] Bees get gravity in void. Fixes MC-167279
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/animal/Bee.java b/src/main/java/net/minecraft/world/entity/animal/Bee.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/animal/Bee.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java
-@@ -0,0 +0,0 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
-     public Bee(EntityType<? extends Bee> type, Level world) {
-         super(type, world);
-         this.remainingCooldownBeforeLocatingNewFlower = Mth.nextInt(this.random, 20, 60);
-        this.moveControl = new FlyingMoveControl(this, 20, true);
-+        // Paper start - Fix MC-167279
-+        class BeeFlyingMoveControl extends FlyingMoveControl {
-+            public BeeFlyingMoveControl(final Mob entity, final int maxPitchChange, final boolean noGravity) {
-+                super(entity, maxPitchChange, noGravity);
-+            }
-+
-+            @Override
-+            public void tick() {
-+                if (this.mob.getY() <= Bee.this.level().getMinBuildHeight()) {
-+                    this.mob.setNoGravity(false);
-+                }
-+                super.tick();
-+            }
-+        }
-+        this.moveControl = new BeeFlyingMoveControl(this, 20, true);
-+        // Paper end - Fix MC-167279
-         this.lookControl = new Bee.BeeLookControl(this);
-         this.setPathfindingMalus(PathType.DANGER_FIRE, -1.0F);
-         this.setPathfindingMalus(PathType.WATER, -1.0F);
--- a/patches/unapplied/server/Call-WhitelistToggleEvent-when-whitelist-is-toggled.patch
+++ b/patches/unapplied/server/Call-WhitelistToggleEvent-when-whitelist-is-toggled.patch
@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
-Date: Wed, 13 Mar 2019 20:08:09 +0200
-Subject: [PATCH] Call WhitelistToggleEvent when whitelist is toggled
-
-
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-     }
- 
-     public void setUsingWhiteList(boolean whitelistEnabled) {
-+        new com.destroystokyo.paper.event.server.WhitelistToggleEvent(whitelistEnabled).callEvent(); // Paper - WhitelistToggleEvent
-         this.doWhiteList = whitelistEnabled;
-     }
- 
--- a/patches/unapplied/server/Configurable-chance-of-villager-zombie-infection.patch
+++ b/patches/unapplied/server/Configurable-chance-of-villager-zombie-infection.patch
@ -1,26 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zero <zero@cock.li>
-Date: Sat, 22 Feb 2020 16:10:31 -0500
-Subject: [PATCH] Configurable chance of villager zombie infection
-
-This allows you to solve an issue in vanilla behavior where:
-* On easy difficulty your villagers will NEVER get infected, meaning they will always die.
-* On normal difficulty they will have a 50% of getting infected or dying.
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Zombie.java b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
-@@ -0,0 +0,0 @@ public class Zombie extends Monster {
-     public boolean killedEntity(ServerLevel world, LivingEntity other) {
-         boolean flag = super.killedEntity(world, other);
- 
-        if ((world.getDifficulty() == Difficulty.NORMAL || world.getDifficulty() == Difficulty.HARD) && other instanceof Villager entityvillager) {
-            if (world.getDifficulty() != Difficulty.HARD && this.random.nextBoolean()) {
-                return flag;
-            }
-+        final double fallbackChance = world.getDifficulty() == Difficulty.HARD ? 100d : world.getDifficulty() == Difficulty.NORMAL ? 50d : 0d; // Paper - Configurable chance of villager zombie infection
-+        if (this.random.nextDouble() * 100 < world.paperConfig().entities.behavior.zombieVillagerInfectionChance.or(fallbackChance) && other instanceof Villager entityvillager) { // Paper - Configurable chance of villager zombie infection
-             // CraftBukkit start
-             flag = Zombie.zombifyVillager(world, entityvillager, this.blockPosition(), this.isSilent(), CreatureSpawnEvent.SpawnReason.INFECTION) == null;
-         }
--- a/patches/unapplied/server/Configurable-projectile-relative-velocity.patch
+++ b/patches/unapplied/server/Configurable-projectile-relative-velocity.patch
@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Lucavon <lucavonlp@gmail.com>
-Date: Tue, 23 Jul 2019 20:29:20 -0500
-Subject: [PATCH] Configurable projectile relative velocity
-
-This patch adds an option "disable relative projectile velocity", which, when
-enabled, will cause projectiles to ignore the shooter's current velocity,
-like they did in Minecraft 1.8 and prior.
-If a player is falling, for example, their shooting range will be drastically
-reduced, as a downwards velocity is applied to the projectile. This prevents
-players from saving themselves from falling off floating islands, for example,
-as a thrown ender pearl will not make it back to the island, while it would
-have in 1.8.
-
-While this could easily be done with plugins, too, there are multiple problems:
-P1) If multiple plugins cancel the velocity by subtracting the shooter's velocity
-from the projectile's velocity, the projectile's velocity would be different.
-As there's no way to detect whether the projectile's velocity has already been
-adjusted to ignore the player's velocity, plugins can't not do it if it's not
-necessary.
-P2) I've noticed some inconsistencies, e.g. weird velocity when shooting while
-using an elytra. Checking for those inconsistencies is possible, but not as
-efficient as just not applying the velocity in the first place.
-P3) Solutions for 1) and especially 2) might not be future-proof, while this
-server-internal fix makes this change future-proof.
-
-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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-@@ -0,0 +0,0 @@ public abstract class Projectile extends Entity implements TraceableEntity {
-         this.shoot((double) f5, (double) f6, (double) f7, speed, divergence);
-         Vec3 vec3d = shooter.getDeltaMovement();
- 
-        this.setDeltaMovement(this.getDeltaMovement().add(vec3d.x, shooter.onGround() ? 0.0D : vec3d.y, vec3d.z));
-+        if (!shooter.level().paperConfig().misc.disableRelativeProjectileVelocity) this.setDeltaMovement(this.getDeltaMovement().add(vec3d.x, shooter.onGround() ? 0.0D : vec3d.y, vec3d.z)); // Paper - allow disabling relative velocity
-     }
- 
-     // CraftBukkit start - call projectile hit event
--- a/patches/unapplied/server/Convert-legacy-attributes-in-Item-Meta.patch
+++ b/patches/unapplied/server/Convert-legacy-attributes-in-Item-Meta.patch
@ -1,44 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 1 Jul 2020 04:50:22 -0400
-Subject: [PATCH] Convert legacy attributes in Item Meta
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/attribute/CraftAttributeMap.java b/src/main/java/org/bukkit/craftbukkit/attribute/CraftAttributeMap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/attribute/CraftAttributeMap.java
-+++ b/src/main/java/org/bukkit/craftbukkit/attribute/CraftAttributeMap.java
-@@ -0,0 +0,0 @@ import org.bukkit.attribute.AttributeInstance;
- public class CraftAttributeMap implements Attributable {
- 
-     private final AttributeMap handle;
-+    // Paper start - convert legacy attributes
-+    private static final com.google.common.collect.ImmutableMap<String, String> legacyNMS = com.google.common.collect.ImmutableMap.<String, String>builder().put("generic.maxHealth", "generic.max_health").put("Max Health", "generic.max_health").put("zombie.spawnReinforcements", "zombie.spawn_reinforcements").put("Spawn Reinforcements Chance", "zombie.spawn_reinforcements").put("horse.jumpStrength", "horse.jump_strength").put("Jump Strength", "horse.jump_strength").put("generic.followRange", "generic.follow_range").put("Follow Range", "generic.follow_range").put("generic.knockbackResistance", "generic.knockback_resistance").put("Knockback Resistance", "generic.knockback_resistance").put("generic.movementSpeed", "generic.movement_speed").put("Movement Speed", "generic.movement_speed").put("generic.flyingSpeed", "generic.flying_speed").put("Flying Speed", "generic.flying_speed").put("generic.attackDamage", "generic.attack_damage").put("generic.attackKnockback", "generic.attack_knockback").put("generic.attackSpeed", "generic.attack_speed").put("generic.armorToughness", "generic.armor_toughness").build();
-+
-+    public static String convertIfNeeded(String nms) {
-+        if (nms == null) {
-+            return null;
-+        }
-+        nms = legacyNMS.getOrDefault(nms, nms);
-+        if (!nms.toLowerCase(java.util.Locale.ROOT).equals(nms) || nms.indexOf(' ') != -1) {
-+            return null;
-+        }
-+        return nms;
-+    }
-+    // Paper end
- 
-     public CraftAttributeMap(AttributeMap handle) {
-         this.handle = handle;
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
- 
-             AttributeModifier attribMod = CraftAttributeInstance.convert(nmsModifier);
- 
-            String attributeName = entry.getString(CraftMetaItem.ATTRIBUTES_IDENTIFIER.NBT);
-+            String attributeName = org.bukkit.craftbukkit.attribute.CraftAttributeMap.convertIfNeeded(entry.getString(CraftMetaItem.ATTRIBUTES_IDENTIFIER.NBT)); // Paper
-             if (attributeName == null || attributeName.isEmpty()) {
-                 continue;
-             }
--- a/patches/unapplied/server/Dead-Player-s-shouldn-t-be-able-to-move.patch
+++ b/patches/unapplied/server/Dead-Player-s-shouldn-t-be-able-to-move.patch
@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 2 Apr 2020 19:31:16 -0400
-Subject: [PATCH] Dead Player's shouldn't be able to move
-
-This fixes a lot of game state issues where packets were delayed for processing
-due to 1.15's new queue but processed while dead.
-
-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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
- 
-     @Override
-     protected boolean isImmobile() {
-        return super.isImmobile() || this.isSleeping();
-+        return super.isImmobile() || this.isSleeping() || this.isRemoved() || !valid; // Paper - player's who are dead or not in a world shouldn't move...
-     }
- 
-     @Override
--- a/patches/unapplied/server/Do-not-accept-invalid-client-settings.patch
+++ b/patches/unapplied/server/Do-not-accept-invalid-client-settings.patch
@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sat, 7 May 2022 14:58:53 -0700
-Subject: [PATCH] Do not accept invalid client settings
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-     @Override
-     public void handleClientInformation(ServerboundClientInformationPacket packet) {
-         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
-+        // Paper start - do not accept invalid information
-+        if (packet.information().viewDistance() < 0) {
-+            LOGGER.warn("Disconnecting " + this.player.getScoreboardName() + " for invalid view distance: " + packet.information().viewDistance());
-+            this.disconnect("Invalid client settings", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION);
-+            return;
-+        }
-+        // Paper end - do not accept invalid information
-         this.player.updateOptions(packet.information());
-         this.connection.channel.attr(io.papermc.paper.adventure.PaperAdventure.LOCALE_ATTRIBUTE).set(net.kyori.adventure.translation.Translator.parseLocale(packet.information().language())); // Paper
-     }
--- a/patches/unapplied/server/Do-not-allow-bees-to-load-chunks-for-beehives.patch
+++ b/patches/unapplied/server/Do-not-allow-bees-to-load-chunks-for-beehives.patch
@ -1,58 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: chickeneer <emcchickeneer@gmail.com>
-Date: Tue, 17 Mar 2020 14:18:50 -0500
-Subject: [PATCH] Do not allow bees to load chunks for beehives
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/animal/Bee.java b/src/main/java/net/minecraft/world/entity/animal/Bee.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/animal/Bee.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java
-@@ -0,0 +0,0 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
-         if (this.hivePos == null) {
-             return false;
-         } else {
-+            if (!this.level().isLoadedAndInBounds(this.hivePos)) return false; // Paper - Do not allow bees to load chunks for beehives
-             BlockEntity tileentity = this.level().getBlockEntity(this.hivePos);
- 
-             return tileentity instanceof BeehiveBlockEntity && ((BeehiveBlockEntity) tileentity).isFireNearby();
-@@ -0,0 +0,0 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
-     }
- 
-     private boolean doesHiveHaveSpace(BlockPos pos) {
-+        if (!this.level().isLoadedAndInBounds(pos)) return false; // Paper - Do not allow bees to load chunks for beehives
-         BlockEntity tileentity = this.level().getBlockEntity(pos);
- 
-         return tileentity instanceof BeehiveBlockEntity ? !((BeehiveBlockEntity) tileentity).isFull() : false;
-@@ -0,0 +0,0 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
-         @Override
-         public boolean canBeeUse() {
-             if (Bee.this.hasHive() && Bee.this.wantsToEnterHive() && Bee.this.hivePos.closerToCenterThan(Bee.this.position(), 2.0D)) {
-+                if (!Bee.this.level().isLoadedAndInBounds(Bee.this.hivePos)) return false; // Paper - Do not allow bees to load chunks for beehives
-                 BlockEntity tileentity = Bee.this.level().getBlockEntity(Bee.this.hivePos);
- 
-                 if (tileentity instanceof BeehiveBlockEntity) {
-@@ -0,0 +0,0 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
- 
-         @Override
-         public void start() {
-+            if (!Bee.this.level().isLoadedAndInBounds(Bee.this.hivePos)) return; // Paper - Do not allow bees to load chunks for beehives
-             BlockEntity tileentity = Bee.this.level().getBlockEntity(Bee.this.hivePos);
- 
-             if (tileentity instanceof BeehiveBlockEntity tileentitybeehive) {
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Vex.java b/src/main/java/net/minecraft/world/entity/monster/Vex.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/monster/Vex.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Vex.java
-@@ -0,0 +0,0 @@ public class Vex extends Monster implements TraceableEntity {
-             for (int i = 0; i < 3; ++i) {
-                 BlockPos blockposition1 = blockposition.offset(Vex.this.random.nextInt(15) - 7, Vex.this.random.nextInt(11) - 5, Vex.this.random.nextInt(15) - 7);
- 
-                if (Vex.this.level().isEmptyBlock(blockposition1)) {
-+                // Paper start - Don't load chunks
-+                final net.minecraft.world.level.block.state.BlockState blockState = Vex.this.level().getBlockStateIfLoaded(blockposition1);
-+                if (blockState != null && blockState.isAir()) {
-+                    // Paper end - Don't load chunks
-                     Vex.this.moveControl.setWantedPosition((double) blockposition1.getX() + 0.5D, (double) blockposition1.getY() + 0.5D, (double) blockposition1.getZ() + 0.5D, 0.25D);
-                     if (Vex.this.getTarget() == null) {
-                         Vex.this.getLookControl().setLookAt((double) blockposition1.getX() + 0.5D, (double) blockposition1.getY() + 0.5D, (double) blockposition1.getZ() + 0.5D, 180.0F, 20.0F);
--- a/patches/unapplied/server/Don-t-crash-if-player-is-attempted-to-be-removed-fro.patch
+++ b/patches/unapplied/server/Don-t-crash-if-player-is-attempted-to-be-removed-fro.patch
@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 18 Apr 2020 15:59:41 -0400
-Subject: [PATCH] Don't crash if player is attempted to be removed from
- untracked chunk.
-
-I suspect it deals with teleporting as it uses players current x/y/z
-
-diff --git a/src/main/java/net/minecraft/server/level/DistanceManager.java b/src/main/java/net/minecraft/server/level/DistanceManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/DistanceManager.java
-+++ b/src/main/java/net/minecraft/server/level/DistanceManager.java
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-         ObjectSet<ServerPlayer> objectset = (ObjectSet) this.playersPerChunk.get(i);
-         if (objectset == null) return; // CraftBukkit - SPIGOT-6208
- 
-        objectset.remove(player);
-        if (objectset.isEmpty()) {
-+        if (objectset != null) objectset.remove(player); // Paper - some state corruption happens here, don't crash, clean up gracefully
-+        if (objectset == null || objectset.isEmpty()) { // Paper
-             this.playersPerChunk.remove(i);
-             this.naturalSpawnChunkCounter.update(i, Integer.MAX_VALUE, false);
-             this.playerTicketManager.update(i, Integer.MAX_VALUE, false);
--- a/patches/unapplied/server/Don-t-fire-BlockFade-on-worldgen-threads.patch
+++ b/patches/unapplied/server/Don-t-fire-BlockFade-on-worldgen-threads.patch
@ -1,27 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 23 Apr 2020 01:36:39 -0400
-Subject: [PATCH] Don't fire BlockFade on worldgen threads
-
-
-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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/FireBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/FireBlock.java
-@@ -0,0 +0,0 @@ public class FireBlock extends BaseFireBlock {
-     @Override
-     protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
-         // CraftBukkit start
-+        if (!(world instanceof ServerLevel)) return this.canSurvive(state, world, pos) ? (BlockState) this.getStateWithAge(world, pos, (Integer) state.getValue(FireBlock.AGE)) : Blocks.AIR.defaultBlockState(); // Paper - don't fire events in world generation
-         if (!this.canSurvive(state, world, pos)) {
-             // Suppress during worldgen
-             if (!(world instanceof Level)) {
-@@ -0,0 +0,0 @@ public class FireBlock extends BaseFireBlock {
-                 return blockState.getHandle();
-             }
-         }
-        return this.getStateWithAge(world, pos, (Integer) state.getValue(FireBlock.AGE));
-+        return this.getStateWithAge(world, pos, (Integer) state.getValue(FireBlock.AGE)); // Paper - don't fire events in world generation; diff on change, see "don't fire events in world generation"
-         // CraftBukkit end
-     }
- 
--- a/patches/unapplied/server/Don-t-load-Chunks-from-Hoppers-and-other-things.patch
+++ b/patches/unapplied/server/Don-t-load-Chunks-from-Hoppers-and-other-things.patch
@ -1,32 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 3 Nov 2016 20:28:12 -0400
-Subject: [PATCH] Don't load Chunks from Hoppers and other things
-
-Hoppers call this to I guess "get the primary side" of a double sided chest.
-
-If the double sided chest crosses chunk lines, it causes the chunk to load.
-This will end up causing sync chunk loads, which will unload with Chunk GC,
-only to be reloaded again the next tick.
-
-This of course is undesirable, so just return the loaded side as "primary"
-and treat it as a single chest if the other sides are unloaded
-
-diff --git a/src/main/java/net/minecraft/world/level/block/DoubleBlockCombiner.java b/src/main/java/net/minecraft/world/level/block/DoubleBlockCombiner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/DoubleBlockCombiner.java
-+++ b/src/main/java/net/minecraft/world/level/block/DoubleBlockCombiner.java
-@@ -0,0 +0,0 @@ public class DoubleBlockCombiner {
-                 return new DoubleBlockCombiner.NeighborCombineResult.Single<>(blockEntity);
-             } else {
-                 BlockPos blockPos = pos.relative(directionMapper.apply(state));
-                BlockState blockState = world.getBlockState(blockPos);
-+                // Paper start - Don't load Chunks from Hoppers and other things
-+                BlockState blockState = world.getBlockStateIfLoaded(blockPos);
-+                if (blockState == null) {
-+                    return new DoubleBlockCombiner.NeighborCombineResult.Single<>(blockEntity);
-+                }
-+                // Paper end - Don't load Chunks from Hoppers and other things
-                 if (blockState.is(state.getBlock())) {
-                     DoubleBlockCombiner.BlockType blockType2 = typeMapper.apply(blockState);
-                     if (blockType2 != DoubleBlockCombiner.BlockType.SINGLE
--- a/patches/unapplied/server/Don-t-move-existing-players-to-world-spawn.patch
+++ b/patches/unapplied/server/Don-t-move-existing-players-to-world-spawn.patch
@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 9 Apr 2020 21:20:33 -0400
-Subject: [PATCH] Don't move existing players to world spawn
-
-This can cause a nasty server lag the spawn chunks are not kept loaded
-or they aren't finished loading yet, or if the world spawn radius is
-larger than the keep loaded range.
-
-By skipping this, we avoid potential for a large spike on server start.
-
-== AT ==
-public net.minecraft.server.level.ServerPlayer fudgeSpawnLocation(Lnet/minecraft/server/level/ServerLevel;)V
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-         this.server = server;
-         this.stats = server.getPlayerList().getPlayerStats(this);
-         this.advancements = server.getPlayerList().getPlayerAdvancements(this);
-        this.fudgeSpawnLocation(world);
-+        // this.fudgeSpawnLocation(world); // Paper - Don't move existing players to world spawn
-         this.updateOptions(clientOptions);
-         this.object = null;
- 
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-                 position = Vec3.atCenterOf(world.getSharedSpawnPos());
-             }
-             this.setLevel(world);
-            this.setPos(position);
-+            this.setPosRaw(position.x(), position.y(), position.z()); // Paper - don't register to chunks yet
-         }
-         this.gameMode.setLevel((ServerLevel) world);
-     }
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-         // Paper start - Entity#getEntitySpawnReason
-         if (optional.isEmpty()) {
-             player.spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DEFAULT; // set Player SpawnReason to DEFAULT on first login
-+            player.fudgeSpawnLocation(worldserver1); // Paper - Don't move existing players to world spawn
-         }
-         // Paper end - Entity#getEntitySpawnReason
-         player.setServerLevel(worldserver1);
--- a/patches/unapplied/server/Don-t-run-entity-collision-code-if-not-needed.patch
+++ b/patches/unapplied/server/Don-t-run-entity-collision-code-if-not-needed.patch
@ -1,43 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Wed, 15 Apr 2020 17:56:07 -0700
-Subject: [PATCH] Don't run entity collision code if not needed
-
-Will not run if:
-Max entity cramming is disabled and the max collisions per entity is less than or equal to 0.
-Entity#isPushable() returns false, meaning all entities will not be able to collide with this
-entity anyways.
-The entity's current team collision rule causes them to NEVER collide.
-
-Co-authored-by: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-         if (this.level().isClientSide()) {
-             this.level().getEntities(EntityTypeTest.forClass(net.minecraft.world.entity.player.Player.class), this.getBoundingBox(), EntitySelector.pushableBy(this)).forEach(this::doPush);
-         } else {
-+            // Paper start - don't run getEntities if we're not going to use its result
-+            if (!this.isPushable()) {
-+                return;
-+            }
-+            net.minecraft.world.scores.Team team = this.getTeam();
-+            if (team != null && team.getCollisionRule() == net.minecraft.world.scores.Team.CollisionRule.NEVER) {
-+                return;
-+            }
-+
-+            int i = this.level().getGameRules().getInt(GameRules.RULE_MAX_ENTITY_CRAMMING);
-+            if (i <= 0 && this.level().paperConfig().collisions.maxEntityCollisions <= 0) {
-+                return;
-+            }
-+            // Paper end - don't run getEntities if we're not going to use its result
-             List<Entity> list = this.level().getEntities((Entity) this, this.getBoundingBox(), EntitySelector.pushableBy(this));
- 
-             if (!list.isEmpty()) {
-                int i = this.level().getGameRules().getInt(GameRules.RULE_MAX_ENTITY_CRAMMING);
-+                // Paper - don't run getEntities if we're not going to use its result; moved up
- 
-                 if (i > 0 && list.size() > i - 1 && this.random.nextInt(4) == 0) {
-                     int j = 0;
--- a/patches/unapplied/server/Don-t-tick-dead-players.patch
+++ b/patches/unapplied/server/Don-t-tick-dead-players.patch
@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 2 Apr 2020 17:16:48 -0400
-Subject: [PATCH] Don't tick dead players
-
-Causes sync chunk loads and who knows what all else.
-This is safe because Spectators are skipped in unloaded chunks too in vanilla.
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
- 
-     public void doTick() {
-         try {
-            if (!this.isSpectator() || !this.touchingUnloadedChunk()) {
-+            if (valid && !this.isSpectator() || !this.touchingUnloadedChunk()) { // Paper - don't tick dead players that are not in the world currently (pending respawn)
-                 super.tick();
-             }
- 
--- a/patches/unapplied/server/Dont-send-unnecessary-sign-update.patch
+++ b/patches/unapplied/server/Dont-send-unnecessary-sign-update.patch
@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Nassim Jahnke <nassim@njahnke.dev>
-Date: Sat, 11 Sep 2021 11:56:51 +0200
-Subject: [PATCH] Dont send unnecessary sign update
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-@@ -0,0 +0,0 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
-             this.level.sendBlockUpdated(this.getBlockPos(), this.getBlockState(), this.getBlockState(), 3);
-         } else {
-             SignBlockEntity.LOGGER.warn("Player {} just tried to change non-editable sign", player.getName().getString());
-+            if (player.distanceToSqr(this.getBlockPos().getX(), this.getBlockPos().getY(), this.getBlockPos().getZ()) < 32 * 32) // Paper - Dont send far away sign update
-             ((ServerPlayer) player).connection.send(this.getUpdatePacket()); // CraftBukkit
-         }
-     }
--- a/patches/unapplied/server/Duplicate-UUID-Resolve-Option.patch
+++ b/patches/unapplied/server/Duplicate-UUID-Resolve-Option.patch
@ -1,93 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 21 Jul 2018 14:27:34 -0400
-Subject: [PATCH] Duplicate UUID Resolve Option
-
-Due to a bug in https://github.com/PaperMC/Paper/commit/2e29af3df05ec0a383f48be549d1c03200756d24
-which was added all the way back in March of 2016, it was unknown (potentially not at the time)
-that an entity might actually change the seed of the random object.
-
-At some point, EntitySquid did start setting the seed. Due to this shared random, this caused
-every entity to use a Random object with a predictable seed.
-
-This has caused entities to potentially generate with the same UUID....
-
-Over the years, servers have had entities disappear, but no sign of trouble
-because CraftBukkit removed the log lines indicating that something was wrong.
-
-We have fixed the root issue causing duplicate UUID's, however we now have chunk
-files full of entities that have the same UUID as another entity!
-
-When these chunks load, the 2nd entity will not be added to the world correctly.
-
-If that chunk loads in a different order in the future, then it will reverse and the
-missing one is now the one added to the world and not the other. This results in very
-inconsistent entity behavior.
-
-This change allows you to recover any duplicate entity by generating a new UUID for it.
-This also lets you delete them instead if you don't want to risk having new entities added to
-the world that you previously did not see.
-
-But for those who are ok with leaving this inconsistent behavior, you may use WARN or NOTHING options.
-
-It is recommended you regenerate the entities, as these were legit entities, and deserve your love.
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-                     entity.discard(null); // CraftBukkit - add Bukkit remove cause
-                     needsRemoval = true;
-                 }
-+                checkDupeUUID(world, entity); // Paper - duplicate uuid resolving
-                 return !needsRemoval;
-             }));
-             // CraftBukkit end
-@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-         });
-     }
- 
-+    // Paper start - duplicate uuid resolving
-+    // rets true if to prevent the entity from being added
-+    public static boolean checkDupeUUID(ServerLevel level, Entity entity) {
-+        io.papermc.paper.configuration.WorldConfiguration.Entities.Spawning.DuplicateUUID.DuplicateUUIDMode mode = level.paperConfig().entities.spawning.duplicateUuid.mode;
-+        if (mode != io.papermc.paper.configuration.WorldConfiguration.Entities.Spawning.DuplicateUUID.DuplicateUUIDMode.WARN
-+            && mode != io.papermc.paper.configuration.WorldConfiguration.Entities.Spawning.DuplicateUUID.DuplicateUUIDMode.DELETE
-+            && mode != io.papermc.paper.configuration.WorldConfiguration.Entities.Spawning.DuplicateUUID.DuplicateUUIDMode.SAFE_REGEN) {
-+            return false;
-+        }
-+        Entity other = level.getEntity(entity.getUUID());
-+
-+        if (other == null || other == entity) {
-+            return false;
-+        }
-+
-+        if (mode == io.papermc.paper.configuration.WorldConfiguration.Entities.Spawning.DuplicateUUID.DuplicateUUIDMode.SAFE_REGEN && other != null && !other.isRemoved()
-+            && Objects.equals(other.getEncodeId(), entity.getEncodeId())
-+            && entity.getBukkitEntity().getLocation().distance(other.getBukkitEntity().getLocation()) < level.paperConfig().entities.spawning.duplicateUuid.safeRegenDeleteRange
-+        ) {
-+            entity.discard(null);
-+            return true;
-+        }
-+        if (!other.isRemoved()) {
-+            switch (mode) {
-+                case SAFE_REGEN: {
-+                    entity.setUUID(java.util.UUID.randomUUID());
-+                    break;
-+                }
-+                case DELETE: {
-+                    entity.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.DISCARD);
-+                    return true;
-+                }
-+                default:
-+                    break;
-+            }
-+        }
-+        return false;
-+    }
-+    // Paper end - duplicate uuid resolving
-+
-     public CompletableFuture<ChunkResult<LevelChunk>> prepareTickingChunk(ChunkHolder holder) {
-         CompletableFuture<ChunkResult<List<ChunkAccess>>> completablefuture = this.getChunkRangeFuture(holder, 1, (i) -> {
-             return ChunkStatus.FULL;
--- a/patches/unapplied/server/Ensure-Entity-position-and-AABB-are-never-invalid.patch
+++ b/patches/unapplied/server/Ensure-Entity-position-and-AABB-are-never-invalid.patch
@ -1,65 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 10 May 2020 22:12:46 -0400
-Subject: [PATCH] Ensure Entity position and AABB are never invalid
-
-Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     }
- 
-     public void setPos(double x, double y, double z) {
-        this.setPosRaw(x, y, z);
-        this.setBoundingBox(this.makeBoundingBox());
-+        this.setPosRaw(x, y, z, true); // Paper - Block invalid positions and bounding box; force update
-+        // this.setBoundingBox(this.makeBoundingBox()); // Paper - Block invalid positions and bounding box; move into setPosRaw
-     }
- 
-     protected AABB makeBoundingBox() {
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-         return this.getZ((2.0D * this.random.nextDouble() - 1.0D) * widthScale);
-     }
- 
-+    // Paper start - Block invalid positions and bounding box
-+    public static boolean checkPosition(Entity entity, double newX, double newY, double newZ) {
-+        if (Double.isFinite(newX) && Double.isFinite(newY) && Double.isFinite(newZ)) {
-+            return true;
-+        }
-+
-+        String entityInfo;
-+        try {
-+            entityInfo = entity.toString();
-+        } catch (Exception ex) {
-+            entityInfo = "[Entity info unavailable] ";
-+        }
-+        LOGGER.error("New entity position is invalid! Tried to set invalid position ({},{},{}) for entity {} located at {}, entity info: {}", newX, newY, newZ, entity.getClass().getName(), entity.position, entityInfo, new Throwable());
-+        return false;
-+    }
-     public final void setPosRaw(double x, double y, double z) {
-+        this.setPosRaw(x, y, z, false);
-+    }
-+    public final void setPosRaw(double x, double y, double z, boolean forceBoundingBoxUpdate) {
-+        if (!checkPosition(this, x, y, z)) {
-+            return;
-+        }
-+        // Paper end - Block invalid positions and bounding box
-         if (this.position.x != x || this.position.y != y || this.position.z != z) {
-             this.position = new Vec3(x, y, z);
-             int i = Mth.floor(x);
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-             this.levelCallback.onMove();
-         }
- 
-+        // Paper start - Block invalid positions and bounding box; don't allow desync of pos and AABB
-+        // hanging has its own special logic
-+        if (!(this instanceof net.minecraft.world.entity.decoration.HangingEntity) && (forceBoundingBoxUpdate || this.position.x != x || this.position.y != y || this.position.z != z)) {
-+            this.setBoundingBox(this.makeBoundingBox());
-+        }
-+        // Paper end - Block invalid positions and bounding box
-     }
- 
-     public void checkDespawn() {}
--- a/patches/unapplied/server/Ensure-EntityRaider-respects-game-and-entity-rules-f.patch
+++ b/patches/unapplied/server/Ensure-EntityRaider-respects-game-and-entity-rules-f.patch
@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: kickash32 <kickash32@gmail.com>
-Date: Sat, 9 May 2020 02:01:48 -0400
-Subject: [PATCH] Ensure EntityRaider respects game and entity rules for
- picking up items
-
-
-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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/raid/Raider.java
-+++ b/src/main/java/net/minecraft/world/entity/raid/Raider.java
-@@ -0,0 +0,0 @@ public abstract class Raider extends PatrollingMonster {
- 
-         @Override
-         public boolean canUse() {
-+            if (!this.mob.level().getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) || !this.mob.canPickUpLoot()) return false; // Paper - respect game and entity rules for picking up items
-             Raid raid = this.mob.getCurrentRaid();
- 
-             if (this.mob.hasActiveRaid() && !this.mob.getCurrentRaid().isOver() && this.mob.canBeLeader() && !ItemStack.matches(this.mob.getItemBySlot(EquipmentSlot.HEAD), Raid.getLeaderBannerInstance(this.mob.registryAccess().lookupOrThrow(Registries.BANNER_PATTERN)))) {
--- a/patches/unapplied/server/Ensure-safe-gateway-teleport.patch
+++ b/patches/unapplied/server/Ensure-safe-gateway-teleport.patch
@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: kickash32 <kickash32@gmail.com>
-Date: Fri, 15 May 2020 01:10:03 -0400
-Subject: [PATCH] Ensure safe gateway teleport
-
-== AT ==
-public net.minecraft.world.entity.Entity teleportPassengers()V
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
-@@ -0,0 +0,0 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
- 
-                     entity1.setPortalCooldown();
-                     ((ServerPlayer) entity1).connection.teleport(teleEvent.getTo());
-+                    entity1.teleportPassengers(); // Paper - teleport passengers as well, preventing invisible passengers post teleport.
-                     TheEndGatewayBlockEntity.triggerCooldown(world, pos, state, blockEntity); // CraftBukkit - call at end of method
-                     return;
- 
--- a/patches/unapplied/server/Entity-Jump-API.patch
+++ b/patches/unapplied/server/Entity-Jump-API.patch
@ -1,76 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sat, 8 Feb 2020 23:26:11 -0600
-Subject: [PATCH] Entity Jump API
-
-== AT ==
-public net.minecraft.world.entity.LivingEntity jumping
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-             } else if (this.isInLava() && (!this.onGround() || d3 > d4)) {
-                 this.jumpInLiquid(FluidTags.LAVA);
-             } else if ((this.onGround() || flag && d3 <= d4) && this.noJumpDelay == 0) {
-+                if (new com.destroystokyo.paper.event.entity.EntityJumpEvent(getBukkitLivingEntity()).callEvent()) { // Paper - Entity Jump API
-                 this.jumpFromGround();
-                 this.noJumpDelay = 10;
-+                } else { this.setJumping(false); } // Paper - Entity Jump API; setJumping(false) stops a potential loop
-             }
-         } else {
-             this.noJumpDelay = 0;
-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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/animal/Panda.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Panda.java
-@@ -0,0 +0,0 @@ public class Panda extends Animal {
-             Panda entitypanda = (Panda) iterator.next();
- 
-             if (!entitypanda.isBaby() && entitypanda.onGround() && !entitypanda.isInWater() && entitypanda.canPerformAction()) {
-+                if (new com.destroystokyo.paper.event.entity.EntityJumpEvent(getBukkitLivingEntity()).callEvent()) { // Paper - Entity Jump API
-                 entitypanda.jumpFromGround();
-+                } else { this.setJumping(false); } // Paper - Entity Jump API; setJumping(false) stops a potential loop
-             }
-         }
- 
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Ravager.java b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/monster/Ravager.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
-@@ -0,0 +0,0 @@ public class Ravager extends Raider {
-                 }
- 
-                 if (!flag && this.onGround()) {
-+                    if (new com.destroystokyo.paper.event.entity.EntityJumpEvent(getBukkitLivingEntity()).callEvent()) { // Paper - Entity Jump API
-                     this.jumpFromGround();
-+                    } else { this.setJumping(false); } // Paper - Entity Jump API; setJumping(false) stops a potential loop
-                 }
-             }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-         return org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(this.getHandle().getUsedItemHand());
-     }
-     // Paper end - active item API
-+
-+    // Paper start - entity jump API
-+    @Override
-+    public boolean isJumping() {
-+        return getHandle().jumping;
-+    }
-+
-+    @Override
-+    public void setJumping(boolean jumping) {
-+        getHandle().setJumping(jumping);
-+        if (jumping && getHandle() instanceof Mob) {
-+            // this is needed to actually make a mob jump
-+            ((Mob) getHandle()).getJumpControl().jump();
-+        }
-+    }
-+    // Paper end - entity jump API
- }
--- a/patches/unapplied/server/Entity-getEntitySpawnReason.patch
+++ b/patches/unapplied/server/Entity-getEntitySpawnReason.patch
@ -1,150 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 24 Mar 2019 00:24:52 -0400
-Subject: [PATCH] Entity#getEntitySpawnReason
-
-Allows you to return the SpawnReason for why an Entity Spawned
-
-Pre existing entities will return NATURAL if it was a non
-persistenting Living Entity, SPAWNER for spawners,
-or DEFAULT since data was not stored.
-
-diff --git a/src/main/java/net/minecraft/server/commands/SummonCommand.java b/src/main/java/net/minecraft/server/commands/SummonCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/commands/SummonCommand.java
-+++ b/src/main/java/net/minecraft/server/commands/SummonCommand.java
-@@ -0,0 +0,0 @@ public class SummonCommand {
-             ServerLevel worldserver = source.getLevel();
-             Entity entity = EntityType.loadEntityRecursive(nbttagcompound1, worldserver, (entity1) -> {
-                 entity1.moveTo(pos.x, pos.y, pos.z, entity1.getYRot(), entity1.getXRot());
-+                entity1.spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.COMMAND; // Paper - Entity#getEntitySpawnReason
-                 return entity1;
-             });
- 
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-             return true;
-         }
-         // Paper end - extra debug info
-+        if (entity.spawnReason == null) entity.spawnReason = spawnReason; // Paper - Entity#getEntitySpawnReason
-         if (entity.isRemoved()) {
-             // WorldServer.LOGGER.warn("Tried to add entity {} but it was marked as removed already", EntityTypes.getKey(entity.getType())); // CraftBukkit
-             return false;
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-             worldserver1 = worldserver;
-         }
- 
-+        // Paper start - Entity#getEntitySpawnReason
-+        if (optional.isEmpty()) {
-+            player.spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DEFAULT; // set Player SpawnReason to DEFAULT on first login
-+        }
-+        // Paper end - Entity#getEntitySpawnReason
-         player.setServerLevel(worldserver1);
-         String s1 = connection.getLoggableAddress(this.server.logIPs());
- 
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-             CompoundTag nbttagcompound = ((CompoundTag) optional.get()).getCompound("RootVehicle");
-             ServerLevel finalWorldServer = worldserver1; // CraftBukkit - decompile error
-             Entity entity = EntityType.loadEntityRecursive(nbttagcompound.getCompound("Entity"), worldserver1, (entity1) -> {
-                return !finalWorldServer.addWithUUID(entity1) ? null : entity1; // CraftBukkit - decompile error
-+                return !finalWorldServer.addWithUUID(entity1, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.MOUNT) ? null : entity1; // CraftBukkit - decompile error // Paper - Entity#getEntitySpawnReason
-             });
- 
-             if (entity != null) {
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-         }
-     }
-     // Paper end - Share random for entities to make them more random
-+    public org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason spawnReason; // Paper - Entity#getEntitySpawnReason
- 
-     private CraftEntity bukkitEntity;
- 
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                 }
-                 nbttagcompound.put("Paper.Origin", this.newDoubleList(origin.getX(), origin.getY(), origin.getZ()));
-             }
-+            if (spawnReason != null) {
-+                nbttagcompound.putString("Paper.SpawnReason", spawnReason.name());
-+            }
-             // Save entity's from mob spawner status
-             if (spawnedViaMobSpawner) {
-                 nbttagcompound.putBoolean("Paper.FromMobSpawner", true);
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-             }
- 
-             spawnedViaMobSpawner = nbt.getBoolean("Paper.FromMobSpawner"); // Restore entity's from mob spawner status
-+            if (nbt.contains("Paper.SpawnReason")) {
-+                String spawnReasonName = nbt.getString("Paper.SpawnReason");
-+                try {
-+                    spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.valueOf(spawnReasonName);
-+                } catch (Exception ignored) {
-+                    LOGGER.error("Unknown SpawnReason " + spawnReasonName + " for " + this);
-+                }
-+            }
-+            if (spawnReason == null) {
-+                if (spawnedViaMobSpawner) {
-+                    spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER;
-+                } else if (this instanceof Mob && (this instanceof net.minecraft.world.entity.animal.Animal || this instanceof net.minecraft.world.entity.animal.AbstractFish) && !((Mob) this).removeWhenFarAway(0.0)) {
-+                    if (!nbt.getBoolean("PersistenceRequired")) {
-+                        spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL;
-+                    }
-+                }
-+            }
-+            if (spawnReason == null) {
-+                spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DEFAULT;
-+            }
-             // Paper end
- 
-         } catch (Throwable throwable) {
-diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
-@@ -0,0 +0,0 @@ public abstract class BaseSpawner {
-                         }
- 
-                         entity.spawnedViaMobSpawner = true; // Paper
-+                        entity.spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER; // Paper - Entity#getEntitySpawnReason
-                         flag = true; // Paper
-                         // CraftBukkit start
-                         if (org.bukkit.craftbukkit.event.CraftEventFactory.callSpawnerSpawnEvent(entity, pos).isCancelled()) {
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/SculkShriekerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SculkShriekerBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/entity/SculkShriekerBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/SculkShriekerBlockEntity.java
-@@ -0,0 +0,0 @@ public class SculkShriekerBlockEntity extends BlockEntity implements GameEventLi
- 
-     private boolean trySummonWarden(ServerLevel world) {
-         return this.warningLevel >= 4
-            && SpawnUtil.trySpawnMob(EntityType.WARDEN, MobSpawnType.TRIGGERED, world, this.getBlockPos(), 20, 5, 6, SpawnUtil.Strategy.ON_TOP_OF_COLLIDER)
-+            && SpawnUtil.trySpawnMob(EntityType.WARDEN, MobSpawnType.TRIGGERED, world, this.getBlockPos(), 20, 5, 6, SpawnUtil.Strategy.ON_TOP_OF_COLLIDER, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL, null) // Paper - Entity#getEntitySpawnReason
-                 .isPresent();
-     }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-@@ -0,0 +0,0 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
-         return this.getHandle().spawnedViaMobSpawner;
-     }
-     // Paper end - Entity#fromMobSpawner
-+
-+    // Paper start - entity spawn reason API
-+    @Override
-+    public org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason getEntitySpawnReason() {
-+        return getHandle().spawnReason;
-+    }
-+    // Paper end - entity spawn reason API
- }
--- a/patches/unapplied/server/ExperienceOrb-merging-stacking-API-and-fixes.patch
+++ b/patches/unapplied/server/ExperienceOrb-merging-stacking-API-and-fixes.patch
@ -1,113 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 10 Nov 2017 23:03:12 -0500
-Subject: [PATCH] ExperienceOrb merging/stacking API and fixes
-
-Adds an option for maximum exp value when merging orbs
-
-Adds ExperienceOrbMergeEvent
-Fired when the server is about to merge 2 experience orbs
-as entities. Plugins can cancel it if they want to ensure experience orbs do not lose important
-metadata such as spawn reason, or conditionally move data from source to target.
-
-Fixes an issue where the stacked count was not taking into account
-for mending repairs and when merging with spigot's merge-on-spawn
-logic
-
-== AT ==
-public net.minecraft.world.entity.ExperienceOrb count
-
-Co-authored-by: Aikar <aikar@aikar.co>
-Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
-
-diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-     }
- 
-     private static boolean tryMergeToExisting(ServerLevel world, Vec3 pos, int amount) {
-+        // Paper - TODO some other event for this kind of merge
-         AABB axisalignedbb = AABB.ofSize(pos, 1.0D, 1.0D, 1.0D);
-         int j = world.getRandom().nextInt(40);
-         List<ExperienceOrb> list = world.getEntities(EntityTypeTest.forClass(ExperienceOrb.class), axisalignedbb, (entityexperienceorb) -> {
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-     }
- 
-     private void merge(ExperienceOrb other) {
-+        // Paper start - call orb merge event
-+        if (!new com.destroystokyo.paper.event.entity.ExperienceOrbMergeEvent((org.bukkit.entity.ExperienceOrb) this.getBukkitEntity(), (org.bukkit.entity.ExperienceOrb) other.getBukkitEntity()).callEvent()) {
-+            return;
-+        }
-+        // Paper end - call orb merge event
-         this.count += other.count;
-         this.age = Math.min(this.age, other.age);
-         other.discard(EntityRemoveEvent.Cause.MERGE); // CraftBukkit - add Bukkit remove cause
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
- 
-             itemstack.setDamageValue(itemstack.getDamageValue() - j);
-             int k = amount - this.durabilityToXp(j);
-            this.value = k; // CraftBukkit - update exp value of orb for PlayerItemMendEvent calls
-+            // this.value = k; // CraftBukkit - update exp value of orb for PlayerItemMendEvent calls // Paper - the value field should not be mutated here because it doesn't take "count" into account
- 
-             return k > 0 ? this.repairPlayerItems(player, k) : 0;
-         } else {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
-@@ -0,0 +0,0 @@ public class CraftExperienceOrb extends CraftEntity implements ExperienceOrb {
-         this.getHandle().value = value;
-     }
- 
-+    // Paper start - expose count
-+    @Override
-+    public int getCount() {
-+        return this.getHandle().count;
-+    }
-+
-+    @Override
-+    public void setCount(final int count) {
-+        this.getHandle().count = count;
-+    }
-+    // Paper end
-+
-     // Paper start
-     public java.util.UUID getTriggerEntityId() {
-         return getHandle().triggerEntityId;
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         if (entity instanceof net.minecraft.world.entity.ExperienceOrb xp) {
-             double radius = world.spigotConfig.expMerge;
-             if (radius > 0) {
-+                // Paper start - Maximum exp value when merging; Whole section has been tweaked, see comments for specifics
-+                final long maxValue = world.paperConfig().entities.behavior.experienceMergeMaxValue;
-+                final boolean mergeUnconditionally = maxValue <= 0;
-+                if (mergeUnconditionally || xp.value < maxValue) { // Paper - Skip iteration if unnecessary
-+
-                 List<Entity> entities = world.getEntities(entity, entity.getBoundingBox().inflate(radius, radius, radius));
-                 for (Entity e : entities) {
-                     if (e instanceof net.minecraft.world.entity.ExperienceOrb loopItem) {
-                        if (!loopItem.isRemoved()) {
-+                        // Paper start
-+                        if (!loopItem.isRemoved() && xp.count == loopItem.count && (mergeUnconditionally || loopItem.value < maxValue) && new com.destroystokyo.paper.event.entity.ExperienceOrbMergeEvent((org.bukkit.entity.ExperienceOrb) entity.getBukkitEntity(), (org.bukkit.entity.ExperienceOrb) loopItem.getBukkitEntity()).callEvent()) { // Paper - ExperienceOrbMergeEvent
-+                            long newTotal = (long)xp.value + (long)loopItem.value;
-+                            if ((int) newTotal < 0) continue; // Overflow
-+                            if (!mergeUnconditionally && newTotal > maxValue) {
-+                                loopItem.value = (int) (newTotal - maxValue);
-+                                xp.value = (int) maxValue;
-+                            } else {
-                             xp.value += loopItem.value;
-                             loopItem.discard(null); // Add Bukkit remove cause
-+                            } // Paper end - Maximum exp value when merging
-                         }
-                     }
-                 }
-+                } // Paper end - End iteration skip check - All tweaking ends here
-             }
-         }
-         // Spigot end
--- a/patches/unapplied/server/Expose-MinecraftServer-isRunning.patch
+++ b/patches/unapplied/server/Expose-MinecraftServer-isRunning.patch
@ -1,22 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Fri, 10 Apr 2020 21:24:12 -0400
-Subject: [PATCH] Expose MinecraftServer#isRunning
-
-This allows for plugins to detect if the server is actually turning off in onDisable rather than just plugins reloading.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-     public int getCurrentTick() {
-         return net.minecraft.server.MinecraftServer.currentTick;
-     }
-+
-+    @Override
-+    public boolean isStopping() {
-+        return net.minecraft.server.MinecraftServer.getServer().hasStopped();
-+    }
-     // Paper end
- }
--- a/patches/unapplied/server/Expose-the-internal-current-tick.patch
+++ b/patches/unapplied/server/Expose-the-internal-current-tick.patch
@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <blake.galbreath@gmail.com>
-Date: Sat, 20 Apr 2019 19:47:34 -0500
-Subject: [PATCH] Expose the internal current tick
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         profile.getGameProfile().getProperties().putAll(((CraftPlayer) player).getHandle().getGameProfile().getProperties());
-         return profile;
-     }
-+
-+    @Override
-+    public int getCurrentTick() {
-+        return net.minecraft.server.MinecraftServer.currentTick;
-+    }
-     // Paper end
- }
--- a/patches/unapplied/server/Fire-PlayerJoinEvent-when-Player-is-actually-ready.patch
+++ b/patches/unapplied/server/Fire-PlayerJoinEvent-when-Player-is-actually-ready.patch
@ -1,106 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 19 Apr 2020 00:05:46 -0400
-Subject: [PATCH] Fire PlayerJoinEvent when Player is actually ready
-
-For years, plugin developers have had to delay many things they do
-inside of the PlayerJoinEvent by 1 tick to make it actually work.
-
-This all boiled down to 1 reason why: The event fired before the
-player was fully ready and joined to the world!
-
-Additionally, if that player logged out on a vehicle, the event
-fired before the vehicle was even loaded, so that plugins had no
-access to the vehicle during this event either.
-
-This change finally fixes this issue, fully preparing the player
-into the world as a fully ready entity, vehicle included.
-
-There should be no plugins that break because of this change, but might
-improve consistency with other plugins instead.
-
-For example, if 2 plugins listens to this event, and the first one
-teleported the player in the event, then the 2nd plugin actually
-would be getting a valid player!
-
-This was very non deterministic. This change will ensure every plugin
-receives a deterministic result, and should no longer require 1 tick
-delays anymore.
-
-== AT ==
-public net.minecraft.server.level.ChunkMap addEntity(Lnet/minecraft/world/entity/Entity;)V
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-             return;
-         }
-         // Paper end - ignore and warn about illegal addEntity calls instead of crashing server
-+        if (entity instanceof ServerPlayer && ((ServerPlayer) entity).supressTrackerForLogin) return; // Paper - Fire PlayerJoinEvent when Player is actually ready; Delay adding to tracker until after list packets
-         if (!(entity instanceof EnderDragonPart)) {
-             EntityType<?> entitytypes = entity.getType();
-             int i = entitytypes.clientTrackingRange() * 16;
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-     public double maxHealthCache;
-     public boolean joining = true;
-     public boolean sentListPacket = false;
-+    public boolean supressTrackerForLogin = false; // Paper - Fire PlayerJoinEvent when Player is actually ready
-     public String kickLeaveMessage = null; // SPIGOT-3034: Forward leave message to PlayerQuitEvent
-     // CraftBukkit end
-     public boolean isRealPlayer; // Paper
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-         this.playersByUUID.put(player.getUUID(), player);
-         // this.broadcastAll(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(entityplayer))); // CraftBukkit - replaced with loop below
- 
-+        // Paper start - Fire PlayerJoinEvent when Player is actually ready; correctly register player BEFORE PlayerJoinEvent, so the entity is valid and doesn't require tick delay hacks
-+        player.supressTrackerForLogin = true;
-+        worldserver1.addNewPlayer(player);
-+        this.server.getCustomBossEvents().onPlayerConnect(player); // see commented out section below worldserver.addPlayerJoin(entityplayer);
-+        this.mountSavedVehicle(player, worldserver1, optional);
-+        // Paper end - Fire PlayerJoinEvent when Player is actually ready
-         // CraftBukkit start
-         CraftPlayer bukkitPlayer = player.getBukkitEntity();
- 
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-             player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(entityplayer1)));
-         }
-         player.sentListPacket = true;
-+        player.supressTrackerForLogin = false; // Paper - Fire PlayerJoinEvent when Player is actually ready
-+        ((ServerLevel)player.level()).getChunkSource().chunkMap.addEntity(player); // Paper - Fire PlayerJoinEvent when Player is actually ready; track entity now
-         // CraftBukkit end
- 
-         player.refreshEntityData(player); // CraftBukkit - BungeeCord#2321, send complete data to self on spawn
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
- 
-             playerconnection.send(new ClientboundUpdateMobEffectPacket(player.getId(), mobeffect, false));
-         }
-
-+        // Paper start - Fire PlayerJoinEvent when Player is actually ready; move vehicle into method so it can be called above - short circuit around that code
-+        this.onPlayerJoinFinish(player, worldserver1, s1);
-+    }
-+    private void mountSavedVehicle(ServerPlayer player, ServerLevel worldserver1, Optional<CompoundTag> optional) {
-+        // Paper end - Fire PlayerJoinEvent when Player is actually ready
-         if (optional.isPresent() && ((CompoundTag) optional.get()).contains("RootVehicle", 10)) {
-             CompoundTag nbttagcompound = ((CompoundTag) optional.get()).getCompound("RootVehicle");
-             ServerLevel finalWorldServer = worldserver1; // CraftBukkit - decompile error
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-             }
-         }
- 
-+        // Paper start - Fire PlayerJoinEvent when Player is actually ready
-+    }
-+    public void onPlayerJoinFinish(ServerPlayer player, ServerLevel worldserver1, String s1) {
-+        // Paper end - Fire PlayerJoinEvent when Player is actually ready
-         player.initInventoryMenu();
-         // CraftBukkit - Moved from above, added world
-         // Paper start - Configurable player collision; Add to collideRule team if needed
--- a/patches/unapplied/server/Fire-event-on-GS4-query.patch
+++ b/patches/unapplied/server/Fire-event-on-GS4-query.patch
@ -1,134 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
-Date: Sun, 17 Mar 2019 21:46:56 +0200
-Subject: [PATCH] Fire event on GS4 query
-
-
-diff --git a/src/main/java/net/minecraft/server/rcon/thread/QueryThreadGs4.java b/src/main/java/net/minecraft/server/rcon/thread/QueryThreadGs4.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/rcon/thread/QueryThreadGs4.java
-+++ b/src/main/java/net/minecraft/server/rcon/thread/QueryThreadGs4.java
-@@ -0,0 +0,0 @@ public class QueryThreadGs4 extends GenericThread {
-                         NetworkDataOutputStream networkDataOutputStream = new NetworkDataOutputStream(1460);
-                         networkDataOutputStream.write(0);
-                         networkDataOutputStream.writeBytes(this.getIdentBytes(packet.getSocketAddress()));
-                        networkDataOutputStream.writeString(this.serverName);
-+
-+                        com.destroystokyo.paper.event.server.GS4QueryEvent.QueryType queryType =
-+                            com.destroystokyo.paper.event.server.GS4QueryEvent.QueryType.BASIC;
-+                        com.destroystokyo.paper.event.server.GS4QueryEvent.QueryResponse queryResponse = com.destroystokyo.paper.event.server.GS4QueryEvent.QueryResponse.builder()
-+                            .motd(this.serverName)
-+                            .map(this.worldName)
-+                            .currentPlayers(this.serverInterface.getPlayerCount())
-+                            .maxPlayers(this.maxPlayers)
-+                            .port(this.serverPort)
-+                            .hostname(this.hostIp)
-+                            .gameVersion(this.serverInterface.getServerVersion())
-+                            .serverVersion(org.bukkit.Bukkit.getServer().getName() + " on " + org.bukkit.Bukkit.getServer().getBukkitVersion())
-+                            .build();
-+                        com.destroystokyo.paper.event.server.GS4QueryEvent queryEvent =
-+                            new com.destroystokyo.paper.event.server.GS4QueryEvent(queryType, packet.getAddress(), queryResponse);
-+                        queryEvent.callEvent();
-+                        queryResponse = queryEvent.getResponse();
-+
-+                        networkDataOutputStream.writeString(queryResponse.getMotd());
-                         networkDataOutputStream.writeString("SMP");
-                        networkDataOutputStream.writeString(this.worldName);
-                        networkDataOutputStream.writeString(Integer.toString(this.serverInterface.getPlayerCount()));
-                        networkDataOutputStream.writeString(Integer.toString(this.maxPlayers));
-                        networkDataOutputStream.writeShort((short)this.serverPort);
-                        networkDataOutputStream.writeString(this.hostIp);
-+                        networkDataOutputStream.writeString(queryResponse.getMap());
-+                        networkDataOutputStream.writeString(Integer.toString(queryResponse.getCurrentPlayers()));
-+                        networkDataOutputStream.writeString(Integer.toString(queryResponse.getMaxPlayers()));
-+                        networkDataOutputStream.writeShort((short) queryResponse.getPort());
-+                        networkDataOutputStream.writeString(queryResponse.getHostname());
-+                        // Paper end
-                         this.sendTo(networkDataOutputStream.toByteArray(), packet);
-                         LOGGER.debug("Status [{}]", socketAddress);
-                     }
-@@ -0,0 +0,0 @@ public class QueryThreadGs4 extends GenericThread {
-             this.rulesResponse.writeString("splitnum");
-             this.rulesResponse.write(128);
-             this.rulesResponse.write(0);
-+            // Paper start
-+            // Pack plugins
-+            java.util.List<com.destroystokyo.paper.event.server.GS4QueryEvent.QueryResponse.PluginInformation> plugins = java.util.Collections.emptyList();
-+            org.bukkit.plugin.Plugin[] bukkitPlugins;
-+            if (((net.minecraft.server.dedicated.DedicatedServer) this.serverInterface).server.getQueryPlugins() && (bukkitPlugins = org.bukkit.Bukkit.getPluginManager().getPlugins()).length > 0) {
-+                plugins = java.util.stream.Stream.of(bukkitPlugins)
-+                    .map(plugin -> com.destroystokyo.paper.event.server.GS4QueryEvent.QueryResponse.PluginInformation.of(plugin.getName(), plugin.getDescription().getVersion()))
-+                    .collect(java.util.stream.Collectors.toList());
-+            }
-+
-+            com.destroystokyo.paper.event.server.GS4QueryEvent.QueryResponse queryResponse = com.destroystokyo.paper.event.server.GS4QueryEvent.QueryResponse.builder()
-+                .motd(this.serverName)
-+                .map(this.worldName)
-+                .currentPlayers(this.serverInterface.getPlayerCount())
-+                .maxPlayers(this.maxPlayers)
-+                .port(this.serverPort)
-+                .hostname(this.hostIp)
-+                .plugins(plugins)
-+                .players(this.serverInterface.getPlayerNames())
-+                .gameVersion(this.serverInterface.getServerVersion())
-+                .serverVersion(org.bukkit.Bukkit.getServer().getName() + " on " + org.bukkit.Bukkit.getServer().getBukkitVersion())
-+                .build();
-+            com.destroystokyo.paper.event.server.GS4QueryEvent.QueryType queryType =
-+                com.destroystokyo.paper.event.server.GS4QueryEvent.QueryType.FULL;
-+            com.destroystokyo.paper.event.server.GS4QueryEvent queryEvent =
-+                new com.destroystokyo.paper.event.server.GS4QueryEvent(queryType, packet.getAddress(), queryResponse);
-+            queryEvent.callEvent();
-+            queryResponse = queryEvent.getResponse();
-             this.rulesResponse.writeString("hostname");
-            this.rulesResponse.writeString(this.serverName);
-+            this.rulesResponse.writeString(queryResponse.getMotd());
-             this.rulesResponse.writeString("gametype");
-             this.rulesResponse.writeString("SMP");
-             this.rulesResponse.writeString("game_id");
-             this.rulesResponse.writeString("MINECRAFT");
-             this.rulesResponse.writeString("version");
-            this.rulesResponse.writeString(this.serverInterface.getServerVersion());
-+            this.rulesResponse.writeString(queryResponse.getGameVersion());
-             this.rulesResponse.writeString("plugins");
-            this.rulesResponse.writeString(this.serverInterface.getPluginNames());
-+            java.lang.StringBuilder pluginsString = new java.lang.StringBuilder();
-+            pluginsString.append(queryResponse.getServerVersion());
-+            if (!queryResponse.getPlugins().isEmpty()) {
-+                pluginsString.append(": ");
-+                java.util.Iterator<com.destroystokyo.paper.event.server.GS4QueryEvent.QueryResponse.PluginInformation> iter = queryResponse.getPlugins().iterator();
-+                while (iter.hasNext()) {
-+                    com.destroystokyo.paper.event.server.GS4QueryEvent.QueryResponse.PluginInformation info = iter.next();
-+                    pluginsString.append(info.getName());
-+                    if (info.getVersion() != null) {
-+                        pluginsString.append(' ').append(info.getVersion().replace(";", ","));
-+                    }
-+                    if (iter.hasNext()) {
-+                        pluginsString.append(';').append(' ');
-+                    }
-+                }
-+            }
-+            this.rulesResponse.writeString(pluginsString.toString());
-             this.rulesResponse.writeString("map");
-            this.rulesResponse.writeString(this.worldName);
-+            this.rulesResponse.writeString(queryResponse.getMap());
-             this.rulesResponse.writeString("numplayers");
-            this.rulesResponse.writeString(this.serverInterface.getPlayerCount() + "");
-+            this.rulesResponse.writeString(Integer.toString(queryResponse.getCurrentPlayers()));
-             this.rulesResponse.writeString("maxplayers");
-            this.rulesResponse.writeString(this.maxPlayers + "");
-+            this.rulesResponse.writeString(Integer.toString(queryResponse.getMaxPlayers()));
-             this.rulesResponse.writeString("hostport");
-            this.rulesResponse.writeString(this.serverPort + "");
-+            this.rulesResponse.writeString(Integer.toString(queryResponse.getPort()));
-             this.rulesResponse.writeString("hostip");
-            this.rulesResponse.writeString(this.hostIp);
-+            this.rulesResponse.writeString(queryResponse.getHostname());
-             this.rulesResponse.write(0);
-             this.rulesResponse.write(1);
-             this.rulesResponse.writeString("player_");
-             this.rulesResponse.write(0);
-            String[] strings = this.serverInterface.getPlayerNames();
-+            String[] strings = queryResponse.getPlayers().toArray(String[]::new);
- 
-             for (String string : strings) {
-                 this.rulesResponse.writeString(string);
--- a/patches/unapplied/server/Fix-CB-call-to-changed-postToMainThread-method.patch
+++ b/patches/unapplied/server/Fix-CB-call-to-changed-postToMainThread-method.patch
@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Fri, 10 May 2019 18:38:19 +0100
-Subject: [PATCH] Fix CB call to changed postToMainThread method
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
- 
-         Objects.requireNonNull(this.connection);
-         // CraftBukkit - Don't wait
-        minecraftserver.wrapRunnable(networkmanager::handleDisconnection);
-+        minecraftserver.scheduleOnMain(networkmanager::handleDisconnection); // Paper
-     }
- 
-     protected boolean isSingleplayerOwner() {
--- a/patches/unapplied/server/Fix-CraftScheduler-runTaskTimerAsynchronously-Plugin.patch
+++ b/patches/unapplied/server/Fix-CraftScheduler-runTaskTimerAsynchronously-Plugin.patch
@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: ossi <oser0002@gmail.com>
-Date: Fri, 12 Jun 2020 01:38:06 +0300
-Subject: [PATCH] Fix CraftScheduler#runTaskTimerAsynchronously(Plugin,
- Consumer<BukkitTask>, long, long) scheduling a non-repeating task instead of
- a repeating one.
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
-+++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
- 
-     @Override
-     public void runTaskTimerAsynchronously(Plugin plugin, Consumer<? super BukkitTask> task, long delay, long period) throws IllegalArgumentException {
-        this.runTaskTimerAsynchronously(plugin, (Object) task, delay, CraftTask.NO_REPEATING);
-+        this.runTaskTimerAsynchronously(plugin, (Object) task, delay, period); // Paper
-     }
- 
-     @Override
--- a/patches/unapplied/server/Fix-Per-World-Difficulty-Remembering-Difficulty.patch
+++ b/patches/unapplied/server/Fix-Per-World-Difficulty-Remembering-Difficulty.patch
@ -1,131 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 28 Jun 2020 03:59:10 -0400
-Subject: [PATCH] Fix Per World Difficulty / Remembering Difficulty
-
-Fixes per world difficulty with /difficulty command and also
-makes it so that the server keeps the last difficulty used instead
-of restoring the server.properties every single load.
-
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         worldloadlistener.stop();
-         // CraftBukkit start
-         // this.updateMobSpawningFlags();
-        worldserver.setSpawnSettings(this.isSpawningMonsters(), this.isSpawningAnimals());
-+        worldserver.setSpawnSettings(worldserver.serverLevelData.getDifficulty() != Difficulty.PEACEFUL && ((DedicatedServer) this).settings.getProperties().spawnMonsters, this.isSpawningAnimals()); // Paper - per level difficulty (from setDifficulty(ServerLevel, Difficulty, boolean))
- 
-         this.forceTicks = false;
-         // CraftBukkit end
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         }
-     }
- 
-    public void setDifficulty(Difficulty difficulty, boolean forceUpdate) {
-        if (forceUpdate || !this.worldData.isDifficultyLocked()) {
-            this.worldData.setDifficulty(this.worldData.isHardcore() ? Difficulty.HARD : difficulty);
-            this.updateMobSpawningFlags();
-            this.getPlayerList().getPlayers().forEach(this::sendDifficultyUpdate);
-+    // Paper start - per level difficulty
-+    public void setDifficulty(ServerLevel level, Difficulty difficulty, boolean forceUpdate) {
-+        PrimaryLevelData worldData = level.serverLevelData;
-+        if (forceUpdate || !worldData.isDifficultyLocked()) {
-+            worldData.setDifficulty(worldData.isHardcore() ? Difficulty.HARD : difficulty);
-+            level.setSpawnSettings(worldData.getDifficulty() != Difficulty.PEACEFUL && ((DedicatedServer) this).settings.getProperties().spawnMonsters, this.isSpawningAnimals());
-+            // this.getPlayerList().getPlayers().forEach(this::sendDifficultyUpdate);
-+            // Paper end - per level difficulty
-         }
-     }
- 
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         while (iterator.hasNext()) {
-             ServerLevel worldserver = (ServerLevel) iterator.next();
- 
-            worldserver.setSpawnSettings(this.isSpawningMonsters(), this.isSpawningAnimals());
-+            worldserver.setSpawnSettings(worldserver.serverLevelData.getDifficulty() != Difficulty.PEACEFUL && ((DedicatedServer) this).settings.getProperties().spawnMonsters, this.isSpawningAnimals()); // Paper - per level difficulty (from setDifficulty(ServerLevel, Difficulty, boolean))
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/server/commands/DifficultyCommand.java b/src/main/java/net/minecraft/server/commands/DifficultyCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/commands/DifficultyCommand.java
-+++ b/src/main/java/net/minecraft/server/commands/DifficultyCommand.java
-@@ -0,0 +0,0 @@ public class DifficultyCommand {
-         if (worldServer.getDifficulty() == difficulty) { // CraftBukkit
-             throw DifficultyCommand.ERROR_ALREADY_DIFFICULT.create(difficulty.getKey());
-         } else {
-            worldServer.serverLevelData.setDifficulty(difficulty); // CraftBukkit
-+            minecraftserver.setDifficulty(worldServer, difficulty, true); // Paper - per level difficulty; don't skip other difficulty-changing logic (fix upstream's fix)
-             source.sendSuccess(() -> {
-                 return Component.translatable("commands.difficulty.success", difficulty.getDisplayName());
-             }, true);
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
- 
-     @Override
-     public void forceDifficulty() {
-        this.setDifficulty(this.getProperties().difficulty, true);
-+        // this.setDifficulty(this.getProperties().difficulty, true); // Paper - per level difficulty; Don't overwrite level.dat's difficulty, keep current
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-                 this.isChangingDimension = true; // CraftBukkit - Set teleport invulnerability only if player changing worlds
- 
-                 this.connection.send(new ClientboundRespawnPacket(this.createCommonSpawnInfo(worldserver), (byte) 3));
-                this.connection.send(new ClientboundChangeDifficultyPacket(this.level().getDifficulty(), this.level().getLevelData().isDifficultyLocked()));
-+                this.connection.send(new ClientboundChangeDifficultyPacket(worldserver.getDifficulty(), this.level().getLevelData().isDifficultyLocked())); // Paper - per level difficulty
-                 PlayerList playerlist = this.server.getPlayerList();
- 
-                 playerlist.sendPlayerPermissionLevel(this);
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-     public void handleChangeDifficulty(ServerboundChangeDifficultyPacket packet) {
-         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
-         if (this.player.hasPermissions(2) || this.isSingleplayerOwner()) {
-            this.server.setDifficulty(packet.getDifficulty(), false);
-+            // this.server.setDifficulty(packet.getDifficulty(), false); // Paper - per level difficulty; don't allow clients to change this
-         }
-     }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         org.spigotmc.SpigotConfig.init((File) this.console.options.valueOf("spigot-settings")); // Spigot
-         this.console.paperConfigurations.reloadConfigs(this.console);
-         for (ServerLevel world : this.console.getAllLevels()) {
-            world.serverLevelData.setDifficulty(config.difficulty);
-            world.setSpawnSettings(config.spawnMonsters, config.spawnAnimals);
-+            // world.serverLevelData.setDifficulty(config.difficulty); // Paper - per level difficulty
-+            world.setSpawnSettings(world.serverLevelData.getDifficulty() != Difficulty.PEACEFUL && config.spawnMonsters, config.spawnAnimals); // Paper - per level difficulty (from MinecraftServer#setDifficulty(ServerLevel, Difficulty, boolean))
- 
-             for (SpawnCategory spawnCategory : SpawnCategory.values()) {
-                 if (CraftSpawnCategory.isValidForLimits(spawnCategory)) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
- 
-     @Override
-     public void setDifficulty(Difficulty difficulty) {
-        this.getHandle().serverLevelData.setDifficulty(net.minecraft.world.Difficulty.byId(difficulty.getValue()));
-+        this.getHandle().getServer().setDifficulty(this.getHandle(), net.minecraft.world.Difficulty.byId(difficulty.getValue()), true); // Paper - per level difficulty; don't skip other difficulty-changing logic
-     }
- 
-     @Override
--- a/patches/unapplied/server/Fix-PotionEffect-ignores-icon-flag.patch
+++ b/patches/unapplied/server/Fix-PotionEffect-ignores-icon-flag.patch
@ -1,60 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: kickash32 <kickash32@gmail.com>
-Date: Fri, 8 May 2020 00:49:18 -0400
-Subject: [PATCH] Fix PotionEffect ignores icon flag
-
-Co-authored-by: Tamion <70228790+notTamion@users.noreply.github.com>
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
- 
-     @Override
-     public boolean addPotionEffect(PotionEffect effect, boolean force) {
-        this.getHandle().addEffect(new MobEffectInstance(CraftPotionEffectType.bukkitToMinecraftHolder(effect.getType()), effect.getDuration(), effect.getAmplifier(), effect.isAmbient(), effect.hasParticles()), EntityPotionEffectEvent.Cause.PLUGIN);
-+        this.getHandle().addEffect(org.bukkit.craftbukkit.potion.CraftPotionUtil.fromBukkit(effect), EntityPotionEffectEvent.Cause.PLUGIN); // Paper - Don't ignore icon
-         return true;
-     }
- 
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-     @Override
-     public PotionEffect getPotionEffect(PotionEffectType type) {
-         MobEffectInstance handle = this.getHandle().getEffect(CraftPotionEffectType.bukkitToMinecraftHolder(type));
-        return (handle == null) ? null : new PotionEffect(CraftPotionEffectType.minecraftHolderToBukkit(handle.getEffect()), handle.getDuration(), handle.getAmplifier(), handle.isAmbient(), handle.isVisible());
-+        return (handle == null) ? null : org.bukkit.craftbukkit.potion.CraftPotionUtil.toBukkit(handle); // Paper
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-     public Collection<PotionEffect> getActivePotionEffects() {
-         List<PotionEffect> effects = new ArrayList<PotionEffect>();
-         for (MobEffectInstance handle : this.getHandle().activeEffects.values()) {
-            effects.add(new PotionEffect(CraftPotionEffectType.minecraftHolderToBukkit(handle.getEffect()), handle.getDuration(), handle.getAmplifier(), handle.isAmbient(), handle.isVisible()));
-+            effects.add(org.bukkit.craftbukkit.potion.CraftPotionUtil.toBukkit(handle)); // Paper
-         }
-         return effects;
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionUtil.java b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionUtil.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionUtil.java
-+++ b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionUtil.java
-@@ -0,0 +0,0 @@ public class CraftPotionUtil {
- 
-     public static MobEffectInstance fromBukkit(PotionEffect effect) {
-         Holder<MobEffect> type = CraftPotionEffectType.bukkitToMinecraftHolder(effect.getType());
-        return new MobEffectInstance(type, effect.getDuration(), effect.getAmplifier(), effect.isAmbient(), effect.hasParticles());
-+        return new MobEffectInstance(type, effect.getDuration(), effect.getAmplifier(), effect.isAmbient(), effect.hasParticles(), effect.hasIcon()); // Paper
-     }
- 
-     public static PotionEffect toBukkit(MobEffectInstance effect) {
-@@ -0,0 +0,0 @@ public class CraftPotionUtil {
-         int duration = effect.getDuration();
-         boolean ambient = effect.isAmbient();
-         boolean particles = effect.isVisible();
-        return new PotionEffect(type, duration, amp, ambient, particles);
-+        return new PotionEffect(type, duration, amp, ambient, particles, effect.showIcon()); // Paper
-     }
- 
-     public static boolean equals(Holder<MobEffect> mobEffect, PotionEffectType type) {
--- a/patches/unapplied/server/Fix-item-duplication-and-teleport-issues.patch
+++ b/patches/unapplied/server/Fix-item-duplication-and-teleport-issues.patch
@ -1,167 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 25 Apr 2020 06:46:35 -0400
-Subject: [PATCH] Fix item duplication and teleport issues
-
-This notably fixes the newest "Donkey Dupe", but also fixes a lot
-of dupe bugs in general around nether portals and entity world transfer
-
-We also fix item duplication generically by anytime we clone an item
-to drop it on the ground, destroy the source item.
-
-This avoid an itemstack ever existing twice in the world state pre
-clean up stage.
-
-So even if something NEW comes up, it would be impossible to drop the
-same item twice because the source was destroyed.
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-         } else {
-             // CraftBukkit start - Capture drops for death event
-             if (this instanceof net.minecraft.world.entity.LivingEntity && !((net.minecraft.world.entity.LivingEntity) this).forceDrops) {
-                ((net.minecraft.world.entity.LivingEntity) this).drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(stack));
-+                ((net.minecraft.world.entity.LivingEntity) this).drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(stack)); // Paper - mirror so we can destroy it later
-                 return null;
-             }
-             // CraftBukkit end
-            ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY() + (double) yOffset, this.getZ(), stack);
-+            ItemEntity entityitem = new ItemEntity(this.level(), this.getX(), this.getY() + (double) yOffset, this.getZ(), stack.copy()); // Paper - copy so we can destroy original
-+            stack.setCount(0); // Paper - destroy this item - if this ever leaks due to game bugs, ensure it doesn't dupe
- 
-             entityitem.setDefaultPickUpDelay();
-             // CraftBukkit start
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     @Nullable
-     public Entity teleportTo(ServerLevel worldserver, Vec3 location) {
-         // CraftBukkit end
-+        // Paper start - Fix item duplication and teleport issues
-+        if (!this.isAlive() || !this.valid) {
-+            LOGGER.warn("Illegal Entity Teleport " + this + " to " + worldserver + ":" + location, new Throwable());
-+            return null;
-+        }
-+        // Paper end - Fix item duplication and teleport issues
-         if (this.level() instanceof ServerLevel && !this.isRemoved()) {
-             this.level().getProfiler().push("changeDimension");
-             // CraftBukkit start
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                 // CraftBukkit end
- 
-                 this.level().getProfiler().popPush("reloading");
-+                // Paper start - Fix item duplication and teleport issues
-+                if (this instanceof Mob) {
-+                    ((Mob) this).dropLeash(true, true); // Paper drop lead
-+                }
-+                // Paper end - Fix item duplication and teleport issues
-                 Entity entity = this.getType().create(worldserver);
- 
-                 if (entity != null) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                     // CraftBukkit start - Forward the CraftEntity to the new entity
-                     this.getBukkitEntity().setHandle(entity);
-                     entity.bukkitEntity = this.getBukkitEntity();
-
-                    if (this instanceof Mob) {
-                        ((Mob) this).dropLeash(true, false); // Unleash to prevent duping of leads.
-                    }
-                     // CraftBukkit end
-                 }
- 
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     }
- 
-     public boolean canChangeDimensions() {
-        return !this.isPassenger() && !this.isVehicle();
-+        return !this.isPassenger() && !this.isVehicle() && isAlive() && valid; // Paper - Fix item duplication and teleport issues
-     }
- 
-     public float getBlockExplosionResistance(Explosion explosion, BlockGetter world, BlockPos pos, BlockState blockState, FluidState fluidState, float max) {
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                 // Paper start
-                 org.bukkit.event.entity.EntityDeathEvent deathEvent = this.dropAllDeathLoot(damageSource);
-                 if (deathEvent == null || !deathEvent.isCancelled()) {
-                    if (this.deathScore >= 0 && entityliving != null) {
-                        entityliving.awardKillScore(this, this.deathScore, damageSource);
-                    }
-+                    // if (this.deathScore >= 0 && entityliving != null) { // Paper - Fix item duplication and teleport issues; moved to be run earlier in #dropAllDeathLoot before destroying the drop items in CraftEventFactory#callEntityDeathEvent
-+                    //     entityliving.awardKillScore(this, this.deathScore, damageSource);
-+                    // }
-                     // Paper start - clear equipment if event is not cancelled
-                     if (this instanceof Mob) {
-                         for (EquipmentSlot slot : this.clearedEquipmentSlots) {
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-             this.dropCustomDeathLoot(source, i, flag);
-             this.clearEquipmentSlots = prev; // Paper
-         }
-        // CraftBukkit start - Call death event
-        org.bukkit.event.entity.EntityDeathEvent deathEvent = CraftEventFactory.callEntityDeathEvent(this, source, this.drops); // Paper
-+        // CraftBukkit start - Call death event // Paper start - call advancement triggers with correct entity equipment
-+        org.bukkit.event.entity.EntityDeathEvent deathEvent = CraftEventFactory.callEntityDeathEvent(this, source, this.drops, () -> {
-+            final LivingEntity entityliving = this.getKillCredit();
-+            if (this.deathScore >= 0 && entityliving != null) {
-+                entityliving.awardKillScore(this, this.deathScore, source);
-+            }
-+        }); // Paper end
-         this.postDeathDropItems(deathEvent); // Paper
-         this.drops = new ArrayList<>();
-         // CraftBukkit end
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-         for (i = 0; i < this.handItems.size(); ++i) {
-             itemstack = (ItemStack) this.handItems.get(i);
-             if (!itemstack.isEmpty()) {
-                this.drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(itemstack)); // CraftBukkit - add to drops
-+                this.drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack)); // CraftBukkit - add to drops // Paper - mirror so we can destroy it later - though this call site was safe
-                 this.handItems.set(i, ItemStack.EMPTY);
-             }
-         }
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-         for (i = 0; i < this.armorItems.size(); ++i) {
-             itemstack = (ItemStack) this.armorItems.get(i);
-             if (!itemstack.isEmpty()) {
-                this.drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(itemstack)); // CraftBukkit - add to drops
-+                this.drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack)); // CraftBukkit - add to drops // Paper - mirror so we can destroy it later - though this call site was safe
-                 this.armorItems.set(i, ItemStack.EMPTY);
-             }
-         }
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-     }
- 
-     public static EntityDeathEvent callEntityDeathEvent(net.minecraft.world.entity.LivingEntity victim, DamageSource damageSource, List<org.bukkit.inventory.ItemStack> drops) {
-+        // Paper start
-+        return CraftEventFactory.callEntityDeathEvent(victim, damageSource, drops, com.google.common.util.concurrent.Runnables.doNothing());
-+    }
-+    public static EntityDeathEvent callEntityDeathEvent(net.minecraft.world.entity.LivingEntity victim, DamageSource damageSource, List<org.bukkit.inventory.ItemStack> drops, Runnable lootCheck) {
-+        // Paper end
-         CraftLivingEntity entity = (CraftLivingEntity) victim.getBukkitEntity();
-         CraftDamageSource bukkitDamageSource = new CraftDamageSource(damageSource);
-         EntityDeathEvent event = new EntityDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward());
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         playDeathSound(victim, event);
-         // Paper end
-         victim.expToDrop = event.getDroppedExp();
-+        lootCheck.run(); // Paper - advancement triggers before destroying items
- 
-         for (org.bukkit.inventory.ItemStack stack : event.getDrops()) {
-             if (stack == null || stack.getType() == Material.AIR || stack.getAmount() == 0) continue;
- 
-            world.dropItem(entity.getLocation(), stack);
-+            world.dropItem(entity.getLocation(), stack); // Paper - note: dropItem already clones due to this being bukkit -> NMS
-+            if (stack instanceof CraftItemStack) stack.setAmount(0); // Paper - destroy this item - if this ever leaks due to game bugs, ensure it doesn't dupe, but don't nuke bukkit stacks of manually added items
-         }
- 
-         return event;
--- a/patches/unapplied/server/Fix-items-not-falling-correctly.patch
+++ b/patches/unapplied/server/Fix-items-not-falling-correctly.patch
@ -1,42 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: AJMFactsheets <AJMFactsheets@gmail.com>
-Date: Fri, 17 Jan 2020 17:17:54 -0600
-Subject: [PATCH] Fix items not falling correctly
-
-Since 1.14, Mojang has added an optimization which skips checking if
-an item should fall every fourth tick.
-
-However, Spigot's entity activation range class also has an
-optimization which skips ticking active entities every fourth tick.
-This can result in a state where an item will never properly fall
-due to its move method never being called.
-
-This patch resolves the conflict by offsetting checking Spigot's entity
-activation range check from an item's move method.
-
-diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-@@ -0,0 +0,0 @@ public class ItemEntity extends Entity implements TraceableEntity {
-                 }
-             }
- 
-            if (!this.onGround() || this.getDeltaMovement().horizontalDistanceSqr() > 9.999999747378752E-6D || (this.tickCount + this.getId()) % 4 == 0) {
-+            if (!this.onGround() || this.getDeltaMovement().horizontalDistanceSqr() > 9.999999747378752E-6D || (this.tickCount + this.getId()) % 4 == 0) { // Paper - Diff on change
-                 this.move(MoverType.SELF, this.getDeltaMovement());
-                 float f = 0.98F;
- 
-diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/spigotmc/ActivationRange.java
-+++ b/src/main/java/org/spigotmc/ActivationRange.java
-@@ -0,0 +0,0 @@ public class ActivationRange
-                 isActive = true;
-             }
-             // Add a little performance juice to active entities. Skip 1/4 if not immune.
-        } else if ( !entity.defaultActivationState && entity.tickCount % 4 == 0 && !ActivationRange.checkEntityImmunities( entity ) )
-+        } else if ( !entity.defaultActivationState && (entity.tickCount + entity.getId()) % 4 == 0 && !ActivationRange.checkEntityImmunities( entity ) ) // Paper - Ensure checking item movement is offset from Spigot's entity activation range check
-         {
-             isActive = false;
-         }
--- a/patches/unapplied/server/Fix-missing-chunks-due-to-integer-overflow.patch
+++ b/patches/unapplied/server/Fix-missing-chunks-due-to-integer-overflow.patch
@ -1,29 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: David Slovikosky <davidslovikosky@gmail.com>
-Date: Tue, 9 Jun 2020 00:10:03 -0700
-Subject: [PATCH] Fix missing chunks due to integer overflow
-
-This patch fixes a bug in the EndIslandDensityFunction class where the distance
-from 0,0 squared overflows the maximum size of an integer. The overflow leads
-to hard chunk borders around 370,000 blocks from 0,0. After this cutoff there
-is a few hundred thousand block gap before end land resuming to generate at
-530,000 blocks from spawn. This is due to the integer flipping back and forth.
-
-The fix for the issue is quite simple, casting chunk coordinates to longs
-allows the distance calculation to avoid overflow and work as intended.
-
-This issue is being tracked in Mojira ticket MC-159283
-
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java b/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java
-@@ -0,0 +0,0 @@ public final class DensityFunctions {
-             int j = z / 2;
-             int k = x % 2;
-             int l = z % 2;
-            float f = 100.0F - Mth.sqrt((float)(x * x + z * z)) * 8.0F;
-+            float f = 100.0F - Mth.sqrt((long) x * (long) x + (long) z * (long) z) * 8.0F; // Paper - cast ints to long to avoid integer overflow
-             f = Mth.clamp(f, -100.0F, 80.0F);
- 
-             for (int m = -12; m <= 12; m++) {
--- a/patches/unapplied/server/Fix-piston-physics-inconsistency-MC-188840.patch
+++ b/patches/unapplied/server/Fix-piston-physics-inconsistency-MC-188840.patch
@ -1,80 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Thu, 11 Jun 2020 17:29:42 -0700
-Subject: [PATCH] Fix piston physics inconsistency - MC-188840
-
-Pistons invoke physics when they move blocks. The physics can cause
-tnt blocks to ignite. However, pistons (when storing the blocks they "moved")
-don't actually go back to the world state sometimes to check if something
-like that happened. As a result they end up moving the tnt like it was
-never ignited. This resulted in the ability to create machines
-that can duplicate tnt, called "world eaters".
-This patch makes the piston logic retrieve the block state from the world
-prevent this from occuring.
-
-This patch also sets the moved pos to air immediately after creating
-the moving piston TE. This prevents the block from being updated from
-other physics calls by the piston.
-
-Tested against the following tnt duper design:
-https://www.youtube.com/watch?v=mS7xxNGhjxs
-
-This patch also affects every type of machine that utilises
-this mechanic. For example, dead coral is removed by a physics
-update when being moved while it is attached to slimeblocks.
-
-Standard piston machines that don't destroy or modify the
-blocks they move by physics updates should be entirely
-unaffected.
-
-This patch fixes https://bugs.mojang.com/browse/MC-188840
-
-This patch also fixes rail duping and carpet duping.
-
-diff --git a/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java b/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/piston/PistonBaseBlock.java
-@@ -0,0 +0,0 @@ public class PistonBaseBlock extends DirectionalBlock {
-             }
- 
-             for (j = list.size() - 1; j >= 0; --j) {
-                blockposition3 = (BlockPos) list.get(j);
-                iblockdata1 = world.getBlockState(blockposition3);
-+                // Paper start - fix a variety of piston desync dupes
-+                boolean allowDesync = io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.allowPistonDuplication;
-+                BlockPos oldPos = blockposition3 = (BlockPos) list.get(j);
-+                iblockdata1 = allowDesync ? world.getBlockState(oldPos) : null;
-+                // Paper end - fix a variety of piston desync dupes
-                 blockposition3 = blockposition3.relative(enumdirection1);
-                 map.remove(blockposition3);
-                 BlockState iblockdata2 = (BlockState) Blocks.MOVING_PISTON.defaultBlockState().setValue(PistonBaseBlock.FACING, dir);
- 
-                 world.setBlock(blockposition3, iblockdata2, 68);
-                world.setBlockEntity(MovingPistonBlock.newMovingBlockEntity(blockposition3, iblockdata2, (BlockState) list1.get(j), dir, retract, false));
-+                // Paper start - fix a variety of piston desync dupes
-+                if (!allowDesync) {
-+                    iblockdata1 = world.getBlockState(oldPos);
-+                    map.replace(oldPos, iblockdata1);
-+                }
-+                world.setBlockEntity(MovingPistonBlock.newMovingBlockEntity(blockposition3, iblockdata2, allowDesync ? list1.get(j) : iblockdata1, dir, retract, false));
-+                if (!allowDesync) {
-+                    world.setBlock(oldPos, Blocks.AIR.defaultBlockState(), Block.UPDATE_CLIENTS | Block.UPDATE_KNOWN_SHAPE | Block.UPDATE_MOVE_BY_PISTON | 1024); // set air to prevent later physics updates from seeing this block
-+                }
-+                // Paper end - fix a variety of piston desync dupes
-                 aiblockdata[i++] = iblockdata1;
-             }
- 
-diff --git a/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java b/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
-@@ -0,0 +0,0 @@ public class PistonMovingBlockEntity extends BlockEntity {
-                 if (world.getBlockState(pos).is(Blocks.MOVING_PISTON)) {
-                     BlockState blockState = Block.updateFromNeighbourShapes(blockEntity.movedState, world, pos);
-                     if (blockState.isAir()) {
-                        world.setBlock(pos, blockEntity.movedState, 84);
-+                        world.setBlock(pos, blockEntity.movedState, io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.allowPistonDuplication ? 84 : (84 | Block.UPDATE_CLIENTS)); // Paper - fix a variety of piston desync dupes; force notify (flag 2), it's possible the set type by the piston block (which doesn't notify) set this block to air
-                         Block.updateOrDestroy(blockEntity.movedState, blockState, world, pos, 3);
-                     } else {
-                         if (blockState.hasProperty(BlockStateProperties.WATERLOGGED) && blockState.getValue(BlockStateProperties.WATERLOGGED)) {
--- a/patches/unapplied/server/Fix-sounds-when-item-frames-are-modified-MC-123450.patch
+++ b/patches/unapplied/server/Fix-sounds-when-item-frames-are-modified-MC-123450.patch
@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Phoenix616 <mail@moep.tv>
-Date: Sat, 27 Apr 2019 20:00:43 +0100
-Subject: [PATCH] Fix sounds when item frames are modified (MC-123450)
-
-This also fixes the adding sound playing when the item frame direction is changed.
-
-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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
-@@ -0,0 +0,0 @@ public class ItemFrame extends HangingEntity {
- 
-         this.onItemChanged(itemstack);
-         this.getEntityData().set(ItemFrame.DATA_ITEM, itemstack);
-        if (!itemstack.isEmpty() && playSound) { // CraftBukkit
-+        if (!itemstack.isEmpty() && flag && playSound) { // CraftBukkit // Paper - only play sound when update flag is set
-             this.playSound(this.getAddItemSound(), 1.0F, 1.0F);
-         }
- 
--- a/patches/unapplied/server/Fix-villager-trading-demand-MC-163962.patch
+++ b/patches/unapplied/server/Fix-villager-trading-demand-MC-163962.patch
@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: chickeneer <emcchickeneer@gmail.com>
-Date: Fri, 5 Jun 2020 20:02:04 -0500
-Subject: [PATCH] Fix villager trading demand - MC-163962
-
-Prevent demand from going negative and tending to negative infinity
-
-diff --git a/src/main/java/net/minecraft/world/item/trading/MerchantOffer.java b/src/main/java/net/minecraft/world/item/trading/MerchantOffer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/item/trading/MerchantOffer.java
-+++ b/src/main/java/net/minecraft/world/item/trading/MerchantOffer.java
-@@ -0,0 +0,0 @@ public class MerchantOffer {
-     }
- 
-     public void updateDemand() {
-        this.demand = this.demand + this.uses - (this.maxUses - this.uses);
-+        this.demand = Math.max(0, this.demand + this.uses - (this.maxUses - this.uses)); // Paper - Fix MC-163962
-     }
- 
-     public ItemStack assemble() {
--- a/patches/unapplied/server/Guard-against-serializing-mismatching-chunk-coordina.patch
+++ b/patches/unapplied/server/Guard-against-serializing-mismatching-chunk-coordina.patch
@ -1,51 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Fri, 27 Dec 2019 09:42:26 -0800
-Subject: [PATCH] Guard against serializing mismatching chunk coordinate
-
-Should help if something dumb happens
-
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
-@@ -0,0 +0,0 @@ public class ChunkSerializer {
- 
-     public ChunkSerializer() {}
- 
-+    // Paper start - guard against serializing mismatching coordinates
-+    // TODO Note: This needs to be re-checked each update
-+    public static ChunkPos getChunkCoordinate(final CompoundTag chunkData) {
-+        final int dataVersion = ChunkStorage.getVersion(chunkData);
-+        if (dataVersion < 2842) { // Level tag is removed after this version
-+            final CompoundTag levelData = chunkData.getCompound("Level");
-+            return new ChunkPos(levelData.getInt("xPos"), levelData.getInt("zPos"));
-+        } else {
-+            return new ChunkPos(chunkData.getInt("xPos"), chunkData.getInt("zPos"));
-+        }
-+    }
-+    // Paper end - guard against serializing mismatching coordinates
-     public static ProtoChunk read(ServerLevel world, PoiManager poiStorage, ChunkPos chunkPos, CompoundTag nbt) {
-        ChunkPos chunkcoordintpair1 = new ChunkPos(nbt.getInt("xPos"), nbt.getInt("zPos"));
-+        ChunkPos chunkcoordintpair1 = new ChunkPos(nbt.getInt("xPos"), nbt.getInt("zPos")); // Paper - guard against serializing mismatching coordinates; diff on change, see ChunkSerializer#getChunkCoordinate
- 
-         if (!Objects.equals(chunkPos, chunkcoordintpair1)) {
-             ChunkSerializer.LOGGER.error("Chunk file at {} is in the wrong location; relocating. (Expected {}, got {})", new Object[]{chunkPos, chunkPos, chunkcoordintpair1});
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java
-@@ -0,0 +0,0 @@ public class ChunkStorage implements AutoCloseable {
-     }
- 
-     public CompletableFuture<Void> write(ChunkPos chunkPos, CompoundTag nbt) {
-+        // Paper start - guard against serializing mismatching coordinates
-+        if (nbt != null && !chunkPos.equals(ChunkSerializer.getChunkCoordinate(nbt))) {
-+            final String world = (this instanceof net.minecraft.server.level.ChunkMap) ? ((net.minecraft.server.level.ChunkMap) this).level.getWorld().getName() : null;
-+            throw new IllegalArgumentException("Chunk coordinate and serialized data do not have matching coordinates, trying to serialize coordinate " + chunkPos
-+                + " but compound says coordinate is " + ChunkSerializer.getChunkCoordinate(nbt) + (world == null ? " for an unknown world" : (" for world: " + world)));
-+        }
-+        // Paper end - guard against serializing mismatching coordinates
-         this.handleLegacyStructureIndex(chunkPos);
-         return this.worker.store(chunkPos, nbt);
-     }
--- a/patches/unapplied/server/Hide-sync-chunk-writes-behind-flag.patch
+++ b/patches/unapplied/server/Hide-sync-chunk-writes-behind-flag.patch
@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Fri, 26 Jun 2020 22:35:08 -0700
-Subject: [PATCH] Hide sync chunk writes behind flag
-
-Syncing writes on each write call has terrible performance
-on harddrives.
-
-DPaper.enable-sync-chunk-writes=true to enable
-
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java
-+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java
-@@ -0,0 +0,0 @@ public class DedicatedServerProperties extends Settings<DedicatedServerPropertie
-         this.maxWorldSize = this.get("max-world-size", (integer) -> {
-             return Mth.clamp(integer, 1, 29999984);
-         }, 29999984);
-        this.syncChunkWrites = this.get("sync-chunk-writes", true);
-+        this.syncChunkWrites = this.get("sync-chunk-writes", true) && Boolean.getBoolean("Paper.enable-sync-chunk-writes"); // Paper - Hide sync chunk writes behind flag
-         this.regionFileComression = this.get("region-file-compression", "deflate");
-         this.enableJmxMonitoring = this.get("enable-jmx-monitoring", false);
-         this.enableStatus = this.get("enable-status", true);
--- a/patches/unapplied/server/Implement-CraftBlockSoundGroup.patch
+++ b/patches/unapplied/server/Implement-CraftBlockSoundGroup.patch
@ -1,72 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: simpleauthority <jacob@algorithmjunkie.com>
-Date: Tue, 28 May 2019 03:48:51 -0700
-Subject: [PATCH] Implement CraftBlockSoundGroup
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/block/CraftBlockSoundGroup.java b/src/main/java/com/destroystokyo/paper/block/CraftBlockSoundGroup.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/block/CraftBlockSoundGroup.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.block;
-+
-+import net.minecraft.world.level.block.SoundType;
-+import org.bukkit.Sound;
-+import org.bukkit.craftbukkit.CraftSound;
-+
-+@Deprecated(forRemoval = true)
-+public class CraftBlockSoundGroup implements BlockSoundGroup {
-+    private final SoundType soundEffectType;
-+
-+    public CraftBlockSoundGroup(SoundType soundEffectType) {
-+        this.soundEffectType = soundEffectType;
-+    }
-+
-+    @Override
-+    public Sound getBreakSound() {
-+        return CraftSound.minecraftToBukkit(soundEffectType.getBreakSound());
-+    }
-+
-+    @Override
-+    public Sound getStepSound() {
-+        return CraftSound.minecraftToBukkit(soundEffectType.getStepSound());
-+    }
-+
-+    @Override
-+    public Sound getPlaceSound() {
-+        return CraftSound.minecraftToBukkit(soundEffectType.getPlaceSound());
-+    }
-+
-+    @Override
-+    public Sound getHitSound() {
-+        return CraftSound.minecraftToBukkit(soundEffectType.getHitSound());
-+    }
-+
-+    @Override
-+    public Sound getFallSound() {
-+        return CraftSound.minecraftToBukkit(soundEffectType.getFallSound());
-+    }
-+}
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-@@ -0,0 +0,0 @@ public class CraftBlock implements Block {
-     public String getTranslationKey() {
-         return this.getNMS().getBlock().getDescriptionId();
-     }
-+
-+    // Paper start
-+    @Override
-+    public com.destroystokyo.paper.block.BlockSoundGroup getSoundGroup() {
-+        return new com.destroystokyo.paper.block.CraftBlockSoundGroup(getNMS().getBlock().defaultBlockState().getSoundType());
-+    }
-+
-+    @Override
-+    public org.bukkit.SoundGroup getBlockSoundGroup() {
-+        return org.bukkit.craftbukkit.CraftSoundGroup.getSoundGroup(this.getNMS().getSoundType());
-+    }
-+    // Paper end
- }
--- a/patches/unapplied/server/Implement-Mob-Goal-API.patch
+++ b/patches/unapplied/server/Implement-Mob-Goal-API.patch
@ -1,798 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MiniDigger | Martin <admin@minidigger.dev>
-Date: Fri, 3 Jan 2020 16:26:19 +0100
-Subject: [PATCH] Implement Mob Goal API
-
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -0,0 +0,0 @@ dependencies {
-     runtimeOnly("org.apache.maven.resolver:maven-resolver-connector-basic:1.9.18")
-     runtimeOnly("org.apache.maven.resolver:maven-resolver-transport-http:1.9.18")
- 
-+    testImplementation("io.github.classgraph:classgraph:4.8.47") // Paper - mob goal test
-     testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
-     testImplementation("org.hamcrest:hamcrest:2.2")
-     testImplementation("org.mockito:mockito-core:5.11.0")
-diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/MobGoalHelper.java b/src/main/java/com/destroystokyo/paper/entity/ai/MobGoalHelper.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/entity/ai/MobGoalHelper.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.entity.ai;
-+
-+import com.destroystokyo.paper.entity.RangedEntity;
-+import com.destroystokyo.paper.util.set.OptimizedSmallEnumSet;
-+import com.google.common.collect.BiMap;
-+import com.google.common.collect.HashBiMap;
-+import io.papermc.paper.util.ObfHelper;
-+import java.lang.reflect.Constructor;
-+import java.util.EnumSet;
-+import java.util.HashMap;
-+import java.util.HashSet;
-+import java.util.Map;
-+import java.util.Set;
-+import net.minecraft.world.entity.FlyingMob;
-+import net.minecraft.world.entity.PathfinderMob;
-+import net.minecraft.world.entity.TamableAnimal;
-+import net.minecraft.world.entity.ai.goal.Goal;
-+import net.minecraft.world.entity.ambient.AmbientCreature;
-+import net.minecraft.world.entity.animal.AbstractFish;
-+import net.minecraft.world.entity.animal.AbstractGolem;
-+import net.minecraft.world.entity.animal.AbstractSchoolingFish;
-+import net.minecraft.world.entity.animal.Animal;
-+import net.minecraft.world.entity.animal.Pufferfish;
-+import net.minecraft.world.entity.animal.ShoulderRidingEntity;
-+import net.minecraft.world.entity.animal.SnowGolem;
-+import net.minecraft.world.entity.animal.WaterAnimal;
-+import net.minecraft.world.entity.animal.camel.Camel;
-+import net.minecraft.world.entity.animal.horse.AbstractChestedHorse;
-+import net.minecraft.world.entity.boss.wither.WitherBoss;
-+import net.minecraft.world.entity.monster.AbstractIllager;
-+import net.minecraft.world.entity.monster.EnderMan;
-+import net.minecraft.world.entity.monster.PatrollingMonster;
-+import net.minecraft.world.entity.monster.RangedAttackMob;
-+import net.minecraft.world.entity.monster.SpellcasterIllager;
-+import net.minecraft.world.entity.monster.ZombifiedPiglin;
-+import net.minecraft.world.entity.monster.breeze.Breeze;
-+import net.minecraft.world.entity.monster.piglin.AbstractPiglin;
-+import org.bukkit.NamespacedKey;
-+import org.bukkit.entity.AbstractHorse;
-+import org.bukkit.entity.AbstractSkeleton;
-+import org.bukkit.entity.AbstractVillager;
-+import org.bukkit.entity.Ageable;
-+import org.bukkit.entity.Ambient;
-+import org.bukkit.entity.Animals;
-+import org.bukkit.entity.Bat;
-+import org.bukkit.entity.Bee;
-+import org.bukkit.entity.Blaze;
-+import org.bukkit.entity.Cat;
-+import org.bukkit.entity.CaveSpider;
-+import org.bukkit.entity.ChestedHorse;
-+import org.bukkit.entity.Chicken;
-+import org.bukkit.entity.Cod;
-+import org.bukkit.entity.Cow;
-+import org.bukkit.entity.Creature;
-+import org.bukkit.entity.Creeper;
-+import org.bukkit.entity.Dolphin;
-+import org.bukkit.entity.Donkey;
-+import org.bukkit.entity.Drowned;
-+import org.bukkit.entity.ElderGuardian;
-+import org.bukkit.entity.EnderDragon;
-+import org.bukkit.entity.Enderman;
-+import org.bukkit.entity.Endermite;
-+import org.bukkit.entity.Evoker;
-+import org.bukkit.entity.Fish;
-+import org.bukkit.entity.Flying;
-+import org.bukkit.entity.Fox;
-+import org.bukkit.entity.Ghast;
-+import org.bukkit.entity.Giant;
-+import org.bukkit.entity.Golem;
-+import org.bukkit.entity.Guardian;
-+import org.bukkit.entity.Hoglin;
-+import org.bukkit.entity.Horse;
-+import org.bukkit.entity.Husk;
-+import org.bukkit.entity.Illager;
-+import org.bukkit.entity.Illusioner;
-+import org.bukkit.entity.IronGolem;
-+import org.bukkit.entity.Llama;
-+import org.bukkit.entity.MagmaCube;
-+import org.bukkit.entity.Mob;
-+import org.bukkit.entity.Monster;
-+import org.bukkit.entity.Mule;
-+import org.bukkit.entity.MushroomCow;
-+import org.bukkit.entity.Ocelot;
-+import org.bukkit.entity.Panda;
-+import org.bukkit.entity.Parrot;
-+import org.bukkit.entity.Phantom;
-+import org.bukkit.entity.Pig;
-+import org.bukkit.entity.PigZombie;
-+import org.bukkit.entity.Piglin;
-+import org.bukkit.entity.PiglinAbstract;
-+import org.bukkit.entity.PiglinBrute;
-+import org.bukkit.entity.Pillager;
-+import org.bukkit.entity.PolarBear;
-+import org.bukkit.entity.PufferFish;
-+import org.bukkit.entity.Rabbit;
-+import org.bukkit.entity.Raider;
-+import org.bukkit.entity.Ravager;
-+import org.bukkit.entity.Salmon;
-+import org.bukkit.entity.Sheep;
-+import org.bukkit.entity.Shulker;
-+import org.bukkit.entity.Silverfish;
-+import org.bukkit.entity.Skeleton;
-+import org.bukkit.entity.SkeletonHorse;
-+import org.bukkit.entity.Slime;
-+import org.bukkit.entity.Snowman;
-+import org.bukkit.entity.Spellcaster;
-+import org.bukkit.entity.Spider;
-+import org.bukkit.entity.Squid;
-+import org.bukkit.entity.Stray;
-+import org.bukkit.entity.Strider;
-+import org.bukkit.entity.Tameable;
-+import org.bukkit.entity.TraderLlama;
-+import org.bukkit.entity.TropicalFish;
-+import org.bukkit.entity.Turtle;
-+import org.bukkit.entity.Vex;
-+import org.bukkit.entity.Villager;
-+import org.bukkit.entity.Vindicator;
-+import org.bukkit.entity.WanderingTrader;
-+import org.bukkit.entity.WaterMob;
-+import org.bukkit.entity.Witch;
-+import org.bukkit.entity.Wither;
-+import org.bukkit.entity.WitherSkeleton;
-+import org.bukkit.entity.Wolf;
-+import org.bukkit.entity.Zoglin;
-+import org.bukkit.entity.Zombie;
-+import org.bukkit.entity.ZombieHorse;
-+import org.bukkit.entity.ZombieVillager;
-+
-+public class MobGoalHelper {
-+
-+    private static final BiMap<String, String> deobfuscationMap = HashBiMap.create();
-+    private static final Map<Class<? extends Goal>, Class<? extends Mob>> entityClassCache = new HashMap<>();
-+    private static final Map<Class<? extends net.minecraft.world.entity.Mob>, Class<? extends Mob>> bukkitMap = new HashMap<>();
-+
-+    static final Set<String> ignored = new HashSet<>();
-+
-+    static {
-+        // TODO these kinda should be checked on each release, in case obfuscation changes
-+        deobfuscationMap.put("abstract_skeleton_1", "abstract_skeleton_melee");
-+
-+        ignored.add("goal_selector_1");
-+        ignored.add("goal_selector_2");
-+        ignored.add("selector_1");
-+        ignored.add("selector_2");
-+        ignored.add("wrapped");
-+
-+        bukkitMap.put(net.minecraft.world.entity.Mob.class, Mob.class);
-+        bukkitMap.put(net.minecraft.world.entity.AgeableMob.class, Ageable.class);
-+        bukkitMap.put(AmbientCreature.class, Ambient.class);
-+        bukkitMap.put(Animal.class, Animals.class);
-+        bukkitMap.put(net.minecraft.world.entity.ambient.Bat.class, Bat.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Bee.class, Bee.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Blaze.class, Blaze.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Cat.class, Cat.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.CaveSpider.class, CaveSpider.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Chicken.class, Chicken.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Cod.class, Cod.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Cow.class, Cow.class);
-+        bukkitMap.put(PathfinderMob.class, Creature.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Creeper.class, Creeper.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Dolphin.class, Dolphin.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Drowned.class, Drowned.class);
-+        bukkitMap.put(net.minecraft.world.entity.boss.enderdragon.EnderDragon.class, EnderDragon.class);
-+        bukkitMap.put(EnderMan.class, Enderman.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Endermite.class, Endermite.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Evoker.class, Evoker.class);
-+        bukkitMap.put(AbstractFish.class, Fish.class);
-+        bukkitMap.put(AbstractSchoolingFish.class, Fish.class); // close enough
-+        bukkitMap.put(FlyingMob.class, Flying.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Fox.class, Fox.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Ghast.class, Ghast.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Giant.class, Giant.class);
-+        bukkitMap.put(AbstractGolem.class, Golem.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Guardian.class, Guardian.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.ElderGuardian.class, ElderGuardian.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.horse.Horse.class, Horse.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.horse.AbstractHorse.class, AbstractHorse.class);
-+        bukkitMap.put(AbstractChestedHorse.class, ChestedHorse.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.horse.Donkey.class, Donkey.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.horse.Mule.class, Mule.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.horse.SkeletonHorse.class, SkeletonHorse.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.horse.ZombieHorse.class, ZombieHorse.class);
-+        bukkitMap.put(Camel.class, org.bukkit.entity.Camel.class);
-+        bukkitMap.put(AbstractIllager.class, Illager.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Illusioner.class, Illusioner.class);
-+        bukkitMap.put(SpellcasterIllager.class, Spellcaster.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.IronGolem.class, IronGolem.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.horse.Llama.class, Llama.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.horse.TraderLlama.class, TraderLlama.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.MagmaCube.class, MagmaCube.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Monster.class, Monster.class);
-+        bukkitMap.put(PatrollingMonster.class, Raider.class); // close enough
-+        bukkitMap.put(net.minecraft.world.entity.animal.MushroomCow.class, MushroomCow.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Ocelot.class, Ocelot.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Panda.class, Panda.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Parrot.class, Parrot.class);
-+        bukkitMap.put(ShoulderRidingEntity.class, Parrot.class); // close enough
-+        bukkitMap.put(net.minecraft.world.entity.monster.Phantom.class, Phantom.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Pig.class, Pig.class);
-+        bukkitMap.put(ZombifiedPiglin.class, PigZombie.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Pillager.class, Pillager.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.PolarBear.class, PolarBear.class);
-+        bukkitMap.put(Pufferfish.class, PufferFish.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Rabbit.class, Rabbit.class);
-+        bukkitMap.put(net.minecraft.world.entity.raid.Raider.class, Raider.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Ravager.class, Ravager.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Salmon.class, Salmon.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Sheep.class, Sheep.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Shulker.class, Shulker.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Silverfish.class, Silverfish.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Skeleton.class, Skeleton.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.AbstractSkeleton.class, AbstractSkeleton.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Stray.class, Stray.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.WitherSkeleton.class, WitherSkeleton.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Slime.class, Slime.class);
-+        bukkitMap.put(SnowGolem.class, Snowman.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Spider.class, Spider.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Squid.class, Squid.class);
-+        bukkitMap.put(TamableAnimal.class, Tameable.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.TropicalFish.class, TropicalFish.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Turtle.class, Turtle.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Vex.class, Vex.class);
-+        bukkitMap.put(net.minecraft.world.entity.npc.Villager.class, Villager.class);
-+        bukkitMap.put(net.minecraft.world.entity.npc.AbstractVillager.class, AbstractVillager.class);
-+        bukkitMap.put(net.minecraft.world.entity.npc.WanderingTrader.class, WanderingTrader.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Vindicator.class, Vindicator.class);
-+        bukkitMap.put(WaterAnimal.class, WaterMob.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Witch.class, Witch.class);
-+        bukkitMap.put(WitherBoss.class, Wither.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.Wolf.class, Wolf.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Zombie.class, Zombie.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Husk.class, Husk.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.ZombieVillager.class, ZombieVillager.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.hoglin.Hoglin.class, Hoglin.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.piglin.Piglin.class, Piglin.class);
-+        bukkitMap.put(AbstractPiglin.class, PiglinAbstract.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.piglin.PiglinBrute.class, PiglinBrute.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Strider.class, Strider.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Zoglin.class, Zoglin.class);
-+        bukkitMap.put(net.minecraft.world.entity.GlowSquid.class, org.bukkit.entity.GlowSquid.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.axolotl.Axolotl.class, org.bukkit.entity.Axolotl.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.goat.Goat.class, org.bukkit.entity.Goat.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.frog.Frog.class, org.bukkit.entity.Frog.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.frog.Tadpole.class, org.bukkit.entity.Tadpole.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.warden.Warden.class, org.bukkit.entity.Warden.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.allay.Allay.class, org.bukkit.entity.Allay.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.sniffer.Sniffer.class, org.bukkit.entity.Sniffer.class);
-+        bukkitMap.put(Breeze.class, org.bukkit.entity.Breeze.class);
-+        bukkitMap.put(net.minecraft.world.entity.animal.armadillo.Armadillo.class, org.bukkit.entity.Armadillo.class);
-+        bukkitMap.put(net.minecraft.world.entity.monster.Bogged.class, org.bukkit.entity.Bogged.class);
-+    }
-+
-+    public static String getUsableName(Class<?> clazz) {
-+        String name = io.papermc.paper.util.MappingEnvironment.reobf() ? ObfHelper.INSTANCE.deobfClassName(clazz.getName()) : clazz.getName();
-+        name = name.substring(name.lastIndexOf(".") + 1);
-+        boolean flag = false;
-+        // inner classes
-+        if (name.contains("$")) {
-+            String cut = name.substring(name.indexOf("$") + 1);
-+            if (cut.length() <= 2) {
-+                name = name.replace("Entity", "");
-+                name = name.replace("$", "_");
-+                flag = true;
-+            } else {
-+                // mapped, wooo
-+                name = cut;
-+            }
-+        }
-+        name = name.replace("PathfinderGoal", "");
-+        name = name.replace("TargetGoal", "");
-+        name = name.replace("Goal", "");
-+        StringBuilder sb = new StringBuilder();
-+        for (char c : name.toCharArray()) {
-+            if (c >= 'A' && c <= 'Z') {
-+                sb.append("_");
-+                sb.append(Character.toLowerCase(c));
-+            } else {
-+                sb.append(c);
-+            }
-+        }
-+        name = sb.toString();
-+        name = name.replaceFirst("_", "");
-+
-+        if (flag && !deobfuscationMap.containsKey(name.toLowerCase(java.util.Locale.ROOT)) && !ignored.contains(name)) {
-+            System.out.println("need to map " + clazz.getName() + " (" + name.toLowerCase(java.util.Locale.ROOT) + ")");
-+        }
-+
-+        // did we rename this key?
-+        return deobfuscationMap.getOrDefault(name, name);
-+    }
-+
-+    public static EnumSet<GoalType> vanillaToPaper(Goal goal) {
-+        EnumSet<GoalType> goals = EnumSet.noneOf(GoalType.class);
-+        for (GoalType type : GoalType.values()) {
-+            if (goal.getFlags().contains(paperToVanilla(type))) {
-+                goals.add(type);
-+            }
-+        }
-+        return goals;
-+    }
-+
-+    public static GoalType vanillaToPaper(Goal.Flag type) {
-+        switch (type) {
-+            case MOVE:
-+                return GoalType.MOVE;
-+            case LOOK:
-+                return GoalType.LOOK;
-+            case JUMP:
-+                return GoalType.JUMP;
-+            case UNKNOWN_BEHAVIOR:
-+                return GoalType.UNKNOWN_BEHAVIOR;
-+            case TARGET:
-+                return GoalType.TARGET;
-+            default:
-+                throw new IllegalArgumentException("Unknown vanilla mob goal type " + type.name());
-+        }
-+    }
-+
-+    public static EnumSet<Goal.Flag> paperToVanilla(EnumSet<GoalType> types) {
-+        EnumSet<Goal.Flag> goals = EnumSet.noneOf(Goal.Flag.class);
-+        for (GoalType type : types) {
-+            goals.add(paperToVanilla(type));
-+        }
-+        return goals;
-+    }
-+
-+    public static Goal.Flag paperToVanilla(GoalType type) {
-+        switch (type) {
-+            case MOVE:
-+                return Goal.Flag.MOVE;
-+            case LOOK:
-+                return Goal.Flag.LOOK;
-+            case JUMP:
-+                return Goal.Flag.JUMP;
-+            case UNKNOWN_BEHAVIOR:
-+                return Goal.Flag.UNKNOWN_BEHAVIOR;
-+            case TARGET:
-+                return Goal.Flag.TARGET;
-+            default:
-+                throw new IllegalArgumentException("Unknown paper mob goal type " + type.name());
-+        }
-+    }
-+
-+    public static <T extends Mob> GoalKey<T> getKey(Class<? extends Goal> goalClass) {
-+        String name = getUsableName(goalClass);
-+        if (ignored.contains(name)) {
-+            //noinspection unchecked
-+            return (GoalKey<T>) GoalKey.of(Mob.class, NamespacedKey.minecraft(name));
-+        }
-+        return GoalKey.of(getEntity(goalClass), NamespacedKey.minecraft(name));
-+    }
-+
-+    public static <T extends Mob> Class<T> getEntity(Class<? extends Goal> goalClass) {
-+        //noinspection unchecked
-+        return (Class<T>) entityClassCache.computeIfAbsent(goalClass, key -> {
-+            for (Constructor<?> ctor : key.getDeclaredConstructors()) {
-+                for (int i = 0; i < ctor.getParameterCount(); i++) {
-+                    Class<?> param = ctor.getParameterTypes()[i];
-+                    if (net.minecraft.world.entity.Mob.class.isAssignableFrom(param)) {
-+                        //noinspection unchecked
-+                        return toBukkitClass((Class<? extends net.minecraft.world.entity.Mob>) param);
-+                    } else if (RangedAttackMob.class.isAssignableFrom(param)) {
-+                        return RangedEntity.class;
-+                    }
-+                }
-+            }
-+            throw new RuntimeException("Can't figure out applicable entity for mob goal " + goalClass); // maybe just return EntityInsentient?
-+        });
-+    }
-+
-+    public static Class<? extends Mob> toBukkitClass(Class<? extends net.minecraft.world.entity.Mob> nmsClass) {
-+        Class<? extends Mob> bukkitClass = bukkitMap.get(nmsClass);
-+        if (bukkitClass == null) {
-+            throw new RuntimeException("Can't figure out applicable bukkit entity for nms entity " + nmsClass); // maybe just return Mob?
-+        }
-+        return bukkitClass;
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/PaperCustomGoal.java b/src/main/java/com/destroystokyo/paper/entity/ai/PaperCustomGoal.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/entity/ai/PaperCustomGoal.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.entity.ai;
-+
-+import org.bukkit.entity.Mob;
-+
-+/**
-+ * Wraps api in vanilla
-+ */
-+public class PaperCustomGoal<T extends Mob> extends net.minecraft.world.entity.ai.goal.Goal {
-+
-+    private final Goal<T> handle;
-+
-+    public PaperCustomGoal(Goal<T> handle) {
-+        this.handle = handle;
-+
-+        this.setFlags(MobGoalHelper.paperToVanilla(handle.getTypes()));
-+        if (this.getFlags().size() == 0) {
-+            this.getFlags().add(Flag.UNKNOWN_BEHAVIOR);
-+        }
-+    }
-+
-+    @Override
-+    public boolean canUse() {
-+        return handle.shouldActivate();
-+    }
-+
-+    @Override
-+    public boolean canContinueToUse() {
-+        return handle.shouldStayActive();
-+    }
-+
-+    @Override
-+    public void start() {
-+        handle.start();
-+    }
-+
-+    @Override
-+    public void stop() {
-+        handle.stop();
-+    }
-+
-+    @Override
-+    public void tick() {
-+        handle.tick();
-+    }
-+
-+    public Goal<T> getHandle() {
-+        return handle;
-+    }
-+
-+    public GoalKey<T> getKey() {
-+        return handle.getKey();
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/PaperMobGoals.java b/src/main/java/com/destroystokyo/paper/entity/ai/PaperMobGoals.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/entity/ai/PaperMobGoals.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.entity.ai;
-+
-+import java.util.Collection;
-+import java.util.EnumSet;
-+import java.util.HashSet;
-+import java.util.LinkedList;
-+import java.util.List;
-+import java.util.Set;
-+import net.minecraft.world.entity.ai.goal.GoalSelector;
-+import net.minecraft.world.entity.ai.goal.WrappedGoal;
-+import org.bukkit.craftbukkit.entity.CraftMob;
-+import org.bukkit.entity.Mob;
-+
-+public class PaperMobGoals implements MobGoals {
-+
-+    @Override
-+    public <T extends Mob> void addGoal(T mob, int priority, Goal<T> goal) {
-+        CraftMob craftMob = (CraftMob) mob;
-+        net.minecraft.world.entity.ai.goal.Goal mojangGoal;
-+
-+        if (goal instanceof PaperVanillaGoal vanillaGoal) {
-+            mojangGoal = vanillaGoal.getHandle();
-+        } else {
-+            mojangGoal = new PaperCustomGoal<>(goal);
-+        }
-+
-+        getHandle(craftMob, goal.getTypes()).addGoal(priority, mojangGoal);
-+    }
-+
-+    @Override
-+    public <T extends Mob> void removeGoal(T mob, Goal<T> goal) {
-+        CraftMob craftMob = (CraftMob) mob;
-+        if (goal instanceof PaperCustomGoal) {
-+            getHandle(craftMob, goal.getTypes()).removeGoal((net.minecraft.world.entity.ai.goal.Goal) goal);
-+        } else if (goal instanceof PaperVanillaGoal) {
-+            getHandle(craftMob, goal.getTypes()).removeGoal(((PaperVanillaGoal<?>) goal).getHandle());
-+        } else {
-+            List<net.minecraft.world.entity.ai.goal.Goal> toRemove = new LinkedList<>();
-+            for (WrappedGoal item : getHandle(craftMob, goal.getTypes()).getAvailableGoals()) {
-+                if (item.getGoal() instanceof PaperCustomGoal) {
-+                    //noinspection unchecked
-+                    if (((PaperCustomGoal<T>) item.getGoal()).getHandle() == goal) {
-+                        toRemove.add(item.getGoal());
-+                    }
-+                }
-+            }
-+
-+            for (net.minecraft.world.entity.ai.goal.Goal g : toRemove) {
-+                getHandle(craftMob, goal.getTypes()).removeGoal(g);
-+            }
-+        }
-+    }
-+
-+    @Override
-+    public <T extends Mob> void removeAllGoals(T mob) {
-+        for (GoalType type : GoalType.values()) {
-+            removeAllGoals(mob, type);
-+        }
-+    }
-+
-+    @Override
-+    public <T extends Mob> void removeAllGoals(T mob, GoalType type) {
-+        for (Goal<T> goal : getAllGoals(mob, type)) {
-+            removeGoal(mob, goal);
-+        }
-+    }
-+
-+    @Override
-+    public <T extends Mob> void removeGoal(T mob, GoalKey<T> key) {
-+        for (Goal<T> goal : getGoals(mob, key)) {
-+            removeGoal(mob, goal);
-+        }
-+    }
-+
-+    @Override
-+    public <T extends Mob> boolean hasGoal(T mob, GoalKey<T> key) {
-+        for (Goal<T> g : getAllGoals(mob)) {
-+            if (g.getKey().equals(key)) {
-+                return true;
-+            }
-+        }
-+        return false;
-+    }
-+
-+    @Override
-+    public <T extends Mob> Goal<T> getGoal(T mob, GoalKey<T> key) {
-+        for (Goal<T> g : getAllGoals(mob)) {
-+            if (g.getKey().equals(key)) {
-+                return g;
-+            }
-+        }
-+        return null;
-+    }
-+
-+    @Override
-+    public <T extends Mob> Collection<Goal<T>> getGoals(T mob, GoalKey<T> key) {
-+        Set<Goal<T>> goals = new HashSet<>();
-+        for (Goal<T> g : getAllGoals(mob)) {
-+            if (g.getKey().equals(key)) {
-+                goals.add(g);
-+            }
-+        }
-+        return goals;
-+    }
-+
-+    @Override
-+    public <T extends Mob> Collection<Goal<T>> getAllGoals(T mob) {
-+        Set<Goal<T>> goals = new HashSet<>();
-+        for (GoalType type : GoalType.values()) {
-+            goals.addAll(getAllGoals(mob, type));
-+        }
-+        return goals;
-+    }
-+
-+    @Override
-+    public <T extends Mob> Collection<Goal<T>> getAllGoals(T mob, GoalType type) {
-+        CraftMob craftMob = (CraftMob) mob;
-+        Set<Goal<T>> goals = new HashSet<>();
-+        for (WrappedGoal item : getHandle(craftMob, type).getAvailableGoals()) {
-+            if (!item.getGoal().getFlags().contains(MobGoalHelper.paperToVanilla(type))) {
-+                continue;
-+            }
-+
-+            if (item.getGoal() instanceof PaperCustomGoal) {
-+                //noinspection unchecked
-+                goals.add(((PaperCustomGoal<T>) item.getGoal()).getHandle());
-+            } else {
-+                goals.add(item.getGoal().asPaperVanillaGoal());
-+            }
-+        }
-+        return goals;
-+    }
-+
-+    @Override
-+    public <T extends Mob> Collection<Goal<T>> getAllGoalsWithout(T mob, GoalType type) {
-+        CraftMob craftMob = (CraftMob) mob;
-+        Set<Goal<T>> goals = new HashSet<>();
-+        for (GoalType internalType : GoalType.values()) {
-+            if (internalType == type) {
-+                continue;
-+            }
-+            for (WrappedGoal item : getHandle(craftMob, internalType).getAvailableGoals()) {
-+                if (item.getGoal().getFlags().contains(MobGoalHelper.paperToVanilla(type))) {
-+                    continue;
-+                }
-+
-+                if (item.getGoal() instanceof PaperCustomGoal) {
-+                    //noinspection unchecked
-+                    goals.add(((PaperCustomGoal<T>) item.getGoal()).getHandle());
-+                } else {
-+                    goals.add(item.getGoal().asPaperVanillaGoal());
-+                }
-+            }
-+        }
-+        return goals;
-+    }
-+
-+    @Override
-+    public <T extends Mob> Collection<Goal<T>> getRunningGoals(T mob) {
-+        Set<Goal<T>> goals = new HashSet<>();
-+        for (GoalType type : GoalType.values()) {
-+            goals.addAll(getRunningGoals(mob, type));
-+        }
-+        return goals;
-+    }
-+
-+    @Override
-+    public <T extends Mob> Collection<Goal<T>> getRunningGoals(T mob, GoalType type) {
-+        CraftMob craftMob = (CraftMob) mob;
-+        Set<Goal<T>> goals = new HashSet<>();
-+        getHandle(craftMob, type).getAvailableGoals()
-+            .stream().filter(WrappedGoal::isRunning)
-+            .filter(item -> item.getGoal().getFlags().contains(MobGoalHelper.paperToVanilla(type)))
-+            .forEach(item -> {
-+                if (item.getGoal() instanceof PaperCustomGoal) {
-+                    //noinspection unchecked
-+                    goals.add(((PaperCustomGoal<T>) item.getGoal()).getHandle());
-+                } else {
-+                    goals.add(item.getGoal().asPaperVanillaGoal());
-+                }
-+            });
-+        return goals;
-+    }
-+
-+    @Override
-+    public <T extends Mob> Collection<Goal<T>> getRunningGoalsWithout(T mob, GoalType type) {
-+        CraftMob craftMob = (CraftMob) mob;
-+        Set<Goal<T>> goals = new HashSet<>();
-+        for (GoalType internalType : GoalType.values()) {
-+            if (internalType == type) {
-+                continue;
-+            }
-+            getHandle(craftMob, internalType).getAvailableGoals()
-+                .stream()
-+                .filter(WrappedGoal::isRunning)
-+                .filter(item -> !item.getGoal().getFlags().contains(MobGoalHelper.paperToVanilla(type)))
-+                .forEach(item -> {
-+                    if (item.getGoal() instanceof PaperCustomGoal) {
-+                        //noinspection unchecked
-+                        goals.add(((PaperCustomGoal<T>) item.getGoal()).getHandle());
-+                    } else {
-+                        goals.add(item.getGoal().asPaperVanillaGoal());
-+                    }
-+                });
-+        }
-+        return goals;
-+    }
-+
-+    private GoalSelector getHandle(CraftMob mob, EnumSet<GoalType> types) {
-+        if (types.contains(GoalType.TARGET)) {
-+            return mob.getHandle().targetSelector;
-+        } else {
-+            return mob.getHandle().goalSelector;
-+        }
-+    }
-+
-+    private GoalSelector getHandle(CraftMob mob, GoalType type) {
-+        if (type == GoalType.TARGET) {
-+            return mob.getHandle().targetSelector;
-+        } else {
-+            return mob.getHandle().goalSelector;
-+        }
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/PaperVanillaGoal.java b/src/main/java/com/destroystokyo/paper/entity/ai/PaperVanillaGoal.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/entity/ai/PaperVanillaGoal.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.entity.ai;
-+
-+import java.util.EnumSet;
-+import net.minecraft.world.entity.ai.goal.Goal;
-+import org.bukkit.entity.Mob;
-+
-+/**
-+ * Wraps vanilla in api
-+ */
-+public class PaperVanillaGoal<T extends Mob> implements VanillaGoal<T> {
-+
-+    private final Goal handle;
-+    private final GoalKey<T> key;
-+
-+    private final EnumSet<GoalType> types;
-+
-+    public PaperVanillaGoal(Goal handle) {
-+        this.handle = handle;
-+        this.key = MobGoalHelper.getKey(handle.getClass());
-+        this.types = MobGoalHelper.vanillaToPaper(handle);
-+    }
-+
-+    public Goal getHandle() {
-+        return handle;
-+    }
-+
-+    @Override
-+    public boolean shouldActivate() {
-+        return handle.canUse();
-+    }
-+
-+    @Override
-+    public boolean shouldStayActive() {
-+        return handle.canContinueToUse();
-+    }
-+
-+    @Override
-+    public void start() {
-+        handle.start();
-+    }
-+
-+    @Override
-+    public void stop() {
-+        handle.stop();
-+    }
-+
-+    @Override
-+    public void tick() {
-+        handle.tick();
-+    }
-+
-+    @Override
-+    public GoalKey<T> getKey() {
-+        return key;
-+    }
-+
-+    @Override
-+    public EnumSet<GoalType> getTypes() {
-+        return types;
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/Goal.java b/src/main/java/net/minecraft/world/entity/ai/goal/Goal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/ai/goal/Goal.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/goal/Goal.java
-@@ -0,0 +0,0 @@ public abstract class Goal {
-         return Mth.positiveCeilDiv(serverTicks, 2);
-     }
- 
-+    // Paper start - Mob goal api
-+    private com.destroystokyo.paper.entity.ai.PaperVanillaGoal<?> vanillaGoal;
-+    public <T extends org.bukkit.entity.Mob> com.destroystokyo.paper.entity.ai.Goal<T> asPaperVanillaGoal() {
-+        if(this.vanillaGoal == null) {
-+            this.vanillaGoal = new com.destroystokyo.paper.entity.ai.PaperVanillaGoal<>(this);
-+        }
-+        //noinspection unchecked
-+        return (com.destroystokyo.paper.entity.ai.Goal<T>) this.vanillaGoal;
-+    }
-+    // Paper end - Mob goal api
-+
-     public static enum Flag {
-+        UNKNOWN_BEHAVIOR, // Paper - add UNKNOWN_BEHAVIOR
-         MOVE,
-         LOOK,
-         JUMP,
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-     public boolean isStopping() {
-         return net.minecraft.server.MinecraftServer.getServer().hasStopped();
-     }
-+
-+    private com.destroystokyo.paper.entity.ai.MobGoals mobGoals = new com.destroystokyo.paper.entity.ai.PaperMobGoals();
-+    @Override
-+    public com.destroystokyo.paper.entity.ai.MobGoals getMobGoals() {
-+        return mobGoals;
-+    }
-     // Paper end
- }
--- a/patches/unapplied/server/Implement-Player-Client-Options-API.patch
+++ b/patches/unapplied/server/Implement-Player-Client-Options-API.patch
@ -1,194 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MiniDigger | Martin <admin@minidigger.dev>
-Date: Mon, 20 Jan 2020 21:38:15 +0100
-Subject: [PATCH] Implement Player Client Options API
-
-== AT ==
-public net.minecraft.world.entity.player.Player DATA_PLAYER_MODE_CUSTOMISATION
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperSkinParts.java b/src/main/java/com/destroystokyo/paper/PaperSkinParts.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/PaperSkinParts.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper;
-+
-+import com.google.common.base.Objects;
-+
-+import java.util.StringJoiner;
-+
-+public class PaperSkinParts implements SkinParts {
-+
-+    private final int raw;
-+
-+    public PaperSkinParts(int raw) {
-+        this.raw = raw;
-+    }
-+
-+    public boolean hasCapeEnabled() {
-+        return (raw & 1) == 1;
-+    }
-+
-+    public boolean hasJacketEnabled() {
-+        return (raw >> 1 & 1) == 1;
-+    }
-+
-+    public boolean hasLeftSleeveEnabled() {
-+        return (raw >> 2 & 1) == 1;
-+    }
-+
-+    public boolean hasRightSleeveEnabled() {
-+        return (raw >> 3 & 1) == 1;
-+    }
-+
-+    public boolean hasLeftPantsEnabled() {
-+        return (raw >> 4 & 1) == 1;
-+    }
-+
-+    public boolean hasRightPantsEnabled() {
-+        return (raw >> 5 & 1) == 1;
-+    }
-+
-+    public boolean hasHatsEnabled() {
-+        return (raw >> 6 & 1) == 1;
-+    }
-+
-+    @Override
-+    public int getRaw() {
-+        return raw;
-+    }
-+
-+    @Override
-+    public boolean equals(Object o) {
-+        if (this == o) return true;
-+        if (o == null || getClass() != o.getClass()) return false;
-+        PaperSkinParts that = (PaperSkinParts) o;
-+        return raw == that.raw;
-+    }
-+
-+    @Override
-+    public int hashCode() {
-+        return Objects.hashCode(raw);
-+    }
-+
-+    @Override
-+    public String toString() {
-+        return new StringJoiner(", ", PaperSkinParts.class.getSimpleName() + "[", "]")
-+            .add("raw=" + raw)
-+            .add("cape=" + hasCapeEnabled())
-+            .add("jacket=" + hasJacketEnabled())
-+            .add("leftSleeve=" + hasLeftSleeveEnabled())
-+            .add("rightSleeve=" + hasRightSleeveEnabled())
-+            .add("leftPants=" + hasLeftPantsEnabled())
-+            .add("rightPants=" + hasRightPantsEnabled())
-+            .add("hats=" + hasHatsEnabled())
-+            .toString();
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-         this.stats = server.getPlayerList().getPlayerStats(this);
-         this.advancements = server.getPlayerList().getPlayerAdvancements(this);
-         // this.fudgeSpawnLocation(world); // Paper - Don't move existing players to world spawn
-        this.updateOptions(clientOptions);
-+        this.updateOptionsNoEvents(clientOptions); // Paper - don't call options events on login
-         this.object = null;
- 
-         this.cachedSingleHashSet = new com.destroystokyo.paper.util.misc.PooledLinkedHashSets.PooledObjectLinkedOpenHashSet<>(this); // Paper
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-         }
-     }
- 
-+    // Paper start - Client option API
-+    private java.util.Map<com.destroystokyo.paper.ClientOption<?>, ?> getClientOptionMap(String locale, int viewDistance, com.destroystokyo.paper.ClientOption.ChatVisibility chatVisibility, boolean chatColors, com.destroystokyo.paper.PaperSkinParts skinParts, org.bukkit.inventory.MainHand mainHand, boolean allowsServerListing, boolean textFilteringEnabled) {
-+        java.util.Map<com.destroystokyo.paper.ClientOption<?>, Object> map = new java.util.HashMap<>();
-+        map.put(com.destroystokyo.paper.ClientOption.LOCALE, locale);
-+        map.put(com.destroystokyo.paper.ClientOption.VIEW_DISTANCE, viewDistance);
-+        map.put(com.destroystokyo.paper.ClientOption.CHAT_VISIBILITY, chatVisibility);
-+        map.put(com.destroystokyo.paper.ClientOption.CHAT_COLORS_ENABLED, chatColors);
-+        map.put(com.destroystokyo.paper.ClientOption.SKIN_PARTS, skinParts);
-+        map.put(com.destroystokyo.paper.ClientOption.MAIN_HAND, mainHand);
-+        map.put(com.destroystokyo.paper.ClientOption.ALLOW_SERVER_LISTINGS, allowsServerListing);
-+        map.put(com.destroystokyo.paper.ClientOption.TEXT_FILTERING_ENABLED, textFilteringEnabled);
-+        return map;
-+    }
-+    // Paper end
-+
-     public void updateOptions(ClientInformation clientOptions) {
-+        new com.destroystokyo.paper.event.player.PlayerClientOptionsChangeEvent(getBukkitEntity(), getClientOptionMap(clientOptions.language(), clientOptions.viewDistance(), com.destroystokyo.paper.ClientOption.ChatVisibility.valueOf(clientOptions.chatVisibility().name()), clientOptions.chatColors(), new com.destroystokyo.paper.PaperSkinParts(clientOptions.modelCustomisation()), clientOptions.mainHand() == HumanoidArm.LEFT ? MainHand.LEFT : MainHand.RIGHT, clientOptions.allowsListing(), clientOptions.textFilteringEnabled())).callEvent(); // Paper - settings event
-         // CraftBukkit start
-         if (this.getMainArm() != clientOptions.mainHand()) {
-             PlayerChangedMainHandEvent event = new PlayerChangedMainHandEvent(this.getBukkitEntity(), this.getMainArm() == HumanoidArm.LEFT ? MainHand.LEFT : MainHand.RIGHT);
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-             this.server.server.getPluginManager().callEvent(new com.destroystokyo.paper.event.player.PlayerLocaleChangeEvent(this.getBukkitEntity(), this.language, clientOptions.language())); // Paper
-         }
-         // CraftBukkit end
-+        // Paper start - don't call options events on login
-+        updateOptionsNoEvents(clientOptions);
-+    }
-+    public void updateOptionsNoEvents(ClientInformation clientOptions) {
-+        // Paper end
-         this.language = clientOptions.language();
-         this.adventure$locale = java.util.Objects.requireNonNullElse(net.kyori.adventure.translation.Translator.parseLocale(this.language), java.util.Locale.US); // Paper
-         this.requestedViewDistance = clientOptions.viewDistance();
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-             connection.disconnect(message == null ? net.kyori.adventure.text.Component.empty() : message);
-         }
-     }
-+
-+    @Override
-+    public <T> T getClientOption(com.destroystokyo.paper.ClientOption<T> type) {
-+        if (com.destroystokyo.paper.ClientOption.SKIN_PARTS == type) {
-+            return type.getType().cast(new com.destroystokyo.paper.PaperSkinParts(getHandle().getEntityData().get(net.minecraft.world.entity.player.Player.DATA_PLAYER_MODE_CUSTOMISATION)));
-+        } else if (com.destroystokyo.paper.ClientOption.CHAT_COLORS_ENABLED == type) {
-+            return type.getType().cast(getHandle().canChatInColor());
-+        } else if (com.destroystokyo.paper.ClientOption.CHAT_VISIBILITY == type) {
-+            return type.getType().cast(getHandle().getChatVisibility() == null ? com.destroystokyo.paper.ClientOption.ChatVisibility.UNKNOWN : com.destroystokyo.paper.ClientOption.ChatVisibility.valueOf(getHandle().getChatVisibility().name()));
-+        } else if (com.destroystokyo.paper.ClientOption.LOCALE == type) {
-+            return type.getType().cast(getLocale());
-+        } else if (com.destroystokyo.paper.ClientOption.MAIN_HAND == type) {
-+            return type.getType().cast(getMainHand());
-+        } else if (com.destroystokyo.paper.ClientOption.VIEW_DISTANCE == type) {
-+            return type.getType().cast(getClientViewDistance());
-+        } else if (com.destroystokyo.paper.ClientOption.ALLOW_SERVER_LISTINGS == type) {
-+            return type.getType().cast(getHandle().allowsListing());
-+        } else if (com.destroystokyo.paper.ClientOption.TEXT_FILTERING_ENABLED == type) {
-+            return type.getType().cast(getHandle().isTextFilteringEnabled());
-+        }
-+        throw new RuntimeException("Unknown settings type");
-+    }
-     // Paper end
- 
-     @Override
-diff --git a/src/test/java/io/papermc/paper/world/TranslationKeyTest.java b/src/test/java/io/papermc/paper/world/TranslationKeyTest.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/test/java/io/papermc/paper/world/TranslationKeyTest.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.world;
-+
-+import com.destroystokyo.paper.ClientOption;
-+import net.minecraft.world.entity.player.ChatVisiblity;
-+import org.bukkit.Difficulty;
-+import org.junit.jupiter.api.Assertions;
-+import org.junit.jupiter.api.Test;
-+
-+public class TranslationKeyTest {
-+
-+    @Test
-+    public void testChatVisibilityKeys() {
-+        for (ClientOption.ChatVisibility chatVisibility : ClientOption.ChatVisibility.values()) {
-+            if (chatVisibility == ClientOption.ChatVisibility.UNKNOWN) continue;
-+            Assertions.assertEquals(ChatVisiblity.valueOf(chatVisibility.name()).getKey(), chatVisibility.translationKey(), chatVisibility + "'s translation key doesn't match");
-+        }
-+    }
-+}
--- a/patches/unapplied/server/Improve-Block-breakNaturally-API.patch
+++ b/patches/unapplied/server/Improve-Block-breakNaturally-API.patch
@ -1,95 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Thu, 2 Jan 2020 12:25:07 -0600
-Subject: [PATCH] Improve Block#breakNaturally API
-
-Adds bool parameter to play world effect on block break
-
-Adds bool parameter to drop xp from blocks
-
-Fixes fluid-logged blocks not leaving fluid behind if
-broken
-
-Handles special cases for ice and turtle eggs
-
-== AT ==
-public net.minecraft.world.level.block.TurtleEggBlock decreaseEggs(Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/state/BlockState;)V
-
-Co-authored-by: William Blake Galbreath <Blake.Galbreath@GMail.com>
-
-diff --git a/src/main/java/net/minecraft/world/level/block/IceBlock.java b/src/main/java/net/minecraft/world/level/block/IceBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/IceBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/IceBlock.java
-@@ -0,0 +0,0 @@ public class IceBlock extends HalfTransparentBlock {
-     @Override
-     public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool) {
-         super.playerDestroy(world, player, pos, state, blockEntity, tool);
-+        // Paper start - Improve Block#breakNaturally API
-+        this.afterDestroy(world, pos, tool);
-+    }
-+    public void afterDestroy(Level world, BlockPos pos, ItemStack tool) {
-+        // Paper end - Improve Block#breakNaturally API
-         if (EnchantmentHelper.getItemEnchantmentLevel(Enchantments.SILK_TOUCH, tool) == 0) {
-             if (world.dimensionType().ultraWarm()) {
-                 world.removeBlock(pos, false);
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-@@ -0,0 +0,0 @@ public class CraftBlock implements Block {
- 
-     @Override
-     public boolean breakNaturally(ItemStack item) {
-+        // Paper start
-+        return this.breakNaturally(item, false);
-+    }
-+
-+    @Override
-+    public boolean breakNaturally(boolean triggerEffect, boolean dropExperience) {
-+        return this.breakNaturally(null, triggerEffect, dropExperience);
-+    }
-+
-+    @Override
-+    public boolean breakNaturally(ItemStack item, boolean triggerEffect, boolean dropExperience) {
-+        // Paper end
-         // Order matters here, need to drop before setting to air so skulls can get their data
-         net.minecraft.world.level.block.state.BlockState iblockdata = this.getNMS();
-         net.minecraft.world.level.block.Block block = iblockdata.getBlock();
-@@ -0,0 +0,0 @@ public class CraftBlock implements Block {
-         // Modelled off EntityHuman#hasBlock
-         if (block != Blocks.AIR && (item == null || !iblockdata.requiresCorrectToolForDrops() || nmsItem.isCorrectToolForDrops(iblockdata))) {
-             net.minecraft.world.level.block.Block.dropResources(iblockdata, this.world.getMinecraftWorld(), this.position, this.world.getBlockEntity(this.position), null, nmsItem);
-+            // Paper start - improve Block#breanNaturally
-+            if (triggerEffect) {
-+                if (iblockdata.getBlock() instanceof net.minecraft.world.level.block.BaseFireBlock) {
-+                    this.world.levelEvent(net.minecraft.world.level.block.LevelEvent.SOUND_EXTINGUISH_FIRE, this.position, 0);
-+                } else {
-+                    this.world.levelEvent(net.minecraft.world.level.block.LevelEvent.PARTICLES_DESTROY_BLOCK, this.position, net.minecraft.world.level.block.Block.getId(iblockdata));
-+                }
-+            }
-+            if (dropExperience) block.popExperience(this.world.getMinecraftWorld(), this.position, block.getExpDrop(iblockdata, this.world.getMinecraftWorld(), this.position, nmsItem, true));
-+            // Paper end
-             result = true;
-         }
- 
-         // SPIGOT-6778: Directly call setBlock instead of setTypeAndData, so that the tile entiy is not removed and custom remove logic is run.
-        return this.world.setBlock(this.position, Blocks.AIR.defaultBlockState(), 3) && result;
-+        // Paper start - improve breakNaturally
-+        boolean destroyed = this.world.removeBlock(this.position, false);
-+        if (destroyed) {
-+            block.destroy(this.world, this.position, iblockdata);
-+        }
-+        if (result) {
-+            // special cases
-+            if (block instanceof net.minecraft.world.level.block.IceBlock iceBlock) {
-+                iceBlock.afterDestroy(this.world.getMinecraftWorld(), this.position, nmsItem);
-+            } else if (block instanceof net.minecraft.world.level.block.TurtleEggBlock turtleEggBlock) {
-+                turtleEggBlock.decreaseEggs(this.world.getMinecraftWorld(), this.position, iblockdata);
-+            }
-+        }
-+        return destroyed && result;
-+        // Paper end
-     }
- 
-     @Override
--- a/patches/unapplied/server/Improve-Legacy-Component-serialization-size.patch
+++ b/patches/unapplied/server/Improve-Legacy-Component-serialization-size.patch
@ -1,56 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 28 Jun 2020 19:08:41 -0400
-Subject: [PATCH] Improve Legacy Component serialization size
-
-Don't constantly send format: false for all formatting options when parent already
-has it false
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftChatMessage.java b/src/main/java/org/bukkit/craftbukkit/util/CraftChatMessage.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/util/CraftChatMessage.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftChatMessage.java
-@@ -0,0 +0,0 @@ public final class CraftChatMessage {
-         // Separate pattern with no group 3, new lines are part of previous string
-         private static final Pattern INCREMENTAL_PATTERN_KEEP_NEWLINES = Pattern.compile("(" + String.valueOf(org.bukkit.ChatColor.COLOR_CHAR) + "[0-9a-fk-orx])|((?:(?:https?):\\/\\/)?(?:[-\\w_\\.]{2,}\\.[a-z]{2,4}.*?(?=[\\.\\?!,;:]?(?:[" + String.valueOf(org.bukkit.ChatColor.COLOR_CHAR) + " ]|$))))", Pattern.CASE_INSENSITIVE);
-         // ChatColor.b does not explicitly reset, its more of empty
-+        private static final Style EMPTY = Style.EMPTY.withItalic(false); // Paper - Improve Legacy Component serialization size
-         private static final Style RESET = Style.EMPTY.withBold(false).withItalic(false).withUnderlined(false).withStrikethrough(false).withObfuscated(false);
- 
-         private final List<Component> list = new ArrayList<Component>();
-@@ -0,0 +0,0 @@ public final class CraftChatMessage {
-             Matcher matcher = (keepNewlines ? StringMessage.INCREMENTAL_PATTERN_KEEP_NEWLINES : StringMessage.INCREMENTAL_PATTERN).matcher(message);
-             String match = null;
-             boolean needsAdd = false;
-+            boolean hasReset = false; // Paper - Improve Legacy Component serialization size
-             while (matcher.find()) {
-                 int groupId = 0;
-                 while ((match = matcher.group(++groupId)) == null) {
-@@ -0,0 +0,0 @@ public final class CraftChatMessage {
-                             throw new AssertionError("Unexpected message format");
-                         }
-                     } else { // Color resets formatting
-                        this.modifier = StringMessage.RESET.withColor(format);
-+                        // Paper start - Improve Legacy Component serialization size
-+                        Style previous = modifier;
-+                        modifier = (!hasReset ? RESET : EMPTY).withColor(format);
-+                        hasReset = true;
-+                        if (previous.isBold()) {
-+                            modifier = modifier.withBold(false);
-+                        }
-+                        if (previous.isItalic()) {
-+                            modifier = modifier.withItalic(false);
-+                        }
-+                        if (previous.isObfuscated()) {
-+                            modifier = modifier.withObfuscated(false);
-+                        }
-+                        if (previous.isStrikethrough()) {
-+                            modifier = modifier.withStrikethrough(false);
-+                        }
-+                        if (previous.isUnderlined()) {
-+                            modifier = modifier.withUnderlined(false);
-+                        }
-+                        // Paper end - Improve Legacy Component serialization size
-                     }
-                     needsAdd = true;
-                     break;
--- a/patches/unapplied/server/Improve-fix-EntityTargetLivingEntityEvent.patch
+++ b/patches/unapplied/server/Improve-fix-EntityTargetLivingEntityEvent.patch
@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Fri, 9 Dec 2022 03:10:23 -0800
-Subject: [PATCH] Improve/fix EntityTargetLivingEntityEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/StopAttackingIfTargetInvalid.java b/src/main/java/net/minecraft/world/entity/ai/behavior/StopAttackingIfTargetInvalid.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/ai/behavior/StopAttackingIfTargetInvalid.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/StopAttackingIfTargetInvalid.java
-@@ -0,0 +0,0 @@ public class StopAttackingIfTargetInvalid {
-                     if (entityinsentient.canAttack(entityliving) && (!shouldForgetIfTargetUnreachable || !StopAttackingIfTargetInvalid.isTiredOfTryingToReachTarget(entityinsentient, behaviorbuilder_b.tryGet(memoryaccessor1))) && entityliving.isAlive() && entityliving.level() == entityinsentient.level() && !alternativeCondition.test(entityliving)) {
-                         return true;
-                     } else {
-+                        // Paper start - better track target change reason
-+                        final EntityTargetEvent.TargetReason reason;
-+                        if (!entityinsentient.canAttack(entityliving)) {
-+                            reason = EntityTargetEvent.TargetReason.TARGET_INVALID;
-+                        } else if (shouldForgetIfTargetUnreachable && StopAttackingIfTargetInvalid.isTiredOfTryingToReachTarget(entityinsentient, behaviorbuilder_b.tryGet(memoryaccessor1))) {
-+                            reason = EntityTargetEvent.TargetReason.FORGOT_TARGET;
-+                        } else if (!entityliving.isAlive()) {
-+                            reason = EntityTargetEvent.TargetReason.TARGET_DIED;
-+                        } else if (entityliving.level() != entityinsentient.level()) {
-+                            reason = EntityTargetEvent.TargetReason.TARGET_OTHER_LEVEL;
-+                        } else {
-+                            reason = EntityTargetEvent.TargetReason.TARGET_INVALID;
-+                        }
-+                        // Paper end
-                         // CraftBukkit start
-                        LivingEntity old = entityinsentient.getBrain().getMemory(MemoryModuleType.ATTACK_TARGET).orElse(null);
-                        EntityTargetEvent event = CraftEventFactory.callEntityTargetLivingEvent(entityinsentient, null, (old != null && !old.isAlive()) ? EntityTargetEvent.TargetReason.TARGET_DIED : EntityTargetEvent.TargetReason.FORGOT_TARGET);
-+                        EntityTargetEvent event = CraftEventFactory.callEntityTargetLivingEvent(entityinsentient, null, reason); // Paper
-                         if (event.isCancelled()) {
-                             return false;
-                         }
-                        if (event.getTarget() == null) {
-                            memoryaccessor.erase();
-                            return true;
-                        }
-                        entityliving = ((CraftLivingEntity) event.getTarget()).getHandle();
-+                        // if (event.getTarget() == null) { // Paper - this is wrong, you are skipping the forgetCallback
-+                        //     memoryaccessor.erase();
-+                        //     return true;
-+                        // }
-+                        // entityliving = ((CraftLivingEntity) event.getTarget()).getHandle();
-                         // CraftBukkit end
-                         forgetCallback.accept(entityinsentient, entityliving);
-                         memoryaccessor.erase();
--- a/patches/unapplied/server/Improve-java-version-check.patch
+++ b/patches/unapplied/server/Improve-java-version-check.patch
@ -1,47 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Nassim Jahnke <nassim@njahnke.dev>
-Date: Wed, 16 Mar 2022 13:58:16 +0100
-Subject: [PATCH] Improve java version check
-
-Co-Authored-By: MiniDigger | Martin <admin@minidigger.dev>
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/Main.java
-+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
-@@ -0,0 +0,0 @@ public class Main {
-                 return;
-             }
- 
-+            // Paper start - Improve java version check
-+            boolean skip = Boolean.getBoolean("Paper.IgnoreJavaVersion");
-             float javaVersion = Float.parseFloat(System.getProperty("java.class.version"));
-            if (javaVersion < 61.0) {
-                System.err.println("Unsupported Java detected (" + javaVersion + "). This version of Minecraft requires at least Java 17. Check your Java version with the command 'java -version'.");
-                return;
-            }
-            if (javaVersion > 66.0) {
-                System.err.println("Unsupported Java detected (" + javaVersion + "). Only up to Java 22 is supported.");
-+            boolean isOldVersion = javaVersion < 61.0;
-+            if (!skip && isOldVersion) {
-+                System.err.println("Unsupported Java detected (" + javaVersion + "). This version of Minecraft requires at least Java 21. Check your Java version with the command 'java -version'. For more info see https://docs.papermc.io/misc/java-install");
-                 return;
-             }
-             String javaVersionName = System.getProperty("java.version");
-             // J2SE SDK/JRE Version String Naming Convention
-             boolean isPreRelease = javaVersionName.contains("-");
-            if (isPreRelease && javaVersion == 61.0) {
-                System.err.println("Unsupported Java detected (" + javaVersionName + "). You are running an outdated, pre-release version. Only general availability versions of Java are supported. Please update your Java version.");
-+            if (!skip && isPreRelease) {
-+                System.err.println("Unsupported Java detected (" + javaVersionName + "). You are running an unsupported, non official, version. Only general availability versions of Java are supported. Please update your Java version. See https://docs.papermc.io/paper/faq#unsupported-java-detected-what-do-i-do for more information.");
-                 return;
-             }
- 
-+            if (skip && (isOldVersion || isPreRelease)) {
-+                System.err.println("Unsupported Java detected ("+ javaVersionName + "), but the check was skipped. Proceed with caution! ");
-+            }
-+            // Paper end - Improve java version check
-+
-             try {
-                 // Paper start - Handled by TerminalConsoleAppender
-                 /*
--- a/patches/unapplied/server/Inventory-getHolder-method-without-block-snapshot.patch
+++ b/patches/unapplied/server/Inventory-getHolder-method-without-block-snapshot.patch
@ -1,42 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Phoenix616 <mail@moep.tv>
-Date: Wed, 10 Jun 2020 23:55:15 +0100
-Subject: [PATCH] Inventory getHolder method without block snapshot
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
-@@ -0,0 +0,0 @@ public class CraftInventory implements Inventory {
-         return this.inventory.getOwner();
-     }
- 
-+    // Paper start - getHolder without snapshot
-+    @Override
-+    public InventoryHolder getHolder(boolean useSnapshot) {
-+        return inventory instanceof net.minecraft.world.level.block.entity.BlockEntity ? ((net.minecraft.world.level.block.entity.BlockEntity) inventory).getOwner(useSnapshot) : getHolder();
-+    }
-+    // Paper end
-+
-     @Override
-     public int getMaxStackSize() {
-         return this.inventory.getMaxStackSize();
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryDoubleChest.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryDoubleChest.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryDoubleChest.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryDoubleChest.java
-@@ -0,0 +0,0 @@ public class CraftInventoryDoubleChest extends CraftInventory implements DoubleC
-         return new DoubleChest(this);
-     }
- 
-+    // Paper start - getHolder without snapshot
-+    @Override
-+    public DoubleChest getHolder(boolean useSnapshot) {
-+        return getHolder();
-+    }
-+    // Paper end
-+
-     @Override
-     public Location getLocation() {
-         return this.getLeftSide().getLocation().add(this.getRightSide().getLocation()).multiply(0.5);
--- a/patches/unapplied/server/Limit-Client-Sign-length-more.patch
+++ b/patches/unapplied/server/Limit-Client-Sign-length-more.patch
@ -1,56 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 27 Feb 2019 22:18:40 -0500
-Subject: [PATCH] Limit Client Sign length more
-
-modified clients can send more data from the client
-to the server and it would get stored on the sign as sent.
-
-Mojang has a limit of 384 which is much higher than reasonable.
-
-the client can barely render around 16 characters as-is, but formatting
-codes can get it to be more than 16 actual length.
-
-Set a limit of 80 which should give an average of 16 characters 2
-sets of legacy formatting codes which should be plenty for all uses.
-
-This does not strip any existing data from the NBT as plugins
-may use this for storing data out of the rendered area.
-
-it only impacts data sent from the client.
-
-Set -DPaper.maxSignLength=XX to change limit or -1 to disable
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-     private final MessageSignatureCache messageSignatureCache = MessageSignatureCache.createDefault();
-     private final FutureChain chatMessageChain;
-     private boolean waitingForSwitchToConfig;
-+    private static final int MAX_SIGN_LINE_LENGTH = Integer.getInteger("Paper.maxSignLength", 80); // Paper - Limit client sign length
- 
-     public ServerGamePacketListenerImpl(MinecraftServer server, Connection connection, ServerPlayer player, CommonListenerCookie clientData) {
-         super(server, connection, clientData, player); // CraftBukkit
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
- 
-     @Override
-     public void handleSignUpdate(ServerboundSignUpdatePacket packet) {
-        List<String> list = (List) Stream.of(packet.getLines()).map(ChatFormatting::stripFormatting).collect(Collectors.toList());
-+        // Paper start - Limit client sign length
-+        String[] lines = packet.getLines();
-+        for (int i = 0; i < lines.length; ++i) {
-+            if (MAX_SIGN_LINE_LENGTH > 0 && lines[i].length() > MAX_SIGN_LINE_LENGTH) {
-+                // This handles multibyte characters as 1
-+                int offset = lines[i].codePoints().limit(MAX_SIGN_LINE_LENGTH).map(Character::charCount).sum();
-+                if (offset < lines[i].length()) {
-+                    lines[i] = lines[i].substring(0, offset); // this will break any filtering, but filtering is NYI as of 1.17
-+                }
-+            }
-+        }
-+        List<String> list = (List) Stream.of(lines).map(ChatFormatting::stripFormatting).collect(Collectors.toList());
-+        // Paper end - Limit client sign length
- 
-         this.filterTextPacket(list).thenAcceptAsync((list1) -> {
-             this.updateSignText(packet, list1);
--- a/patches/unapplied/server/MC-145656-Fix-Follow-Range-Initial-Target.patch
+++ b/patches/unapplied/server/MC-145656-Fix-Follow-Range-Initial-Target.patch
@ -1,50 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Wed, 18 Dec 2019 22:21:35 -0600
-Subject: [PATCH] MC-145656 Fix Follow Range Initial Target
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/target/NearestAttackableTargetGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/target/NearestAttackableTargetGoal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/ai/goal/target/NearestAttackableTargetGoal.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/goal/target/NearestAttackableTargetGoal.java
-@@ -0,0 +0,0 @@ public class NearestAttackableTargetGoal<T extends LivingEntity> extends TargetG
-         this.randomInterval = reducedTickDelay(reciprocalChance);
-         this.setFlags(EnumSet.of(Goal.Flag.TARGET));
-         this.targetConditions = TargetingConditions.forCombat().range(this.getFollowDistance()).selector(targetPredicate);
-+        if (mob.level().paperConfig().entities.entitiesTargetWithFollowRange) this.targetConditions.useFollowRange(); // Paper - Fix MC-145656
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java b/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java
-@@ -0,0 +0,0 @@ public class TargetingConditions {
- 
-                 if (this.range > 0.0) {
-                     double d = this.testInvisible ? targetEntity.getVisibilityPercent(baseEntity) : 1.0;
-                    double e = Math.max(this.range * d, 2.0);
-+                    double e = Math.max((this.useFollowRange ? this.getFollowRange(baseEntity) : this.range) * d, 2.0); // Paper - Fix MC-145656
-                     double f = baseEntity.distanceToSqr(targetEntity.getX(), targetEntity.getY(), targetEntity.getZ());
-                     if (f > e * e) {
-                         return false;
-@@ -0,0 +0,0 @@ public class TargetingConditions {
-             return true;
-         }
-     }
-+
-+    // Paper start - Fix MC-145656
-+    private boolean useFollowRange = false;
-+
-+    public TargetingConditions useFollowRange() {
-+        this.useFollowRange = true;
-+        return this;
-+    }
-+
-+    private double getFollowRange(LivingEntity entityliving) {
-+        net.minecraft.world.entity.ai.attributes.AttributeInstance attributeinstance = entityliving.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.FOLLOW_RANGE);
-+        return attributeinstance == null ? 16.0D : attributeinstance.getValue();
-+    }
-+    // Paper end - Fix MC-145656
- }
--- a/patches/unapplied/server/Make-the-GUI-graph-fancier.patch
+++ b/patches/unapplied/server/Make-the-GUI-graph-fancier.patch
@ -1,399 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 2 Feb 2020 04:00:40 -0600
-Subject: [PATCH] Make the GUI graph fancier
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/gui/GraphColor.java b/src/main/java/com/destroystokyo/paper/gui/GraphColor.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/gui/GraphColor.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.gui;
-+
-+import java.awt.Color;
-+
-+public class GraphColor {
-+    private static final Color[] colorLine = new Color[101];
-+    private static final Color[] colorFill = new Color[101];
-+
-+    static {
-+        for (int i = 0; i < 101; i++) {
-+            Color color = createColor(i);
-+            colorLine[i] = new Color(color.getRed() / 2, color.getGreen() / 2, color.getBlue() / 2, 255);
-+            colorFill[i] = new Color(colorLine[i].getRed(), colorLine[i].getGreen(), colorLine[i].getBlue(), 125);
-+        }
-+    }
-+
-+    public static Color getLineColor(int percent) {
-+        return colorLine[percent];
-+    }
-+
-+    public static Color getFillColor(int percent) {
-+        return colorFill[percent];
-+    }
-+
-+    private static Color createColor(int percent) {
-+        if (percent <= 50) {
-+            return new Color(0X00FF00);
-+        }
-+
-+        int value = 510 - (int) (Math.min(Math.max(0, ((percent - 50) / 50F)), 1) * 510);
-+
-+        int red, green;
-+        if (value < 255) {
-+            red = 255;
-+            green = (int) (Math.sqrt(value) * 16);
-+        } else {
-+            green = 255;
-+            value = value - 255;
-+            red = 255 - (value * value / 255);
-+        }
-+
-+        return new Color(red, green, 0);
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/gui/GraphData.java b/src/main/java/com/destroystokyo/paper/gui/GraphData.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/gui/GraphData.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.gui;
-+
-+import java.awt.Color;
-+
-+public class GraphData {
-+    private long total;
-+    private long free;
-+    private long max;
-+    private long usedMem;
-+    private int usedPercent;
-+
-+    public GraphData(long total, long free, long max) {
-+        this.total = total;
-+        this.free = free;
-+        this.max = max;
-+        this.usedMem = total - free;
-+        this.usedPercent = usedMem == 0 ? 0 : (int) (usedMem * 100L / max);
-+    }
-+
-+    public long getTotal() {
-+        return total;
-+    }
-+
-+    public long getFree() {
-+        return free;
-+    }
-+
-+    public long getMax() {
-+        return max;
-+    }
-+
-+    public long getUsedMem() {
-+        return usedMem;
-+    }
-+
-+    public int getUsedPercent() {
-+        return usedPercent;
-+    }
-+
-+    public Color getFillColor() {
-+        return GraphColor.getFillColor(usedPercent);
-+    }
-+
-+    public Color getLineColor() {
-+        return GraphColor.getLineColor(usedPercent);
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/gui/GuiStatsComponent.java b/src/main/java/com/destroystokyo/paper/gui/GuiStatsComponent.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/gui/GuiStatsComponent.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.gui;
-+
-+import net.minecraft.server.MinecraftServer;
-+
-+import javax.swing.JPanel;
-+import javax.swing.Timer;
-+import java.awt.BorderLayout;
-+import java.awt.Dimension;
-+
-+public class GuiStatsComponent extends JPanel {
-+    private final Timer timer;
-+    private final RAMGraph ramGraph;
-+
-+    public GuiStatsComponent(MinecraftServer server) {
-+        super(new BorderLayout());
-+
-+        setOpaque(false);
-+
-+        ramGraph = new RAMGraph();
-+        RAMDetails ramDetails = new RAMDetails(server);
-+
-+        add(ramGraph, "North");
-+        add(ramDetails, "Center");
-+
-+        timer = new Timer(500, (event) -> {
-+            ramGraph.update();
-+            ramDetails.update();
-+        });
-+        timer.start();
-+    }
-+
-+    @Override
-+    public Dimension getPreferredSize() {
-+        return new Dimension(350, 200);
-+    }
-+
-+    public void close() {
-+        timer.stop();
-+        ramGraph.stop();
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/gui/RAMDetails.java b/src/main/java/com/destroystokyo/paper/gui/RAMDetails.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/gui/RAMDetails.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.gui;
-+
-+import net.minecraft.Util;
-+import net.minecraft.server.MinecraftServer;
-+import net.minecraft.util.TimeUtil;
-+
-+import javax.swing.DefaultListCellRenderer;
-+import javax.swing.DefaultListSelectionModel;
-+import javax.swing.JList;
-+import javax.swing.border.EmptyBorder;
-+import java.awt.Dimension;
-+import java.text.DecimalFormat;
-+import java.text.DecimalFormatSymbols;
-+import java.util.Locale;
-+import java.util.Vector;
-+
-+public class RAMDetails extends JList<String> {
-+    public static final DecimalFormat DECIMAL_FORMAT = Util.make(new DecimalFormat("########0.000"), (format)
-+        -> format.setDecimalFormatSymbols(DecimalFormatSymbols.getInstance(Locale.ROOT)));
-+
-+    private final MinecraftServer server;
-+
-+    public RAMDetails(MinecraftServer server) {
-+        this.server = server;
-+
-+        setBorder(new EmptyBorder(0, 10, 0, 0));
-+        setFixedCellHeight(20);
-+        setOpaque(false);
-+
-+        DefaultListCellRenderer renderer = new DefaultListCellRenderer();
-+        renderer.setOpaque(false);
-+        setCellRenderer(renderer);
-+
-+        setSelectionModel(new DefaultListSelectionModel() {
-+            @Override
-+            public void setAnchorSelectionIndex(final int anchorIndex) {
-+            }
-+
-+            @Override
-+            public void setLeadAnchorNotificationEnabled(final boolean flag) {
-+            }
-+
-+            @Override
-+            public void setLeadSelectionIndex(final int leadIndex) {
-+            }
-+
-+            @Override
-+            public void setSelectionInterval(final int index0, final int index1) {
-+            }
-+        });
-+    }
-+
-+    @Override
-+    public Dimension getPreferredSize() {
-+        return new Dimension(350, 100);
-+    }
-+
-+    public void update() {
-+        GraphData data = RAMGraph.DATA.peekLast();
-+        Vector<String> vector = new Vector<>();
-+        vector.add("Memory use: " + (data.getUsedMem() / 1024L / 1024L) + " mb (" + (data.getFree() * 100L / data.getMax()) + "% free)");
-+        vector.add("Heap: " + (data.getTotal() / 1024L / 1024L) + " / " + (data.getMax() / 1024L / 1024L) + " mb");
-+        vector.add("Avg tick: " + DECIMAL_FORMAT.format((double)this.server.getAverageTickTimeNanos() / (double) TimeUtil.NANOSECONDS_PER_MILLISECOND) + " ms");
-+        setListData(vector);
-+    }
-+
-+    public double getAverage(long[] tickTimes) {
-+        long total = 0L;
-+        for (long value : tickTimes) {
-+            total += value * 1000;
-+        }
-+        return ((double) total / (double) tickTimes.length) * 1.0E-6D;
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/gui/RAMGraph.java b/src/main/java/com/destroystokyo/paper/gui/RAMGraph.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/gui/RAMGraph.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.gui;
-+
-+import javax.swing.JComponent;
-+import javax.swing.SwingUtilities;
-+import javax.swing.Timer;
-+import javax.swing.ToolTipManager;
-+import java.awt.Color;
-+import java.awt.Dimension;
-+import java.awt.Graphics;
-+import java.awt.MouseInfo;
-+import java.awt.Point;
-+import java.awt.PointerInfo;
-+import java.awt.event.MouseAdapter;
-+import java.awt.event.MouseEvent;
-+import java.text.SimpleDateFormat;
-+import java.util.Date;
-+import java.util.LinkedList;
-+import java.util.concurrent.TimeUnit;
-+
-+public class RAMGraph extends JComponent {
-+    public static final LinkedList<GraphData> DATA = new LinkedList<GraphData>() {
-+        @Override
-+        public boolean add(GraphData data) {
-+            if (size() >= 348) {
-+                remove();
-+            }
-+            return super.add(data);
-+        }
-+    };
-+
-+    static {
-+        GraphData empty = new GraphData(0, 0, 0);
-+        for (int i = 0; i < 350; i++) {
-+            DATA.add(empty);
-+        }
-+    }
-+
-+    private final Timer timer;
-+    private final SimpleDateFormat TIME_FORMAT = new SimpleDateFormat("HH:mm:ss");
-+
-+    private int currentTick;
-+
-+    public RAMGraph() {
-+        ToolTipManager.sharedInstance().setInitialDelay(0);
-+
-+        addMouseListener(new MouseAdapter() {
-+            final int defaultDismissTimeout = ToolTipManager.sharedInstance().getDismissDelay();
-+            final int dismissDelayMinutes = (int) TimeUnit.MINUTES.toMillis(10);
-+
-+            @Override
-+            public void mouseEntered(MouseEvent me) {
-+                ToolTipManager.sharedInstance().setDismissDelay(dismissDelayMinutes);
-+            }
-+
-+            @Override
-+            public void mouseExited(MouseEvent me) {
-+                ToolTipManager.sharedInstance().setDismissDelay(defaultDismissTimeout);
-+            }
-+        });
-+
-+        timer = new Timer(50, (event) -> repaint());
-+        timer.start();
-+    }
-+
-+    @Override
-+    public Dimension getPreferredSize() {
-+        return new Dimension(350, 110);
-+    }
-+
-+    public void update() {
-+        Runtime jvm = Runtime.getRuntime();
-+        DATA.add(new GraphData(jvm.totalMemory(), jvm.freeMemory(), jvm.maxMemory()));
-+
-+        PointerInfo pointerInfo = MouseInfo.getPointerInfo();
-+        if (pointerInfo != null) {
-+            Point point = pointerInfo.getLocation();
-+            if (point != null) {
-+                Point loc = new Point(point);
-+                SwingUtilities.convertPointFromScreen(loc, this);
-+                if (this.contains(loc)) {
-+                    ToolTipManager.sharedInstance().mouseMoved(
-+                        new MouseEvent(this, -1, System.currentTimeMillis(), 0, loc.x, loc.y,
-+                            point.x, point.y, 0, false, 0));
-+                }
-+            }
-+        }
-+
-+        currentTick++;
-+    }
-+
-+    @Override
-+    public void paint(Graphics graphics) {
-+        graphics.setColor(new Color(0xFFFFFFFF));
-+        graphics.fillRect(0, 0, 350, 100);
-+
-+        graphics.setColor(new Color(0x888888));
-+        graphics.drawLine(1, 25, 348, 25);
-+        graphics.drawLine(1, 50, 348, 50);
-+        graphics.drawLine(1, 75, 348, 75);
-+
-+        int i = 0;
-+        for (GraphData data : DATA) {
-+            i++;
-+            if ((i + currentTick) % 120 == 0) {
-+                graphics.setColor(new Color(0x888888));
-+                graphics.drawLine(i, 1, i, 99);
-+            }
-+            int used = data.getUsedPercent();
-+            if (used > 0) {
-+                Color color = data.getLineColor();
-+                graphics.setColor(data.getFillColor());
-+                graphics.fillRect(i, 100 - used, 1, used);
-+                graphics.setColor(color);
-+                graphics.fillRect(i, 100 - used, 1, 1);
-+            }
-+        }
-+
-+        graphics.setColor(new Color(0xFF000000));
-+        graphics.drawRect(0, 0, 348, 100);
-+
-+        Point m = getMousePosition();
-+        if (m != null && m.x > 0 && m.x < 348 && m.y > 0 && m.y < 100) {
-+            GraphData data = DATA.get(m.x);
-+            int used = data.getUsedPercent();
-+            graphics.setColor(new Color(0x000000));
-+            graphics.drawLine(m.x, 1, m.x, 99);
-+            graphics.drawOval(m.x - 2, 100 - used - 2, 5, 5);
-+            graphics.setColor(data.getLineColor());
-+            graphics.fillOval(m.x - 2, 100 - used - 2, 5, 5);
-+            setToolTipText(String.format("<html><body>Used: %s mb (%s%%)<br/>%s</body></html>",
-+                Math.round(data.getUsedMem() / 1024F / 1024F),
-+                used, getTime(m.x)));
-+        }
-+    }
-+
-+    public String getTime(int halfSeconds) {
-+        int millis = (348 - halfSeconds) / 2 * 1000;
-+        return TIME_FORMAT.format(new Date((System.currentTimeMillis() - millis)));
-+    }
-+
-+    public void stop() {
-+        timer.stop();
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java b/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java
-+++ b/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java
-@@ -0,0 +0,0 @@ public class MinecraftServerGui extends JComponent {
- 
-     private JComponent buildInfoPanel() {
-         JPanel jpanel = new JPanel(new BorderLayout());
-        StatsComponent guistatscomponent = new StatsComponent(this.server);
-+        com.destroystokyo.paper.gui.GuiStatsComponent guistatscomponent = new com.destroystokyo.paper.gui.GuiStatsComponent(this.server); // Paper - Make GUI graph fancier
-         Collection<Runnable> collection = this.finalizers; // CraftBukkit - decompile error
- 
-         Objects.requireNonNull(guistatscomponent);
--- a/patches/unapplied/server/Maps-shouldn-t-load-chunks.patch
+++ b/patches/unapplied/server/Maps-shouldn-t-load-chunks.patch
@ -1,31 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Phoenix616 <mail@moep.tv>
-Date: Sun, 7 Jun 2020 21:43:42 +0100
-Subject: [PATCH] Maps shouldn't load chunks
-
-Previously maps would load all chunks in a certain radius depending on
- their scale when trying to update their content. This would result in
- main thread chunk loads when they weren't really necessary, especially
- on low view distances or "slow" async chunk loads after teleports or
- other prioritisation.
-
- This changes it to only try to render already loaded chunks based on
- the assumption that the chunks around the player will get loaded
- eventually anyways and that maps will get checked for update every
- five ticks that movement occur in anyways.
-
-diff --git a/src/main/java/net/minecraft/world/item/MapItem.java b/src/main/java/net/minecraft/world/item/MapItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/item/MapItem.java
-+++ b/src/main/java/net/minecraft/world/item/MapItem.java
-@@ -0,0 +0,0 @@ public class MapItem extends ComplexItem {
-                             int r = (j / i + o - 64) * i;
-                             int s = (k / i + p - 64) * i;
-                             Multiset<MapColor> multiset = LinkedHashMultiset.create();
-                            LevelChunk levelChunk = world.getChunk(SectionPos.blockToSectionCoord(r), SectionPos.blockToSectionCoord(s));
-                            if (!levelChunk.isEmpty()) {
-+                            LevelChunk levelChunk = world.getChunkIfLoaded(SectionPos.blockToSectionCoord(r), SectionPos.blockToSectionCoord(s)); // Paper - Maps shouldn't load chunks
-+                            if (levelChunk != null && !levelChunk.isEmpty()) { // Paper - Maps shouldn't load chunks
-                                 int t = 0;
-                                 double e = 0.0;
-                                 if (world.dimensionType().hasCeiling()) {
--- a/patches/unapplied/server/Mob-Spawner-API-Enhancements.patch
+++ b/patches/unapplied/server/Mob-Spawner-API-Enhancements.patch
@ -1,111 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <blake.galbreath@gmail.com>
-Date: Fri, 19 Apr 2019 12:41:13 -0500
-Subject: [PATCH] Mob Spawner API Enhancements
-
-== AT ==
-public net.minecraft.world.level.BaseSpawner isNearPlayer(Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;)Z
-public net.minecraft.world.level.BaseSpawner delay(Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;)V
-public net.minecraft.world.level.BaseSpawner setNextSpawnData(Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/SpawnData;)V
-
-diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
-@@ -0,0 +0,0 @@ public abstract class BaseSpawner {
-     }
- 
-     public void load(@Nullable Level world, BlockPos pos, CompoundTag nbt) {
-+        // Paper start - use larger int if set
-+        if (nbt.contains("Paper.Delay")) {
-+            this.spawnDelay = nbt.getInt("Paper.Delay");
-+        } else {
-         this.spawnDelay = nbt.getShort("Delay");
-+        }
-+        // Paper end
-         boolean flag = nbt.contains("SpawnData", 10);
- 
-         if (flag) {
-@@ -0,0 +0,0 @@ public abstract class BaseSpawner {
-             this.spawnPotentials = SimpleWeightedRandomList.single(this.nextSpawnData != null ? this.nextSpawnData : new SpawnData());
-         }
- 
-+        // Paper start - use ints if set
-+        if (nbt.contains("Paper.MinSpawnDelay", net.minecraft.nbt.Tag.TAG_ANY_NUMERIC)) {
-+            this.minSpawnDelay = nbt.getInt("Paper.MinSpawnDelay");
-+            this.maxSpawnDelay = nbt.getInt("Paper.MaxSpawnDelay");
-+            this.spawnCount = nbt.getShort("SpawnCount");
-+        } else // Paper end
-         if (nbt.contains("MinSpawnDelay", 99)) {
-            this.minSpawnDelay = nbt.getShort("MinSpawnDelay");
-            this.maxSpawnDelay = nbt.getShort("MaxSpawnDelay");
-+            this.minSpawnDelay = nbt.getInt("MinSpawnDelay"); // Paper - short -> int
-+            this.maxSpawnDelay = nbt.getInt("MaxSpawnDelay"); // Paper - short -> int
-             this.spawnCount = nbt.getShort("SpawnCount");
-         }
- 
-@@ -0,0 +0,0 @@ public abstract class BaseSpawner {
-     }
- 
-     public CompoundTag save(CompoundTag nbt) {
-        nbt.putShort("Delay", (short) this.spawnDelay);
-        nbt.putShort("MinSpawnDelay", (short) this.minSpawnDelay);
-        nbt.putShort("MaxSpawnDelay", (short) this.maxSpawnDelay);
-+        // Paper start
-+        if (spawnDelay > Short.MAX_VALUE) {
-+            nbt.putInt("Paper.Delay", this.spawnDelay);
-+        }
-+        nbt.putShort("Delay", (short) Math.min(Short.MAX_VALUE, this.spawnDelay));
-+
-+        if (minSpawnDelay > Short.MAX_VALUE || maxSpawnDelay > Short.MAX_VALUE) {
-+            nbt.putInt("Paper.MinSpawnDelay", this.minSpawnDelay);
-+            nbt.putInt("Paper.MaxSpawnDelay", this.maxSpawnDelay);
-+        }
-+
-+        nbt.putShort("MinSpawnDelay", (short) Math.min(Short.MAX_VALUE, this.minSpawnDelay));
-+        nbt.putShort("MaxSpawnDelay", (short) Math.min(Short.MAX_VALUE, this.maxSpawnDelay));
-+        // Paper end
-         nbt.putShort("SpawnCount", (short) this.spawnCount);
-         nbt.putShort("MaxNearbyEntities", (short) this.maxNearbyEntities);
-         nbt.putShort("RequiredPlayerRange", (short) this.requiredPlayerRange);
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java b/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
-@@ -0,0 +0,0 @@ public class CraftCreatureSpawner extends CraftBlockEntityState<SpawnerBlockEnti
-                 new HashMap<>(nms.slotDropChances().entrySet().stream().collect(Collectors.toMap((entry) -> CraftEquipmentSlot.getSlot(entry.getKey()), Map.Entry::getValue)))
-         )).orElse(null);
-     }
-+
-+    // Paper start
-+    @Override
-+    public boolean isActivated() {
-+        this.requirePlaced();
-+        return this.getSnapshot().getSpawner().isNearPlayer(this.world.getHandle(), this.getPosition());
-+    }
-+
-+    @Override
-+    public void resetTimer() {
-+        this.requirePlaced();
-+        this.getSnapshot().getSpawner().delay(this.world.getHandle(), this.getPosition());
-+    }
-+
-+    @Override
-+    public void setSpawnedItem(org.bukkit.inventory.ItemStack itemStack) {
-+        Preconditions.checkArgument(itemStack != null && !itemStack.getType().isAir(), "spawners cannot spawn air");
-+        net.minecraft.world.item.ItemStack item = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(itemStack);
-+        net.minecraft.nbt.CompoundTag entity = new net.minecraft.nbt.CompoundTag();
-+        entity.putString("id", net.minecraft.core.registries.BuiltInRegistries.ENTITY_TYPE.getKey(net.minecraft.world.entity.EntityType.ITEM).toString());
-+        entity.put("Item", item.save(this.world.getHandle().registryAccess()));
-+        this.getSnapshot().getSpawner().setNextSpawnData(
-+            this.isPlaced() ? this.world.getHandle() : null,
-+            this.getPosition(),
-+            new net.minecraft.world.level.SpawnData(
-+                entity,
-+                java.util.Optional.empty(),
-+                Optional.ofNullable(this.getSnapshot().getSpawner().nextSpawnData).flatMap(SpawnData::equipment)
-+            )
-+        );
-+    }
-+    // Paper end
- }
--- a/patches/unapplied/server/Move-player-to-spawn-point-if-spawn-in-unloaded-worl.patch
+++ b/patches/unapplied/server/Move-player-to-spawn-point-if-spawn-in-unloaded-worl.patch
@ -1,119 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: 2277 <38501234+2277@users.noreply.github.com>
-Date: Tue, 31 Mar 2020 10:33:55 +0100
-Subject: [PATCH] Move player to spawn point if spawn in unloaded world
-
-If the playerdata contains an invalid world (missing, unloaded, invalid,
-etc.), spawn the player at the spawn point of the main world.
-
-Co-authored-by: Wyatt Childers <wchilders@nearce.com>
-Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
-
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-         }
- 
-         Optional<CompoundTag> optional = this.load(player); // CraftBukkit - decompile error
-+        ResourceKey<Level> resourcekey = null; // Paper
-         // CraftBukkit start - Better rename detection
-         if (optional.isPresent()) {
-             CompoundTag nbttagcompound = optional.get();
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-             }
-         }
-         // CraftBukkit end
-        ResourceKey<Level> resourcekey = (ResourceKey) optional.flatMap((nbttagcompound) -> {
-+        // Paper start - move logic in Entity to here, to use bukkit supplied world UUID & reset to main world spawn if no valid world is found
-+        boolean[] invalidPlayerWorld = {false};
-+        bukkitData: if (optional.isPresent()) {
-+            // The main way for bukkit worlds to store the world is the world UUID despite mojang adding custom worlds
-+            final org.bukkit.World bWorld;
-+            if (optional.get().contains("WorldUUIDMost") && optional.get().contains("WorldUUIDLeast")) {
-+                bWorld = org.bukkit.Bukkit.getServer().getWorld(new UUID(optional.get().getLong("WorldUUIDMost"), optional.get().getLong("WorldUUIDLeast")));
-+            } else if (optional.get().contains("world", net.minecraft.nbt.Tag.TAG_STRING)) { // Paper - legacy bukkit world name
-+                bWorld = org.bukkit.Bukkit.getServer().getWorld(optional.get().getString("world"));
-+            } else {
-+                break bukkitData; // if neither of the bukkit data points exist, proceed to the vanilla migration section
-+            }
-+            if (bWorld != null) {
-+                resourcekey = ((CraftWorld) bWorld).getHandle().dimension();
-+            } else {
-+                resourcekey = Level.OVERWORLD;
-+                invalidPlayerWorld[0] = true;
-+            }
-+        }
-+        if (resourcekey == null) { // only run the vanilla logic if we haven't found a world from the bukkit data
-+        // Below is the vanilla way of getting the dimension, this is for migration from vanilla servers
-+        resourcekey = optional.flatMap((nbttagcompound) -> {
-+            // Paper end
-             DataResult<ResourceKey<Level>> dataresult = DimensionType.parseLegacy(new Dynamic(NbtOps.INSTANCE, nbttagcompound.get("Dimension"))); // CraftBukkit - decompile error
-             Logger logger = PlayerList.LOGGER;
- 
-             Objects.requireNonNull(logger);
-            return dataresult.resultOrPartial(logger::error);
-        }).orElse(player.serverLevel().dimension()); // CraftBukkit - SPIGOT-7507: If no dimension, fall back to existing dimension loaded from "WorldUUID", which in turn defaults to World.OVERWORLD
-+            // Paper start - reset to main world spawn if no valid world is found
-+            final Optional<ResourceKey<Level>> result = dataresult.resultOrPartial(logger::error);
-+            invalidPlayerWorld[0] = result.isEmpty();
-+            return result;
-+        }).orElse(Level.OVERWORLD); // Paper - revert to vanilla default main world, this isn't an "invalid world" since no player data existed
-+        }
-+        // Paper end
-         ServerLevel worldserver = this.server.getLevel(resourcekey);
-         ServerLevel worldserver1;
- 
-         if (worldserver == null) {
-             PlayerList.LOGGER.warn("Unknown respawn dimension {}, defaulting to overworld", resourcekey);
-             worldserver1 = this.server.overworld();
-+            invalidPlayerWorld[0] = true; // Paper - reset to main world if no world with parsed value is found
-         } else {
-             worldserver1 = worldserver;
-         }
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-         // Paper start - Entity#getEntitySpawnReason
-         if (optional.isEmpty()) {
-             player.spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DEFAULT; // set Player SpawnReason to DEFAULT on first login
-+            // Paper start - reset to main world spawn if first spawn or invalid world
-+        }
-+        if (optional.isEmpty() || invalidPlayerWorld[0]) {
-+            // Paper end - reset to main world spawn if first spawn or invalid world
-             player.fudgeSpawnLocation(worldserver1); // Paper - Don't move existing players to world spawn
-         }
-         // Paper end - Entity#getEntitySpawnReason
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-             }
-             // CraftBukkit end
- 
-            // CraftBukkit start - Reset world
-            if (this instanceof ServerPlayer) {
-                Server server = Bukkit.getServer();
-                org.bukkit.World bworld = null;
-
-                // TODO: Remove World related checks, replaced with WorldUID
-                String worldName = nbt.getString("world");
-
-                if (nbt.contains("WorldUUIDMost") && nbt.contains("WorldUUIDLeast")) {
-                    UUID uid = new UUID(nbt.getLong("WorldUUIDMost"), nbt.getLong("WorldUUIDLeast"));
-                    bworld = server.getWorld(uid);
-                } else {
-                    bworld = server.getWorld(worldName);
-                }
-
-                if (bworld == null) {
-                    bworld = ((org.bukkit.craftbukkit.CraftServer) server).getServer().getLevel(Level.OVERWORLD).getWorld();
-                }
-
-                ((ServerPlayer) this).setLevel(bworld == null ? null : ((CraftWorld) bworld).getHandle());
-            }
-+            // CraftBukkit start
-+            // Paper - move world parsing/loading to PlayerList#placeNewPlayer
-             this.getBukkitEntity().readBukkitValues(nbt);
-             if (nbt.contains("Bukkit.invisible")) {
-                 boolean bukkitInvisible = nbt.getBoolean("Bukkit.invisible");
--- a/patches/unapplied/server/Only-count-Natural-Spawned-mobs-towards-natural-spaw.patch
+++ b/patches/unapplied/server/Only-count-Natural-Spawned-mobs-towards-natural-spaw.patch
@ -1,36 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 24 Mar 2019 01:01:32 -0400
-Subject: [PATCH] Only count Natural Spawned mobs towards natural spawn mob
- limit
-
-This resolves the super common complaint about mobs not spawning.
-
-This was ultimately a flaw in the vanilla count algorithim that allows
-spawners and other misc mobs to count against the mob limit, which are
-not bounded, and can prevent the entire world from spawning new.
-
-I believe Bukkits changes around persistence may of actually made it
-worse than vanilla.
-
-This should fully solve all of the issues around it so that only natural
-influences natural spawns.
-
-diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-             MobCategory enumcreaturetype = entity.getType().getCategory();
- 
-             if (enumcreaturetype != MobCategory.MISC) {
-+                // Paper start - Only count natural spawns
-+                if (!entity.level().paperConfig().entities.spawning.countAllMobsForSpawning &&
-+                    !(entity.spawnReason == org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL ||
-+                        entity.spawnReason == org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.CHUNK_GEN)) {
-+                    continue;
-+                }
-+                // Paper end - Only count natural spawns
-                 BlockPos blockposition = entity.blockPosition();
- 
-                 chunkSource.query(ChunkPos.asLong(blockposition), (chunk) -> {
--- a/patches/unapplied/server/Optimise-Chunk-getFluid.patch
+++ b/patches/unapplied/server/Optimise-Chunk-getFluid.patch
@ -1,61 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Tue, 14 Jan 2020 14:59:08 -0800
-Subject: [PATCH] Optimise Chunk#getFluid
-
-Removing the try catch and generally reducing ops should make it
-faster on its own, however removing the try catch makes it
-easier to inline due to code size
-
-diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
-@@ -0,0 +0,0 @@ public class LevelChunk extends ChunkAccess {
-     }
- 
-     public FluidState getFluidState(int x, int y, int z) {
-        try {
-            int l = this.getSectionIndex(y);
-
-            if (l >= 0 && l < this.sections.length) {
-                LevelChunkSection chunksection = this.sections[l];
-+        // Paper start - Perf: Optimise Chunk#getFluid
-+        // try {  // Remove try catch
-+        int index = this.getSectionIndex(y);
-+            if (index >= 0 && index < this.sections.length) {
-+                LevelChunkSection chunksection = this.sections[index];
- 
-                 if (!chunksection.hasOnlyAir()) {
-                    return chunksection.getFluidState(x & 15, y & 15, z & 15);
-+                    return chunksection.states.get((y & 15) << 8 | (z & 15) << 4 | x & 15).getFluidState();
-+                    // Paper end - Perf: Optimise Chunk#getFluid
-                 }
-             }
- 
-             return Fluids.EMPTY.defaultFluidState();
-+        /* // Paper - Perf: Optimise Chunk#getFluid
-         } catch (Throwable throwable) {
-             CrashReport crashreport = CrashReport.forThrowable(throwable, "Getting fluid state");
-             CrashReportCategory crashreportsystemdetails = crashreport.addCategory("Block being got");
-@@ -0,0 +0,0 @@ public class LevelChunk extends ChunkAccess {
-             });
-             throw new ReportedException(crashreport);
-         }
-+         */  // Paper - Perf: Optimise Chunk#getFluid
-     }
- 
-     // CraftBukkit start
-diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-@@ -0,0 +0,0 @@ public class LevelChunkSection {
-     }
- 
-     public FluidState getFluidState(int x, int y, int z) {
-        return ((BlockState) this.states.get(x, y, z)).getFluidState();
-+        return this.states.get(x, y, z).getFluidState(); // Paper - Perf: Optimise Chunk#getFluid; diff on change - we expect this to be effectively just getType(x, y, z).getFluid(). If this changes we need to check other patches that use IBlockData#getFluid.
-     }
- 
-     public void acquire() {
--- a/patches/unapplied/server/Optimise-EntityGetter-getPlayerByUUID.patch
+++ b/patches/unapplied/server/Optimise-EntityGetter-getPlayerByUUID.patch
@ -1,27 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sat, 11 Jan 2020 21:50:56 -0800
-Subject: [PATCH] Optimise EntityGetter#getPlayerByUUID
-
-Use the PlayerList map instead of iterating over all players
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-     }
-     // Paper end
- 
-+    // Paper start - optimise getPlayerByUUID
-+    @Nullable
-+    @Override
-+    public Player getPlayerByUUID(UUID uuid) {
-+        final Player player = this.getServer().getPlayerList().getPlayer(uuid);
-+        return player != null && player.level() == this ? player : null;
-+    }
-+    // Paper end - optimise getPlayerByUUID
-+
-     // Add env and gen to constructor, IWorldDataServer -> WorldDataServer
-     public ServerLevel(MinecraftServer minecraftserver, Executor executor, LevelStorageSource.LevelStorageAccess convertable_conversionsession, PrimaryLevelData iworlddataserver, ResourceKey<Level> resourcekey, LevelStem worlddimension, ChunkProgressListener worldloadlistener, boolean flag, long i, List<CustomSpawner> list, boolean flag1, @Nullable RandomSequences randomsequences, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider) {
-         // IRegistryCustom.Dimension iregistrycustom_dimension = minecraftserver.registryAccess(); // CraftBukkit - decompile error
--- a/patches/unapplied/server/Optimise-getChunkAt-calls-for-loaded-chunks.patch
+++ b/patches/unapplied/server/Optimise-getChunkAt-calls-for-loaded-chunks.patch
@ -1,66 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sat, 25 Jan 2020 17:04:35 -0800
-Subject: [PATCH] Optimise getChunkAt calls for loaded chunks
-
-bypass the need to get a player chunk, then get the either,
-then unwrap it...
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-                 return this.getChunk(x, z, leastStatus, create);
-             }, this.mainThreadProcessor).join();
-         } else {
-+            // Paper start - Perf: Optimise getChunkAt calls for loaded chunks
-+            LevelChunk ifLoaded = this.getChunkAtIfLoadedMainThread(x, z);
-+            if (ifLoaded != null) {
-+                return ifLoaded;
-+            }
-+            // Paper end - Perf: Optimise getChunkAt calls for loaded chunks
-             ProfilerFiller gameprofilerfiller = this.level.getProfiler();
- 
-             gameprofilerfiller.incrementCounter("getChunk");
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-         if (Thread.currentThread() != this.mainThread) {
-             return null;
-         } else {
-            this.level.getProfiler().incrementCounter("getChunkNow");
-            long k = ChunkPos.asLong(chunkX, chunkZ);
-
-            for (int l = 0; l < 4; ++l) {
-                if (k == this.lastChunkPos[l] && this.lastChunkStatus[l] == ChunkStatus.FULL) {
-                    ChunkAccess ichunkaccess = this.lastChunk[l];
-
-                    return ichunkaccess instanceof LevelChunk ? (LevelChunk) ichunkaccess : null;
-                }
-            }
-
-            ChunkHolder playerchunk = this.getVisibleChunkIfPresent(k);
-
-            if (playerchunk == null) {
-                return null;
-            } else {
-                ChunkResult<ChunkAccess> chunkresult = (ChunkResult) playerchunk.getFutureIfPresent(ChunkStatus.FULL).getNow(null); // CraftBukkit - decompile error
-
-                if (chunkresult == null) {
-                    return null;
-                } else {
-                    ChunkAccess ichunkaccess1 = (ChunkAccess) chunkresult.orElse(null); // CraftBukkit - decompile error
-
-                    if (ichunkaccess1 != null) {
-                        this.storeInCache(k, ichunkaccess1, ChunkStatus.FULL);
-                        if (ichunkaccess1 instanceof LevelChunk) {
-                            return (LevelChunk) ichunkaccess1;
-                        }
-                    }
-
-                    return null;
-                }
-            }
-+            return this.getChunkAtIfLoadedMainThread(chunkX, chunkZ); // Paper - Perf: Optimise getChunkAt calls for loaded chunks
-         }
-     }
- 
--- a/patches/unapplied/server/Optimize-Captured-BlockEntity-Lookup.patch
+++ b/patches/unapplied/server/Optimize-Captured-BlockEntity-Lookup.patch
@ -1,30 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 6 Apr 2019 10:16:48 -0400
-Subject: [PATCH] Optimize Captured BlockEntity Lookup
-
-upstream was doing a containsKey/get pattern, and always doing it at that.
-that scenario is only even valid if were in the middle of a block place.
-
-Optimize to check if the captured list even has values in it, and also to
-just do a get call since the value can never be null.
-
-diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/Level.java
-+++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
- 
-     @Nullable
-     public BlockEntity getBlockEntity(BlockPos blockposition, boolean validate) {
-        if (this.capturedTileEntities.containsKey(blockposition)) {
-            return this.capturedTileEntities.get(blockposition);
-+        // Paper start - Perf: Optimize capturedTileEntities lookup
-+        net.minecraft.world.level.block.entity.BlockEntity blockEntity;
-+        if (!this.capturedTileEntities.isEmpty() && (blockEntity = this.capturedTileEntities.get(blockposition)) != null) {
-+            return blockEntity;
-         }
-+        // Paper end - Perf: Optimize capturedTileEntities lookup
-         // CraftBukkit end
-         return this.isOutsideBuildHeight(blockposition) ? null : (!this.isClientSide && Thread.currentThread() != this.thread ? null : this.getChunkAt(blockposition).getBlockEntity(blockposition, LevelChunk.EntityCreationType.IMMEDIATE));
-     }
--- a/patches/unapplied/server/Optimize-Pathfinding.patch
+++ b/patches/unapplied/server/Optimize-Pathfinding.patch
@ -1,47 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 3 Mar 2016 02:02:07 -0600
-Subject: [PATCH] Optimize Pathfinding
-
-Prevents pathfinding from spamming failures for things such as
-arrow attacks.
-
-diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java
-@@ -0,0 +0,0 @@ public abstract class PathNavigation {
-         return this.moveTo(this.createPath(x, y, z, 1), speed);
-     }
- 
-+    // Paper start - Perf: Optimise pathfinding
-+    private int lastFailure = 0;
-+    private int pathfindFailures = 0;
-+    // Paper end - Perf: Optimise pathfinding
-+
-     public boolean moveTo(double x, double y, double z, int distance, double speed) {
-         return this.moveTo(this.createPath(x, y, z, distance), speed);
-     }
- 
-     public boolean moveTo(Entity entity, double speed) {
-+        // Paper start - Perf: Optimise pathfinding
-+        if (this.pathfindFailures > 10 && this.path == null && net.minecraft.server.MinecraftServer.currentTick < this.lastFailure + 40) {
-+            return false;
-+        }
-+        // Paper end - Perf: Optimise pathfinding
-         Path path = this.createPath(entity, 1);
-        return path != null && this.moveTo(path, speed);
-+        // Paper start - Perf: Optimise pathfinding
-+        if (path != null && this.moveTo(path, speed)) {
-+            this.lastFailure = 0;
-+            this.pathfindFailures = 0;
-+            return true;
-+        } else {
-+            this.pathfindFailures++;
-+            this.lastFailure = net.minecraft.server.MinecraftServer.currentTick;
-+            return false;
-+        }
-+        // Paper end - Perf: Optimise pathfinding
-     }
- 
-     public boolean moveTo(@Nullable Path path, double speed) {
--- a/patches/unapplied/server/Optimize-call-to-getFluid-for-explosions.patch
+++ b/patches/unapplied/server/Optimize-call-to-getFluid-for-explosions.patch
@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BrodyBeckwith <brody@beckwith.dev>
-Date: Tue, 14 Jan 2020 17:49:03 -0500
-Subject: [PATCH] Optimize call to getFluid for explosions
-
-
-diff --git a/src/main/java/net/minecraft/world/level/Explosion.java b/src/main/java/net/minecraft/world/level/Explosion.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/Explosion.java
-+++ b/src/main/java/net/minecraft/world/level/Explosion.java
-@@ -0,0 +0,0 @@ public class Explosion {
-                         for (float f1 = 0.3F; f > 0.0F; f -= 0.22500001F) {
-                             BlockPos blockposition = BlockPos.containing(d4, d5, d6);
-                             BlockState iblockdata = this.level.getBlockState(blockposition);
-                            FluidState fluid = this.level.getFluidState(blockposition);
-+                            FluidState fluid = iblockdata.getFluidState(); // Paper - Perf: Optimize call to getFluid for explosions
- 
-                             if (!this.level.isInWorldBounds(blockposition)) {
-                                 break;
--- a/patches/unapplied/server/Paper-dumpitem-command.patch
+++ b/patches/unapplied/server/Paper-dumpitem-command.patch
@ -1,158 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 28 Jun 2020 19:27:20 -0400
-Subject: [PATCH] Paper dumpitem command
-
-Let's you quickly view the item in your hands NBT data
-
-diff --git a/src/main/java/io/papermc/paper/command/PaperCommand.java b/src/main/java/io/papermc/paper/command/PaperCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/io/papermc/paper/command/PaperCommand.java
-+++ b/src/main/java/io/papermc/paper/command/PaperCommand.java
-@@ -0,0 +0,0 @@ public final class PaperCommand extends Command {
-         commands.put(Set.of("version"), new VersionCommand());
-         commands.put(Set.of("dumpplugins"), new DumpPluginsCommand());
-         commands.put(Set.of("syncloadinfo"), new SyncLoadInfoCommand());
-+        commands.put(Set.of("dumpitem"), new DumpItemCommand());
- 
-         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/DumpItemCommand.java b/src/main/java/io/papermc/paper/command/subcommands/DumpItemCommand.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/io/papermc/paper/command/subcommands/DumpItemCommand.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.command.subcommands;
-+
-+import io.papermc.paper.adventure.PaperAdventure;
-+import io.papermc.paper.command.CommandUtil;
-+import io.papermc.paper.command.PaperSubcommand;
-+import java.util.ArrayList;
-+import java.util.Collections;
-+import java.util.IdentityHashMap;
-+import java.util.List;
-+import java.util.Map;
-+import java.util.Optional;
-+import java.util.Set;
-+import java.util.function.Consumer;
-+import net.kyori.adventure.text.Component;
-+import net.kyori.adventure.text.ComponentLike;
-+import net.kyori.adventure.text.JoinConfiguration;
-+import net.kyori.adventure.text.TextComponent;
-+import net.minecraft.core.Registry;
-+import net.minecraft.core.RegistryAccess;
-+import net.minecraft.core.component.DataComponentMap;
-+import net.minecraft.core.component.DataComponentPatch;
-+import net.minecraft.core.component.DataComponentType;
-+import net.minecraft.core.component.TypedDataComponent;
-+import net.minecraft.core.registries.Registries;
-+import net.minecraft.nbt.NbtOps;
-+import net.minecraft.nbt.NbtUtils;
-+import net.minecraft.nbt.SnbtPrinterTagVisitor;
-+import net.minecraft.nbt.Tag;
-+import net.minecraft.resources.RegistryOps;
-+import net.minecraft.world.item.ItemStack;
-+import org.bukkit.command.CommandSender;
-+import org.bukkit.craftbukkit.CraftServer;
-+import org.bukkit.craftbukkit.inventory.CraftItemStack;
-+import org.bukkit.entity.Player;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+import org.checkerframework.checker.nullness.qual.Nullable;
-+import org.checkerframework.framework.qual.DefaultQualifier;
-+
-+import static net.kyori.adventure.text.Component.join;
-+import static net.kyori.adventure.text.Component.text;
-+import static net.kyori.adventure.text.Component.textOfChildren;
-+import static net.kyori.adventure.text.event.ClickEvent.copyToClipboard;
-+import static net.kyori.adventure.text.format.NamedTextColor.AQUA;
-+import static net.kyori.adventure.text.format.NamedTextColor.GRAY;
-+import static net.kyori.adventure.text.format.NamedTextColor.RED;
-+import static net.kyori.adventure.text.format.NamedTextColor.WHITE;
-+import static net.kyori.adventure.text.format.NamedTextColor.YELLOW;
-+import static net.kyori.adventure.text.format.TextColor.color;
-+import static net.kyori.adventure.text.format.TextDecoration.ITALIC;
-+
-+@DefaultQualifier(NonNull.class)
-+public final class DumpItemCommand implements PaperSubcommand {
-+    @Override
-+    public boolean execute(final CommandSender sender, final String subCommand, final String[] args) {
-+        this.doDumpItem(sender, args.length > 0 && "all".equals(args[0]));
-+        return true;
-+    }
-+
-+    @SuppressWarnings({"unchecked", "OptionalAssignedToNull", "rawtypes"})
-+    private void doDumpItem(final CommandSender sender, final boolean includeAllComponents) {
-+        if (!(sender instanceof final Player player)) {
-+            sender.sendMessage("Only players can use this command");
-+            return;
-+        }
-+        final ItemStack itemStack = CraftItemStack.asNMSCopy(player.getInventory().getItemInMainHand());
-+        final TextComponent.Builder visualOutput = Component.text();
-+        final StringBuilder itemCommandBuilder = new StringBuilder();
-+        final String itemName = itemStack.getItemHolder().unwrapKey().orElseThrow().location().toString();
-+        itemCommandBuilder.append(itemName);
-+        visualOutput.append(text(itemName, YELLOW)); // item type
-+        final Set<DataComponentType<?>> referencedComponentTypes = Collections.newSetFromMap(new IdentityHashMap<>());
-+        final DataComponentPatch patch = itemStack.getComponentsPatch();
-+        referencedComponentTypes.addAll(patch.entrySet().stream().map(Map.Entry::getKey).toList());
-+        final DataComponentMap prototype = itemStack.getItem().components();
-+        if (includeAllComponents) {
-+            referencedComponentTypes.addAll(prototype.keySet());
-+        }
-+
-+        final RegistryAccess.Frozen access = ((CraftServer) sender.getServer()).getServer().registryAccess();
-+        final RegistryOps<Tag> ops = access.createSerializationContext(NbtOps.INSTANCE);
-+        final Registry<DataComponentType<?>> registry = access.registryOrThrow(Registries.DATA_COMPONENT_TYPE);
-+        final List<ComponentLike> componentComponents = new ArrayList<>();
-+        final List<String> commandComponents = new ArrayList<>();
-+        for (final DataComponentType<?> type : referencedComponentTypes) {
-+            final String path = registry.getResourceKey(type).orElseThrow().location().getPath();
-+            final @Nullable Optional<?> patchedValue = patch.get(type);
-+            final @Nullable TypedDataComponent<?> prototypeValue = prototype.getTyped(type);
-+            if (patchedValue != null) {
-+                if (patchedValue.isEmpty()) {
-+                    componentComponents.add(text().append(text('!', RED), text(path, AQUA)));
-+                    commandComponents.add("!" + path);
-+                } else {
-+                    final Tag serialized = (Tag) ((DataComponentType) type).codecOrThrow().encodeStart(ops, patchedValue.get()).getOrThrow();
-+                    writeComponentValue(componentComponents::add, commandComponents::add, path, serialized);
-+                }
-+            } else if (includeAllComponents && prototypeValue != null) {
-+                final Tag serialized = prototypeValue.encodeValue(ops).getOrThrow();
-+                writeComponentValue(componentComponents::add, commandComponents::add, path, serialized);
-+            }
-+        }
-+        if (!componentComponents.isEmpty()) {
-+            visualOutput.append(
-+                text("[", color(0x8910CE)),
-+                join(JoinConfiguration.separator(text(",", GRAY)), componentComponents),
-+                text("]", color(0x8910CE))
-+            );
-+            itemCommandBuilder
-+                .append("[")
-+                .append(String.join(",", commandComponents))
-+                .append("]");
-+        }
-+        player.sendMessage(visualOutput.build().compact());
-+        final Component copyMsg = text("Click to copy item definition to clipboard for use with /pgive", GRAY, ITALIC);
-+        sender.sendMessage(copyMsg.clickEvent(copyToClipboard(itemCommandBuilder.toString())));
-+    }
-+
-+    private static void writeComponentValue(final Consumer<Component> visualOutput, final Consumer<String> commandOutput, final String path, final Tag serialized) {
-+        visualOutput.accept(textOfChildren(
-+            text(path, color(0xFF7FD7)),
-+            text("=", WHITE),
-+            PaperAdventure.asAdventure(NbtUtils.toPrettyComponent(serialized))
-+        ));
-+        commandOutput.accept(path + "=" + new SnbtPrinterTagVisitor("", 0, new ArrayList<>()).visit(serialized));
-+    }
-+
-+    @Override
-+    public List<String> tabComplete(final CommandSender sender, final String subCommand, final String[] args) {
-+        if (args.length == 1) {
-+            return CommandUtil.getListMatchingLast(sender, args, "all");
-+        }
-+        return Collections.emptyList();
-+    }
-+}
--- a/patches/unapplied/server/Pillager-patrol-spawn-settings-and-per-player-option.patch
+++ b/patches/unapplied/server/Pillager-patrol-spawn-settings-and-per-player-option.patch
@ -1,96 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Phoenix616 <mail@moep.tv>
-Date: Sat, 1 Feb 2020 16:50:39 +0100
-Subject: [PATCH] Pillager patrol spawn settings and per player options
-
-This adds config options for defining the spawn chance, spawn delay and
-spawn start day as well as toggles for handling the spawn delay and
-start day per player. (Based on the time played statistic)
-When not per player it will use the Vanilla mechanic of one delay per
-world and the world age for the start day.
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-     public boolean wonGame;
-     private int containerUpdateDelay; // Paper - Configurable container update tick rate
-     public long loginTime; // Paper - Replace OfflinePlayer#getLastPlayed
-+    public int patrolSpawnDelay; // Paper - Pillager patrol spawn settings and per player options
-     // Paper start - cancellable death event
-     public boolean queueHealthUpdatePacket;
-     public net.minecraft.network.protocol.game.ClientboundSetHealthPacket queuedHealthUpdatePacket;
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
-@@ -0,0 +0,0 @@ public class PatrolSpawner implements CustomSpawner {
- 
-     @Override
-     public int tick(ServerLevel world, boolean spawnMonsters, boolean spawnAnimals) {
-        if (world.paperConfig().entities.behavior.pillagerPatrols.disable) return 0; // Paper - Add option to disable pillager patrols
-+        if (world.paperConfig().entities.behavior.pillagerPatrols.disable || world.paperConfig().entities.behavior.pillagerPatrols.spawnChance == 0) return 0; // Paper - Add option to disable pillager patrols & Pillager patrol spawn settings and per player options
-         if (!spawnMonsters) {
-             return 0;
-         } else if (!world.getGameRules().getBoolean(GameRules.RULE_DO_PATROL_SPAWNING)) {
-@@ -0,0 +0,0 @@ public class PatrolSpawner implements CustomSpawner {
-         } else {
-             RandomSource randomsource = world.random;
- 
-            --this.nextTick;
-            if (this.nextTick > 0) {
-+            // Paper start - Pillager patrol spawn settings and per player options
-+            // Random player selection moved up for per player spawning and configuration
-+            int j = world.players().size();
-+            if (j < 1) {
-                 return 0;
-+            }
-+
-+            net.minecraft.server.level.ServerPlayer entityhuman = world.players().get(randomsource.nextInt(j));
-+            if (entityhuman.isSpectator()) {
-+                return 0;
-+            }
-+
-+            int patrolSpawnDelay;
-+            if (world.paperConfig().entities.behavior.pillagerPatrols.spawnDelay.perPlayer) {
-+                --entityhuman.patrolSpawnDelay;
-+                patrolSpawnDelay = entityhuman.patrolSpawnDelay;
-             } else {
-                this.nextTick += 12000 + randomsource.nextInt(1200);
-                long i = world.getDayTime() / 24000L;
-+                this.nextTick--;
-+                patrolSpawnDelay = this.nextTick;
-+            }
-+
-+            if (patrolSpawnDelay > 0) {
-+                return 0;
-+            } else {
-+                long days;
-+                if (world.paperConfig().entities.behavior.pillagerPatrols.start.perPlayer) {
-+                    days = entityhuman.getStats().getValue(net.minecraft.stats.Stats.CUSTOM.get(net.minecraft.stats.Stats.PLAY_TIME)) / 24000L; // PLAY_ONE_MINUTE is actually counting in ticks, a misnomer by Mojang
-+                } else {
-+                    days = world.getDayTime() / 24000L;
-+                }
-+                if (world.paperConfig().entities.behavior.pillagerPatrols.spawnDelay.perPlayer) {
-+                    entityhuman.patrolSpawnDelay += world.paperConfig().entities.behavior.pillagerPatrols.spawnDelay.ticks + randomsource.nextInt(1200);
-+                } else {
-+                    this.nextTick += world.paperConfig().entities.behavior.pillagerPatrols.spawnDelay.ticks + randomsource.nextInt(1200);
-+                }
- 
-                if (i >= 5L && world.isDay()) {
-                    if (randomsource.nextInt(5) != 0) {
-+                if (days >= world.paperConfig().entities.behavior.pillagerPatrols.start.day && world.isDay()) {
-+                    if (randomsource.nextDouble() >= world.paperConfig().entities.behavior.pillagerPatrols.spawnChance) {
-+                        // Paper end - Pillager patrol spawn settings and per player options
-                         return 0;
-                     } else {
-                        int j = world.players().size();
- 
-                         if (j < 1) {
-                             return 0;
-                         } else {
-                            Player entityhuman = (Player) world.players().get(randomsource.nextInt(j));
- 
-                             if (entityhuman.isSpectator()) {
-                                 return 0;
--- a/patches/unapplied/server/PlayerDeathEvent-getItemsToKeep.patch
+++ b/patches/unapplied/server/PlayerDeathEvent-getItemsToKeep.patch
@ -1,77 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 27 Mar 2019 23:01:33 -0400
-Subject: [PATCH] PlayerDeathEvent#getItemsToKeep
-
-Exposes a mutable array on items a player should keep on death
-
-Example Usage: https://gist.github.com/aikar/5bb202de6057a051a950ce1f29feb0b4
-
-== AT ==
-public net.minecraft.world.entity.player.Inventory compartments
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-         });
-     }
- 
-+    // Paper start - PlayerDeathEvent#getItemsToKeep
-+    private static void processKeep(org.bukkit.event.entity.PlayerDeathEvent event, NonNullList<ItemStack> inv) {
-+        List<org.bukkit.inventory.ItemStack> itemsToKeep = event.getItemsToKeep();
-+        if (inv == null) {
-+            // remainder of items left in toKeep - plugin added stuff on death that wasn't in the initial loot?
-+            if (!itemsToKeep.isEmpty()) {
-+                for (org.bukkit.inventory.ItemStack itemStack : itemsToKeep) {
-+                    event.getEntity().getInventory().addItem(itemStack);
-+                }
-+            }
-+
-+            return;
-+        }
-+
-+        for (int i = 0; i < inv.size(); ++i) {
-+            ItemStack item = inv.get(i);
-+            if (EnchantmentHelper.hasVanishingCurse(item) || itemsToKeep.isEmpty() || item.isEmpty()) {
-+                inv.set(i, ItemStack.EMPTY);
-+                continue;
-+            }
-+
-+            final org.bukkit.inventory.ItemStack bukkitStack = item.getBukkitStack();
-+            boolean keep = false;
-+            final Iterator<org.bukkit.inventory.ItemStack> iterator = itemsToKeep.iterator();
-+            while (iterator.hasNext()) {
-+                final org.bukkit.inventory.ItemStack itemStack = iterator.next();
-+                if (bukkitStack.equals(itemStack)) {
-+                    iterator.remove();
-+                    keep = true;
-+                    break;
-+                }
-+            }
-+
-+            if (!keep) {
-+                inv.set(i, ItemStack.EMPTY);
-+            }
-+        }
-+    }
-+    // Paper end - PlayerDeathEvent#getItemsToKeep
-+
-     @Override
-     public void die(DamageSource damageSource) {
-         // this.gameEvent(GameEvent.ENTITY_DIE); // Paper - move below event cancellation check
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-         this.dropExperience();
-         // we clean the player's inventory after the EntityDeathEvent is called so plugins can get the exact state of the inventory.
-         if (!event.getKeepInventory()) {
-            this.getInventory().clearContent();
-+            // Paper start - PlayerDeathEvent#getItemsToKeep
-+            for (NonNullList<ItemStack> inv : this.getInventory().compartments) {
-+                processKeep(event, inv);
-+            }
-+            processKeep(event, null);
-+            // Paper end - PlayerDeathEvent#getItemsToKeep
-         }
- 
-         this.setCamera(this); // Remove spectated target
--- a/patches/unapplied/server/PlayerDeathEvent-shouldDropExperience.patch
+++ b/patches/unapplied/server/PlayerDeathEvent-shouldDropExperience.patch
@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Tue, 24 Dec 2019 00:35:42 +0000
-Subject: [PATCH] PlayerDeathEvent#shouldDropExperience
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-             this.tellNeutralMobsThatIDied();
-         }
-         // SPIGOT-5478 must be called manually now
-        this.dropExperience();
-+        if (event.shouldDropExperience()) this.dropExperience(); // Paper - tie to event
-         // we clean the player's inventory after the EntityDeathEvent is called so plugins can get the exact state of the inventory.
-         if (!event.getKeepInventory()) {
-             // Paper start - PlayerDeathEvent#getItemsToKeep
--- a/patches/unapplied/server/Potential-bed-API.patch
+++ b/patches/unapplied/server/Potential-bed-API.patch
@ -1,44 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Sun, 10 May 2020 23:06:30 -0400
-Subject: [PATCH] Potential bed API
-
-Adds a new method to fetch the location of a player's bed without generating any sync loads.
-
-getPotentialBedLocation - Gets the last known location of a player's bed. This does not preform any check if the bed is still valid and does not load any chunks.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-@@ -0,0 +0,0 @@ import net.minecraft.nbt.CompoundTag;
- import net.minecraft.network.chat.Component;
- import net.minecraft.network.protocol.game.ClientboundOpenScreenPacket;
- import net.minecraft.network.protocol.game.ServerboundContainerClosePacket;
-+import net.minecraft.server.level.ServerLevel;
- import net.minecraft.server.level.ServerPlayer;
- import net.minecraft.world.MenuProvider;
- import net.minecraft.world.entity.Entity;
-@@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
-         return this.getHandle().sleepCounter;
-     }
- 
-+    // Paper start - Potential bed api
-+    @Override
-+    public Location getPotentialBedLocation() {
-+        ServerPlayer handle = (ServerPlayer) getHandle();
-+        BlockPos bed = handle.getRespawnPosition();
-+        if (bed == null) {
-+            return null;
-+        }
-+
-+        ServerLevel worldServer = handle.server.getLevel(handle.getRespawnDimension());
-+        if (worldServer == null) {
-+            return null;
-+        }
-+        return new Location(worldServer.getWorld(), bed.getX(), bed.getY(), bed.getZ());
-+    }
-+    // Paper end
-     @Override
-     public boolean sleep(Location location, boolean force) {
-         Preconditions.checkArgument(location != null, "Location cannot be null");
--- a/patches/unapplied/server/Prevent-Double-PlayerChunkMap-adds-crashing-server.patch
+++ b/patches/unapplied/server/Prevent-Double-PlayerChunkMap-adds-crashing-server.patch
@ -1,47 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 2 Apr 2020 01:42:39 -0400
-Subject: [PATCH] Prevent Double PlayerChunkMap adds crashing server
-
-Suspected case would be around the technique used in .stopRiding
-Stack will identify any causer of this and warn instead of crashing.
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
- 
-     public void addEntity(Entity entity) {
-         org.spigotmc.AsyncCatcher.catchOp("entity track"); // Spigot
-+        // Paper start - ignore and warn about illegal addEntity calls instead of crashing server
-+        if (!entity.valid || entity.level() != this.level || this.entityMap.containsKey(entity.getId())) {
-+            LOGGER.error("Illegal ChunkMap::addEntity for world " + this.level.getWorld().getName()
-+                + ": " + entity  + (this.entityMap.containsKey(entity.getId()) ? " ALREADY CONTAINED (This would have crashed your server)" : ""), new Throwable());
-+            return;
-+        }
-+        // Paper end - ignore and warn about illegal addEntity calls instead of crashing server
-         if (!(entity instanceof EnderDragonPart)) {
-             EntityType<?> entitytypes = entity.getType();
-             int i = entitytypes.clientTrackingRange() * 16;
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
- 
-         public void onTrackingStart(Entity entity) {
-             org.spigotmc.AsyncCatcher.catchOp("entity register"); // Spigot
-            ServerLevel.this.getChunkSource().addEntity(entity);
-+            // ServerLevel.this.getChunkSource().addEntity(entity); // Paper - ignore and warn about illegal addEntity calls instead of crashing server; moved down below valid=true
-             if (entity instanceof ServerPlayer entityplayer) {
-                 ServerLevel.this.players.add(entityplayer);
-                 ServerLevel.this.updateSleepingPlayerList();
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-             entity.updateDynamicGameEventListener(DynamicGameEventListener::add);
-             entity.inWorld = true; // CraftBukkit - Mark entity as in world
-             entity.valid = true; // CraftBukkit
-+            ServerLevel.this.getChunkSource().addEntity(entity); // Paper - ignore and warn about illegal addEntity calls instead of crashing server
-             // Paper start - Entity origin API
-             if (entity.getOriginVector() == null) {
-                 entity.setOrigin(entity.getBukkitEntity().getLocation());
--- a/patches/unapplied/server/Prevent-bees-loading-chunks-checking-hive-position.patch
+++ b/patches/unapplied/server/Prevent-bees-loading-chunks-checking-hive-position.patch
@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 5 Jan 2020 17:24:34 -0600
-Subject: [PATCH] Prevent bees loading chunks checking hive position
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/animal/Bee.java b/src/main/java/net/minecraft/world/entity/animal/Bee.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/animal/Bee.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java
-@@ -0,0 +0,0 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
-         } else if (this.isTooFarAway(this.hivePos)) {
-             return false;
-         } else {
-+            if (this.level().getChunkIfLoadedImmediately(this.hivePos.getX() >> 4, this.hivePos.getZ() >> 4) == null) return true; // Paper - just assume the hive is still there, no need to load the chunk(s)
-             BlockEntity tileentity = this.level().getBlockEntity(this.hivePos);
- 
-             return tileentity != null && tileentity.getType() == BlockEntityType.BEEHIVE;
--- a/patches/unapplied/server/Prevent-consuming-the-wrong-itemstack.patch
+++ b/patches/unapplied/server/Prevent-consuming-the-wrong-itemstack.patch
@ -1,45 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: kickash32 <kickash32@gmail.com>
-Date: Mon, 19 Aug 2019 19:42:35 +0500
-Subject: [PATCH] Prevent consuming the wrong itemstack
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-     }
- 
-     public void startUsingItem(InteractionHand hand) {
-+        // Paper start - Prevent consuming the wrong itemstack
-+        this.startUsingItem(hand, false);
-+    }
-+    public void startUsingItem(InteractionHand hand, boolean forceUpdate) {
-+        // Paper end - Prevent consuming the wrong itemstack
-         ItemStack itemstack = this.getItemInHand(hand);
- 
-        if (!itemstack.isEmpty() && !this.isUsingItem()) {
-+        if (!itemstack.isEmpty() && !this.isUsingItem() || forceUpdate) { // Paper - Prevent consuming the wrong itemstack
-             this.useItem = itemstack;
-             this.useItemRemaining = itemstack.getUseDuration();
-             if (!this.level().isClientSide) {
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                 this.releaseUsingItem();
-             } else {
-                 if (!this.useItem.isEmpty() && this.isUsingItem()) {
-+                    this.startUsingItem(this.getUsedItemHand(), true); // Paper - Prevent consuming the wrong itemstack
-                     this.triggerItemUseEffects(this.useItem, 16);
-                     // CraftBukkit start - fire PlayerItemConsumeEvent
-                     ItemStack itemstack;
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                     }
- 
-                     this.stopUsingItem();
-                    // Paper start - if the replacement is anything but the default, update the client inventory
-                    if (this instanceof ServerPlayer && !com.google.common.base.Objects.equal(defaultReplacement, itemstack)) {
-+                    // Paper start
-+                    if (this instanceof ServerPlayer) {
-                         ((ServerPlayer) this).getBukkitEntity().updateInventory();
-                     }
-                     // Paper end
--- a/patches/unapplied/server/Prevent-opening-inventories-when-frozen.patch
+++ b/patches/unapplied/server/Prevent-opening-inventories-when-frozen.patch
@ -1,50 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Mon, 13 Apr 2020 07:31:44 +0100
-Subject: [PATCH] Prevent opening inventories when frozen
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-             containerUpdateDelay = this.level().paperConfig().tickRates.containerUpdate;
-         }
-         // Paper end - Configurable container update tick rate
-        if (!this.level().isClientSide && !this.containerMenu.stillValid(this)) {
-+        if (!this.level().isClientSide && this.containerMenu != this.inventoryMenu && (this.isImmobile() || !this.containerMenu.stillValid(this))) { // Paper - Prevent opening inventories when frozen
-             this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.CANT_USE); // Paper - Inventory close reason
-             this.containerMenu = this.inventoryMenu;
-         }
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-             } else {
-                 // CraftBukkit start
-                 this.containerMenu = container;
-                this.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(), container.getTitle()));
-+                if (!this.isImmobile()) this.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(), container.getTitle())); // Paper - Prevent opening inventories when frozen
-                 // CraftBukkit end
-                 this.initMenu(container);
-                 return OptionalInt.of(this.containerCounter);
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-@@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
-         if (adventure$title == null) adventure$title = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(container.getBukkitView().getTitle()); // Paper
- 
-         //player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, CraftChatMessage.fromString(title)[0])); // Paper - comment
-        player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, io.papermc.paper.adventure.PaperAdventure.asVanilla(adventure$title))); // Paper
-+        if (!player.isImmobile()) player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, io.papermc.paper.adventure.PaperAdventure.asVanilla(adventure$title))); // Paper - Prevent opening inventories when frozen
-         player.containerMenu = container;
-         player.initMenu(container);
-     }
-@@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
-         net.kyori.adventure.text.Component adventure$title = inventory.title(); // Paper
-         if (adventure$title == null) adventure$title = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(inventory.getTitle()); // Paper
-         //player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, CraftChatMessage.fromString(title)[0])); // Paper - comment
-        player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, io.papermc.paper.adventure.PaperAdventure.asVanilla(adventure$title))); // Paper
-+        if (!player.isImmobile()) player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, io.papermc.paper.adventure.PaperAdventure.asVanilla(adventure$title))); // Paper - Prevent opening inventories when frozen
-         player.containerMenu = container;
-         player.initMenu(container);
-     }
--- a/patches/unapplied/server/Prevent-position-desync-causing-tp-exploit.patch
+++ b/patches/unapplied/server/Prevent-position-desync-causing-tp-exploit.patch
@ -1,30 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Fri, 12 Jun 2020 16:51:39 -0700
-Subject: [PATCH] Prevent position desync causing tp exploit
-
-Caused the server to revert to the player's overworld coordinates
-after teleporting into the end.
-
-Sidenote: The underlying issue is that the move call can teleport
-entities and do other things like kill the entity. In the future,
-to fix all exploits derieved from this usually unexpected
-behaviour, we need to move all of this dangerous logic outside
-of the move call and into an appropriate place in the tick method.
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
- 
-                             this.player.move(MoverType.PLAYER, new Vec3(d6, d7, d8));
-                             this.player.onGround = packet.isOnGround(); // CraftBukkit - SPIGOT-5810, SPIGOT-5835, SPIGOT-6828: reset by this.player.move
-+                            // Paper start - prevent position desync
-+                            if (this.awaitingPositionFromClient != null) {
-+                                return; // ... thanks Mojang for letting move calls teleport across dimensions.
-+                            }
-+                            // Paper end - prevent position desync
-                             double d11 = d7;
- 
-                             d6 = d0 - this.player.getX();
--- a/patches/unapplied/server/Prevent-sync-chunk-loads-when-villagers-try-to-find-.patch
+++ b/patches/unapplied/server/Prevent-sync-chunk-loads-when-villagers-try-to-find-.patch
@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Callahan <mr.callahhh@gmail.com>
-Date: Mon, 13 Jan 2020 23:47:28 -0600
-Subject: [PATCH] Prevent sync chunk loads when villagers try to find beds
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/SleepInBed.java b/src/main/java/net/minecraft/world/entity/ai/behavior/SleepInBed.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/ai/behavior/SleepInBed.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/SleepInBed.java
-@@ -0,0 +0,0 @@ public class SleepInBed extends Behavior<LivingEntity> {
-                     }
-                 }
- 
-                BlockState blockState = world.getBlockState(globalPos.pos());
-+                BlockState blockState = world.getBlockStateIfLoaded(globalPos.pos()); // Paper - Prevent sync chunk loads when villagers try to find beds
-+                if (blockState == null) { return false; } // Paper - Prevent sync chunk loads when villagers try to find beds
-                 return globalPos.pos().closerToCenterThan(entity.position(), 2.0) && blockState.is(BlockTags.BEDS) && !blockState.getValue(BedBlock.OCCUPIED);
-             }
-         }
--- a/patches/unapplied/server/Prevent-teleporting-dead-entities.patch
+++ b/patches/unapplied/server/Prevent-teleporting-dead-entities.patch
@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Tue, 3 Mar 2020 05:26:40 +0000
-Subject: [PATCH] Prevent teleporting dead entities
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-     }
- 
-     public void internalTeleport(double d0, double d1, double d2, float f, float f1, Set<RelativeMovement> set) { // Paper
-+        // Paper start - Prevent teleporting dead entities
-+        if (player.isRemoved()) {
-+            LOGGER.info("Attempt to teleport removed player {} restricted", player.getScoreboardName());
-+            if (server.isDebugging()) io.papermc.paper.util.TraceUtil.dumpTraceForThread("Attempt to teleport removed player");
-+            return;
-+        }
-+        // Paper end - Prevent teleporting dead entities
-         // CraftBukkit start
-         if (Float.isNaN(f)) {
-             f = 0;
--- a/patches/unapplied/server/Reduce-Either-Optional-allocation.patch
+++ b/patches/unapplied/server/Reduce-Either-Optional-allocation.patch
@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Mon, 6 Apr 2020 18:35:09 -0700
-Subject: [PATCH] Reduce Either Optional allocation
-
-In order to get chunk values, we shouldn't need to create
-an optional each time.
-
-diff --git a/src/main/java/com/mojang/datafixers/util/Either.java b/src/main/java/com/mojang/datafixers/util/Either.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/com/mojang/datafixers/util/Either.java
-+++ b/src/main/java/com/mojang/datafixers/util/Either.java
-@@ -0,0 +0,0 @@ public abstract class Either<L, R> implements App<Either.Mu<R>, L> {
-     }
- 
-     private static final class Left<L, R> extends Either<L, R> {
-        private final L value;
-+        private final L value; private Optional<L> valueOptional; // Paper - Perf: Reduce Either Optional allocation
- 
-         public Left(final L value) {
-             this.value = value;
-@@ -0,0 +0,0 @@ public abstract class Either<L, R> implements App<Either.Mu<R>, L> {
- 
-         @Override
-         public Optional<L> left() {
-            return Optional.of(value);
-+            return this.valueOptional == null ? this.valueOptional = Optional.of(this.value) : this.valueOptional; // Paper - Perf: Reduce Either Optional allocation
-         }
- 
-         @Override
-@@ -0,0 +0,0 @@ public abstract class Either<L, R> implements App<Either.Mu<R>, L> {
-     }
- 
-     private static final class Right<L, R> extends Either<L, R> {
-        private final R value;
-+        private final R value; private Optional<R> valueOptional; // Paper - Perf: Reduce Either Optional allocation
- 
-         public Right(final R value) {
-             this.value = value;
-@@ -0,0 +0,0 @@ public abstract class Either<L, R> implements App<Either.Mu<R>, L> {
- 
-         @Override
-         public Optional<R> right() {
-            return Optional.of(value);
-+            return this.valueOptional == null ? this.valueOptional = Optional.of(this.value) : this.valueOptional; // Paper - Perf: Reduce Either Optional allocation
-         }
- 
-         @Override
--- a/patches/unapplied/server/Reduce-memory-footprint-of-CompoundTag.patch
+++ b/patches/unapplied/server/Reduce-memory-footprint-of-CompoundTag.patch
@ -1,50 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Mon, 6 Apr 2020 17:39:25 -0700
-Subject: [PATCH] Reduce memory footprint of CompoundTag
-
-Fastutil maps are going to have a lower memory footprint - which
-is important because we clone chunk data after reading it for safety.
-So, reduce the impact of the clone on GC.
-
-diff --git a/src/main/java/net/minecraft/nbt/CompoundTag.java b/src/main/java/net/minecraft/nbt/CompoundTag.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/nbt/CompoundTag.java
-+++ b/src/main/java/net/minecraft/nbt/CompoundTag.java
-@@ -0,0 +0,0 @@ public class CompoundTag implements Tag {
- 
-         private static CompoundTag loadCompound(DataInput input, NbtAccounter tracker) throws IOException {
-             tracker.accountBytes(48L);
-            Map<String, Tag> map = Maps.newHashMap();
-+            it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<String, Tag> map = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f); // Paper - Reduce memory footprint of CompoundTag
- 
-             byte b;
-             while ((b = input.readByte()) != 0) {
-@@ -0,0 +0,0 @@ public class CompoundTag implements Tag {
-     }
- 
-     public CompoundTag() {
-        this(Maps.newHashMap());
-+        this(new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f)); // Paper - Reduce memory footprint of CompoundTag
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CompoundTag implements Tag {
- 
-     @Override
-     public CompoundTag copy() {
-        Map<String, Tag> map = Maps.newHashMap(Maps.transformValues(this.tags, Tag::copy));
-        return new CompoundTag(map);
-+        // Paper start - Reduce memory footprint of CompoundTag
-+        it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<String, Tag> ret = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(this.tags.size(), 0.8f);
-+        java.util.Iterator<java.util.Map.Entry<String, Tag>> iterator = (this.tags instanceof it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap) ? ((it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap)this.tags).object2ObjectEntrySet().fastIterator() : this.tags.entrySet().iterator();
-+        while (iterator.hasNext()) {
-+            Map.Entry<String, Tag> entry = iterator.next();
-+            ret.put(entry.getKey(), entry.getValue().copy());
-+        }
-+
-+        return new CompoundTag(ret);
-+        // Paper end - Reduce memory footprint of CompoundTag
-     }
- 
-     @Override
--- a/patches/unapplied/server/Remote-Connections-shouldn-t-hold-up-shutdown.patch
+++ b/patches/unapplied/server/Remote-Connections-shouldn-t-hold-up-shutdown.patch
@ -1,44 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 31 Mar 2020 03:50:42 -0400
-Subject: [PATCH] Remote Connections shouldn't hold up shutdown
-
-Bugs in the connection logic appears to leave stale connections even, preventing shutdown
-
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-         }
- 
-         if (this.rconThread != null) {
-            this.rconThread.stop();
-+            this.rconThread.stopNonBlocking(); // Paper - don't wait for remote connections
-         }
- 
-         if (this.queryThreadGs4 != null) {
-            this.queryThreadGs4.stop();
-+            // this.remoteStatusListener.stop(); // Paper - don't wait for remote connections
-         }
- 
-         System.exit(0); // CraftBukkit
-diff --git a/src/main/java/net/minecraft/server/rcon/thread/RconThread.java b/src/main/java/net/minecraft/server/rcon/thread/RconThread.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/rcon/thread/RconThread.java
-+++ b/src/main/java/net/minecraft/server/rcon/thread/RconThread.java
-@@ -0,0 +0,0 @@ public class RconThread extends GenericThread {
- 
-         this.clients.clear();
-     }
-+    // Paper start - don't wait for remote connections
-+    public void stopNonBlocking() {
-+        this.running = false;
-+        for (RconClient client : this.clients) {
-+            client.running = false;
-+        }
-+    }
-+    // Paper end - don't wait for remote connections
- 
-     private void closeSocket(ServerSocket socket) {
-         LOGGER.debug("closeSocket: {}", socket);
--- a/patches/unapplied/server/Server-Tick-Events.patch
+++ b/patches/unapplied/server/Server-Tick-Events.patch
@ -1,31 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 27 Mar 2019 22:48:45 -0400
-Subject: [PATCH] Server Tick Events
-
-Fires event at start and end of a server tick
-
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         });
-         isOversleep = false;MinecraftTimings.serverOversleep.stopTiming();
-         // Paper end
-+        new com.destroystokyo.paper.event.server.ServerTickStartEvent(this.tickCount+1).callEvent(); // Paper - Server Tick Events
- 
-         ++this.tickCount;
-         this.tickRateManager.tick();
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.runAllTasks();
-         }
-         // Paper end
-+        // Paper start - Server Tick Events
-+        long endTime = System.nanoTime();
-+        long remaining = (TICK_TIME - (endTime - lastTick)) - catchupTime;
-+        new com.destroystokyo.paper.event.server.ServerTickEndEvent(this.tickCount, ((double)(endTime - lastTick) / 1000000D), remaining).callEvent();
-+        // Paper end - Server Tick Events
-         this.profiler.push("tallying");
-         long j = Util.getNanos() - i;
-         int k = this.tickCount % 100;
--- a/patches/unapplied/server/Set-cap-on-JDK-per-thread-native-byte-buffer-cache.patch
+++ b/patches/unapplied/server/Set-cap-on-JDK-per-thread-native-byte-buffer-cache.patch
@ -1,30 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 4 May 2020 01:08:56 -0400
-Subject: [PATCH] Set cap on JDK per-thread native byte buffer cache
-
-See: https://www.evanjones.ca/java-bytebuffer-leak.html
-
-This is potentially a source of lots of native memory usage.
-
-We are clearly seeing native usage upwards to 1-4GB which doesn't make sense.
-
-Region File usage fixed in previous patch should of tecnically only been somewhat
-temporary until GC finally gets it some time later, but between all the various
-plugins doing IO on various threads, this hidden detail of the JDK could be
-keeping long lived large direct buffers in cache.
-
-Set system properly at server startup if not set already to help protect from this.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/Main.java
-+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
-@@ -0,0 +0,0 @@ public class Main {
-         }
-         // Paper end
-         // Todo: Installation script
-+        if (System.getProperty("jdk.nio.maxCachedBufferSize") == null) System.setProperty("jdk.nio.maxCachedBufferSize", "262144"); // Paper - cap per-thread NIO cache size; https://www.evanjones.ca/java-bytebuffer-leak.html
-         OptionParser parser = new OptionParser() {
-             {
-                 this.acceptsAll(Main.asList("?", "help"), "Show the help");
--- a/patches/unapplied/server/Set-spigots-verbose-world-setting-to-false-by-def.patch
+++ b/patches/unapplied/server/Set-spigots-verbose-world-setting-to-false-by-def.patch
@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Wed, 2 Dec 2020 20:17:54 -0800
-Subject: [PATCH] Set spigots verbose world setting to false by def
-
-
-diff --git a/src/main/java/org/spigotmc/SpigotWorldConfig.java b/src/main/java/org/spigotmc/SpigotWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/spigotmc/SpigotWorldConfig.java
-+++ b/src/main/java/org/spigotmc/SpigotWorldConfig.java
-@@ -0,0 +0,0 @@ public class SpigotWorldConfig
- 
-     public void init()
-     {
-        this.verbose = this.getBoolean( "verbose", true );
-+        this.verbose = this.getBoolean( "verbose", false ); // Paper
- 
-         this.log( "-------- World Settings For [" + this.worldName + "] --------" );
-         SpigotConfig.readConfig( SpigotWorldConfig.class, this );
--- a/patches/unapplied/server/Show-blockstate-location-if-we-failed-to-read-it.patch
+++ b/patches/unapplied/server/Show-blockstate-location-if-we-failed-to-read-it.patch
@ -1,33 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sat, 15 Jun 2019 10:28:25 -0700
-Subject: [PATCH] Show blockstate location if we failed to read it
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
-@@ -0,0 +0,0 @@ public class CraftBlockEntityState<T extends BlockEntity> extends CraftBlockStat
- 
-         this.tileEntity = tileEntity;
- 
-+        try { // Paper - Show blockstate location if we failed to read it
-         // Paper start
-         this.snapshotDisabled = DISABLE_SNAPSHOT;
-         if (DISABLE_SNAPSHOT) {
-@@ -0,0 +0,0 @@ public class CraftBlockEntityState<T extends BlockEntity> extends CraftBlockStat
-             this.load(this.snapshot);
-         }
-         // Paper end
-+        // Paper start - Show blockstate location if we failed to read it
-+        } catch (Throwable thr) {
-+            if (thr instanceof ThreadDeath) {
-+                throw (ThreadDeath)thr;
-+            }
-+            throw new RuntimeException("Failed to read BlockState at: world: " + this.getWorld().getName() + " location: (" + this.getX() + ", " + this.getY() + ", " + this.getZ() + ")", thr);
-+        }
-+        // Paper end - Show blockstate location if we failed to read it
-     }
- 
-     protected CraftBlockEntityState(CraftBlockEntityState<T> state, Location location) {
--- a/patches/unapplied/server/Tracking-Range-Improvements.patch
+++ b/patches/unapplied/server/Tracking-Range-Improvements.patch
@ -1,78 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: kickash32 <kickash32@gmail.com>
-Date: Sat, 21 Dec 2019 15:22:09 -0500
-Subject: [PATCH] Tracking Range Improvements
-
-Sets tracking range of watermobs to animals instead of misc and simplifies code
-
-Also ignores Enderdragon, defaulting it to Mojang's setting
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-             while (iterator.hasNext()) {
-                 Entity entity = (Entity) iterator.next();
-                 int j = entity.getType().clientTrackingRange() * 16;
-+                j = org.spigotmc.TrackingRange.getEntityTrackingRange(entity, j); // Paper
- 
-                 if (j > i) {
-                     i = j;
-diff --git a/src/main/java/org/spigotmc/TrackingRange.java b/src/main/java/org/spigotmc/TrackingRange.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/spigotmc/TrackingRange.java
-+++ b/src/main/java/org/spigotmc/TrackingRange.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.ExperienceOrb;
- import net.minecraft.world.entity.decoration.ItemFrame;
- import net.minecraft.world.entity.decoration.Painting;
- import net.minecraft.world.entity.item.ItemEntity;
-import net.minecraft.world.entity.monster.Ghast;
- 
- public class TrackingRange
- {
-@@ -0,0 +0,0 @@ public class TrackingRange
-         if ( entity instanceof ServerPlayer )
-         {
-             return config.playerTrackingRange;
-        } else if ( entity.activationType == ActivationRange.ActivationType.MONSTER || entity.activationType == ActivationRange.ActivationType.RAIDER )
-        {
-            return config.monsterTrackingRange;
-        } else if ( entity instanceof Ghast )
-        {
-            if ( config.monsterTrackingRange > config.monsterActivationRange )
-            {
-+        // Paper start - Simplify and set water mobs to animal tracking range
-+        }
-+        switch (entity.activationType) {
-+            case RAIDER:
-+            case MONSTER:
-+            case FLYING_MONSTER:
-                 return config.monsterTrackingRange;
-            } else
-            {
-                return config.monsterActivationRange;
-            }
-        } else if ( entity.activationType == ActivationRange.ActivationType.ANIMAL )
-        {
-            return config.animalTrackingRange;
-        } else if ( entity instanceof ItemFrame || entity instanceof Painting || entity instanceof ItemEntity || entity instanceof ExperienceOrb )
-+            case WATER:
-+            case VILLAGER:
-+            case ANIMAL:
-+                return config.animalTrackingRange;
-+            case MISC:
-+        }
-+        if ( entity instanceof ItemFrame || entity instanceof Painting || entity instanceof ItemEntity || entity instanceof ExperienceOrb )
-+        // Paper end
-         {
-             return config.miscTrackingRange;
-         } else if ( entity instanceof Display )
-@@ -0,0 +0,0 @@ public class TrackingRange
-             return config.displayTrackingRange;
-         } else
-         {
-+            if (entity instanceof net.minecraft.world.entity.boss.enderdragon.EnderDragon) return ((net.minecraft.server.level.ServerLevel)(entity.getCommandSenderWorld())).getChunkSource().chunkMap.serverViewDistance; // Paper - enderdragon is exempt
-             return config.otherTrackingRange;
-         }
-     }
--- a/patches/unapplied/server/Use-seed-based-lookup-for-Treasure-Maps-Fixes-lag-fr.patch
+++ b/patches/unapplied/server/Use-seed-based-lookup-for-Treasure-Maps-Fixes-lag-fr.patch
@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 7 Jun 2020 19:25:13 -0400
-Subject: [PATCH] Use seed based lookup for Treasure Maps - Fixes lag from
- carto/sunken maps
-
-
-diff --git a/src/main/java/net/minecraft/world/item/MapItem.java b/src/main/java/net/minecraft/world/item/MapItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/item/MapItem.java
-+++ b/src/main/java/net/minecraft/world/item/MapItem.java
-@@ -0,0 +0,0 @@ public class MapItem extends ComplexItem {
- 
-                 for (int n = 0; n < 128; n++) {
-                     for (int o = 0; o < 128; o++) {
-                        Holder<Biome> holder = world.getBiome(mutableBlockPos.set((l + o) * i, 0, (m + n) * i));
-+                        Holder<Biome> holder = world.getUncachedNoiseBiome((l + o) * i, 0, (m + n) * i); // Paper - Perf: Use seed based lookup for treasure maps
-                         bls[n * 128 + o] = holder.is(BiomeTags.WATER_ON_MAP_OUTLINES);
-                     }
-                 }
--- a/patches/unapplied/server/Validate-PickItem-Packet-and-kick-for-invalid.patch
+++ b/patches/unapplied/server/Validate-PickItem-Packet-and-kick-for-invalid.patch
@ -1,26 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 2 May 2020 03:09:46 -0400
-Subject: [PATCH] Validate PickItem Packet and kick for invalid
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-     @Override
-     public void handlePickItem(ServerboundPickItemPacket packet) {
-         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
-        this.player.getInventory().pickSlot(packet.getSlot());
-+        // Paper start - validate pick item position
-+        if (!(packet.getSlot() >= 0 && packet.getSlot() < this.player.getInventory().items.size())) {
-+            ServerGamePacketListenerImpl.LOGGER.warn("{} tried to set an invalid carried item", this.player.getName().getString());
-+            this.disconnect("Invalid hotbar selection (Hacking?)");
-+            return;
-+        }
-+        this.player.getInventory().pickSlot(packet.getSlot()); // Paper - Diff above if changed
-+        // Paper end - validate pick item position
-         this.player.connection.send(new ClientboundContainerSetSlotPacket(-2, 0, this.player.getInventory().selected, this.player.getInventory().getItem(this.player.getInventory().selected)));
-         this.player.connection.send(new ClientboundContainerSetSlotPacket(-2, 0, packet.getSlot(), this.player.getInventory().getItem(packet.getSlot())));
-         this.player.connection.send(new ClientboundSetCarriedItemPacket(this.player.getInventory().selected));
--- a/Show More
+++ b/Show More